On Fri, 18 Oct 2024, Jason Merrill wrote:
> 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?
IIUC the src/ subdirectory is for stuff that gets compiled into the .so
which isn't the case here. And if we want to support the std module in
C++20 mode as an extension, a c++23 subdirectory might not be ideal either.
Maybe libstdc++-v3/modules/ then?
>
> 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
> + {}
Empty namespace (here and twice more below)?
> + 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
Just wondering, why are only some exports guarded by their feature-test
macro? Relatedly would we want to support the std module as an
extension in C++20 mode and to that end guard all C++23 exports?
> +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
>
>
