This patch is not ready for integration, but I'd like to get feedback on the
approach (and various specific questions below).
-- 8< --
This patch introduces an installed source form of module std and std.compat.
To find them, we install a libstdc++.modules.json file alongside
libstdc++.so, which tells the build system where the files are and any
special flags it should use when compiling them (none, in our case). The
format is from a proposal in SG15.
The build system can find this file with
gcc -print-file-name=libstdc++.modules.json
It seems preferable to use a relative path from this file to the sources so
that moving the installation doesn't break the reference, but I didn't see
any obvious way to compute that without relying on coreutils, perl, or
python, so I wrote a POSIX shell script for it.
Currently this installs the sources under $(pkgdata), i.e.
/usr/share/libstdc++/modules. It could also make sense to install them
under $(gxx_include_dir), i.e. /usr/include/c++/15/modules. And/or the
subdirectory could be "miu" (module interface unit) instead of "modules".
The sources currently have the extension .cc, like other source files.
Alternatively, they could use one of the module interface unit extensions,
perhaps .ccm.
std.cc started with m.cencora's implementation in PR114600. I've made some
adjustments, but more is probably desirable, e.g. of the <algorithm>
handling of namespace ranges, and to remove exports of templates that are
only specialized in a particular header.
The std module is missing exports for some newer headers, including some
that are already implemented (<generator>, <print>, <stop_token>). I've
added some FIXMEs where I noticed missing bits.
Since bits/stdc++.h also intends to include the whole standard library, I
include it rather than duplicate it. But stdc++.h comments out <exception>,
so I include it separately. Alternatively, we could uncomment it in
stdc++.h.
stdc++.h also doesn't include the eternally deprecated <strstream>. There
are some other deprecated facilities that I notice are included: <codecvt>
and float_denorm_style, at least. It would be nice for L{E,}WG to clarify
whether module std is intended to include interfaces that were deprecated in
C++23, since ancient code isn't going to be relying on module std.
If they are supposed to included, do we also want to keep exporting them in
C++26, where they are removed from the standard?
It seemed most convenient for the two files to be monolithic so we don't
need to worry about include paths. So the C library names that module
std.compat exports in both namespace std and :: in module are a block of
code that is identical in both files, adjusted based on whether the macro
STD_COMPAT is defined before the block.
In this implementation std.compat imports std; it would also be valid for it
to duplicate everything in std. I see the libc++ std.compat also imports
std.
Is it useful for std.cc to live in a subdirectory of c++23 as in this patch, or
should it be in c++23 itself? Or elsewhere?
This patch doesn't yet provide a convenient way for a user to find std.cc.
libstdc++-v3/ChangeLog:
* src/c++23/Makefile.am: Add module std/std.compat.
* src/c++23/Makefile.in: Regenerate.
* src/c++23/modules/std.cc: New file.
* src/c++23/modules/std.compat.cc: New file.
* src/c++23/libstdc++.modules.json.in: New file.
contrib/ChangeLog:
* relpath.sh: New file.
---
libstdc++-v3/src/c++23/modules/std.cc | 3575 +++++++++++++++++
libstdc++-v3/src/c++23/modules/std.compat.cc | 640 +++
contrib/relpath.sh | 70 +
libstdc++-v3/src/c++23/Makefile.am | 18 +
libstdc++-v3/src/c++23/Makefile.in | 133 +-
.../src/c++23/libstdc++.modules.json.in | 17 +
6 files changed, 4436 insertions(+), 17 deletions(-)
create mode 100644 libstdc++-v3/src/c++23/modules/std.cc
create mode 100644 libstdc++-v3/src/c++23/modules/std.compat.cc
create mode 100755 contrib/relpath.sh
create mode 100644 libstdc++-v3/src/c++23/libstdc++.modules.json.in
diff --git a/libstdc++-v3/src/c++23/modules/std.cc
b/libstdc++-v3/src/c++23/modules/std.cc
new file mode 100644
index 00000000000..d823b915b9c
--- /dev/null
+++ b/libstdc++-v3/src/c++23/modules/std.cc
@@ -0,0 +1,3575 @@
+// -*- C++ -*- [std.modules] module std
+
+// Copyright The GNU Toolchain Authors.
+//
+// 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.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+module;
+
+#include <bits/stdc++.h>
+
+// ??? Commented out in stdc++.h
+#include <execution>
+
+#undef __DEPRECATED
+#include <strstream>
+
+export module std;
+
+// **** Any changes to the C library section below must also be made to the
+// **** verbatim copy in std.compat.cc.
+
+// C standard library headers [tab:headers.cpp.c]
+
+#ifndef STD_COMPAT
+#define C_LIB_NAMESPACE namespace std
+#endif
+
+// 19.3 <cassert>
+// No exports
+
+// 23.5.1 <cctype>
+export C_LIB_NAMESPACE
+{
+ using std::isalnum;
+ using std::isalpha;
+ using std::isblank;
+ using std::iscntrl;
+ using std::isdigit;
+ using std::isgraph;
+ using std::islower;
+ using std::isprint;
+ using std::ispunct;
+ using std::isspace;
+ using std::isupper;
+ using std::isxdigit;
+ using std::tolower;
+ using std::toupper;
+}
+
+// 19.4 <cerrno>
+// No exports
+
+// 28.3 <cfenv>
+export C_LIB_NAMESPACE
+{
+ using std::feclearexcept;
+ using std::fegetenv;
+ using std::fegetexceptflag;
+ using std::fegetround;
+ using std::feholdexcept;
+ using std::fenv_t;
+ using std::feraiseexcept;
+ using std::fesetenv;
+ using std::fesetexceptflag;
+ using std::fesetround;
+ using std::fetestexcept;
+ using std::feupdateenv;
+ using std::fexcept_t;
+}
+
+// 17.3.7 <cfloat> [cfloat.syn]
+// No exports, only provides macros
+
+// 31.13.2 <cinttypes>
+export C_LIB_NAMESPACE
+{
+ using std::imaxabs;
+ using std::imaxdiv;
+ using std::imaxdiv_t;
+ using std::strtoimax;
+ using std::strtoumax;
+ using std::wcstoimax;
+ using std::wcstoumax;
+}
+
+// 17.3.6 <climits> [climits.syn]
+// No exports, only provides macros
+
+// 30.5 <clocale>
+export C_LIB_NAMESPACE
+{
+ using std::lconv;
+ using std::localeconv;
+ using std::setlocale;
+ // LC_* macros not exported
+}
+
+// 28.7.1 <cmath>
+// FIXME missing special functions
+export C_LIB_NAMESPACE
+{
+ using std::abs;
+ using std::acos;
+ using std::acosf;
+ using std::acosh;
+ using std::acoshf;
+ using std::acoshl;
+ using std::acosl;
+ using std::asin;
+ using std::asinf;
+ using std::asinh;
+ using std::asinhf;
+ using std::asinhl;
+ using std::asinl;
+ using std::atan;
+ using std::atan2;
+ using std::atan2f;
+ using std::atan2l;
+ using std::atanf;
+ using std::atanh;
+ using std::atanhf;
+ using std::atanhl;
+ using std::atanl;
+ using std::cbrt;
+ using std::cbrtf;
+ using std::cbrtl;
+ using std::ceil;
+ using std::ceilf;
+ using std::ceill;
+ using std::copysign;
+ using std::copysignf;
+ using std::copysignl;
+ using std::cos;
+ using std::cosf;
+ using std::cosh;
+ using std::coshf;
+ using std::coshl;
+ using std::cosl;
+ using std::double_t;
+ using std::erf;
+ using std::erfc;
+ using std::erfcf;
+ using std::erfcl;
+ using std::erff;
+ using std::erfl;
+ using std::exp;
+ using std::exp2;
+ using std::exp2f;
+ using std::exp2l;
+ using std::expf;
+ using std::expl;
+ using std::expm1;
+ using std::expm1f;
+ using std::expm1l;
+ using std::fabs;
+ using std::fabsf;
+ using std::fabsl;
+ using std::fdim;
+ using std::fdimf;
+ using std::fdiml;
+ using std::float_t;
+ using std::floor;
+ using std::floorf;
+ using std::floorl;
+ using std::fma;
+ using std::fmaf;
+ using std::fmal;
+ using std::fmax;
+ using std::fmaxf;
+ using std::fmaxl;
+ using std::fmin;
+ using std::fminf;
+ using std::fminl;
+ using std::fmod;
+ using std::fmodf;
+ using std::fmodl;
+ using std::fpclassify;
+ using std::frexp;
+ using std::frexpf;
+ using std::frexpl;
+ using std::hypot;
+ using std::hypotf;
+ using std::hypotl;
+ using std::ilogb;
+ using std::ilogbf;
+ using std::ilogbl;
+ using std::isfinite;
+ using std::isgreater;
+ using std::isgreaterequal;
+ using std::isinf;
+ using std::isless;
+ using std::islessequal;
+ using std::islessgreater;
+ using std::isnan;
+ using std::isnormal;
+ using std::isunordered;
+ using std::ldexp;
+ using std::ldexpf;
+ using std::ldexpl;
+#ifndef STD_COMPAT
+ using std::lerp;
+#endif
+ using std::lgamma;
+ using std::lgammaf;
+ using std::lgammal;
+ using std::llrint;
+ using std::llrintf;
+ using std::llrintl;
+ using std::llround;
+ using std::llroundf;
+ using std::llroundl;
+ using std::log;
+ using std::log10;
+ using std::log10f;
+ using std::log10l;
+ using std::log1p;
+ using std::log1pf;
+ using std::log1pl;
+ using std::log2;
+ using std::log2f;
+ using std::log2l;
+ using std::logb;
+ using std::logbf;
+ using std::logbl;
+ using std::logf;
+ using std::logl;
+ using std::lrint;
+ using std::lrintf;
+ using std::lrintl;
+ using std::lround;
+ using std::lroundf;
+ using std::lroundl;
+ using std::modf;
+ using std::modff;
+ using std::modfl;
+ using std::nan;
+ using std::nanf;
+ using std::nanl;
+ using std::nearbyint;
+ using std::nearbyintf;
+ using std::nearbyintl;
+ using std::nextafter;
+ using std::nextafterf;
+ using std::nextafterl;
+ using std::nexttoward;
+ using std::nexttowardf;
+ using std::nexttowardl;
+ using std::pow;
+ using std::powf;
+ using std::powl;
+ using std::remainder;
+ using std::remainderf;
+ using std::remainderl;
+ using std::remquo;
+ using std::remquof;
+ using std::remquol;
+ using std::rint;
+ using std::rintf;
+ using std::rintl;
+ using std::round;
+ using std::roundf;
+ using std::roundl;
+ using std::scalbln;
+ using std::scalblnf;
+ using std::scalblnl;
+ using std::scalbn;
+ using std::scalbnf;
+ using std::scalbnl;
+ using std::signbit;
+ using std::sin;
+ using std::sinf;
+ using std::sinh;
+ using std::sinhf;
+ using std::sinhl;
+ using std::sinl;
+ using std::sqrt;
+ using std::sqrtf;
+ using std::sqrtl;
+ using std::tan;
+ using std::tanf;
+ using std::tanh;
+ using std::tanhf;
+ using std::tanhl;
+ using std::tanl;
+ using std::tgamma;
+ using std::tgammaf;
+ using std::tgammal;
+ using std::trunc;
+ using std::truncf;
+ using std::truncl;
+}
+
+// 17.13.3 <csetjmp>
+export C_LIB_NAMESPACE
+{
+ using std::jmp_buf;
+ using std::longjmp;
+ // setjmp macro not exported
+}
+
+// 17.13.4 <csignal>
+export C_LIB_NAMESPACE
+{
+ using std::raise;
+ using std::sig_atomic_t;
+ using std::signal;
+ // SIG_* macros not exported
+}
+
+// 17.13.2 <cstdarg>
+export C_LIB_NAMESPACE
+{
+ using std::va_list;
+ // va_arg and friend macros not exported
+}
+
+// 17.2.1 <cstddef> [cstddef.syn]
+export C_LIB_NAMESPACE
+{
+ using std::max_align_t;
+ using std::nullptr_t;
+ using std::ptrdiff_t;
+ using std::size_t;
+#ifndef STD_COMPAT
+ using std::byte;
+ using std::operator<<=;
+ using std::operator<<;
+ using std::operator>>=;
+ using std::operator>>;
+ using std::operator|=;
+ using std::operator|;
+ using std::operator&=;
+ using std::operator&;
+ using std::operator^=;
+ using std::operator^;
+ using std::operator~;
+ using std::to_integer;
+#endif
+ // NULL and offsetof macros not exported
+}
+
+// 17.4 <cstdint>
+export C_LIB_NAMESPACE
+{
+ using std::int8_t;
+ using std::int16_t;
+ using std::int32_t;
+ using std::int64_t;
+ using std::int_fast16_t;
+ using std::int_fast32_t;
+ using std::int_fast64_t;
+ using std::int_fast8_t;
+ using std::int_least16_t;
+ using std::int_least32_t;
+ using std::int_least64_t;
+ using std::int_least8_t;
+ using std::intmax_t;
+ using std::intptr_t;
+ using std::uint8_t;
+ using std::uint16_t;
+ using std::uint32_t;
+ using std::uint64_t;
+ using std::uint_fast16_t;
+ using std::uint_fast32_t;
+ using std::uint_fast64_t;
+ using std::uint_fast8_t;
+ using std::uint_least16_t;
+ using std::uint_least32_t;
+ using std::uint_least64_t;
+ using std::uint_least8_t;
+ using std::uintmax_t;
+ using std::uintptr_t;
+}
+
+// 31.13.1 <cstdio>
+export C_LIB_NAMESPACE
+{
+ using std::clearerr;
+ using std::fclose;
+ using std::feof;
+ using std::ferror;
+ using std::fflush;
+ using std::fgetc;
+ using std::fgetpos;
+ using std::fgets;
+ using std::FILE;
+ using std::fopen;
+ using std::fpos_t;
+ using std::fprintf;
+ using std::fputc;
+ using std::fputs;
+ using std::fread;
+ using std::freopen;
+ using std::fscanf;
+ using std::fseek;
+ using std::fsetpos;
+ using std::ftell;
+ using std::fwrite;
+ using std::getc;
+ using std::getchar;
+ using std::perror;
+ using std::printf;
+ using std::putc;
+ using std::putchar;
+ using std::puts;
+ using std::remove;
+ using std::rename;
+ using std::rewind;
+ using std::scanf;
+ using std::setbuf;
+ using std::setvbuf;
+ using std::size_t;
+ using std::snprintf;
+ using std::sprintf;
+ using std::sscanf;
+ using std::tmpfile;
+ using std::tmpnam;
+ using std::ungetc;
+ using std::vfprintf;
+ using std::vfscanf;
+ using std::vprintf;
+ using std::vscanf;
+ using std::vsnprintf;
+ using std::vsprintf;
+ using std::vsscanf;
+}
+
+// 17.2.2 <cstdlib> [cstdlib.syn]
+export C_LIB_NAMESPACE
+{
+ using std::_Exit;
+ using std::abort;
+ using std::abs;
+ using std::aligned_alloc;
+ using std::at_quick_exit;
+ using std::atexit;
+ using std::atof;
+ using std::atoi;
+ using std::atol;
+ using std::atoll;
+ using std::bsearch;
+ using std::calloc;
+ using std::div;
+ using std::div_t;
+ using std::exit;
+ using std::free;
+ using std::getenv;
+ using std::labs;
+ using std::ldiv;
+ using std::ldiv_t;
+ using std::llabs;
+ using std::lldiv;
+ using std::lldiv_t;
+ using std::malloc;
+ using std::mblen;
+ using std::mbstowcs;
+ using std::mbtowc;
+ using std::qsort;
+ using std::quick_exit;
+ using std::rand;
+ using std::realloc;
+ using std::size_t;
+ using std::srand;
+ using std::strtod;
+ using std::strtof;
+ using std::strtol;
+ using std::strtold;
+ using std::strtoll;
+ using std::strtoul;
+ using std::strtoull;
+ using std::system;
+ using std::wcstombs;
+ using std::wctomb;
+}
+
+// 23.5.3 <cstring>
+export C_LIB_NAMESPACE
+{
+ using std::memchr;
+ using std::memcmp;
+ using std::memcpy;
+ using std::memmove;
+ using std::memset;
+ using std::size_t;
+ using std::strcat;
+ using std::strchr;
+ using std::strcmp;
+ using std::strcoll;
+ using std::strcpy;
+ using std::strcspn;
+ using std::strerror;
+ using std::strlen;
+ using std::strncat;
+ using std::strncmp;
+ using std::strncpy;
+ using std::strpbrk;
+ using std::strrchr;
+ using std::strspn;
+ using std::strstr;
+ using std::strtok;
+ using std::strxfrm;
+}
+
+// 29.15 <ctime>
+export C_LIB_NAMESPACE
+{
+ using std::asctime;
+ using std::clock;
+ using std::clock_t;
+ using std::ctime;
+ using std::difftime;
+ using std::gmtime;
+ using std::localtime;
+ using std::mktime;
+ using std::size_t;
+ using std::strftime;
+ using std::time;
+ using std::time_t;
+ using std::timespec;
+ using std::tm;
+ using std::timespec_get;
+}
+
+// 23.5.5 <cuchar>
+export C_LIB_NAMESPACE
+{
+ using std::mbrtoc8;
+ using std::c8rtomb;
+ using std::mbrtoc16;
+ using std::c16rtomb;
+ using std::mbrtoc32;
+ using std::c32rtomb;
+}
+
+// 23.5.4 <cwchar>
+export C_LIB_NAMESPACE
+{
+ using std::btowc;
+ using std::fgetwc;
+ using std::fgetws;
+ using std::fputwc;
+ using std::fputws;
+ using std::fwide;
+ using std::fwprintf;
+ using std::fwscanf;
+ using std::getwc;
+ using std::getwchar;
+ using std::mbrlen;
+ using std::mbrtowc;
+ using std::mbsinit;
+ using std::mbsrtowcs;
+ using std::mbstate_t;
+ using std::putwc;
+ using std::putwchar;
+ using std::size_t;
+ using std::swprintf;
+ using std::swscanf;
+ using std::tm;
+ using std::ungetwc;
+ using std::vfwprintf;
+ using std::vfwscanf;
+ using std::vswprintf;
+ using std::vswscanf;
+ using std::vwprintf;
+ using std::vwscanf;
+ using std::wcrtomb;
+ using std::wcscat;
+ using std::wcschr;
+ using std::wcscmp;
+ using std::wcscoll;
+ using std::wcscpy;
+ using std::wcscspn;
+ using std::wcsftime;
+ using std::wcslen;
+ using std::wcsncat;
+ using std::wcsncmp;
+ using std::wcsncpy;
+ using std::wcspbrk;
+ using std::wcsrchr;
+ using std::wcsrtombs;
+ using std::wcsspn;
+ using std::wcsstr;
+ using std::wcstod;
+ using std::wcstof;
+ using std::wcstok;
+ using std::wcstol;
+ using std::wcstold;
+ using std::wcstoll;
+ using std::wcstoul;
+ using std::wcstoull;
+ using std::wcsxfrm;
+ using std::wctob;
+ using std::wint_t;
+ using std::wmemchr;
+ using std::wmemcmp;
+ using std::wmemcpy;
+ using std::wmemmove;
+ using std::wmemset;
+ using std::wprintf;
+ using std::wscanf;
+}
+
+// 23.5.2 <cwctype>
+export C_LIB_NAMESPACE
+{
+ using std::iswalnum;
+ using std::iswalpha;
+ using std::iswblank;
+ using std::iswcntrl;
+ using std::iswctype;
+ using std::iswdigit;
+ using std::iswgraph;
+ using std::iswlower;
+ using std::iswprint;
+ using std::iswpunct;
+ using std::iswspace;
+ using std::iswupper;
+ using std::iswxdigit;
+ using std::towctrans;
+ using std::towlower;
+ using std::towupper;
+ using std::wctrans;
+ using std::wctrans_t;
+ using std::wctype;
+ using std::wctype_t;
+ using std::wint_t;
+}
+
+// **** End of C library ****
+
+// 27.4 <algorithm>
+export namespace std
+{
+ namespace ranges
+ {
+ using std::ranges::in_found_result;
+ using std::ranges::in_fun_result;
+ using std::ranges::in_in_out_result;
+ using std::ranges::in_in_result;
+ using std::ranges::in_out_out_result;
+ using std::ranges::in_out_result;
+ using std::ranges::min_max_result;
+ }
+ using std::all_of;
+ namespace ranges
+ {
+ using std::ranges::all_of;
+ }
+ using std::any_of;
+ namespace ranges
+ {
+ using std::ranges::any_of;
+ }
+ using std::none_of;
+ namespace ranges
+ {
+ using std::ranges::none_of;
+ }
+ using std::for_each;
+ namespace ranges
+ {
+ using std::ranges::for_each;
+ using std::ranges::for_each_result;
+ }
+ using std::for_each_n;
+ namespace ranges
+ {
+ using std::ranges::for_each_n;
+ using std::ranges::for_each_n_result;
+ }
+ using std::find;
+ using std::find_if;
+ using std::find_if_not;
+ namespace ranges
+ {
+ using std::ranges::find;
+ using std::ranges::find_if;
+ using std::ranges::find_if_not;
+ }
+ using std::find_end;
+ namespace ranges
+ {
+ using std::ranges::find_end;
+ }
+ using std::find_first_of;
+ namespace ranges
+ {
+ using std::ranges::find_first_of;
+ }
+ using std::adjacent_find;
+ namespace ranges
+ {
+ using std::ranges::adjacent_find;
+ }
+ using std::count;
+ using std::count_if;
+ namespace ranges
+ {
+ using std::ranges::count;
+ using std::ranges::count_if;
+ }
+ using std::mismatch;
+ namespace ranges
+ {
+ using std::ranges::mismatch;
+ using std::ranges::mismatch_result;
+ }
+ using std::equal;
+ namespace ranges
+ {
+ using std::ranges::equal;
+ }
+ using std::is_permutation;
+ namespace ranges
+ {
+ using std::ranges::is_permutation;
+ }
+ using std::search;
+ namespace ranges
+ {
+ using std::ranges::search;
+ }
+ using std::search_n;
+ namespace ranges
+ {
+ using std::ranges::search_n;
+ }
+ namespace ranges
+ {}
+ using std::copy;
+ namespace ranges
+ {
+ using std::ranges::copy;
+ using std::ranges::copy_result;
+ }
+ using std::copy_n;
+ namespace ranges
+ {
+ using std::ranges::copy_n;
+ using std::ranges::copy_n_result;
+ }
+ using std::copy_if;
+ namespace ranges
+ {
+ using std::ranges::copy_if;
+ using std::ranges::copy_if_result;
+ }
+ using std::copy_backward;
+ namespace ranges
+ {
+ using std::ranges::copy_backward;
+ using std::ranges::copy_backward_result;
+ }
+ using std::move;
+ namespace ranges
+ {
+ using std::ranges::move;
+ using std::ranges::move_result;
+ }
+ using std::move_backward;
+ namespace ranges
+ {
+ using std::ranges::move_backward;
+ using std::ranges::move_backward_result;
+ }
+ using std::swap_ranges;
+ namespace ranges
+ {
+ using std::ranges::swap_ranges;
+ using std::ranges::swap_ranges_result;
+ }
+ using std::iter_swap;
+ using std::transform;
+ namespace ranges
+ {
+ using std::ranges::binary_transform_result;
+ using std::ranges::transform;
+ using std::ranges::unary_transform_result;
+ }
+ using std::replace;
+ using std::replace_if;
+ namespace ranges
+ {
+ using std::ranges::replace;
+ using std::ranges::replace_if;
+ }
+ using std::replace_copy;
+ using std::replace_copy_if;
+ namespace ranges
+ {
+ using std::ranges::replace_copy;
+ using std::ranges::replace_copy_if;
+ using std::ranges::replace_copy_if_result;
+ using std::ranges::replace_copy_result;
+ }
+ using std::fill;
+ using std::fill_n;
+ namespace ranges
+ {
+ using std::ranges::fill;
+ using std::ranges::fill_n;
+ }
+ using std::generate;
+ using std::generate_n;
+ namespace ranges
+ {
+ using std::ranges::generate;
+ using std::ranges::generate_n;
+ }
+ using std::remove;
+ using std::remove_if;
+ namespace ranges
+ {
+ using std::ranges::remove;
+ using std::ranges::remove_if;
+ }
+ using std::remove_copy;
+ using std::remove_copy_if;
+ namespace ranges
+ {
+ using std::ranges::remove_copy;
+ using std::ranges::remove_copy_if;
+ using std::ranges::remove_copy_if_result;
+ using std::ranges::remove_copy_result;
+ }
+ using std::unique;
+ namespace ranges
+ {
+ using std::ranges::unique;
+ }
+ using std::unique_copy;
+ namespace ranges
+ {
+ using std::ranges::unique_copy;
+ using std::ranges::unique_copy_result;
+ }
+ using std::reverse;
+ namespace ranges
+ {
+ using std::ranges::reverse;
+ }
+ using std::reverse_copy;
+ namespace ranges
+ {
+ using std::ranges::reverse_copy;
+ using std::ranges::reverse_copy_result;
+ }
+ using std::rotate;
+ namespace ranges
+ {
+ using std::ranges::rotate;
+ }
+ using std::rotate_copy;
+ namespace ranges
+ {
+ using std::ranges::rotate_copy;
+ using std::ranges::rotate_copy_result;
+ }
+ using std::sample;
+ namespace ranges
+ {
+ using std::ranges::sample;
+ }
+ using std::shuffle;
+ namespace ranges
+ {
+ using std::ranges::shuffle;
+ }
+ using std::shift_left;
+ namespace ranges
+ {}
+ using std::shift_right;
+ namespace ranges
+ {}
+ using std::sort;
+ namespace ranges
+ {
+ using std::ranges::sort;
+ }
+ using std::stable_sort;
+ namespace ranges
+ {
+ using std::ranges::stable_sort;
+ }
+ using std::partial_sort;
+ namespace ranges
+ {
+ using std::ranges::partial_sort;
+ }
+ using std::partial_sort_copy;
+ namespace ranges
+ {
+ using std::ranges::partial_sort_copy;
+ using std::ranges::partial_sort_copy_result;
+ }
+ using std::is_sorted;
+ using std::is_sorted_until;
+ namespace ranges
+ {
+ using std::ranges::is_sorted;
+ using std::ranges::is_sorted_until;
+ }
+ using std::nth_element;
+ namespace ranges
+ {
+ using std::ranges::nth_element;
+ }
+ using std::lower_bound;
+ namespace ranges
+ {
+ using std::ranges::lower_bound;
+ }
+ using std::upper_bound;
+ namespace ranges
+ {
+ using std::ranges::upper_bound;
+ }
+ using std::equal_range;
+ namespace ranges
+ {
+ using std::ranges::equal_range;
+ }
+ using std::binary_search;
+ namespace ranges
+ {
+ using std::ranges::binary_search;
+ }
+ using std::is_partitioned;
+ namespace ranges
+ {
+ using std::ranges::is_partitioned;
+ }
+ using std::partition;
+ namespace ranges
+ {
+ using std::ranges::partition;
+ }
+ using std::stable_partition;
+ namespace ranges
+ {
+ using std::ranges::stable_partition;
+ }
+ using std::partition_copy;
+ namespace ranges
+ {
+ using std::ranges::partition_copy;
+ using std::ranges::partition_copy_result;
+ }
+ using std::partition_point;
+ namespace ranges
+ {
+ using std::ranges::partition_point;
+ }
+ using std::merge;
+ namespace ranges
+ {
+ using std::ranges::merge;
+ using std::ranges::merge_result;
+ }
+ using std::inplace_merge;
+ namespace ranges
+ {
+ using std::ranges::inplace_merge;
+ }
+ using std::includes;
+ namespace ranges
+ {
+ using std::ranges::includes;
+ }
+ using std::set_union;
+ namespace ranges
+ {
+ using std::ranges::set_union;
+ using std::ranges::set_union_result;
+ }
+ using std::set_intersection;
+ namespace ranges
+ {
+ using std::ranges::set_intersection;
+ using std::ranges::set_intersection_result;
+ }
+ using std::set_difference;
+ namespace ranges
+ {
+ using std::ranges::set_difference;
+ using std::ranges::set_difference_result;
+ }
+ using std::set_symmetric_difference;
+ namespace ranges
+ {
+ using std::ranges::set_symmetric_difference;
+ using std::ranges::set_symmetric_difference_result;
+ }
+ using std::push_heap;
+ namespace ranges
+ {
+ using std::ranges::push_heap;
+ }
+ using std::pop_heap;
+ namespace ranges
+ {
+ using std::ranges::pop_heap;
+ }
+ using std::make_heap;
+ namespace ranges
+ {
+ using std::ranges::make_heap;
+ }
+ using std::sort_heap;
+ namespace ranges
+ {
+ using std::ranges::sort_heap;
+ }
+ using std::is_heap;
+ namespace ranges
+ {
+ using std::ranges::is_heap;
+ }
+ using std::is_heap_until;
+ namespace ranges
+ {
+ using std::ranges::is_heap_until;
+ }
+ using std::min;
+ namespace ranges
+ {
+ using std::ranges::min;
+ }
+ using std::max;
+ namespace ranges
+ {
+ using std::ranges::max;
+ }
+ using std::minmax;
+ namespace ranges
+ {
+ using std::ranges::minmax;
+ using std::ranges::minmax_result;
+ }
+ using std::min_element;
+ namespace ranges
+ {
+ using std::ranges::min_element;
+ }
+ using std::max_element;
+ namespace ranges
+ {
+ using std::ranges::max_element;
+ }
+ using std::minmax_element;
+ namespace ranges
+ {
+ using std::ranges::minmax_element;
+ using std::ranges::minmax_element_result;
+ }
+ using std::clamp;
+ namespace ranges
+ {
+ using std::ranges::clamp;
+ }
+ using std::lexicographical_compare;
+ namespace ranges
+ {
+ using std::ranges::lexicographical_compare;
+ }
+ using std::lexicographical_compare_three_way;
+ using std::next_permutation;
+ namespace ranges
+ {
+ using std::ranges::next_permutation;
+ using std::ranges::next_permutation_result;
+ }
+ using std::prev_permutation;
+ namespace ranges
+ {
+ using std::ranges::prev_permutation;
+ using std::ranges::prev_permutation_result;
+ }
+}
+
+// 22.7.2 <any>
+#if __cpp_lib_any
+export namespace std
+{
+ using std::any;
+ using std::any_cast;
+ using std::bad_any_cast;
+ using std::make_any;
+ using std::swap;
+}
+#endif
+
+// 24.3.2 <array>
+export namespace std
+{
+ using std::array;
+ using std::operator==;
+ using std::operator<=>;
+ using std::get;
+ using std::swap;
+ using std::to_array;
+ using std::tuple_element;
+ using std::tuple_size;
+}
+
+// 33.5.2 <atomic>
+export namespace std
+{
+ using std::atomic;
+ using std::atomic_bool;
+ using std::atomic_char;
+ using std::atomic_char16_t;
+ using std::atomic_char32_t;
+ using std::atomic_char8_t;
+ using std::atomic_compare_exchange_strong;
+ using std::atomic_compare_exchange_strong_explicit;
+ using std::atomic_compare_exchange_weak;
+ using std::atomic_compare_exchange_weak_explicit;
+ using std::atomic_exchange;
+ using std::atomic_exchange_explicit;
+ using std::atomic_fetch_add;
+ using std::atomic_fetch_add_explicit;
+ using std::atomic_fetch_and;
+ using std::atomic_fetch_and_explicit;
+ using std::atomic_fetch_or;
+ using std::atomic_fetch_or_explicit;
+ using std::atomic_fetch_sub;
+ using std::atomic_fetch_sub_explicit;
+ using std::atomic_fetch_xor;
+ using std::atomic_fetch_xor_explicit;
+ using std::atomic_flag;
+ using std::atomic_flag_clear;
+ using std::atomic_flag_clear_explicit;
+ using std::atomic_flag_notify_all;
+ using std::atomic_flag_notify_one;
+ using std::atomic_flag_test;
+ using std::atomic_flag_test_and_set;
+ using std::atomic_flag_test_and_set_explicit;
+ using std::atomic_flag_test_explicit;
+ using std::atomic_flag_wait;
+ using std::atomic_flag_wait_explicit;
+ using std::atomic_init;
+ using std::atomic_int;
+ using std::atomic_int16_t;
+ using std::atomic_int32_t;
+ using std::atomic_int64_t;
+ using std::atomic_int8_t;
+ using std::atomic_int_fast16_t;
+ using std::atomic_int_fast32_t;
+ using std::atomic_int_fast64_t;
+ using std::atomic_int_fast8_t;
+ using std::atomic_int_least16_t;
+ using std::atomic_int_least32_t;
+ using std::atomic_int_least64_t;
+ using std::atomic_int_least8_t;
+ using std::atomic_intmax_t;
+ using std::atomic_intptr_t;
+ using std::atomic_is_lock_free;
+ using std::atomic_llong;
+ using std::atomic_load;
+ using std::atomic_load_explicit;
+ using std::atomic_long;
+ using std::atomic_notify_all;
+ using std::atomic_notify_one;
+ using std::atomic_ptrdiff_t;
+ using std::atomic_schar;
+ using std::atomic_short;
+ using std::atomic_signal_fence;
+ using std::atomic_signed_lock_free;
+ using std::atomic_size_t;
+ using std::atomic_store;
+ using std::atomic_store_explicit;
+ using std::atomic_thread_fence;
+ using std::atomic_uchar;
+ using std::atomic_uint;
+ using std::atomic_uint16_t;
+ using std::atomic_uint32_t;
+ using std::atomic_uint64_t;
+ using std::atomic_uint8_t;
+ using std::atomic_uint_fast16_t;
+ using std::atomic_uint_fast32_t;
+ using std::atomic_uint_fast64_t;
+ using std::atomic_uint_fast8_t;
+ using std::atomic_uint_least16_t;
+ using std::atomic_uint_least32_t;
+ using std::atomic_uint_least64_t;
+ using std::atomic_uint_least8_t;
+ using std::atomic_uintmax_t;
+ using std::atomic_uintptr_t;
+ using std::atomic_ullong;
+ using std::atomic_ulong;
+ using std::atomic_unsigned_lock_free;
+ using std::atomic_ushort;
+ using std::atomic_wait;
+ using std::atomic_wait_explicit;
+ using std::atomic_wchar_t;
+ using std::kill_dependency;
+ using std::memory_order;
+ using std::memory_order_acq_rel;
+ using std::memory_order_acquire;
+ using std::memory_order_consume;
+ using std::memory_order_relaxed;
+ using std::memory_order_release;
+ using std::memory_order_seq_cst;
+ // ATOMIC_*_LOCK_FREE not exported
+}
+
+// 33.9.3 <barrier>
+#if __cpp_lib_barrier
+export namespace std
+{
+ using std::barrier;
+}
+#endif
+
+// 22.15 <bit>
+export namespace std
+{
+ using std::bit_cast;
+ using std::bit_ceil;
+ using std::bit_floor;
+ using std::bit_width;
+ using std::countl_one;
+ using std::countl_zero;
+ using std::countr_one;
+ using std::countr_zero;
+ using std::endian;
+ using std::has_single_bit;
+ using std::popcount;
+ using std::rotl;
+ using std::rotr;
+}
+
+// 22.9 <bitset>
+#if __cpp_lib_bitset
+export namespace std
+{
+ using std::bitset;
+ using std::operator&;
+ using std::operator|;
+ using std::operator^;
+ using std::operator>>;
+ using std::operator<<;
+ using std::hash;
+}
+#endif
+
+// 22.13 <charconv>
+export namespace std
+{
+ using std::chars_format;
+ using std::operator&;
+ using std::operator&=;
+ using std::operator^;
+ using std::operator^=;
+ using std::operator|;
+ using std::operator|=;
+ using std::operator~;
+ using std::from_chars;
+ using std::from_chars_result;
+ using std::to_chars;
+ using std::to_chars_result;
+}
+
+// 29.2 <chrono>
+#if __cpp_lib_chrono
+export namespace std
+{
+ namespace chrono
+ {
+ using std::chrono::duration;
+ using std::chrono::time_point;
+ }
+ using std::common_type;
+ namespace chrono
+ {
+ using std::chrono::duration_values;
+ using std::chrono::treat_as_floating_point;
+ using std::chrono::treat_as_floating_point_v;
+ using std::chrono::operator+;
+ using std::chrono::operator-;
+ using std::chrono::operator*;
+ using std::chrono::operator/;
+ using std::chrono::operator%;
+ using std::chrono::operator==;
+ using std::chrono::operator<;
+ using std::chrono::operator>;
+ using std::chrono::operator<=;
+ using std::chrono::operator>=;
+ using std::chrono::operator<=>;
+ using std::chrono::ceil;
+ using std::chrono::duration_cast;
+ using std::chrono::floor;
+ using std::chrono::round;
+ using std::chrono::operator<<;
+ using std::chrono::abs;
+ using std::chrono::day;
+ using std::chrono::days;
+ using std::chrono::file_clock;
+ using std::chrono::file_time;
+ using std::chrono::hh_mm_ss;
+ using std::chrono::high_resolution_clock;
+ using std::chrono::hours;
+ using std::chrono::is_am;
+ using std::chrono::is_pm;
+ using std::chrono::last_spec;
+ using std::chrono::local_days;
+ using std::chrono::local_seconds;
+ using std::chrono::local_t;
+ using std::chrono::local_time;
+ using std::chrono::make12;
+ using std::chrono::make24;
+ using std::chrono::microseconds;
+ using std::chrono::milliseconds;
+ using std::chrono::minutes;
+ using std::chrono::month;
+ using std::chrono::month_day;
+ using std::chrono::month_day_last;
+ using std::chrono::month_weekday;
+ using std::chrono::month_weekday_last;
+ using std::chrono::months;
+ using std::chrono::nanoseconds;
+ using std::chrono::seconds;
+ using std::chrono::steady_clock;
+ using std::chrono::sys_days;
+ using std::chrono::sys_seconds;
+ using std::chrono::sys_time;
+ using std::chrono::system_clock;
+ using std::chrono::time_point_cast;
+ using std::chrono::weekday;
+ using std::chrono::weekday_indexed;
+ using std::chrono::weekday_last;
+ using std::chrono::weeks;
+ using std::chrono::year;
+ using std::chrono::year_month;
+ using std::chrono::year_month_day;
+ using std::chrono::year_month_day_last;
+ using std::chrono::year_month_weekday;
+ using std::chrono::year_month_weekday_last;
+ using std::chrono::years;
+ }
+ using std::formatter;
+ namespace chrono
+ {
+ using std::chrono::April;
+ using std::chrono::August;
+ using std::chrono::December;
+ using std::chrono::February;
+ using std::chrono::Friday;
+ using std::chrono::January;
+ using std::chrono::July;
+ using std::chrono::June;
+ using std::chrono::last;
+ using std::chrono::March;
+ using std::chrono::May;
+ using std::chrono::Monday;
+ using std::chrono::November;
+ using std::chrono::October;
+ using std::chrono::Saturday;
+ using std::chrono::September;
+ using std::chrono::Sunday;
+ using std::chrono::Thursday;
+ using std::chrono::Tuesday;
+ using std::chrono::Wednesday;
+ }
+}
+export namespace std::inline literals::inline chrono_literals
+{
+ using std::literals::chrono_literals::operator""h;
+ using std::literals::chrono_literals::operator""min;
+ using std::literals::chrono_literals::operator""s;
+ using std::literals::chrono_literals::operator""ms;
+ using std::literals::chrono_literals::operator""us;
+ using std::literals::chrono_literals::operator""ns;
+ using std::literals::chrono_literals::operator""d;
+ using std::literals::chrono_literals::operator""y;
+}
+#endif // __cpp_lib_chrono
+
+// <codecvt>: deprecated C++17, removed C++26
+export namespace std
+{
+ using std::codecvt_mode;
+ using std::codecvt_utf16;
+ using std::codecvt_utf8;
+ using std::codecvt_utf8_utf16;
+}
+
+// 17.11.1 <compare>
+#if __cpp_lib_three_way_comparison
+export namespace std
+{
+ using std::common_comparison_category;
+ using std::common_comparison_category_t;
+ using std::compare_three_way;
+ using std::compare_three_way_result;
+ using std::compare_three_way_result_t;
+ using std::is_eq;
+ using std::is_gt;
+ using std::is_gteq;
+ using std::is_lt;
+ using std::is_lteq;
+ using std::is_neq;
+ using std::partial_ordering;
+ using std::strong_ordering;
+ using std::three_way_comparable;
+ using std::three_way_comparable_with;
+ using std::weak_ordering;
+ using std::compare_partial_order_fallback;
+ using std::compare_strong_order_fallback;
+ using std::compare_weak_order_fallback;
+ using std::partial_order;
+ using std::strong_order;
+ using std::weak_order;
+}
+#endif // __cpp_lib_three_way_comparison
+
+// 28.4 <complex>
+export namespace std
+{
+ using std::complex;
+ using std::operator+;
+ using std::operator-;
+ using std::operator*;
+ using std::operator/;
+ using std::operator==;
+ using std::operator>>;
+ using std::operator<<;
+ using std::abs;
+ using std::acos;
+ using std::acosh;
+ using std::arg;
+ using std::asin;
+ using std::asinh;
+ using std::atan;
+ using std::atanh;
+ using std::conj;
+ using std::cos;
+ using std::cosh;
+ using std::exp;
+ using std::imag;
+ using std::log;
+ using std::log10;
+ using std::norm;
+ using std::polar;
+ using std::pow;
+ using std::proj;
+ using std::real;
+ using std::sin;
+ using std::sinh;
+ using std::sqrt;
+ using std::tan;
+ using std::tanh;
+ using std::operator""il;
+ using std::operator""i;
+ using std::operator""if;
+}
+
+// 18 <concepts>
+#if __cpp_lib_concepts
+export namespace std
+{
+ using std::assignable_from;
+ using std::common_reference_with;
+ using std::common_with;
+ using std::convertible_to;
+ using std::derived_from;
+ using std::floating_point;
+ using std::integral;
+ using std::same_as;
+ using std::signed_integral;
+ using std::unsigned_integral;
+ namespace ranges
+ {
+ using std::ranges::swap;
+ }
+ using std::constructible_from;
+ using std::copy_constructible;
+ using std::copyable;
+ using std::default_initializable;
+ using std::destructible;
+ using std::equality_comparable;
+ using std::equality_comparable_with;
+ using std::equivalence_relation;
+ using std::invocable;
+ using std::movable;
+ using std::move_constructible;
+ using std::predicate;
+ using std::regular;
+ using std::regular_invocable;
+ using std::relation;
+ using std::semiregular;
+ using std::strict_weak_order;
+ using std::swappable;
+ using std::swappable_with;
+ using std::totally_ordered;
+ using std::totally_ordered_with;
+}
+#endif
+
+// 33.7 <condition_variable>
+export namespace std
+{
+ using std::condition_variable;
+ using std::condition_variable_any;
+ using std::cv_status;
+ using std::notify_all_at_thread_exit;
+}
+
+// 17.12.2 <coroutine>
+#if __cpp_lib_coroutine
+export namespace std
+{
+ using std::coroutine_handle;
+ using std::coroutine_traits;
+ using std::operator==;
+ using std::operator<=>;
+ using std::hash;
+ using std::noop_coroutine;
+ using std::noop_coroutine_handle;
+ using std::noop_coroutine_promise;
+ using std::suspend_always;
+ using std::suspend_never;
+}
+#endif // __cpp_lib_coroutine
+
+// 22.16 <debugging>
+#if __cpp_lib_debugging
+export namespace std
+{
+ using std::breakpoint;
+ using std::breakpoint_if_debugging;
+ using std::is_debugger_present;
+}
+#endif
+
+// 24.3 <deque>
+export namespace std
+{
+ using std::deque;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::deque;
+ }
+}
+
+// 17.9.2 <exception>
+export namespace std
+{
+ using std::bad_exception;
+ using std::current_exception;
+ using std::exception;
+ using std::exception_ptr;
+ using std::get_terminate;
+ using std::make_exception_ptr;
+ using std::nested_exception;
+ using std::rethrow_exception;
+ using std::rethrow_if_nested;
+ using std::set_terminate;
+ using std::terminate;
+ using std::terminate_handler;
+ using std::throw_with_nested;
+ using std::uncaught_exception;
+ using std::uncaught_exceptions;
+}
+
+// 34.4 <execution>
+#if __cpp_lib_execution
+export namespace std
+{
+ using std::is_execution_policy;
+ using std::is_execution_policy_v;
+ namespace execution
+ {
+ using std::execution::sequenced_policy;
+ using std::execution::parallel_policy;
+ using std::execution::parallel_unsequenced_policy;
+ using std::execution::unsequenced_policy;
+ using std::execution::seq;
+ using std::execution::par;
+ using std::execution::par_unseq;
+ using std::execution::unseq;
+ }
+#if __cpp_lib_senders
+ using std::forwarding_query_t;
+ using std::get_allocator_t;
+ using std::get_stop_token_t;
+ using std::forwarding_query;
+ using std::get_allocator;
+ using std::get_stop_token;
+ using std::stop_token_of_t;
+ namespace execution
+ {
+ using std::execution::get_domain_t;
+ using std::execution::get_scheduler_t;
+ using std::execution::get_delegation_scheduler_t;
+ using std::execution::get_forward_progress_guarantee_t;
+ using std::execution::get_completion_scheduler_t;
+ using std::execution::get_domain;
+ using std::execution::get_scheduler;
+ using std::execution::get_delegation_scheduler;
+ using std::execution::forward_progress_guarantee;
+ using std::execution::get_forward_progress_guarantee;
+ using std::execution::get_completion_scheduler;
+ using std::execution::empty_env;
+ using std::execution::get_env_t;
+ using std::execution::get_env;
+ using std::execution::env_of_t;
+ using std::execution::default_domain;
+ using std::execution::scheduler_t;
+ using std::execution::scheduler;
+ using std::execution::receiver_t;
+ using std::execution::receiver;
+ using std::execution::receiver_of;
+ using std::execution::set_value_t;
+ using std::execution::set_error_t;
+ using std::execution::set_stopped_t;
+ using std::execution::set_value;
+ using std::execution::set_error;
+ using std::execution::set_stopped;
+ using std::execution::operation_state_t;
+ using std::execution::operation_state;
+ using std::execution::start_t;
+ using std::execution::start;
+ using std::execution::sender_t;
+ using std::execution::sender;
+ using std::execution::sender_in;
+ using std::execution::sender_to;
+ using std::execution::get_completion_signatures_t;
+ using std::execution::get_completion_signatures;
+ using std::execution::completion_signatures_of_t;
+ using std::execution::value_types_of_t;
+ using std::execution::error_types_of_t;
+ using std::execution::sends_stopped;
+ using std::execution::tag_of_t;
+ using std::execution::transform_sender;
+ using std::execution::transform_env;
+ using std::execution::apply_sender;
+ using std::execution::connect_t;
+ using std::execution::connect;
+ using std::execution::connect_result_t;
+ using std::execution::just_t;
+ using std::execution::just_error_t;
+ using std::execution::just_stopped_t;
+ using std::execution::schedule_t;
+ using std::execution::just;
+ using std::execution::just_error;
+ using std::execution::just_stopped;
+ using std::execution::schedule;
+ using std::execution::read_env;
+ using std::execution::schedule_result_t;
+ using std::execution::sender_adaptor_closure;
+ using std::execution::starts_on_t;
+ using std::execution::continues_on_t;
+ using std::execution::on_t;
+ using std::execution::schedule_from_t;
+ using std::execution::then_t;
+ using std::execution::upon_error_t;
+ using std::execution::upon_stopped_t;
+ using std::execution::let_value_t;
+ using std::execution::let_error_t;
+ using std::execution::let_stopped_t;
+ using std::execution::bulk_t;
+ using std::execution::split_t;
+ using std::execution::when_all_t;
+ using std::execution::when_all_with_variant_t;
+ using std::execution::into_variant_t;
+ using std::execution::stopped_as_optional_t;
+ using std::execution::stopped_as_error_t;
+ using std::execution::starts_on;
+ using std::execution::continues_on;
+ using std::execution::on;
+ using std::execution::schedule_from;
+ using std::execution::then;
+ using std::execution::upon_error;
+ using std::execution::upon_stopped;
+ using std::execution::let_value;
+ using std::execution::let_error;
+ using std::execution::let_stopped;
+ using std::execution::bulk;
+ using std::execution::split;
+ using std::execution::when_all;
+ using std::execution::when_all_with_variant;
+ using std::execution::into_variant;
+ using std::execution::stopped_as_optional;
+ using std::execution::stopped_as_error;
+ using std::execution::completion_signatures;
+ using std::execution::transform_completion_signatures;
+ using std::execution::transform_completion_signatures_of;
+ using std::execution::run_loop;
+ }
+ namespace this_thread
+ {
+ using std::this_thread::sync_wait_t;
+ using std::this_thread::sync_wait_with_variant_t;
+ using std::this_thread::sync_wait;
+ using std::this_thread::sync_wait_with_variant;
+ }
+#endif // __cpp_lib_senders
+}
+#endif // __cpp_lib_execution
+
+// 22.8 <expected>
+#if __cpp_lib_expected
+export namespace std
+{
+ using std::unexpected;
+ using std::bad_expected_access;
+ using std::unexpect_t;
+ using std::unexpect;
+ using std::expected;
+}
+#endif
+
+// <filesystem>
+#if __cpp_lib_filesystem
+export namespace std::filesystem
+{
+ using std::filesystem::begin;
+ using std::filesystem::copy_options;
+ using std::filesystem::directory_entry;
+ using std::filesystem::directory_iterator;
+ using std::filesystem::directory_options;
+ using std::filesystem::end;
+ using std::filesystem::file_status;
+ using std::filesystem::file_time_type;
+ using std::filesystem::file_type;
+ using std::filesystem::filesystem_error;
+ using std::filesystem::hash_value;
+ using std::filesystem::path;
+ using std::filesystem::perm_options;
+ using std::filesystem::perms;
+ using std::filesystem::recursive_directory_iterator;
+ using std::filesystem::space_info;
+ using std::filesystem::swap;
+ using std::filesystem::operator&;
+ using std::filesystem::operator&=;
+ using std::filesystem::operator^;
+ using std::filesystem::operator^=;
+ using std::filesystem::operator|;
+ using std::filesystem::operator|=;
+ using std::filesystem::operator~;
+ using std::filesystem::absolute;
+ using std::filesystem::canonical;
+ using std::filesystem::copy;
+ using std::filesystem::copy_file;
+ using std::filesystem::copy_symlink;
+ using std::filesystem::create_directories;
+ using std::filesystem::create_directory;
+ using std::filesystem::create_directory_symlink;
+ using std::filesystem::create_hard_link;
+ using std::filesystem::create_symlink;
+ using std::filesystem::current_path;
+ using std::filesystem::equivalent;
+ using std::filesystem::exists;
+ using std::filesystem::file_size;
+ using std::filesystem::hard_link_count;
+ using std::filesystem::is_block_file;
+ using std::filesystem::is_character_file;
+ using std::filesystem::is_directory;
+ using std::filesystem::is_empty;
+ using std::filesystem::is_fifo;
+ using std::filesystem::is_other;
+ using std::filesystem::is_regular_file;
+ using std::filesystem::is_socket;
+ using std::filesystem::is_symlink;
+ using std::filesystem::last_write_time;
+ using std::filesystem::permissions;
+ using std::filesystem::proximate;
+ using std::filesystem::read_symlink;
+ using std::filesystem::relative;
+ using std::filesystem::remove;
+ using std::filesystem::remove_all;
+ using std::filesystem::rename;
+ using std::filesystem::resize_file;
+ using std::filesystem::space;
+ using std::filesystem::status;
+ using std::filesystem::status_known;
+ using std::filesystem::symlink_status;
+ using std::filesystem::temp_directory_path;
+ using std::filesystem::u8path;
+ using std::filesystem::weakly_canonical;
+}
+#endif // __cpp_lib_filesystem
+
+// <flat_map>
+
+// <flat_set>
+
+// <format>
+export namespace std
+{
+ using std::basic_format_arg;
+ using std::basic_format_args;
+ using std::basic_format_context;
+ using std::basic_format_parse_context;
+ using std::basic_format_string;
+ using std::format;
+ using std::format_args;
+ using std::format_context;
+ using std::format_error;
+ using std::format_parse_context;
+ using std::format_string;
+ using std::format_to;
+ using std::format_to_n;
+ using std::format_to_n_result;
+ using std::formatted_size;
+ using std::formatter;
+ using std::make_format_args;
+ using std::make_wformat_args;
+ using std::vformat;
+ using std::vformat_to;
+ using std::visit_format_arg;
+ using std::wformat_args;
+ using std::wformat_context;
+ using std::wformat_parse_context;
+ using std::wformat_string;
+}
+
+// <forward_list>
+export namespace std
+{
+ using std::forward_list;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::forward_list;
+ }
+}
+
+// <fstream>
+export namespace std
+{
+ using std::basic_filebuf;
+ using std::basic_fstream;
+ using std::basic_ifstream;
+ using std::basic_ofstream;
+ using std::filebuf;
+ using std::fstream;
+ using std::ifstream;
+ using std::ofstream;
+ using std::swap;
+ using std::wfilebuf;
+ using std::wfstream;
+ using std::wifstream;
+ using std::wofstream;
+}
+
+// <functional>
+export namespace std
+{
+ using std::bind;
+ using std::bind_front;
+ using std::bit_and;
+ using std::bit_not;
+ using std::bit_or;
+ using std::bit_xor;
+ using std::compare_three_way;
+ using std::cref;
+ using std::divides;
+ using std::equal_to;
+ using std::greater;
+ using std::greater_equal;
+ using std::identity;
+ using std::invoke;
+ using std::is_bind_expression;
+ using std::is_bind_expression_v;
+ using std::is_placeholder;
+ using std::is_placeholder_v;
+ using std::less;
+ using std::less_equal;
+ using std::logical_and;
+ using std::logical_not;
+ using std::logical_or;
+ using std::minus;
+ using std::modulus;
+ using std::multiplies;
+ using std::negate;
+ using std::not_equal_to;
+ using std::not_fn;
+ using std::plus;
+ using std::ref;
+ using std::reference_wrapper;
+ namespace placeholders
+ {
+ using std::placeholders::_1;
+ using std::placeholders::_10;
+ using std::placeholders::_2;
+ using std::placeholders::_3;
+ using std::placeholders::_4;
+ using std::placeholders::_5;
+ using std::placeholders::_6;
+ using std::placeholders::_7;
+ using std::placeholders::_8;
+ using std::placeholders::_9;
+ }
+ using std::bad_function_call;
+ using std::function;
+ using std::mem_fn;
+ using std::swap;
+ using std::operator==;
+ using std::boyer_moore_horspool_searcher;
+ using std::boyer_moore_searcher;
+ using std::default_searcher;
+ using std::hash;
+ namespace ranges
+ {
+ using std::ranges::equal_to;
+ using std::ranges::greater;
+ using std::ranges::greater_equal;
+ using std::ranges::less;
+ using std::ranges::less_equal;
+ using std::ranges::not_equal_to;
+ }
+}
+
+// <future>
+export namespace std
+{
+ using std::future_errc;
+ using std::future_status;
+ using std::launch;
+ using std::operator&;
+ using std::operator&=;
+ using std::operator^;
+ using std::operator^=;
+ using std::operator|;
+ using std::operator|=;
+ using std::operator~;
+ using std::async;
+ using std::future;
+ using std::future_category;
+ using std::future_error;
+ using std::is_error_code_enum;
+ using std::make_error_code;
+ using std::make_error_condition;
+ using std::packaged_task;
+ using std::promise;
+ using std::shared_future;
+ using std::swap;
+ using std::uses_allocator;
+}
+
+// <generator> FIXME
+
+// <hazard_pointer> FIXME
+
+// 17.10.2 <initializer_list>
+export namespace std
+{
+ using std::begin;
+ using std::end;
+ using std::initializer_list;
+}
+
+// <inplace_vector> FIXME
+
+// <iomanip>
+export namespace std
+{
+ using std::get_money;
+ using std::get_time;
+ using std::put_money;
+ using std::put_time;
+ using std::quoted;
+ using std::resetiosflags;
+ using std::setbase;
+ using std::setfill;
+ using std::setiosflags;
+ using std::setprecision;
+ using std::setw;
+}
+
+// <ios>
+export namespace std
+{
+ using std::fpos;
+ using std::operator!=;
+ using std::operator-;
+ using std::operator==;
+ using std::basic_ios;
+ using std::boolalpha;
+ using std::dec;
+ using std::defaultfloat;
+ using std::fixed;
+ using std::hex;
+ using std::hexfloat;
+ using std::internal;
+ using std::io_errc;
+ using std::ios;
+ using std::ios_base;
+ using std::iostream_category;
+ using std::is_error_code_enum;
+ using std::left;
+ using std::make_error_code;
+ using std::make_error_condition;
+ using std::noboolalpha;
+ using std::noshowbase;
+ using std::noshowpoint;
+ using std::noshowpos;
+ using std::noskipws;
+ using std::nounitbuf;
+ using std::nouppercase;
+ using std::oct;
+ using std::right;
+ using std::scientific;
+ using std::showbase;
+ using std::showpoint;
+ using std::showpos;
+ using std::skipws;
+ using std::streamoff;
+ using std::streamsize;
+ using std::unitbuf;
+ using std::uppercase;
+ using std::wios;
+}
+
+// <iosfwd>
+export namespace std
+{
+ using std::streampos;
+ using std::u16streampos;
+ using std::u32streampos;
+ using std::u8streampos;
+ using std::wstreampos;
+ using std::basic_osyncstream;
+ using std::basic_syncbuf;
+ using std::istreambuf_iterator;
+ using std::ostreambuf_iterator;
+ using std::osyncstream;
+ using std::syncbuf;
+ using std::wosyncstream;
+ using std::wsyncbuf;
+ using std::fpos;
+}
+
+// <iostream>
+export namespace std
+{
+ using std::cerr;
+ using std::cin;
+ using std::clog;
+ using std::cout;
+ using std::wcerr;
+ using std::wcin;
+ using std::wclog;
+ using std::wcout;
+}
+
+// <istream>
+export namespace std
+{
+ using std::basic_iostream;
+ using std::basic_istream;
+ using std::iostream;
+ using std::istream;
+ using std::wiostream;
+ using std::wistream;
+ using std::ws;
+ using std::operator>>;
+}
+
+// <iterator>
+export namespace std
+{
+ using std::incrementable_traits;
+ using std::indirectly_readable_traits;
+ using std::iter_difference_t;
+ using std::iter_reference_t;
+ using std::iter_value_t;
+ using std::iterator_traits;
+ namespace ranges
+ {
+ using std::ranges::iter_move;
+ using std::ranges::iter_swap;
+ }
+ using std::advance;
+ using std::bidirectional_iterator;
+ using std::bidirectional_iterator_tag;
+ using std::contiguous_iterator;
+ using std::contiguous_iterator_tag;
+ using std::disable_sized_sentinel_for;
+ using std::distance;
+ using std::forward_iterator;
+ using std::forward_iterator_tag;
+ using std::incrementable;
+ using std::indirect_binary_predicate;
+ using std::indirect_equivalence_relation;
+ using std::indirect_result_t;
+ using std::indirect_strict_weak_order;
+ using std::indirect_unary_predicate;
+ using std::indirectly_comparable;
+ using std::indirectly_copyable;
+ using std::indirectly_copyable_storable;
+ using std::indirectly_movable;
+ using std::indirectly_movable_storable;
+ using std::indirectly_readable;
+ using std::indirectly_regular_unary_invocable;
+ using std::indirectly_swappable;
+ using std::indirectly_unary_invocable;
+ using std::indirectly_writable;
+ using std::input_iterator;
+ using std::input_iterator_tag;
+ using std::input_or_output_iterator;
+ using std::iter_common_reference_t;
+ using std::iter_rvalue_reference_t;
+ using std::mergeable;
+ using std::next;
+ using std::output_iterator;
+ using std::output_iterator_tag;
+ using std::permutable;
+ using std::prev;
+ using std::projected;
+ using std::random_access_iterator;
+ using std::random_access_iterator_tag;
+ using std::sentinel_for;
+ using std::sized_sentinel_for;
+ using std::sortable;
+ using std::weakly_incrementable;
+ namespace ranges
+ {
+ using std::ranges::advance;
+ using std::ranges::distance;
+ using std::ranges::next;
+ using std::ranges::prev;
+ }
+ using std::reverse_iterator;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::operator-;
+ using std::operator+;
+ using std::back_insert_iterator;
+ using std::back_inserter;
+ using std::begin;
+ using std::cbegin;
+ using std::cend;
+ using std::common_iterator;
+ using std::counted_iterator;
+ using std::crbegin;
+ using std::crend;
+ using std::data;
+ using std::default_sentinel;
+ using std::default_sentinel_t;
+ using std::empty;
+ using std::end;
+ using std::front_insert_iterator;
+ using std::front_inserter;
+ using std::insert_iterator;
+ using std::inserter;
+ using std::istream_iterator;
+ using std::istreambuf_iterator;
+ using std::iterator;
+ using std::make_move_iterator;
+ using std::make_reverse_iterator;
+ using std::move_iterator;
+ using std::move_sentinel;
+ using std::ostream_iterator;
+ using std::ostreambuf_iterator;
+ using std::rbegin;
+ using std::rend;
+ using std::size;
+ using std::ssize;
+ using std::unreachable_sentinel;
+ using std::unreachable_sentinel_t;
+}
+
+// <latch>
+export namespace std
+{
+ using std::latch;
+}
+
+// 17.3.3 <limits> [limits.syn]
+export namespace std
+{
+ using std::float_denorm_style; // deprecated in C++23
+ using std::float_round_style;
+ using std::numeric_limits;
+}
+
+// FIXME <linalg>
+
+// <list>
+export namespace std
+{
+ using std::list;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::list;
+ }
+}
+
+// <locale>
+export namespace std
+{
+ using std::codecvt;
+ using std::codecvt_base;
+ using std::codecvt_byname;
+ using std::collate;
+ using std::collate_byname;
+ using std::ctype;
+ using std::ctype_base;
+ using std::ctype_byname;
+ using std::has_facet;
+ using std::isalnum;
+ using std::isalpha;
+ using std::isblank;
+ using std::iscntrl;
+ using std::isdigit;
+ using std::isgraph;
+ using std::islower;
+ using std::isprint;
+ using std::ispunct;
+ using std::isspace;
+ using std::isupper;
+ using std::isxdigit;
+ using std::locale;
+ using std::messages;
+ using std::messages_base;
+ using std::messages_byname;
+ using std::money_base;
+ using std::money_get;
+ using std::money_put;
+ using std::moneypunct;
+ using std::moneypunct_byname;
+ using std::num_get;
+ using std::num_put;
+ using std::numpunct;
+ using std::numpunct_byname;
+ using std::time_base;
+ using std::time_get;
+ using std::time_get_byname;
+ using std::time_put;
+ using std::time_put_byname;
+ using std::tolower;
+ using std::toupper;
+ using std::use_facet;
+ using std::wbuffer_convert;
+ using std::wstring_convert;
+}
+
+// <map>
+export namespace std
+{
+ using std::map;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase_if;
+ using std::multimap;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::map;
+ using std::pmr::multimap;
+ }
+}
+
+// FIXME <mdspan>
+
+// 20.2 <memory>
+export namespace std
+{
+ using std::align;
+ using std::allocator;
+ using std::allocator_arg;
+ using std::allocator_arg_t;
+ using std::allocator_traits;
+ using std::assume_aligned;
+ using std::make_obj_using_allocator;
+ using std::pointer_traits;
+ using std::to_address;
+ using std::uninitialized_construct_using_allocator;
+ using std::uses_allocator;
+ using std::uses_allocator_construction_args;
+ using std::uses_allocator_v;
+ using std::operator==;
+ using std::addressof;
+ using std::uninitialized_default_construct;
+ using std::uninitialized_default_construct_n;
+ namespace ranges
+ {
+ using std::ranges::uninitialized_default_construct;
+ using std::ranges::uninitialized_default_construct_n;
+ }
+ using std::uninitialized_value_construct;
+ using std::uninitialized_value_construct_n;
+ namespace ranges
+ {
+ using std::ranges::uninitialized_value_construct;
+ using std::ranges::uninitialized_value_construct_n;
+ }
+ using std::uninitialized_copy;
+ using std::uninitialized_copy_n;
+ namespace ranges
+ {
+ using std::ranges::uninitialized_copy;
+ using std::ranges::uninitialized_copy_n;
+ using std::ranges::uninitialized_copy_n_result;
+ using std::ranges::uninitialized_copy_result;
+ }
+ using std::uninitialized_move;
+ using std::uninitialized_move_n;
+ namespace ranges
+ {
+ using std::ranges::uninitialized_move;
+ using std::ranges::uninitialized_move_n;
+ using std::ranges::uninitialized_move_n_result;
+ using std::ranges::uninitialized_move_result;
+ }
+ using std::uninitialized_fill;
+ using std::uninitialized_fill_n;
+ namespace ranges
+ {
+ using std::ranges::uninitialized_fill;
+ using std::ranges::uninitialized_fill_n;
+ }
+ using std::construct_at;
+ namespace ranges
+ {
+ using std::ranges::construct_at;
+ }
+ using std::destroy;
+ using std::destroy_at;
+ using std::destroy_n;
+ namespace ranges
+ {
+ using std::ranges::destroy;
+ using std::ranges::destroy_at;
+ using std::ranges::destroy_n;
+ }
+ using std::default_delete;
+ using std::make_unique;
+ using std::make_unique_for_overwrite;
+ using std::unique_ptr;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::operator<<;
+ using std::allocate_shared;
+ using std::allocate_shared_for_overwrite;
+ using std::bad_weak_ptr;
+ using std::const_pointer_cast;
+ using std::dynamic_pointer_cast;
+ using std::make_shared;
+ using std::make_shared_for_overwrite;
+ using std::reinterpret_pointer_cast;
+ using std::shared_ptr;
+ using std::static_pointer_cast;
+ using std::swap;
+ using std::get_deleter;
+ using std::atomic_compare_exchange_strong;
+ using std::atomic_compare_exchange_strong_explicit;
+ using std::atomic_compare_exchange_weak;
+ using std::atomic_compare_exchange_weak_explicit;
+ using std::atomic_exchange;
+ using std::atomic_exchange_explicit;
+ using std::atomic_is_lock_free;
+ using std::atomic_load;
+ using std::atomic_load_explicit;
+ using std::atomic_store;
+ using std::atomic_store_explicit;
+ using std::enable_shared_from_this;
+ using std::hash;
+ using std::owner_less;
+ using std::weak_ptr;
+}
+
+// 20.4 <memory_resource>
+export namespace std::pmr
+{
+ using std::pmr::memory_resource;
+ using std::pmr::operator==;
+ using std::pmr::get_default_resource;
+ using std::pmr::monotonic_buffer_resource;
+ using std::pmr::new_delete_resource;
+ using std::pmr::null_memory_resource;
+ using std::pmr::polymorphic_allocator;
+ using std::pmr::pool_options;
+ using std::pmr::set_default_resource;
+ using std::pmr::synchronized_pool_resource;
+ using std::pmr::unsynchronized_pool_resource;
+}
+
+// <mutex>
+export namespace std
+{
+ using std::adopt_lock;
+ using std::adopt_lock_t;
+ using std::call_once;
+ using std::defer_lock;
+ using std::defer_lock_t;
+ using std::lock;
+ using std::lock_guard;
+ using std::mutex;
+ using std::once_flag;
+ using std::recursive_mutex;
+ using std::recursive_timed_mutex;
+ using std::scoped_lock;
+ using std::swap;
+ using std::timed_mutex;
+ using std::try_lock;
+ using std::try_to_lock;
+ using std::try_to_lock_t;
+ using std::unique_lock;
+}
+
+// 17.6.2 <new> [new.syn]
+export namespace std
+{
+ using std::align_val_t;
+ using std::bad_alloc;
+ using std::bad_array_new_length;
+ using std::destroying_delete;
+ using std::destroying_delete_t;
+ using std::get_new_handler;
+ using std::hardware_destructive_interference_size;
+ using std::hardware_constructive_interference_size;
+ using std::launder;
+ using std::new_handler;
+ using std::nothrow;
+ using std::nothrow_t;
+ using std::set_new_handler;
+}
+export
+{
+ using ::operator new;
+ using ::operator delete;
+ using ::operator new[];
+ using ::operator delete[];
+}
+
+// <numbers>
+export namespace std::numbers
+{
+ using std::numbers::e;
+ using std::numbers::e_v;
+ using std::numbers::egamma;
+ using std::numbers::egamma_v;
+ using std::numbers::inv_pi;
+ using std::numbers::inv_pi_v;
+ using std::numbers::inv_sqrt3;
+ using std::numbers::inv_sqrt3_v;
+ using std::numbers::inv_sqrtpi;
+ using std::numbers::inv_sqrtpi_v;
+ using std::numbers::ln10;
+ using std::numbers::ln10_v;
+ using std::numbers::ln2;
+ using std::numbers::ln2_v;
+ using std::numbers::log10e;
+ using std::numbers::log10e_v;
+ using std::numbers::log2e;
+ using std::numbers::log2e_v;
+ using std::numbers::phi;
+ using std::numbers::phi_v;
+ using std::numbers::pi;
+ using std::numbers::pi_v;
+ using std::numbers::sqrt2;
+ using std::numbers::sqrt2_v;
+ using std::numbers::sqrt3;
+ using std::numbers::sqrt3_v;
+}
+
+// <numeric>
+export namespace std
+{
+ using std::accumulate;
+ using std::adjacent_difference;
+ using std::exclusive_scan;
+ using std::inclusive_scan;
+ using std::inner_product;
+ using std::iota;
+ using std::partial_sum;
+ using std::reduce;
+ using std::transform_exclusive_scan;
+ using std::transform_inclusive_scan;
+ using std::transform_reduce;
+ using std::gcd;
+ using std::lcm;
+ using std::midpoint;
+}
+
+// <optional>
+export namespace std
+{
+ using std::bad_optional_access;
+ using std::nullopt;
+ using std::nullopt_t;
+ using std::optional;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::hash;
+ using std::make_optional;
+ using std::swap;
+}
+
+// <ostream>
+export namespace std
+{
+ using std::basic_ostream;
+ using std::endl;
+ using std::ends;
+ using std::flush;
+ using std::ostream;
+ using std::wostream;
+ using std::operator<<;
+}
+
+// FIXME <print>
+
+// <queue>
+export namespace std
+{
+ using std::queue;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::priority_queue;
+ using std::swap;
+ using std::uses_allocator;
+}
+
+// <random>
+export namespace std
+{
+ using std::bernoulli_distribution;
+ using std::binomial_distribution;
+ using std::cauchy_distribution;
+ using std::chi_squared_distribution;
+ using std::default_random_engine;
+ using std::discard_block_engine;
+ using std::discrete_distribution;
+ using std::exponential_distribution;
+ using std::extreme_value_distribution;
+ using std::fisher_f_distribution;
+ using std::gamma_distribution;
+ using std::generate_canonical;
+ using std::geometric_distribution;
+ using std::independent_bits_engine;
+ using std::knuth_b;
+ using std::linear_congruential_engine;
+ using std::lognormal_distribution;
+ using std::mersenne_twister_engine;
+ using std::minstd_rand;
+ using std::minstd_rand0;
+ using std::mt19937;
+ using std::mt19937_64;
+ using std::negative_binomial_distribution;
+ using std::normal_distribution;
+ using std::piecewise_constant_distribution;
+ using std::piecewise_linear_distribution;
+ using std::poisson_distribution;
+ using std::random_device;
+ using std::ranlux24;
+ using std::ranlux24_base;
+ using std::ranlux48;
+ using std::ranlux48_base;
+ using std::seed_seq;
+ using std::shuffle_order_engine;
+ using std::student_t_distribution;
+ using std::subtract_with_carry_engine;
+ using std::uniform_int_distribution;
+ using std::uniform_random_bit_generator;
+ using std::uniform_real_distribution;
+ using std::weibull_distribution;
+}
+
+// <ranges>
+export namespace std
+{
+ namespace ranges
+ {
+ using std::ranges::begin;
+ using std::ranges::cbegin;
+ using std::ranges::cdata;
+ using std::ranges::cend;
+ using std::ranges::crbegin;
+ using std::ranges::crend;
+ using std::ranges::data;
+ using std::ranges::empty;
+ using std::ranges::end;
+ using std::ranges::rbegin;
+ using std::ranges::rend;
+ using std::ranges::size;
+ using std::ranges::ssize;
+ using std::ranges::bidirectional_range;
+ using std::ranges::borrowed_range;
+ using std::ranges::common_range;
+ using std::ranges::contiguous_range;
+ using std::ranges::disable_sized_range;
+ using std::ranges::enable_borrowed_range;
+ using std::ranges::enable_view;
+ using std::ranges::forward_range;
+ using std::ranges::get;
+ using std::ranges::input_range;
+ using std::ranges::iterator_t;
+ using std::ranges::output_range;
+ using std::ranges::random_access_range;
+ using std::ranges::range;
+ using std::ranges::range_common_reference_t;
+ using std::ranges::range_difference_t;
+ using std::ranges::range_reference_t;
+ using std::ranges::range_rvalue_reference_t;
+ using std::ranges::range_size_t;
+ using std::ranges::range_value_t;
+ using std::ranges::sentinel_t;
+ using std::ranges::sized_range;
+ using std::ranges::subrange;
+ using std::ranges::subrange_kind;
+ using std::ranges::view;
+ using std::ranges::view_base;
+ using std::ranges::view_interface;
+ using std::ranges::viewable_range;
+ }
+ using std::ranges::get;
+ namespace ranges
+ {
+ using std::ranges::borrowed_iterator_t;
+ using std::ranges::borrowed_subrange_t;
+ using std::ranges::dangling;
+ using std::ranges::empty_view;
+ namespace views
+ {
+ using std::ranges::views::empty;
+ }
+ using std::ranges::single_view;
+ namespace views
+ {
+ using std::ranges::views::single;
+ }
+ using std::ranges::iota_view;
+ namespace views
+ {
+ using std::ranges::views::iota;
+ }
+ using std::ranges::basic_istream_view;
+ using std::ranges::istream_view;
+ using std::ranges::wistream_view;
+ namespace views
+ {
+ using std::ranges::views::istream;
+ }
+ namespace views
+ {
+ using std::ranges::views::all;
+ using std::ranges::views::all_t;
+ }
+ using std::ranges::filter_view;
+ using std::ranges::owning_view;
+ using std::ranges::ref_view;
+ namespace views
+ {
+ using std::ranges::views::filter;
+ }
+ using std::ranges::transform_view;
+ namespace views
+ {
+ using std::ranges::views::transform;
+ }
+ using std::ranges::take_view;
+ namespace views
+ {
+ using std::ranges::views::take;
+ }
+ using std::ranges::take_while_view;
+ namespace views
+ {
+ using std::ranges::views::take_while;
+ }
+ using std::ranges::drop_view;
+ namespace views
+ {
+ using std::ranges::views::drop;
+ }
+ using std::ranges::drop_while_view;
+ namespace views
+ {
+ using std::ranges::views::drop_while;
+ }
+ using std::ranges::join_view;
+ namespace views
+ {
+ using std::ranges::views::join;
+ }
+ using std::ranges::lazy_split_view;
+ using std::ranges::split_view;
+ namespace views
+ {
+ using std::ranges::views::lazy_split;
+ using std::ranges::views::split;
+ }
+ namespace views
+ {
+ using std::ranges::views::counted;
+ }
+ using std::ranges::common_view;
+ namespace views
+ {
+ using std::ranges::views::common;
+ }
+ using std::ranges::reverse_view;
+ namespace views
+ {
+ using std::ranges::views::reverse;
+ }
+ using std::ranges::elements_view;
+ using std::ranges::keys_view;
+ using std::ranges::values_view;
+ namespace views
+ {
+ using std::ranges::views::elements;
+ using std::ranges::views::keys;
+ using std::ranges::views::values;
+ }
+ }
+ namespace views = ranges::views;
+ using std::tuple_element;
+ using std::tuple_size;
+}
+
+// <ratio>
+export namespace std
+{
+ using std::atto;
+ using std::centi;
+ using std::deca;
+ using std::deci;
+ using std::exa;
+ using std::femto;
+ using std::giga;
+ using std::hecto;
+ using std::kilo;
+ using std::mega;
+ using std::micro;
+ using std::milli;
+ using std::nano;
+ using std::peta;
+ using std::pico;
+ using std::ratio;
+ using std::ratio_add;
+ using std::ratio_divide;
+ using std::ratio_equal;
+ using std::ratio_equal_v;
+ using std::ratio_greater;
+ using std::ratio_greater_equal;
+ using std::ratio_greater_equal_v;
+ using std::ratio_greater_v;
+ using std::ratio_less;
+ using std::ratio_less_equal;
+ using std::ratio_less_equal_v;
+ using std::ratio_less_v;
+ using std::ratio_multiply;
+ using std::ratio_not_equal;
+ using std::ratio_not_equal_v;
+ using std::ratio_subtract;
+ using std::tera;
+}
+
+// FIXME <rcu>
+
+// <regex>
+export namespace std
+{
+ namespace regex_constants
+ {
+ using std::regex_constants::error_type;
+ using std::regex_constants::match_flag_type;
+ using std::regex_constants::syntax_option_type;
+ using std::regex_constants::operator&;
+ using std::regex_constants::operator&=;
+ using std::regex_constants::operator^;
+ using std::regex_constants::operator^=;
+ using std::regex_constants::operator|;
+ using std::regex_constants::operator|=;
+ using std::regex_constants::operator~;
+ }
+ using std::basic_regex;
+ using std::csub_match;
+ using std::regex;
+ using std::regex_error;
+ using std::regex_traits;
+ using std::ssub_match;
+ using std::sub_match;
+ using std::swap;
+ using std::wcsub_match;
+ using std::wregex;
+ using std::wssub_match;
+ using std::operator==;
+ using std::operator<=>;
+ using std::operator<<;
+ using std::cmatch;
+ using std::cregex_iterator;
+ using std::cregex_token_iterator;
+ using std::match_results;
+ using std::regex_iterator;
+ using std::regex_match;
+ using std::regex_replace;
+ using std::regex_search;
+ using std::regex_token_iterator;
+ using std::smatch;
+ using std::sregex_iterator;
+ using std::sregex_token_iterator;
+ using std::wcmatch;
+ using std::wcregex_iterator;
+ using std::wcregex_token_iterator;
+ using std::wsmatch;
+ using std::wsregex_iterator;
+ using std::wsregex_token_iterator;
+ namespace pmr
+ {
+ using std::pmr::cmatch;
+ using std::pmr::match_results;
+ using std::pmr::smatch;
+ using std::pmr::wcmatch;
+ using std::pmr::wsmatch;
+ }
+}
+
+// 20.5 <scoped_allocator>
+export namespace std
+{
+ using std::scoped_allocator_adaptor;
+ using std::operator==;
+}
+
+// <semaphore>
+export namespace std
+{
+ using std::binary_semaphore;
+ using std::counting_semaphore;
+}
+
+// <set>
+export namespace std
+{
+ using std::set;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase_if;
+ using std::multiset;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::multiset;
+ using std::pmr::set;
+ }
+}
+
+// <shared_mutex>
+export namespace std
+{
+ using std::shared_lock;
+ using std::shared_mutex;
+ using std::shared_timed_mutex;
+ using std::swap;
+}
+
+// 17.8.1 <source_location>
+export namespace std
+{
+ using std::source_location;
+}
+
+// <span>
+export namespace std
+{
+ using std::dynamic_extent;
+ using std::span;
+ namespace ranges
+ {
+ using std::ranges::enable_borrowed_range;
+ using std::ranges::enable_view;
+ }
+ using std::as_bytes;
+ using std::as_writable_bytes;
+}
+
+// <sstream>
+export namespace std
+{
+ using std::basic_istringstream;
+ using std::basic_ostringstream;
+ using std::basic_stringbuf;
+ using std::basic_stringstream;
+ using std::istringstream;
+ using std::ostringstream;
+ using std::stringbuf;
+ using std::stringstream;
+ using std::swap;
+ using std::wistringstream;
+ using std::wostringstream;
+ using std::wstringbuf;
+ using std::wstringstream;
+}
+
+// <stack>
+export namespace std
+{
+ using std::stack;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::swap;
+ using std::uses_allocator;
+}
+
+// 19.6 <stacktrace>
+export namespace std
+{
+ using std::stacktrace_entry;
+ using std::basic_stacktrace;
+ using std::stacktrace;
+ using std::swap;
+ using std::to_string;
+ using std::operator<<;
+ using std::formatter;
+ namespace pmr
+ {
+ using std::pmr::stacktrace;
+ }
+ using std::hash;
+}
+
+// 19.2 <stdexcept>
+export namespace std
+{
+ using std::domain_error;
+ using std::invalid_argument;
+ using std::length_error;
+ using std::logic_error;
+ using std::out_of_range;
+ using std::overflow_error;
+ using std::range_error;
+ using std::runtime_error;
+ using std::underflow_error;
+}
+
+// 17.4.2 <stdfloat>
+export namespace std
+{
+#ifdef __STDCPP_FLOAT16_T__
+ using std::float16_t;
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+ using std::float32_t;
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+ using std::float64_t;
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+ using std::float128_t;
+#endif
+#ifdef __STDCPP_BFLOAT16_T__
+ using std::bfloat16_t;
+#endif
+}
+
+// FIXME <stop_token>
+
+// <streambuf>
+export namespace std
+{
+ using std::basic_streambuf;
+ using std::streambuf;
+ using std::wstreambuf;
+}
+
+// <string>
+export namespace std
+{
+ using std::basic_string;
+ using std::char_traits;
+ using std::operator+;
+ using std::operator==;
+ using std::operator<=>;
+ using std::swap;
+ using std::operator>>;
+ using std::operator<<;
+ using std::erase;
+ using std::erase_if;
+ using std::getline;
+ using std::stod;
+ using std::stof;
+ using std::stoi;
+ using std::stol;
+ using std::stold;
+ using std::stoll;
+ using std::stoul;
+ using std::stoull;
+ using std::string;
+ using std::to_string;
+ using std::to_wstring;
+ using std::u16string;
+ using std::u32string;
+ using std::u8string;
+ using std::wstring;
+ namespace pmr
+ {
+ using std::pmr::basic_string;
+ using std::pmr::string;
+ using std::pmr::u16string;
+ using std::pmr::u32string;
+ using std::pmr::u8string;
+ using std::pmr::wstring;
+ }
+ using std::hash;
+ using std::operator""s;
+}
+
+// <string_view>
+export namespace std
+{
+ using std::basic_string_view;
+ namespace ranges
+ {
+ using std::ranges::enable_borrowed_range;
+ using std::ranges::enable_view;
+ }
+ using std::operator==;
+ using std::operator<=>;
+ using std::operator<<;
+ using std::hash;
+ using std::string_view;
+ using std::u16string_view;
+ using std::u32string_view;
+ using std::u8string_view;
+ using std::wstring_view;
+ using std::operator""sv;
+}
+
+// <strstream>: deprecated C++98, removed C++26
+export namespace std
+{
+ using std::istrstream;
+ using std::ostrstream;
+ using std::strstream;
+ using std::strstreambuf;
+}
+
+// <syncstream>
+export namespace std
+{
+ using std::basic_syncbuf;
+ using std::swap;
+ using std::basic_osyncstream;
+ using std::osyncstream;
+ using std::syncbuf;
+ using std::wosyncstream;
+ using std::wsyncbuf;
+}
+
+// 19.5 <system_error>
+export namespace std
+{
+ using std::errc;
+ using std::error_category;
+ using std::error_code;
+ using std::error_condition;
+ using std::generic_category;
+ using std::is_error_code_enum;
+ using std::is_error_condition_enum;
+ using std::make_error_code;
+ using std::system_category;
+ using std::system_error;
+ using std::operator<<;
+ using std::make_error_condition;
+ using std::operator==;
+ using std::operator<=>;
+ using std::hash;
+ using std::is_error_code_enum_v;
+ using std::is_error_condition_enum_v;
+}
+
+// FIXME <text_encoding>
+
+// <thread>
+export namespace std
+{
+ using std::swap;
+ using std::thread;
+ using std::jthread;
+ namespace this_thread
+ {
+ using std::this_thread::get_id;
+ using std::this_thread::sleep_for;
+ using std::this_thread::sleep_until;
+ using std::this_thread::yield;
+ }
+ using std::operator==;
+ using std::operator<=>;
+ using std::operator<<;
+ using std::hash;
+}
+
+// <tuple>
+export namespace std
+{
+ using std::apply;
+ using std::forward_as_tuple;
+ using std::get;
+ using std::ignore;
+ using std::make_from_tuple;
+ using std::make_tuple;
+ using std::tie;
+ using std::tuple;
+ using std::tuple_cat;
+ using std::tuple_element;
+ using std::tuple_element_t;
+ using std::tuple_size;
+ using std::operator==;
+ using std::operator<=>;
+ using std::swap;
+ using std::tuple_size_v;
+ using std::uses_allocator;
+}
+
+// <type_traits>
+export namespace std
+{
+ using std::add_const;
+ using std::add_const_t;
+ using std::add_cv;
+ using std::add_cv_t;
+ using std::add_lvalue_reference;
+ using std::add_lvalue_reference_t;
+ using std::add_pointer;
+ using std::add_pointer_t;
+ using std::add_rvalue_reference;
+ using std::add_rvalue_reference_t;
+ using std::add_volatile;
+ using std::add_volatile_t;
+ using std::aligned_storage;
+ using std::aligned_storage_t;
+ using std::aligned_union;
+ using std::aligned_union_t;
+ using std::alignment_of;
+ using std::alignment_of_v;
+ using std::basic_common_reference;
+ using std::bool_constant;
+ using std::common_reference;
+ using std::common_reference_t;
+ using std::common_type;
+ using std::common_type_t;
+ using std::conditional;
+ using std::conditional_t;
+ using std::conjunction;
+ using std::conjunction_v;
+ using std::decay;
+ using std::decay_t;
+ using std::disjunction;
+ using std::disjunction_v;
+ using std::enable_if;
+ using std::enable_if_t;
+ using std::extent;
+ using std::extent_v;
+ using std::false_type;
+ using std::has_unique_object_representations;
+ using std::has_unique_object_representations_v;
+ using std::has_virtual_destructor;
+ using std::has_virtual_destructor_v;
+ using std::integral_constant;
+ using std::invoke_result;
+ using std::invoke_result_t;
+ using std::is_abstract;
+ using std::is_abstract_v;
+ using std::is_aggregate;
+ using std::is_aggregate_v;
+ using std::is_arithmetic;
+ using std::is_arithmetic_v;
+ using std::is_array;
+ using std::is_array_v;
+ using std::is_assignable;
+ using std::is_assignable_v;
+ using std::is_base_of;
+ using std::is_base_of_v;
+ using std::is_bounded_array;
+ using std::is_bounded_array_v;
+ using std::is_class;
+ using std::is_class_v;
+ using std::is_compound;
+ using std::is_compound_v;
+ using std::is_const;
+ using std::is_const_v;
+ using std::is_constant_evaluated;
+ using std::is_constructible;
+ using std::is_constructible_v;
+ using std::is_convertible;
+ using std::is_convertible_v;
+ using std::is_copy_assignable;
+ using std::is_copy_assignable_v;
+ using std::is_copy_constructible;
+ using std::is_copy_constructible_v;
+ using std::is_default_constructible;
+ using std::is_default_constructible_v;
+ using std::is_destructible;
+ using std::is_destructible_v;
+ using std::is_empty;
+ using std::is_empty_v;
+ using std::is_enum;
+ using std::is_enum_v;
+ using std::is_final;
+ using std::is_final_v;
+ using std::is_floating_point;
+ using std::is_floating_point_v;
+ using std::is_function;
+ using std::is_function_v;
+ using std::is_fundamental;
+ using std::is_fundamental_v;
+ using std::is_integral;
+ using std::is_integral_v;
+ using std::is_invocable;
+ using std::is_invocable_r;
+ using std::is_invocable_r_v;
+ using std::is_invocable_v;
+ using std::is_lvalue_reference;
+ using std::is_lvalue_reference_v;
+ using std::is_member_function_pointer;
+ using std::is_member_function_pointer_v;
+ using std::is_member_object_pointer;
+ using std::is_member_object_pointer_v;
+ using std::is_member_pointer;
+ using std::is_member_pointer_v;
+ using std::is_move_assignable;
+ using std::is_move_assignable_v;
+ using std::is_move_constructible;
+ using std::is_move_constructible_v;
+ using std::is_nothrow_assignable;
+ using std::is_nothrow_assignable_v;
+ using std::is_nothrow_constructible;
+ using std::is_nothrow_constructible_v;
+ using std::is_nothrow_convertible;
+ using std::is_nothrow_convertible_v;
+ using std::is_nothrow_copy_assignable;
+ using std::is_nothrow_copy_assignable_v;
+ using std::is_nothrow_copy_constructible;
+ using std::is_nothrow_copy_constructible_v;
+ using std::is_nothrow_default_constructible;
+ using std::is_nothrow_default_constructible_v;
+ using std::is_nothrow_destructible;
+ using std::is_nothrow_destructible_v;
+ using std::is_nothrow_invocable;
+ using std::is_nothrow_invocable_r;
+ using std::is_nothrow_invocable_r_v;
+ using std::is_nothrow_invocable_v;
+ using std::is_nothrow_move_assignable;
+ using std::is_nothrow_move_assignable_v;
+ using std::is_nothrow_move_constructible;
+ using std::is_nothrow_move_constructible_v;
+ using std::is_nothrow_swappable;
+ using std::is_nothrow_swappable_v;
+ using std::is_nothrow_swappable_with;
+ using std::is_nothrow_swappable_with_v;
+ using std::is_null_pointer;
+ using std::is_null_pointer_v;
+ using std::is_object;
+ using std::is_object_v;
+ using std::is_pod;
+ using std::is_pod_v;
+ using std::is_pointer;
+ using std::is_pointer_v;
+ using std::is_polymorphic;
+ using std::is_polymorphic_v;
+ using std::is_reference;
+ using std::is_reference_v;
+ using std::is_rvalue_reference;
+ using std::is_rvalue_reference_v;
+ using std::is_same;
+ using std::is_same_v;
+ using std::is_scalar;
+ using std::is_scalar_v;
+ using std::is_signed;
+ using std::is_signed_v;
+ using std::is_standard_layout;
+ using std::is_standard_layout_v;
+ using std::is_swappable;
+ using std::is_swappable_v;
+ using std::is_swappable_with;
+ using std::is_swappable_with_v;
+ using std::is_trivial;
+ using std::is_trivial_v;
+ using std::is_trivially_assignable;
+ using std::is_trivially_assignable_v;
+ using std::is_trivially_constructible;
+ using std::is_trivially_constructible_v;
+ using std::is_trivially_copy_assignable;
+ using std::is_trivially_copy_assignable_v;
+ using std::is_trivially_copy_constructible;
+ using std::is_trivially_copy_constructible_v;
+ using std::is_trivially_copyable;
+ using std::is_trivially_copyable_v;
+ using std::is_trivially_default_constructible;
+ using std::is_trivially_default_constructible_v;
+ using std::is_trivially_destructible;
+ using std::is_trivially_destructible_v;
+ using std::is_trivially_move_assignable;
+ using std::is_trivially_move_assignable_v;
+ using std::is_trivially_move_constructible;
+ using std::is_trivially_move_constructible_v;
+ using std::is_unbounded_array;
+ using std::is_unbounded_array_v;
+ using std::is_union;
+ using std::is_union_v;
+ using std::is_unsigned;
+ using std::is_unsigned_v;
+ using std::is_void;
+ using std::is_void_v;
+ using std::is_volatile;
+ using std::is_volatile_v;
+ using std::make_signed;
+ using std::make_signed_t;
+ using std::make_unsigned;
+ using std::make_unsigned_t;
+ using std::negation;
+ using std::negation_v;
+ using std::rank;
+ using std::rank_v;
+ using std::remove_all_extents;
+ using std::remove_all_extents_t;
+ using std::remove_const;
+ using std::remove_const_t;
+ using std::remove_cv;
+ using std::remove_cv_t;
+ using std::remove_cvref;
+ using std::remove_cvref_t;
+ using std::remove_extent;
+ using std::remove_extent_t;
+ using std::remove_pointer;
+ using std::remove_pointer_t;
+ using std::remove_reference;
+ using std::remove_reference_t;
+ using std::remove_volatile;
+ using std::remove_volatile_t;
+ using std::true_type;
+ using std::type_identity;
+ using std::type_identity_t;
+ using std::underlying_type;
+ using std::underlying_type_t;
+ using std::unwrap_ref_decay;
+ using std::unwrap_ref_decay_t;
+ using std::unwrap_reference;
+ using std::unwrap_reference_t;
+ using std::void_t;
+}
+
+// <typeindex>
+export namespace std
+{
+ using std::hash;
+ using std::type_index;
+}
+
+// 17.7.2 <typeinfo> [typeinfo.syn]
+export namespace std
+{
+ using std::bad_cast;
+ using std::bad_typeid;
+ using std::type_info;
+}
+
+// <unordered_map>
+export namespace std
+{
+ using std::unordered_map;
+ using std::unordered_multimap;
+ using std::operator==;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::unordered_map;
+ using std::pmr::unordered_multimap;
+ }
+}
+
+// <unordered_set>
+export namespace std
+{
+ using std::unordered_multiset;
+ using std::unordered_set;
+ using std::operator==;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::unordered_multiset;
+ using std::pmr::unordered_set;
+ }
+}
+
+// <utility>
+export namespace std
+{
+ using std::as_const;
+ using std::cmp_equal;
+ using std::cmp_greater;
+ using std::cmp_greater_equal;
+ using std::cmp_less;
+ using std::cmp_less_equal;
+ using std::cmp_not_equal;
+ using std::declval;
+ using std::exchange;
+ using std::forward;
+ using std::in_range;
+ using std::index_sequence;
+ using std::index_sequence_for;
+ using std::integer_sequence;
+ using std::make_index_sequence;
+ using std::make_integer_sequence;
+ using std::move;
+ using std::move_if_noexcept;
+ using std::pair;
+ using std::swap;
+ using std::operator==;
+ using std::operator<=>;
+ using std::get;
+ using std::in_place;
+ using std::in_place_index;
+ using std::in_place_index_t;
+ using std::in_place_t;
+ using std::in_place_type;
+ using std::in_place_type_t;
+ using std::make_pair;
+ using std::piecewise_construct;
+ using std::piecewise_construct_t;
+ using std::tuple_element;
+ using std::tuple_size;
+ namespace rel_ops
+ {
+ using std::rel_ops::operator!=;
+ using std::rel_ops::operator>;
+ using std::rel_ops::operator<=;
+ using std::rel_ops::operator>=;
+ }
+}
+
+// <valarray>
+export namespace std
+{
+ using std::gslice;
+ using std::gslice_array;
+ using std::indirect_array;
+ using std::mask_array;
+ using std::slice;
+ using std::slice_array;
+ using std::swap;
+ using std::valarray;
+ using std::operator*;
+ using std::operator/;
+ using std::operator%;
+ using std::operator+;
+ using std::operator-;
+ using std::operator^;
+ using std::operator&;
+ using std::operator|;
+ using std::operator<<;
+ using std::operator>>;
+ using std::operator&&;
+ using std::operator||;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::abs;
+ using std::acos;
+ using std::asin;
+ using std::atan;
+ using std::atan2;
+ using std::begin;
+ using std::cos;
+ using std::cosh;
+ using std::end;
+ using std::exp;
+ using std::log;
+ using std::log10;
+ using std::pow;
+ using std::sin;
+ using std::sinh;
+ using std::sqrt;
+ using std::tan;
+ using std::tanh;
+}
+
+// <variant>
+export namespace std
+{
+ using std::get;
+ using std::get_if;
+ using std::holds_alternative;
+ using std::variant;
+ using std::variant_alternative;
+ using std::variant_alternative_t;
+ using std::variant_npos;
+ using std::variant_size;
+ using std::variant_size_v;
+ using std::operator==;
+ using std::operator!=;
+ using std::operator<;
+ using std::operator>;
+ using std::operator<=;
+ using std::operator>=;
+ using std::operator<=>;
+ using std::bad_variant_access;
+ using std::hash;
+ using std::monostate;
+ using std::swap;
+ using std::visit;
+}
+
+// <vector>
+export namespace std
+{
+ using std::vector;
+ using std::operator==;
+ using std::operator<=>;
+ using std::erase;
+ using std::erase_if;
+ using std::swap;
+ namespace pmr
+ {
+ using std::pmr::vector;
+ }
+ using std::hash;
+}
diff --git a/libstdc++-v3/src/c++23/modules/std.compat.cc
b/libstdc++-v3/src/c++23/modules/std.compat.cc
new file mode 100644
index 00000000000..7d90f20378a
--- /dev/null
+++ b/libstdc++-v3/src/c++23/modules/std.compat.cc
@@ -0,0 +1,640 @@
+// -*- C++ -*- [std.modules] module std.compat
+
+// Copyright The GNU Toolchain Authors.
+//
+// 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.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+export module std.compat;
+export import std;
+
+#define STD_COMPAT
+
+// **** The below is copied verbatim from std.cc, starting with "C standard
+// **** library headers" and ending with "End of C library". Make any edits
+// **** there and update the copy.
+
+// C standard library headers [tab:headers.cpp.c]
+
+#ifndef STD_COMPAT
+#define C_LIB_NAMESPACE namespace std
+#endif
+
+// 19.3 <cassert>
+// No exports
+
+// 23.5.1 <cctype>
+export C_LIB_NAMESPACE
+{
+ using std::isalnum;
+ using std::isalpha;
+ using std::isblank;
+ using std::iscntrl;
+ using std::isdigit;
+ using std::isgraph;
+ using std::islower;
+ using std::isprint;
+ using std::ispunct;
+ using std::isspace;
+ using std::isupper;
+ using std::isxdigit;
+ using std::tolower;
+ using std::toupper;
+}
+
+// 19.4 <cerrno>
+// No exports
+
+// 28.3 <cfenv>
+export C_LIB_NAMESPACE
+{
+ using std::feclearexcept;
+ using std::fegetenv;
+ using std::fegetexceptflag;
+ using std::fegetround;
+ using std::feholdexcept;
+ using std::fenv_t;
+ using std::feraiseexcept;
+ using std::fesetenv;
+ using std::fesetexceptflag;
+ using std::fesetround;
+ using std::fetestexcept;
+ using std::feupdateenv;
+ using std::fexcept_t;
+}
+
+// 17.3.7 <cfloat> [cfloat.syn]
+// No exports, only provides macros
+
+// 31.13.2 <cinttypes>
+export C_LIB_NAMESPACE
+{
+ using std::imaxabs;
+ using std::imaxdiv;
+ using std::imaxdiv_t;
+ using std::strtoimax;
+ using std::strtoumax;
+ using std::wcstoimax;
+ using std::wcstoumax;
+}
+
+// 17.3.6 <climits> [climits.syn]
+// No exports, only provides macros
+
+// 30.5 <clocale>
+export C_LIB_NAMESPACE
+{
+ using std::lconv;
+ using std::localeconv;
+ using std::setlocale;
+ // LC_* macros not exported
+}
+
+// 28.7.1 <cmath>
+// FIXME missing special functions
+export C_LIB_NAMESPACE
+{
+ using std::abs;
+ using std::acos;
+ using std::acosf;
+ using std::acosh;
+ using std::acoshf;
+ using std::acoshl;
+ using std::acosl;
+ using std::asin;
+ using std::asinf;
+ using std::asinh;
+ using std::asinhf;
+ using std::asinhl;
+ using std::asinl;
+ using std::atan;
+ using std::atan2;
+ using std::atan2f;
+ using std::atan2l;
+ using std::atanf;
+ using std::atanh;
+ using std::atanhf;
+ using std::atanhl;
+ using std::atanl;
+ using std::cbrt;
+ using std::cbrtf;
+ using std::cbrtl;
+ using std::ceil;
+ using std::ceilf;
+ using std::ceill;
+ using std::copysign;
+ using std::copysignf;
+ using std::copysignl;
+ using std::cos;
+ using std::cosf;
+ using std::cosh;
+ using std::coshf;
+ using std::coshl;
+ using std::cosl;
+ using std::double_t;
+ using std::erf;
+ using std::erfc;
+ using std::erfcf;
+ using std::erfcl;
+ using std::erff;
+ using std::erfl;
+ using std::exp;
+ using std::exp2;
+ using std::exp2f;
+ using std::exp2l;
+ using std::expf;
+ using std::expl;
+ using std::expm1;
+ using std::expm1f;
+ using std::expm1l;
+ using std::fabs;
+ using std::fabsf;
+ using std::fabsl;
+ using std::fdim;
+ using std::fdimf;
+ using std::fdiml;
+ using std::float_t;
+ using std::floor;
+ using std::floorf;
+ using std::floorl;
+ using std::fma;
+ using std::fmaf;
+ using std::fmal;
+ using std::fmax;
+ using std::fmaxf;
+ using std::fmaxl;
+ using std::fmin;
+ using std::fminf;
+ using std::fminl;
+ using std::fmod;
+ using std::fmodf;
+ using std::fmodl;
+ using std::fpclassify;
+ using std::frexp;
+ using std::frexpf;
+ using std::frexpl;
+ using std::hypot;
+ using std::hypotf;
+ using std::hypotl;
+ using std::ilogb;
+ using std::ilogbf;
+ using std::ilogbl;
+ using std::isfinite;
+ using std::isgreater;
+ using std::isgreaterequal;
+ using std::isinf;
+ using std::isless;
+ using std::islessequal;
+ using std::islessgreater;
+ using std::isnan;
+ using std::isnormal;
+ using std::isunordered;
+ using std::ldexp;
+ using std::ldexpf;
+ using std::ldexpl;
+#ifndef STD_COMPAT
+ using std::lerp;
+#endif
+ using std::lgamma;
+ using std::lgammaf;
+ using std::lgammal;
+ using std::llrint;
+ using std::llrintf;
+ using std::llrintl;
+ using std::llround;
+ using std::llroundf;
+ using std::llroundl;
+ using std::log;
+ using std::log10;
+ using std::log10f;
+ using std::log10l;
+ using std::log1p;
+ using std::log1pf;
+ using std::log1pl;
+ using std::log2;
+ using std::log2f;
+ using std::log2l;
+ using std::logb;
+ using std::logbf;
+ using std::logbl;
+ using std::logf;
+ using std::logl;
+ using std::lrint;
+ using std::lrintf;
+ using std::lrintl;
+ using std::lround;
+ using std::lroundf;
+ using std::lroundl;
+ using std::modf;
+ using std::modff;
+ using std::modfl;
+ using std::nan;
+ using std::nanf;
+ using std::nanl;
+ using std::nearbyint;
+ using std::nearbyintf;
+ using std::nearbyintl;
+ using std::nextafter;
+ using std::nextafterf;
+ using std::nextafterl;
+ using std::nexttoward;
+ using std::nexttowardf;
+ using std::nexttowardl;
+ using std::pow;
+ using std::powf;
+ using std::powl;
+ using std::remainder;
+ using std::remainderf;
+ using std::remainderl;
+ using std::remquo;
+ using std::remquof;
+ using std::remquol;
+ using std::rint;
+ using std::rintf;
+ using std::rintl;
+ using std::round;
+ using std::roundf;
+ using std::roundl;
+ using std::scalbln;
+ using std::scalblnf;
+ using std::scalblnl;
+ using std::scalbn;
+ using std::scalbnf;
+ using std::scalbnl;
+ using std::signbit;
+ using std::sin;
+ using std::sinf;
+ using std::sinh;
+ using std::sinhf;
+ using std::sinhl;
+ using std::sinl;
+ using std::sqrt;
+ using std::sqrtf;
+ using std::sqrtl;
+ using std::tan;
+ using std::tanf;
+ using std::tanh;
+ using std::tanhf;
+ using std::tanhl;
+ using std::tanl;
+ using std::tgamma;
+ using std::tgammaf;
+ using std::tgammal;
+ using std::trunc;
+ using std::truncf;
+ using std::truncl;
+}
+
+// 17.13.3 <csetjmp>
+export C_LIB_NAMESPACE
+{
+ using std::jmp_buf;
+ using std::longjmp;
+ // setjmp macro not exported
+}
+
+// 17.13.4 <csignal>
+export C_LIB_NAMESPACE
+{
+ using std::raise;
+ using std::sig_atomic_t;
+ using std::signal;
+ // SIG_* macros not exported
+}
+
+// 17.13.2 <cstdarg>
+export C_LIB_NAMESPACE
+{
+ using std::va_list;
+ // va_arg and friend macros not exported
+}
+
+// 17.2.1 <cstddef> [cstddef.syn]
+export C_LIB_NAMESPACE
+{
+ using std::max_align_t;
+ using std::nullptr_t;
+ using std::ptrdiff_t;
+ using std::size_t;
+#ifndef STD_COMPAT
+ using std::byte;
+ using std::operator<<=;
+ using std::operator<<;
+ using std::operator>>=;
+ using std::operator>>;
+ using std::operator|=;
+ using std::operator|;
+ using std::operator&=;
+ using std::operator&;
+ using std::operator^=;
+ using std::operator^;
+ using std::operator~;
+ using std::to_integer;
+#endif
+ // NULL and offsetof macros not exported
+}
+
+// 17.4 <cstdint>
+export C_LIB_NAMESPACE
+{
+ using std::int8_t;
+ using std::int16_t;
+ using std::int32_t;
+ using std::int64_t;
+ using std::int_fast16_t;
+ using std::int_fast32_t;
+ using std::int_fast64_t;
+ using std::int_fast8_t;
+ using std::int_least16_t;
+ using std::int_least32_t;
+ using std::int_least64_t;
+ using std::int_least8_t;
+ using std::intmax_t;
+ using std::intptr_t;
+ using std::uint8_t;
+ using std::uint16_t;
+ using std::uint32_t;
+ using std::uint64_t;
+ using std::uint_fast16_t;
+ using std::uint_fast32_t;
+ using std::uint_fast64_t;
+ using std::uint_fast8_t;
+ using std::uint_least16_t;
+ using std::uint_least32_t;
+ using std::uint_least64_t;
+ using std::uint_least8_t;
+ using std::uintmax_t;
+ using std::uintptr_t;
+}
+
+// 31.13.1 <cstdio>
+export C_LIB_NAMESPACE
+{
+ using std::clearerr;
+ using std::fclose;
+ using std::feof;
+ using std::ferror;
+ using std::fflush;
+ using std::fgetc;
+ using std::fgetpos;
+ using std::fgets;
+ using std::FILE;
+ using std::fopen;
+ using std::fpos_t;
+ using std::fprintf;
+ using std::fputc;
+ using std::fputs;
+ using std::fread;
+ using std::freopen;
+ using std::fscanf;
+ using std::fseek;
+ using std::fsetpos;
+ using std::ftell;
+ using std::fwrite;
+ using std::getc;
+ using std::getchar;
+ using std::perror;
+ using std::printf;
+ using std::putc;
+ using std::putchar;
+ using std::puts;
+ using std::remove;
+ using std::rename;
+ using std::rewind;
+ using std::scanf;
+ using std::setbuf;
+ using std::setvbuf;
+ using std::size_t;
+ using std::snprintf;
+ using std::sprintf;
+ using std::sscanf;
+ using std::tmpfile;
+ using std::tmpnam;
+ using std::ungetc;
+ using std::vfprintf;
+ using std::vfscanf;
+ using std::vprintf;
+ using std::vscanf;
+ using std::vsnprintf;
+ using std::vsprintf;
+ using std::vsscanf;
+}
+
+// 17.2.2 <cstdlib> [cstdlib.syn]
+export C_LIB_NAMESPACE
+{
+ using std::_Exit;
+ using std::abort;
+ using std::abs;
+ using std::aligned_alloc;
+ using std::at_quick_exit;
+ using std::atexit;
+ using std::atof;
+ using std::atoi;
+ using std::atol;
+ using std::atoll;
+ using std::bsearch;
+ using std::calloc;
+ using std::div;
+ using std::div_t;
+ using std::exit;
+ using std::free;
+ using std::getenv;
+ using std::labs;
+ using std::ldiv;
+ using std::ldiv_t;
+ using std::llabs;
+ using std::lldiv;
+ using std::lldiv_t;
+ using std::malloc;
+ using std::mblen;
+ using std::mbstowcs;
+ using std::mbtowc;
+ using std::qsort;
+ using std::quick_exit;
+ using std::rand;
+ using std::realloc;
+ using std::size_t;
+ using std::srand;
+ using std::strtod;
+ using std::strtof;
+ using std::strtol;
+ using std::strtold;
+ using std::strtoll;
+ using std::strtoul;
+ using std::strtoull;
+ using std::system;
+ using std::wcstombs;
+ using std::wctomb;
+}
+
+// 23.5.3 <cstring>
+export C_LIB_NAMESPACE
+{
+ using std::memchr;
+ using std::memcmp;
+ using std::memcpy;
+ using std::memmove;
+ using std::memset;
+ using std::size_t;
+ using std::strcat;
+ using std::strchr;
+ using std::strcmp;
+ using std::strcoll;
+ using std::strcpy;
+ using std::strcspn;
+ using std::strerror;
+ using std::strlen;
+ using std::strncat;
+ using std::strncmp;
+ using std::strncpy;
+ using std::strpbrk;
+ using std::strrchr;
+ using std::strspn;
+ using std::strstr;
+ using std::strtok;
+ using std::strxfrm;
+}
+
+// 29.15 <ctime>
+export C_LIB_NAMESPACE
+{
+ using std::asctime;
+ using std::clock;
+ using std::clock_t;
+ using std::ctime;
+ using std::difftime;
+ using std::gmtime;
+ using std::localtime;
+ using std::mktime;
+ using std::size_t;
+ using std::strftime;
+ using std::time;
+ using std::time_t;
+ using std::timespec;
+ using std::tm;
+ using std::timespec_get;
+}
+
+// 23.5.5 <cuchar>
+export C_LIB_NAMESPACE
+{
+ using std::mbrtoc8;
+ using std::c8rtomb;
+ using std::mbrtoc16;
+ using std::c16rtomb;
+ using std::mbrtoc32;
+ using std::c32rtomb;
+}
+
+// 23.5.4 <cwchar>
+export C_LIB_NAMESPACE
+{
+ using std::btowc;
+ using std::fgetwc;
+ using std::fgetws;
+ using std::fputwc;
+ using std::fputws;
+ using std::fwide;
+ using std::fwprintf;
+ using std::fwscanf;
+ using std::getwc;
+ using std::getwchar;
+ using std::mbrlen;
+ using std::mbrtowc;
+ using std::mbsinit;
+ using std::mbsrtowcs;
+ using std::mbstate_t;
+ using std::putwc;
+ using std::putwchar;
+ using std::size_t;
+ using std::swprintf;
+ using std::swscanf;
+ using std::tm;
+ using std::ungetwc;
+ using std::vfwprintf;
+ using std::vfwscanf;
+ using std::vswprintf;
+ using std::vswscanf;
+ using std::vwprintf;
+ using std::vwscanf;
+ using std::wcrtomb;
+ using std::wcscat;
+ using std::wcschr;
+ using std::wcscmp;
+ using std::wcscoll;
+ using std::wcscpy;
+ using std::wcscspn;
+ using std::wcsftime;
+ using std::wcslen;
+ using std::wcsncat;
+ using std::wcsncmp;
+ using std::wcsncpy;
+ using std::wcspbrk;
+ using std::wcsrchr;
+ using std::wcsrtombs;
+ using std::wcsspn;
+ using std::wcsstr;
+ using std::wcstod;
+ using std::wcstof;
+ using std::wcstok;
+ using std::wcstol;
+ using std::wcstold;
+ using std::wcstoll;
+ using std::wcstoul;
+ using std::wcstoull;
+ using std::wcsxfrm;
+ using std::wctob;
+ using std::wint_t;
+ using std::wmemchr;
+ using std::wmemcmp;
+ using std::wmemcpy;
+ using std::wmemmove;
+ using std::wmemset;
+ using std::wprintf;
+ using std::wscanf;
+}
+
+// 23.5.2 <cwctype>
+export C_LIB_NAMESPACE
+{
+ using std::iswalnum;
+ using std::iswalpha;
+ using std::iswblank;
+ using std::iswcntrl;
+ using std::iswctype;
+ using std::iswdigit;
+ using std::iswgraph;
+ using std::iswlower;
+ using std::iswprint;
+ using std::iswpunct;
+ using std::iswspace;
+ using std::iswupper;
+ using std::iswxdigit;
+ using std::towctrans;
+ using std::towlower;
+ using std::towupper;
+ using std::wctrans;
+ using std::wctrans_t;
+ using std::wctype;
+ using std::wctype_t;
+ using std::wint_t;
+}
+
+// **** End of C library ****
diff --git a/contrib/relpath.sh b/contrib/relpath.sh
new file mode 100755
index 00000000000..51bde081636
--- /dev/null
+++ b/contrib/relpath.sh
@@ -0,0 +1,70 @@
+#!/bin/sh
+
+if [ "$1" == "--help" ]; then
+ echo Usage: relpath.sh FROM TO
+ echo Print the relative path from FROM to TO
+ echo FROM must be a directory, but need not exist
+fi
+
+if [ -f "$1" ]; then
+ echo first argument must be a directory
+ exit 1
+fi
+
+from="${1%%/}"
+to="${2%%/}"
+
+# Canonicalize directories if they contain '..'.
+canonicalize() {
+ path=$1
+ suffix=
+ while ! [ -d "$path" ]; do
+ name=$(basename "$path")
+ # Give up on a .. that doesn't exist.
+ if [ $"name" = ".." ]; then break; fi
+ path=$(dirname "$path")
+ suffix="/$name$suffix"
+ done
+ if [ -d "$path" ]; then
+ echo $(cd "$path"; pwd)$suffix
+ else
+ echo $1
+ fi
+}
+
+case "$to$from" in
+ *..* )
+ from=$(canonicalize "$from")
+ to=$(canonicalize "$to")
+ ;;
+esac
+case "$to$from" in
+ *..* )
+ echo unable to canonicalize ..
+ exit 1
+ ;;
+esac
+
+back=
+while [ "${to#$from}" = "$to" ]; do
+ #echo $from too long
+ from=$(dirname $from);
+ back=../$back
+
+ if [ "$from" = "/" ]; then
+ echo $to
+ exit 0
+ fi
+done
+
+to=${to#$from}
+to=${to##/}
+back=${back%%/}
+
+if [ -n "$to" ] && [ -n "$back" ]; then
+ echo $back/$to
+elif [ -n "$back$to" ]; then
+ echo $back$to
+else
+ echo .
+fi
diff --git a/libstdc++-v3/src/c++23/Makefile.am
b/libstdc++-v3/src/c++23/Makefile.am
index 74996d1e147..f8149e77102 100644
--- a/libstdc++-v3/src/c++23/Makefile.am
+++ b/libstdc++-v3/src/c++23/Makefile.am
@@ -25,6 +25,24 @@ include $(top_srcdir)/fragment.am
# Convenience library for C++23 runtime.
noinst_LTLIBRARIES = libc++23convenience.la
+# module std support. Not compiled for now, only installed.
+toolexeclib_DATA = libstdc++.modules.json
+nobase_pkgdata_DATA = modules/std.cc modules/std.compat.cc
+
+# The manifest to be installed uses the relative path between install dirs.
+libstdc++.modules.json: libstdc++.modules.json.in
+ relpath=$$($(toplevel_srcdir)/contrib/relpath.sh \
+ $(toolexeclibdir) $(pkgdatadir)) && \
+ sed "s,@MODPATH@,$$relpath," $< > $@
+
+# The uninstalled manifest uses the absolute path to srcdir.
+stamp-modules: libstdc++.modules.json.in
+ sed 's,@MODPATH@,$(srcdir),' $< \
+ > ../.libs/libstdc++.modules.json
+ @touch stamp-modules
+
+all-local: stamp-modules
+
headers =
if ENABLE_EXTERN_TEMPLATE
diff --git a/libstdc++-v3/src/c++23/Makefile.in
b/libstdc++-v3/src/c++23/Makefile.in
index ce609688025..f57232b5035 100644
--- a/libstdc++-v3/src/c++23/Makefile.in
+++ b/libstdc++-v3/src/c++23/Makefile.in
@@ -14,6 +14,7 @@
@SET_MAKE@
+
VPATH = @srcdir@
am__is_gnu_make = { \
if test -z '$(MAKELEVEL)'; then \
@@ -162,6 +163,36 @@ am__can_run_installinfo = \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(pkgdatadir)" \
+ "$(DESTDIR)$(toolexeclibdir)"
+DATA = $(nobase_pkgdata_DATA) $(toolexeclib_DATA)
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates. Input order is
@@ -424,6 +455,10 @@ AM_CPPFLAGS = $(GLIBCXX_INCLUDES) $(CPPFLAGS)
# Convenience library for C++23 runtime.
noinst_LTLIBRARIES = libc++23convenience.la
+
+# module std support. Not compiled for now, only installed.
+toolexeclib_DATA = libstdc++.modules.json
+nobase_pkgdata_DATA = modules/std.cc modules/std.compat.cc
headers =
# XTEMPLATE_FLAGS =
@ENABLE_EXTERN_TEMPLATE_FALSE@inst_sources =
@@ -566,6 +601,51 @@ mostlyclean-libtool:
clean-libtool:
-rm -rf .libs _libs
+install-nobase_pkgdataDATA: $(nobase_pkgdata_DATA)
+ @$(NORMAL_INSTALL)
+ @list='$(nobase_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" || exit 1; \
+ fi; \
+ $(am__nobase_list) | while read dir files; do \
+ xfiles=; for file in $$files; do \
+ if test -f "$$file"; then xfiles="$$xfiles $$file"; \
+ else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \
+ test -z "$$xfiles" || { \
+ test "x$$dir" = x. || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)/$$dir'"; \
+ $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)/$$dir"; }; \
+ echo " $(INSTALL_DATA) $$xfiles '$(DESTDIR)$(pkgdatadir)/$$dir'"; \
+ $(INSTALL_DATA) $$xfiles "$(DESTDIR)$(pkgdatadir)/$$dir" || exit
$$?; }; \
+ done
+
+uninstall-nobase_pkgdataDATA:
+ @$(NORMAL_UNINSTALL)
+ @list='$(nobase_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \
+ $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \
+ dir='$(DESTDIR)$(pkgdatadir)'; $(am__uninstall_files_from_dir)
+install-toolexeclibDATA: $(toolexeclib_DATA)
+ @$(NORMAL_INSTALL)
+ @list='$(toolexeclib_DATA)'; test -n "$(toolexeclibdir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(toolexeclibdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(toolexeclibdir)" || exit 1; \
+ fi; \
+ for p in $$list; do \
+ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+ echo "$$d$$p"; \
+ done | $(am__base_list) | \
+ while read files; do \
+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(toolexeclibdir)'"; \
+ $(INSTALL_DATA) $$files "$(DESTDIR)$(toolexeclibdir)" || exit $$?; \
+ done
+
+uninstall-toolexeclibDATA:
+ @$(NORMAL_UNINSTALL)
+ @list='$(toolexeclib_DATA)'; test -n "$(toolexeclibdir)" || list=; \
+ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+ dir='$(DESTDIR)$(toolexeclibdir)'; $(am__uninstall_files_from_dir)
ID: $(am__tagged_files)
$(am__define_uniq_tagged_files); mkid -fID $$unique
@@ -620,8 +700,11 @@ distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
check-am: all-am
check: check-am
-all-am: Makefile $(LTLIBRARIES)
+all-am: Makefile $(LTLIBRARIES) $(DATA) all-local
installdirs:
+ for dir in "$(DESTDIR)$(pkgdatadir)" "$(DESTDIR)$(toolexeclibdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
@@ -674,13 +757,13 @@ info: info-am
info-am:
-install-data-am:
+install-data-am: install-nobase_pkgdataDATA
install-dvi: install-dvi-am
install-dvi-am:
-install-exec-am:
+install-exec-am: install-toolexeclibDATA
install-html: install-html-am
@@ -719,27 +802,43 @@ ps: ps-am
ps-am:
-uninstall-am:
+uninstall-am: uninstall-nobase_pkgdataDATA uninstall-toolexeclibDATA
.MAKE: install-am install-strip
-.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
- clean-libtool clean-noinstLTLIBRARIES cscopelist-am ctags \
- ctags-am distclean distclean-compile distclean-generic \
- distclean-libtool distclean-tags dvi dvi-am html html-am info \
- info-am install install-am install-data install-data-am \
- install-dvi install-dvi-am install-exec install-exec-am \
- install-html install-html-am install-info install-info-am \
- install-man install-pdf install-pdf-am install-ps \
- install-ps-am install-strip installcheck installcheck-am \
- installdirs maintainer-clean maintainer-clean-generic \
- mostlyclean mostlyclean-compile mostlyclean-generic \
- mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
- uninstall-am
+.PHONY: CTAGS GTAGS TAGS all all-am all-local check check-am clean \
+ clean-generic clean-libtool clean-noinstLTLIBRARIES \
+ cscopelist-am ctags ctags-am distclean distclean-compile \
+ distclean-generic distclean-libtool distclean-tags dvi dvi-am \
+ html html-am info info-am install install-am install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-man install-nobase_pkgdataDATA \
+ install-pdf install-pdf-am install-ps install-ps-am \
+ install-strip install-toolexeclibDATA installcheck \
+ installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am \
+ uninstall-nobase_pkgdataDATA uninstall-toolexeclibDATA
.PRECIOUS: Makefile
+# The manifest to be installed uses the relative path between install dirs.
+libstdc++.modules.json: libstdc++.modules.json.in
+ relpath=$$($(toplevel_srcdir)/contrib/relpath.sh \
+ $(toolexeclibdir) $(pkgdatadir)) && \
+ sed "s,@MODPATH@,$$relpath," $< > $@
+
+# The uninstalled manifest uses the absolute path to srcdir.
+stamp-modules: libstdc++.modules.json.in
+ sed 's,@MODPATH@,$(srcdir),' $< \
+ > ../.libs/libstdc++.modules.json
+ @touch stamp-modules
+
+all-local: stamp-modules
+
vpath % $(top_srcdir)/src/c++23
# Use C++26 so that std::filebuf::native_handle() is available.
diff --git a/libstdc++-v3/src/c++23/libstdc++.modules.json.in
b/libstdc++-v3/src/c++23/libstdc++.modules.json.in
new file mode 100644
index 00000000000..50714d9c164
--- /dev/null
+++ b/libstdc++-v3/src/c++23/libstdc++.modules.json.in
@@ -0,0 +1,17 @@
+// C++ module metadata, to install alongside libstdc++.so
+{
+ "version": 1,
+ "revision": 1,
+ "modules": [
+ {
+ "logical-name": "std",
+ "source-path": "@MODPATH@/modules/std.cc",
+ "is-std-library": true
+ },
+ {
+ "logical-name": "std.compat",
+ "source-path": "@MODPATH@/modules/std.compat.cc",
+ "is-std-library": true
+ }
+ ]
+}
base-commit: 453d3d90c374d3bb329f1431b7dfb8d0510a88b9
--
2.47.0
