diff options
| -rw-r--r-- | libstdc++-v3/include/Makefile.am | 10 | ||||
| -rw-r--r-- | libstdc++-v3/include/Makefile.in | 10 | ||||
| -rw-r--r-- | libstdc++-v3/include/bits/version.def | 1597 | ||||
| -rw-r--r-- | libstdc++-v3/include/bits/version.h | 1942 | ||||
| -rw-r--r-- | libstdc++-v3/include/bits/version.tpl | 210 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/version | 350 |
6 files changed, 3770 insertions, 349 deletions
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index a880e8e..9c71c75 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -154,6 +154,7 @@ bits_freestanding = \ ${bits_srcdir}/stl_raw_storage_iter.h \ ${bits_srcdir}/stl_relops.h \ ${bits_srcdir}/stl_uninitialized.h \ + ${bits_srcdir}/version.h \ ${bits_srcdir}/string_view.tcc \ ${bits_srcdir}/uniform_int_dist.h \ ${bits_srcdir}/unique_ptr.h \ @@ -1113,7 +1114,8 @@ allcreated = \ ${host_builddir}/c++config.h \ ${host_builddir}/largefile-config.h \ ${thread_host_headers} \ - ${pch_build} + ${pch_build} \ + ${bits_srcdir}/version.h # Here are the rules for building the headers all-local: ${allstamped} ${allcreated} @@ -1463,6 +1465,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output} -mkdir -p ${pch3_output_builddir} $(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@ +# AutoGen <bits/version.h>. +.PHONY: update-version +update-version: + cd ${bits_srcdir} && \ + autogen version.def + # The real deal. install-data-local: install-headers install-headers: diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 0ff875b..f5b04d3 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -509,6 +509,7 @@ bits_freestanding = \ ${bits_srcdir}/stl_raw_storage_iter.h \ ${bits_srcdir}/stl_relops.h \ ${bits_srcdir}/stl_uninitialized.h \ + ${bits_srcdir}/version.h \ ${bits_srcdir}/string_view.tcc \ ${bits_srcdir}/uniform_int_dist.h \ ${bits_srcdir}/unique_ptr.h \ @@ -1441,7 +1442,8 @@ allcreated = \ ${host_builddir}/c++config.h \ ${host_builddir}/largefile-config.h \ ${thread_host_headers} \ - ${pch_build} + ${pch_build} \ + ${bits_srcdir}/version.h # Host includes for threads @@ -1937,6 +1939,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output} -mkdir -p ${pch3_output_builddir} $(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@ +# AutoGen <bits/version.h>. +${bits_srcdir}/version.h: ${bits_srcdir}/version.def \ + ${bits_srcdir}/version.tpl + cd $(@D) && \ + autogen version.def + # The real deal. install-data-local: install-headers install-headers: diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def new file mode 100644 index 0000000..e63715e --- /dev/null +++ b/libstdc++-v3/include/bits/version.def @@ -0,0 +1,1597 @@ +// Feature test macro definitions -*- C++ -*- +// Copyright (C) 2023 Free Software Foundation, Inc. + +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +AutoGen Definitions version.tpl; + +// The top level variable ftms is an array of feature test macros. Each entry +// consists of a structure like following: + +// Schema: +// ftms = { +// name = FTM NAME; +// [stdname = FTM STANDARD MACRO NAME;] +// values = { +// v = VALUE FOR FTM IF MATCHING; +// [extra_cond = STRING;] +// [cxxmin = NUMBER;] +// [gnuxxmin = NUMBER;] +// [gthread = yes|no;] +// [hosted = yes|no;] +// [cxx11abi = yes|no;] +// }; ... +// }; + +// The elements in square brackets are optional. These are formulated into a +// logical expression like: +// ((strict && c++ >= cxxmin) || (!strict && c++ >= gnuxxmin)) +// && (gthr <=> gthread) +// && (host <=> hosted) +// && (cxx11 <=> cxx11abi) +// && (extra_cond) +// Where gthr, cxx11 and host are _GLIBCXX_HAS_GTHREADS, _GLIBCXX_USE_CXX11_ABI +// and _GLIBCXX_HOSTED respectively. If any of these are omitted, their +// sub-expressions are equivalent to the identity. Specially, if gnuxxmin is +// omitted, it is taken to be the value of cxxmin, and so, only if both are +// omitted, the clause is omitted. + +// stdname configures the name of the *standard* macro emitted, i.e. it +// replaces only the __cpp_lib_ macro in the emitted definition. Defaults to +// __cpp_lib_${name} + +// N.B This list needs to be in topological sort order, as later entries in +// this list can and do use the earlier entries. + +ftms = { + name = incomplete_container_elements; + values = { + v = 201505; + hosted = yes; + }; +}; + +ftms = { + name = uncaught_exceptions; + values = { + v = 201411; + cxxmin = 17; + gnuxxmin = 03; + }; +}; + +ftms = { + name = allocator_traits_is_always_equal; + values = { + v = 201411; + cxxmin = 11; + }; +}; + +ftms = { + name = is_null_pointer; + values = { + v = 201309; + cxxmin = 11; + }; +}; + +ftms = { + name = result_of_sfinae; + values = { + v = 201210; + cxxmin = 11; + }; +}; + +ftms = { + name = shared_ptr_arrays; + values = { + v = 201707; + cxxmin = 20; + hosted = yes; + }; + values = { + v = 201611; + cxxmin = 11; + hosted = yes; + }; +}; + +ftms = { + name = is_swappable; + values = { + v = 201603; + cxxmin = 17; + gnuxxmin = 11; + }; +}; + +ftms = { + name = void_t; + values = { + v = 201411; + cxxmin = 17; + gnuxxmin = 11; + }; +}; + +ftms = { + name = enable_shared_from_this; + values = { + v = 201603; + cxxmin = 17; + gnuxxmin = 11; + hosted = yes; + }; +}; + +ftms = { + name = math_spec_funcs; + stdname = "__STDCPP_MATH_SPEC_FUNCS__"; + values = { + v = 201003; + cxxmin = 11; + }; +}; + +ftms = { + name = coroutine; + values = { + v = 201902; + // It is very likely that earlier versions would work, but they are + // untested. + cxxmin = 14; + extra_cond = "__cpp_impl_coroutine"; + }; +}; + +ftms = { + name = exchange_function; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = integer_sequence; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = integral_constant_callable; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = is_final; + values = { + v = 201402; + cxxmin = 14; + }; +}; + +ftms = { + name = make_reverse_iterator; + values = { + v = 201402; + cxxmin = 14; + }; +}; + +ftms = { + name = null_iterators; + values = { + v = 201304; + cxxmin = 14; + extra_cond = "!defined(_GLIBCXX_DEBUG)"; + }; +}; + +ftms = { + name = transformation_trait_aliases; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = transparent_operators; + values = { + v = 201510; + cxxmin = 14; + }; +}; + +ftms = { + name = tuple_element_t; + values = { + v = 201402; + cxxmin = 14; + }; +}; + +ftms = { + name = tuples_by_type; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = robust_nonmodifying_seq_ops; + values = { + v = 201304; + cxxmin = 14; + }; +}; + +ftms = { + name = to_chars; + values = { + v = 201611; + cxxmin = 14; + extra_cond = "_GLIBCXX_FLOAT_IS_IEEE_BINARY32 " + "&& _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 " + "&& __SIZE_WIDTH__ >= 32"; + }; +}; + +ftms = { + name = chrono_udls; + values = { + v = 201304; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = complex_udls; + values = { + v = 201309; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = generic_associative_lookup; + values = { + v = 201304; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = make_unique; + values = { + v = 201304; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = quoted_string_io; + values = { + v = 201304; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = shared_timed_mutex; + values = { + v = 201402; + cxxmin = 14; + hosted = yes; + gthread = yes; + }; +}; + +ftms = { + name = string_udls; + values = { + v = 201304; + cxxmin = 14; + hosted = yes; + }; +}; + +ftms = { + name = addressof_constexpr; + values = { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2296. std::addressof should be constexpr + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = any; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = apply; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = as_const; + values = { + v = 201510; + cxxmin = 17; + }; +}; + +ftms = { + name = atomic_is_always_lock_free; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = bool_constant; + values = { + v = 201505; + cxxmin = 17; + }; +}; + +ftms = { + name = byte; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = has_unique_object_representations; + values = { + v = 201606; + cxxmin = 17; + extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP)"; + }; +}; + +ftms = { + name = hardware_interference_size; + values = { + v = 201703; + cxxmin = 17; + extra_cond = "defined(__GCC_DESTRUCTIVE_SIZE)"; + }; +}; + +ftms = { + name = invoke; + values = { + v = 201411; + cxxmin = 17; + }; +}; + +ftms = { + name = is_aggregate; + values = { + v = 201703; + cxxmin = 17; + extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE)"; + }; +}; + +ftms = { + name = is_invocable; + values = { + v = 201703; + cxxmin = 17; + }; +}; + +ftms = { + name = launder; + values = { + v = 201606; + cxxmin = 17; + extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER)"; + }; +}; + +ftms = { + name = logical_traits; + values = { + v = 201510; + cxxmin = 17; + }; +}; + +ftms = { + name = make_from_tuple; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = not_fn; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = type_trait_variable_templates; + values = { + v = 201510; + cxxmin = 17; + }; +}; + +ftms = { + name = variant; + values = { + v = 202106; + cxxmin = 20; + extra_cond = "__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L"; + }; + values = { + v = 202102; + cxxmin = 17; + }; +}; + +ftms = { + // Used in earlier draft of SD6. + name = lcm; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + // Used in earlier draft of SD6. + name = gcd; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = gcd_lcm; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = raw_memory_algorithms; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = array_constexpr; + values = { + v = 201811; + cxxmin = 20; + }; + values = { + v = 201803; + cxxmin = 17; + }; +}; + +ftms = { + name = nonmember_container_access; + values = { + v = 201411; + cxxmin = 17; + }; +}; + +ftms = { + name = clamp; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = sample; + values = { + v = 201603; + cxxmin = 17; + }; +}; + +ftms = { + name = boyer_moore_searcher; + values = { + v = 201603; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = chrono; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + }; + values = { + v = 201611; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = execution; + values = { + v = 201902; // FIXME: should be 201603L + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = filesystem; + values = { + v = 201703; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = hypot; + values = { + v = 201603; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = map_try_emplace; + values = { + v = 201411; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = math_special_functions; + values = { + v = 201603; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = memory_resource; + values = { + v = 201603; + cxxmin = 17; + hosted = yes; + gthread = yes; + }; + values = { + v = 1; + /* For when there's no gthread. */ + cxxmin = 17; + hosted = yes; + gthread = no; + }; +}; + +ftms = { + name = node_extract; + values = { + v = 201606; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = parallel_algorithm; + values = { + v = 201603; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = scoped_lock; + values = { + v = 201703; + cxxmin = 17; + hosted = yes; + gthread = yes; + }; +}; + +ftms = { + name = shared_mutex; + values = { + v = 201505; + cxxmin = 17; + hosted = yes; + gthread = yes; + }; +}; + +ftms = { + name = shared_ptr_weak_type; + values = { + v = 201606; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = string_view; + values = { + v = 201803; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = unordered_map_try_emplace; + values = { + v = 201411; + cxxmin = 17; + hosted = yes; + }; +}; + +ftms = { + name = assume_aligned; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_flag_test; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_float; + values = { + v = 201711; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_lock_free_type_aliases; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_ref; + values = { + v = 201806; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_value_initialization; + values = { + v = 201911; + cxxmin = 20; + }; +}; + +ftms = { + name = bind_front; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = starts_ends_with; + values = { + v = 201711; + cxxmin = 20; + }; +}; + +ftms = { + name = bit_cast; + values = { + v = 201806; + cxxmin = 20; + extra_cond = "__has_builtin(__builtin_bit_cast)"; + }; +}; + +ftms = { + name = bitops; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = bounded_array_traits; + values = { + v = 201902; + cxxmin = 20; + }; +}; + +ftms = { + name = concepts; + values = { + v = 202002; + cxxmin = 20; + extra_cond = "__cpp_concepts >= 201907L"; + }; +}; + +// Moved down here (after concepts) by topological sort. +ftms = { + name = optional; + values = { + v = 202110; + cxxmin = 23; + extra_cond = "__glibcxx_concepts"; + }; + values = { + v = 202106; + cxxmin = 20; + }; + values = { + v = 201606; + cxxmin = 17; + }; +}; + +ftms = { + name = destroying_delete; + values = { + v = 201806; + cxxmin = 20; + extra_cond = "__cpp_impl_destroying_delete"; + }; +}; + +ftms = { + name = constexpr_string_view; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = endian; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = int_pow2; + values = { + v = 202002; + cxxmin = 20; + }; +}; + +ftms = { + name = integer_comparison_functions; + values = { + v = 202002; + cxxmin = 20; + }; +}; + +ftms = { + name = is_constant_evaluated; + values = { + v = 201811; + cxxmin = 20; + extra_cond = "defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)"; + }; +}; + +// Moved down here (after is_constant_evaluated) by topological sort. +ftms = { + name = constexpr_char_traits; + values = { + // Unofficial macro indicating P1032R1 support in C++20 + v = 201811; + cxxmin = 20; + extra_cond = "defined(__glibcxx_is_constant_evaluated)"; + }; + values = { + // Unofficial macro indicating P0426R1 support in C++17 + v = 201611; + cxxmin = 17; + extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED"; + }; +}; + +ftms = { + name = is_layout_compatible; + values = { + v = 201907; + cxxmin = 20; + extra_cond = "__has_builtin(__is_layout_compatible) " + "&& __has_builtin(__builtin_is_corresponding_member)"; + }; +}; + +ftms = { + name = is_nothrow_convertible; + values = { + v = 201806; + cxxmin = 20; + }; +}; + +ftms = { + name = is_pointer_interconvertible; + values = { + v = 201907; + cxxmin = 20; + extra_cond = + "__has_builtin(__is_pointer_interconvertible_base_of) " + "&& __has_builtin(__builtin_is_pointer_interconvertible_with_class)"; + }; +}; + +ftms = { + name = math_constants; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = make_obj_using_allocator; + values = { + // Not specified by C++20, used internally + v = 201811; + cxxmin = 20; + extra_cond = "__cpp_concepts"; + }; +}; + +ftms = { + name = remove_cvref; + values = { + v = 201711; + cxxmin = 20; + }; +}; + +ftms = { + name = source_location; + values = { + v = 201907; + cxxmin = 20; + extra_cond = "__has_builtin(__builtin_source_location)"; + }; +}; + +ftms = { + name = span; + values = { + v = 202002; + cxxmin = 20; + extra_cond = "__glibcxx_concepts"; + }; +}; + +ftms = { + name = ssize; + values = { + v = 201902; + cxxmin = 20; + }; +}; + +ftms = { + name = three_way_comparison; + values = { + v = 201907; + cxxmin = 20; + extra_cond = "__cpp_impl_three_way_comparison >= 201907L " + "&& __glibcxx_concepts"; + }; +}; + +ftms = { + name = to_address; + values = { + v = 201711; + cxxmin = 20; + }; +}; + +ftms = { + name = to_array; + values = { + v = 201907; + cxxmin = 20; + extra_cond = "__cpp_generic_lambdas >= 201707L"; + }; +}; + +ftms = { + name = type_identity; + values = { + v = 201806; + cxxmin = 20; + }; +}; + +ftms = { + name = unwrap_ref; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_iterator; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = interpolate; + values = { + v = 201902; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_utility; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = shift; + values = { + v = 201806; + cxxmin = 20; + }; +}; + +ftms = { + name = ranges; + values = { + v = 202202; + cxxmin = 23; + extra_cond = "__glibcxx_concepts"; + }; + values = { + v = 202110; + cxxmin = 20; + extra_cond = "__glibcxx_concepts"; + }; +}; + +ftms = { + name = constexpr_numeric; + values = { + v = 201911; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_functional; + values = { + v = 201907; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_algorithms; + values = { + v = 201806; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_tuple; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = constexpr_memory; + values = { + v = 202202; + cxxmin = 23; + extra_cond = "__cpp_constexpr_dynamic_alloc"; + }; + values = { + v = 201811; + cxxmin = 20; + }; +}; + +ftms = { + name = atomic_shared_ptr; + values = { + v = 201711; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = atomic_wait; + // atomic_wait is available if either futexes or gthread are. + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + gthread = yes; + }; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + gthread = no; + extra_cond = "defined(_GLIBCXX_HAVE_LINUX_FUTEX)"; + }; +}; + +ftms = { + name = barrier; + values = { + v = 201907; + cxxmin = 20; + // This condition carries in the hosted&&(futex||gthread) logic from above. + extra_cond = "__cpp_aligned_new && __glibcxx_atomic_wait"; + }; +}; + +ftms = { + // 201907 Text Formatting, Integration of chrono, printf corner cases. + // 202106 std::format improvements. + // 202110 Fixing locale handling in chrono formatters, generator-like types. + // 202207 Encodings in localized formatting of chrono, basic-format-string. + // 202207 P2286R8 Formatting Ranges + // 202207 P2585R1 Improving default container formatting + // TODO: #define __cpp_lib_format_ranges 202207L + name = format; + values = { + v = 202106; + cxxmin = 20; + hosted = yes; + }; +}; + +// #undef __glibcxx_chrono +// #define __glibcxx_chrono 201907L +// FIXME: #define __glibcxx_execution 201902L + +ftms = { + name = constexpr_complex; + values = { + v = 201711; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = constexpr_dynamic_alloc; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = constexpr_string; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + cxx11abi = yes; + extra_cond = "defined(__glibcxx_is_constant_evaluated)"; + }; + values = { + v = 201811; + cxxmin = 20; + hosted = yes; + cxx11abi = no; + extra_cond = "defined(__glibcxx_is_constant_evaluated)"; + }; + values = { + v = 201611; + cxxmin = 17; + hosted = yes; + extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED"; + }; +}; + +ftms = { + name = constexpr_vector; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = erase_if; + values = { + v = 202002; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = generic_unordered_lookup; + values = { + v = 201811; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = jthread; + values = { + v = 201911; + gthread = yes; + hosted = yes; + cxxmin = 20; + }; +}; + +ftms = { + name = latch; + values = { + v = 201907; + cxxmin = 20; + extra_cond = "__glibcxx_atomic_wait"; + }; +}; + +ftms = { + name = list_remove_return_type; + values = { + v = 201806; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = polymorphic_allocator; + values = { + v = 201902; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = move_iterator_concept; + values = { + v = 202207; + // This is P2520R0, a C++23 change, but we treat it as a DR against C++20. + cxxmin = 20; + extra_cond = "__glibcxx_concepts"; + }; +}; + +ftms = { + name = semaphore; + values = { + v = 201907; + cxxmin = 20; + hosted = yes; + extra_cond = "__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE"; + }; +}; + +ftms = { + name = smart_ptr_for_overwrite; + values = { + v = 202002; + cxxmin = 20; + hosted = yes; + }; +}; + +ftms = { + name = syncbuf; + values = { + v = 201803; + cxxmin = 20; + hosted = yes; + cxx11abi = yes; + }; +}; + +ftms = { + name = byteswap; + values = { + v = 202110; + cxxmin = 23; + }; +}; + +ftms = { + name = constexpr_charconv; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = constexpr_typeinfo; + values = { + v = 202106; + cxxmin = 23; + }; +}; + +ftms = { + name = expected; + values = { + v = 202211; + cxxmin = 23; + extra_cond = "__cpp_concepts >= 202002L"; + }; +}; + +ftms = { + name = invoke_r; + values = { + v = 202106; + cxxmin = 23; + }; +}; + +ftms = { + name = is_scoped_enum; + values = { + v = 202011; + cxxmin = 23; + }; +}; + +ftms = { + name = reference_from_temporary; + values = { + v = 202202; + extra_cond = + "__has_builtin(__reference_constructs_from_temporary) " + "&& __has_builtin(__reference_converts_from_temporary)"; + cxxmin = 23; + }; +}; + +ftms = { + name = to_underlying; + values = { + v = 202102; + cxxmin = 23; + }; +}; + +ftms = { + name = unreachable; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_zip; + values = { + v = 202110; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_chunk; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_slide; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_chunk_by; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_join_with; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_repeat; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_stride; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_cartesian_product; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_as_rvalue; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_as_const; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_enumerate; + values = { + v = 202302; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_fold; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_contains; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_iota; + values = { + v = 202202; + cxxmin = 23; + }; +}; + +ftms = { + name = ranges_find_last; + values = { + v = 202207; + cxxmin = 23; + }; +}; + +ftms = { + name = constexpr_bitset; + values = { + v = 202202; + cxxmin = 23; + hosted = yes; + extra_cond = "__cpp_constexpr_dynamic_alloc"; + }; +}; + +ftms = { + name = stdatomic_h; + values = { + v = 202011; + cxxmin = 23; + }; +}; + +ftms = { + name = adaptor_iterator_pair_constructor; + values = { + v = 202106; + cxxmin = 23; + hosted = yes; + }; +}; + +ftms = { + name = ios_noreplace; + values = { + v = 202207; + cxxmin = 23; + hosted = yes; + }; +}; + +ftms = { + name = move_only_function; + values = { + v = 202110; + cxxmin = 23; + hosted = yes; + }; +}; + +ftms = { + name = spanstream; + values = { + v = 202106; + cxxmin = 23; + hosted = yes; + extra_cond = "__glibcxx_span"; + }; +}; + +ftms = { + name = stacktrace; + values = { + v = 202011; + cxxmin = 23; + hosted = yes; + extra_cond = "_GLIBCXX_HAVE_STACKTRACE"; + }; +}; + +ftms = { + name = string_contains; + values = { + v = 202011; + cxxmin = 23; + hosted = yes; + }; +}; + +ftms = { + name = string_resize_and_overwrite; + values = { + v = 202110; + cxxmin = 23; + hosted = yes; + cxx11abi = yes; + }; +}; + +// Standard test specifications. +stds[97] = ">= 199711L"; +stds[03] = ">= 199711L"; +stds[11] = ">= 201103L"; +stds[14] = ">= 201402L"; +stds[17] = ">= 201703L"; +stds[20] = ">= 202002L"; +stds[23] = "> 202002L"; // TODO: update when finalized + +// Local Variables: +// compile-command: "autogen version.def" +// End: diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h new file mode 100644 index 0000000..5c5e7ff --- /dev/null +++ b/libstdc++-v3/include/bits/version.h @@ -0,0 +1,1942 @@ +// Copyright (C) 2023 Free Software Foundation, Inc. + +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// DO NOT EDIT THIS FILE (version.h) +// +// It has been AutoGen-ed +// From the definitions version.def +// and the template file version.tpl + +/** @file bits/version.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{version} + */ + +// Usage guide: +// +// In your usual header, do something like: +// +// #define __glibcxx_want_ranges +// #define __glibcxx_want_concepts +// #include <bits/version.h> +// +// This will generate the FTMs you named, and let you use them in your code as +// if it was user code. All macros are also exposed under __glibcxx_NAME even +// if unwanted, to permit bits and other FTMs to depend on them for condtional +// computation without exposing extra FTMs to user code. + +#pragma GCC system_header + +#include <bits/c++config.h> + +// from version.def line 65 +#if !defined(__cpp_lib_incomplete_container_elements) +# if _GLIBCXX_HOSTED +# define __glibcxx_incomplete_container_elements 201505L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_incomplete_container_elements) +# define __cpp_lib_incomplete_container_elements 201505L +# endif +# endif +#endif /* !defined(__cpp_lib_incomplete_container_elements) && defined(__glibcxx_want_incomplete_container_elements) */ +#undef __glibcxx_want_incomplete_container_elements + +// from version.def line 73 +#if !defined(__cpp_lib_uncaught_exceptions) +# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 199711L)) +# define __glibcxx_uncaught_exceptions 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_uncaught_exceptions) +# define __cpp_lib_uncaught_exceptions 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_uncaught_exceptions) && defined(__glibcxx_want_uncaught_exceptions) */ +#undef __glibcxx_want_uncaught_exceptions + +// from version.def line 82 +#if !defined(__cpp_lib_allocator_traits_is_always_equal) +# if (__cplusplus >= 201103L) +# define __glibcxx_allocator_traits_is_always_equal 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_allocator_traits_is_always_equal) +# define __cpp_lib_allocator_traits_is_always_equal 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_allocator_traits_is_always_equal) && defined(__glibcxx_want_allocator_traits_is_always_equal) */ +#undef __glibcxx_want_allocator_traits_is_always_equal + +// from version.def line 90 +#if !defined(__cpp_lib_is_null_pointer) +# if (__cplusplus >= 201103L) +# define __glibcxx_is_null_pointer 201309L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_null_pointer) +# define __cpp_lib_is_null_pointer 201309L +# endif +# endif +#endif /* !defined(__cpp_lib_is_null_pointer) && defined(__glibcxx_want_is_null_pointer) */ +#undef __glibcxx_want_is_null_pointer + +// from version.def line 98 +#if !defined(__cpp_lib_result_of_sfinae) +# if (__cplusplus >= 201103L) +# define __glibcxx_result_of_sfinae 201210L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_result_of_sfinae) +# define __cpp_lib_result_of_sfinae 201210L +# endif +# endif +#endif /* !defined(__cpp_lib_result_of_sfinae) && defined(__glibcxx_want_result_of_sfinae) */ +#undef __glibcxx_want_result_of_sfinae + +// from version.def line 106 +#if !defined(__cpp_lib_shared_ptr_arrays) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_shared_ptr_arrays 201707L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays) +# define __cpp_lib_shared_ptr_arrays 201707L +# endif +# elif (__cplusplus >= 201103L) && _GLIBCXX_HOSTED +# define __glibcxx_shared_ptr_arrays 201611L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays) +# define __cpp_lib_shared_ptr_arrays 201611L +# endif +# endif +#endif /* !defined(__cpp_lib_shared_ptr_arrays) && defined(__glibcxx_want_shared_ptr_arrays) */ +#undef __glibcxx_want_shared_ptr_arrays + +// from version.def line 120 +#if !defined(__cpp_lib_is_swappable) +# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L)) +# define __glibcxx_is_swappable 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_swappable) +# define __cpp_lib_is_swappable 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_is_swappable) && defined(__glibcxx_want_is_swappable) */ +#undef __glibcxx_want_is_swappable + +// from version.def line 129 +#if !defined(__cpp_lib_void_t) +# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L)) +# define __glibcxx_void_t 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_void_t) +# define __cpp_lib_void_t 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_void_t) && defined(__glibcxx_want_void_t) */ +#undef __glibcxx_want_void_t + +// from version.def line 138 +#if !defined(__cpp_lib_enable_shared_from_this) +# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L)) && _GLIBCXX_HOSTED +# define __glibcxx_enable_shared_from_this 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_enable_shared_from_this) +# define __cpp_lib_enable_shared_from_this 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_enable_shared_from_this) && defined(__glibcxx_want_enable_shared_from_this) */ +#undef __glibcxx_want_enable_shared_from_this + +// from version.def line 148 +#if !defined(__cpp_lib_math_spec_funcs) +# if (__cplusplus >= 201103L) +# define __glibcxx_math_spec_funcs 201003L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_spec_funcs) +# define __STDCPP_MATH_SPEC_FUNCS__ 201003L +# endif +# endif +#endif /* !defined(__cpp_lib_math_spec_funcs) && defined(__glibcxx_want_math_spec_funcs) */ +#undef __glibcxx_want_math_spec_funcs + +// from version.def line 157 +#if !defined(__cpp_lib_coroutine) +# if (__cplusplus >= 201402L) && (__cpp_impl_coroutine) +# define __glibcxx_coroutine 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_coroutine) +# define __cpp_lib_coroutine 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_coroutine) && defined(__glibcxx_want_coroutine) */ +#undef __glibcxx_want_coroutine + +// from version.def line 168 +#if !defined(__cpp_lib_exchange_function) +# if (__cplusplus >= 201402L) +# define __glibcxx_exchange_function 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_exchange_function) +# define __cpp_lib_exchange_function 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_exchange_function) && defined(__glibcxx_want_exchange_function) */ +#undef __glibcxx_want_exchange_function + +// from version.def line 176 +#if !defined(__cpp_lib_integer_sequence) +# if (__cplusplus >= 201402L) +# define __glibcxx_integer_sequence 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_sequence) +# define __cpp_lib_integer_sequence 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_integer_sequence) && defined(__glibcxx_want_integer_sequence) */ +#undef __glibcxx_want_integer_sequence + +// from version.def line 184 +#if !defined(__cpp_lib_integral_constant_callable) +# if (__cplusplus >= 201402L) +# define __glibcxx_integral_constant_callable 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integral_constant_callable) +# define __cpp_lib_integral_constant_callable 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_integral_constant_callable) && defined(__glibcxx_want_integral_constant_callable) */ +#undef __glibcxx_want_integral_constant_callable + +// from version.def line 192 +#if !defined(__cpp_lib_is_final) +# if (__cplusplus >= 201402L) +# define __glibcxx_is_final 201402L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_final) +# define __cpp_lib_is_final 201402L +# endif +# endif +#endif /* !defined(__cpp_lib_is_final) && defined(__glibcxx_want_is_final) */ +#undef __glibcxx_want_is_final + +// from version.def line 200 +#if !defined(__cpp_lib_make_reverse_iterator) +# if (__cplusplus >= 201402L) +# define __glibcxx_make_reverse_iterator 201402L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_reverse_iterator) +# define __cpp_lib_make_reverse_iterator 201402L +# endif +# endif +#endif /* !defined(__cpp_lib_make_reverse_iterator) && defined(__glibcxx_want_make_reverse_iterator) */ +#undef __glibcxx_want_make_reverse_iterator + +// from version.def line 208 +#if !defined(__cpp_lib_null_iterators) +# if (__cplusplus >= 201402L) && (!defined(_GLIBCXX_DEBUG)) +# define __glibcxx_null_iterators 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_null_iterators) +# define __cpp_lib_null_iterators 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_null_iterators) && defined(__glibcxx_want_null_iterators) */ +#undef __glibcxx_want_null_iterators + +// from version.def line 217 +#if !defined(__cpp_lib_transformation_trait_aliases) +# if (__cplusplus >= 201402L) +# define __glibcxx_transformation_trait_aliases 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transformation_trait_aliases) +# define __cpp_lib_transformation_trait_aliases 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_transformation_trait_aliases) && defined(__glibcxx_want_transformation_trait_aliases) */ +#undef __glibcxx_want_transformation_trait_aliases + +// from version.def line 225 +#if !defined(__cpp_lib_transparent_operators) +# if (__cplusplus >= 201402L) +# define __glibcxx_transparent_operators 201510L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transparent_operators) +# define __cpp_lib_transparent_operators 201510L +# endif +# endif +#endif /* !defined(__cpp_lib_transparent_operators) && defined(__glibcxx_want_transparent_operators) */ +#undef __glibcxx_want_transparent_operators + +// from version.def line 233 +#if !defined(__cpp_lib_tuple_element_t) +# if (__cplusplus >= 201402L) +# define __glibcxx_tuple_element_t 201402L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuple_element_t) +# define __cpp_lib_tuple_element_t 201402L +# endif +# endif +#endif /* !defined(__cpp_lib_tuple_element_t) && defined(__glibcxx_want_tuple_element_t) */ +#undef __glibcxx_want_tuple_element_t + +// from version.def line 241 +#if !defined(__cpp_lib_tuples_by_type) +# if (__cplusplus >= 201402L) +# define __glibcxx_tuples_by_type 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuples_by_type) +# define __cpp_lib_tuples_by_type 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_tuples_by_type) && defined(__glibcxx_want_tuples_by_type) */ +#undef __glibcxx_want_tuples_by_type + +// from version.def line 249 +#if !defined(__cpp_lib_robust_nonmodifying_seq_ops) +# if (__cplusplus >= 201402L) +# define __glibcxx_robust_nonmodifying_seq_ops 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_robust_nonmodifying_seq_ops) +# define __cpp_lib_robust_nonmodifying_seq_ops 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_robust_nonmodifying_seq_ops) && defined(__glibcxx_want_robust_nonmodifying_seq_ops) */ +#undef __glibcxx_want_robust_nonmodifying_seq_ops + +// from version.def line 257 +#if !defined(__cpp_lib_to_chars) +# if (__cplusplus >= 201402L) && (_GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 && __SIZE_WIDTH__ >= 32) +# define __glibcxx_to_chars 201611L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_chars) +# define __cpp_lib_to_chars 201611L +# endif +# endif +#endif /* !defined(__cpp_lib_to_chars) && defined(__glibcxx_want_to_chars) */ +#undef __glibcxx_want_to_chars + +// from version.def line 268 +#if !defined(__cpp_lib_chrono_udls) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_chrono_udls 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono_udls) +# define __cpp_lib_chrono_udls 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_chrono_udls) && defined(__glibcxx_want_chrono_udls) */ +#undef __glibcxx_want_chrono_udls + +// from version.def line 277 +#if !defined(__cpp_lib_complex_udls) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_complex_udls 201309L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_complex_udls) +# define __cpp_lib_complex_udls 201309L +# endif +# endif +#endif /* !defined(__cpp_lib_complex_udls) && defined(__glibcxx_want_complex_udls) */ +#undef __glibcxx_want_complex_udls + +// from version.def line 286 +#if !defined(__cpp_lib_generic_associative_lookup) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_generic_associative_lookup 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_associative_lookup) +# define __cpp_lib_generic_associative_lookup 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_generic_associative_lookup) && defined(__glibcxx_want_generic_associative_lookup) */ +#undef __glibcxx_want_generic_associative_lookup + +// from version.def line 295 +#if !defined(__cpp_lib_make_unique) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_make_unique 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_unique) +# define __cpp_lib_make_unique 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_make_unique) && defined(__glibcxx_want_make_unique) */ +#undef __glibcxx_want_make_unique + +// from version.def line 304 +#if !defined(__cpp_lib_quoted_string_io) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_quoted_string_io 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_quoted_string_io) +# define __cpp_lib_quoted_string_io 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_quoted_string_io) && defined(__glibcxx_want_quoted_string_io) */ +#undef __glibcxx_want_quoted_string_io + +// from version.def line 313 +#if !defined(__cpp_lib_shared_timed_mutex) +# if (__cplusplus >= 201402L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_shared_timed_mutex 201402L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_timed_mutex) +# define __cpp_lib_shared_timed_mutex 201402L +# endif +# endif +#endif /* !defined(__cpp_lib_shared_timed_mutex) && defined(__glibcxx_want_shared_timed_mutex) */ +#undef __glibcxx_want_shared_timed_mutex + +// from version.def line 323 +#if !defined(__cpp_lib_string_udls) +# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED +# define __glibcxx_string_udls 201304L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_udls) +# define __cpp_lib_string_udls 201304L +# endif +# endif +#endif /* !defined(__cpp_lib_string_udls) && defined(__glibcxx_want_string_udls) */ +#undef __glibcxx_want_string_udls + +// from version.def line 332 +#if !defined(__cpp_lib_addressof_constexpr) +# if (__cplusplus >= 201703L) +# define __glibcxx_addressof_constexpr 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_addressof_constexpr) +# define __cpp_lib_addressof_constexpr 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_addressof_constexpr) && defined(__glibcxx_want_addressof_constexpr) */ +#undef __glibcxx_want_addressof_constexpr + +// from version.def line 342 +#if !defined(__cpp_lib_any) +# if (__cplusplus >= 201703L) +# define __glibcxx_any 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_any) +# define __cpp_lib_any 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_any) && defined(__glibcxx_want_any) */ +#undef __glibcxx_want_any + +// from version.def line 350 +#if !defined(__cpp_lib_apply) +# if (__cplusplus >= 201703L) +# define __glibcxx_apply 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_apply) +# define __cpp_lib_apply 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_apply) && defined(__glibcxx_want_apply) */ +#undef __glibcxx_want_apply + +// from version.def line 358 +#if !defined(__cpp_lib_as_const) +# if (__cplusplus >= 201703L) +# define __glibcxx_as_const 201510L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_as_const) +# define __cpp_lib_as_const 201510L +# endif +# endif +#endif /* !defined(__cpp_lib_as_const) && defined(__glibcxx_want_as_const) */ +#undef __glibcxx_want_as_const + +// from version.def line 366 +#if !defined(__cpp_lib_atomic_is_always_lock_free) +# if (__cplusplus >= 201703L) +# define __glibcxx_atomic_is_always_lock_free 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_is_always_lock_free) +# define __cpp_lib_atomic_is_always_lock_free 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_is_always_lock_free) && defined(__glibcxx_want_atomic_is_always_lock_free) */ +#undef __glibcxx_want_atomic_is_always_lock_free + +// from version.def line 374 +#if !defined(__cpp_lib_bool_constant) +# if (__cplusplus >= 201703L) +# define __glibcxx_bool_constant 201505L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bool_constant) +# define __cpp_lib_bool_constant 201505L +# endif +# endif +#endif /* !defined(__cpp_lib_bool_constant) && defined(__glibcxx_want_bool_constant) */ +#undef __glibcxx_want_bool_constant + +// from version.def line 382 +#if !defined(__cpp_lib_byte) +# if (__cplusplus >= 201703L) +# define __glibcxx_byte 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byte) +# define __cpp_lib_byte 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_byte) && defined(__glibcxx_want_byte) */ +#undef __glibcxx_want_byte + +// from version.def line 390 +#if !defined(__cpp_lib_has_unique_object_representations) +# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP)) +# define __glibcxx_has_unique_object_representations 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_has_unique_object_representations) +# define __cpp_lib_has_unique_object_representations 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_has_unique_object_representations) && defined(__glibcxx_want_has_unique_object_representations) */ +#undef __glibcxx_want_has_unique_object_representations + +// from version.def line 399 +#if !defined(__cpp_lib_hardware_interference_size) +# if (__cplusplus >= 201703L) && (defined(__GCC_DESTRUCTIVE_SIZE)) +# define __glibcxx_hardware_interference_size 201703L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hardware_interference_size) +# define __cpp_lib_hardware_interference_size 201703L +# endif +# endif +#endif /* !defined(__cpp_lib_hardware_interference_size) && defined(__glibcxx_want_hardware_interference_size) */ +#undef __glibcxx_want_hardware_interference_size + +// from version.def line 408 +#if !defined(__cpp_lib_invoke) +# if (__cplusplus >= 201703L) +# define __glibcxx_invoke 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke) +# define __cpp_lib_invoke 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_invoke) && defined(__glibcxx_want_invoke) */ +#undef __glibcxx_want_invoke + +// from version.def line 416 +#if !defined(__cpp_lib_is_aggregate) +# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE)) +# define __glibcxx_is_aggregate 201703L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_aggregate) +# define __cpp_lib_is_aggregate 201703L +# endif +# endif +#endif /* !defined(__cpp_lib_is_aggregate) && defined(__glibcxx_want_is_aggregate) */ +#undef __glibcxx_want_is_aggregate + +// from version.def line 425 +#if !defined(__cpp_lib_is_invocable) +# if (__cplusplus >= 201703L) +# define __glibcxx_is_invocable 201703L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_invocable) +# define __cpp_lib_is_invocable 201703L +# endif +# endif +#endif /* !defined(__cpp_lib_is_invocable) && defined(__glibcxx_want_is_invocable) */ +#undef __glibcxx_want_is_invocable + +// from version.def line 433 +#if !defined(__cpp_lib_launder) +# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER)) +# define __glibcxx_launder 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_launder) +# define __cpp_lib_launder 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_launder) && defined(__glibcxx_want_launder) */ +#undef __glibcxx_want_launder + +// from version.def line 442 +#if !defined(__cpp_lib_logical_traits) +# if (__cplusplus >= 201703L) +# define __glibcxx_logical_traits 201510L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_logical_traits) +# define __cpp_lib_logical_traits 201510L +# endif +# endif +#endif /* !defined(__cpp_lib_logical_traits) && defined(__glibcxx_want_logical_traits) */ +#undef __glibcxx_want_logical_traits + +// from version.def line 450 +#if !defined(__cpp_lib_make_from_tuple) +# if (__cplusplus >= 201703L) +# define __glibcxx_make_from_tuple 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_from_tuple) +# define __cpp_lib_make_from_tuple 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_make_from_tuple) && defined(__glibcxx_want_make_from_tuple) */ +#undef __glibcxx_want_make_from_tuple + +// from version.def line 458 +#if !defined(__cpp_lib_not_fn) +# if (__cplusplus >= 201703L) +# define __glibcxx_not_fn 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_not_fn) +# define __cpp_lib_not_fn 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_not_fn) && defined(__glibcxx_want_not_fn) */ +#undef __glibcxx_want_not_fn + +// from version.def line 466 +#if !defined(__cpp_lib_type_trait_variable_templates) +# if (__cplusplus >= 201703L) +# define __glibcxx_type_trait_variable_templates 201510L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_trait_variable_templates) +# define __cpp_lib_type_trait_variable_templates 201510L +# endif +# endif +#endif /* !defined(__cpp_lib_type_trait_variable_templates) && defined(__glibcxx_want_type_trait_variable_templates) */ +#undef __glibcxx_want_type_trait_variable_templates + +// from version.def line 474 +#if !defined(__cpp_lib_variant) +# if (__cplusplus >= 202002L) && (__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L) +# define __glibcxx_variant 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant) +# define __cpp_lib_variant 202106L +# endif +# elif (__cplusplus >= 201703L) +# define __glibcxx_variant 202102L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant) +# define __cpp_lib_variant 202102L +# endif +# endif +#endif /* !defined(__cpp_lib_variant) && defined(__glibcxx_want_variant) */ +#undef __glibcxx_want_variant + +// from version.def line 488 +#if !defined(__cpp_lib_lcm) +# if (__cplusplus >= 201703L) +# define __glibcxx_lcm 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_lcm) +# define __cpp_lib_lcm 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_lcm) && defined(__glibcxx_want_lcm) */ +#undef __glibcxx_want_lcm + +// from version.def line 497 +#if !defined(__cpp_lib_gcd) +# if (__cplusplus >= 201703L) +# define __glibcxx_gcd 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd) +# define __cpp_lib_gcd 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_gcd) && defined(__glibcxx_want_gcd) */ +#undef __glibcxx_want_gcd + +// from version.def line 505 +#if !defined(__cpp_lib_gcd_lcm) +# if (__cplusplus >= 201703L) +# define __glibcxx_gcd_lcm 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd_lcm) +# define __cpp_lib_gcd_lcm 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_gcd_lcm) && defined(__glibcxx_want_gcd_lcm) */ +#undef __glibcxx_want_gcd_lcm + +// from version.def line 513 +#if !defined(__cpp_lib_raw_memory_algorithms) +# if (__cplusplus >= 201703L) +# define __glibcxx_raw_memory_algorithms 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_raw_memory_algorithms) +# define __cpp_lib_raw_memory_algorithms 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_raw_memory_algorithms) && defined(__glibcxx_want_raw_memory_algorithms) */ +#undef __glibcxx_want_raw_memory_algorithms + +// from version.def line 521 +#if !defined(__cpp_lib_array_constexpr) +# if (__cplusplus >= 202002L) +# define __glibcxx_array_constexpr 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr) +# define __cpp_lib_array_constexpr 201811L +# endif +# elif (__cplusplus >= 201703L) +# define __glibcxx_array_constexpr 201803L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr) +# define __cpp_lib_array_constexpr 201803L +# endif +# endif +#endif /* !defined(__cpp_lib_array_constexpr) && defined(__glibcxx_want_array_constexpr) */ +#undef __glibcxx_want_array_constexpr + +// from version.def line 533 +#if !defined(__cpp_lib_nonmember_container_access) +# if (__cplusplus >= 201703L) +# define __glibcxx_nonmember_container_access 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_nonmember_container_access) +# define __cpp_lib_nonmember_container_access 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_nonmember_container_access) && defined(__glibcxx_want_nonmember_container_access) */ +#undef __glibcxx_want_nonmember_container_access + +// from version.def line 541 +#if !defined(__cpp_lib_clamp) +# if (__cplusplus >= 201703L) +# define __glibcxx_clamp 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_clamp) +# define __cpp_lib_clamp 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_clamp) && defined(__glibcxx_want_clamp) */ +#undef __glibcxx_want_clamp + +// from version.def line 549 +#if !defined(__cpp_lib_sample) +# if (__cplusplus >= 201703L) +# define __glibcxx_sample 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_sample) +# define __cpp_lib_sample 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_sample) && defined(__glibcxx_want_sample) */ +#undef __glibcxx_want_sample + +// from version.def line 557 +#if !defined(__cpp_lib_boyer_moore_searcher) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_boyer_moore_searcher 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_boyer_moore_searcher) +# define __cpp_lib_boyer_moore_searcher 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_boyer_moore_searcher) && defined(__glibcxx_want_boyer_moore_searcher) */ +#undef __glibcxx_want_boyer_moore_searcher + +// from version.def line 566 +#if !defined(__cpp_lib_chrono) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_chrono 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono) +# define __cpp_lib_chrono 201907L +# endif +# elif (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_chrono 201611L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono) +# define __cpp_lib_chrono 201611L +# endif +# endif +#endif /* !defined(__cpp_lib_chrono) && defined(__glibcxx_want_chrono) */ +#undef __glibcxx_want_chrono + +// from version.def line 580 +#if !defined(__cpp_lib_execution) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_execution 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_execution) +# define __cpp_lib_execution 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_execution) && defined(__glibcxx_want_execution) */ +#undef __glibcxx_want_execution + +// from version.def line 589 +#if !defined(__cpp_lib_filesystem) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_filesystem 201703L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_filesystem) +# define __cpp_lib_filesystem 201703L +# endif +# endif +#endif /* !defined(__cpp_lib_filesystem) && defined(__glibcxx_want_filesystem) */ +#undef __glibcxx_want_filesystem + +// from version.def line 598 +#if !defined(__cpp_lib_hypot) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_hypot 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hypot) +# define __cpp_lib_hypot 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_hypot) && defined(__glibcxx_want_hypot) */ +#undef __glibcxx_want_hypot + +// from version.def line 607 +#if !defined(__cpp_lib_map_try_emplace) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_map_try_emplace 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_map_try_emplace) +# define __cpp_lib_map_try_emplace 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_map_try_emplace) && defined(__glibcxx_want_map_try_emplace) */ +#undef __glibcxx_want_map_try_emplace + +// from version.def line 616 +#if !defined(__cpp_lib_math_special_functions) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_math_special_functions 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_special_functions) +# define __cpp_lib_math_special_functions 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_math_special_functions) && defined(__glibcxx_want_math_special_functions) */ +#undef __glibcxx_want_math_special_functions + +// from version.def line 625 +#if !defined(__cpp_lib_memory_resource) +# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_memory_resource 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource) +# define __cpp_lib_memory_resource 201603L +# endif +# elif (__cplusplus >= 201703L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_memory_resource 1L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource) +# define __cpp_lib_memory_resource 1L +# endif +# endif +#endif /* !defined(__cpp_lib_memory_resource) && defined(__glibcxx_want_memory_resource) */ +#undef __glibcxx_want_memory_resource + +// from version.def line 642 +#if !defined(__cpp_lib_node_extract) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_node_extract 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_node_extract) +# define __cpp_lib_node_extract 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_node_extract) && defined(__glibcxx_want_node_extract) */ +#undef __glibcxx_want_node_extract + +// from version.def line 651 +#if !defined(__cpp_lib_parallel_algorithm) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_parallel_algorithm 201603L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_parallel_algorithm) +# define __cpp_lib_parallel_algorithm 201603L +# endif +# endif +#endif /* !defined(__cpp_lib_parallel_algorithm) && defined(__glibcxx_want_parallel_algorithm) */ +#undef __glibcxx_want_parallel_algorithm + +// from version.def line 660 +#if !defined(__cpp_lib_scoped_lock) +# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_scoped_lock 201703L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_scoped_lock) +# define __cpp_lib_scoped_lock 201703L +# endif +# endif +#endif /* !defined(__cpp_lib_scoped_lock) && defined(__glibcxx_want_scoped_lock) */ +#undef __glibcxx_want_scoped_lock + +// from version.def line 670 +#if !defined(__cpp_lib_shared_mutex) +# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_shared_mutex 201505L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_mutex) +# define __cpp_lib_shared_mutex 201505L +# endif +# endif +#endif /* !defined(__cpp_lib_shared_mutex) && defined(__glibcxx_want_shared_mutex) */ +#undef __glibcxx_want_shared_mutex + +// from version.def line 680 +#if !defined(__cpp_lib_shared_ptr_weak_type) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_shared_ptr_weak_type 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_weak_type) +# define __cpp_lib_shared_ptr_weak_type 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_shared_ptr_weak_type) && defined(__glibcxx_want_shared_ptr_weak_type) */ +#undef __glibcxx_want_shared_ptr_weak_type + +// from version.def line 689 +#if !defined(__cpp_lib_string_view) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_string_view 201803L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_view) +# define __cpp_lib_string_view 201803L +# endif +# endif +#endif /* !defined(__cpp_lib_string_view) && defined(__glibcxx_want_string_view) */ +#undef __glibcxx_want_string_view + +// from version.def line 698 +#if !defined(__cpp_lib_unordered_map_try_emplace) +# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED +# define __glibcxx_unordered_map_try_emplace 201411L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unordered_map_try_emplace) +# define __cpp_lib_unordered_map_try_emplace 201411L +# endif +# endif +#endif /* !defined(__cpp_lib_unordered_map_try_emplace) && defined(__glibcxx_want_unordered_map_try_emplace) */ +#undef __glibcxx_want_unordered_map_try_emplace + +// from version.def line 707 +#if !defined(__cpp_lib_assume_aligned) +# if (__cplusplus >= 202002L) +# define __glibcxx_assume_aligned 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_assume_aligned) +# define __cpp_lib_assume_aligned 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_assume_aligned) && defined(__glibcxx_want_assume_aligned) */ +#undef __glibcxx_want_assume_aligned + +// from version.def line 715 +#if !defined(__cpp_lib_atomic_flag_test) +# if (__cplusplus >= 202002L) +# define __glibcxx_atomic_flag_test 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_flag_test) +# define __cpp_lib_atomic_flag_test 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_flag_test) && defined(__glibcxx_want_atomic_flag_test) */ +#undef __glibcxx_want_atomic_flag_test + +// from version.def line 723 +#if !defined(__cpp_lib_atomic_float) +# if (__cplusplus >= 202002L) +# define __glibcxx_atomic_float 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_float) +# define __cpp_lib_atomic_float 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_float) && defined(__glibcxx_want_atomic_float) */ +#undef __glibcxx_want_atomic_float + +// from version.def line 731 +#if !defined(__cpp_lib_atomic_lock_free_type_aliases) +# if (__cplusplus >= 202002L) +# define __glibcxx_atomic_lock_free_type_aliases 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_lock_free_type_aliases) +# define __cpp_lib_atomic_lock_free_type_aliases 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_lock_free_type_aliases) && defined(__glibcxx_want_atomic_lock_free_type_aliases) */ +#undef __glibcxx_want_atomic_lock_free_type_aliases + +// from version.def line 739 +#if !defined(__cpp_lib_atomic_ref) +# if (__cplusplus >= 202002L) +# define __glibcxx_atomic_ref 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_ref) +# define __cpp_lib_atomic_ref 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_ref) && defined(__glibcxx_want_atomic_ref) */ +#undef __glibcxx_want_atomic_ref + +// from version.def line 747 +#if !defined(__cpp_lib_atomic_value_initialization) +# if (__cplusplus >= 202002L) +# define __glibcxx_atomic_value_initialization 201911L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_value_initialization) +# define __cpp_lib_atomic_value_initialization 201911L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_value_initialization) && defined(__glibcxx_want_atomic_value_initialization) */ +#undef __glibcxx_want_atomic_value_initialization + +// from version.def line 755 +#if !defined(__cpp_lib_bind_front) +# if (__cplusplus >= 202002L) +# define __glibcxx_bind_front 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_front) +# define __cpp_lib_bind_front 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_bind_front) && defined(__glibcxx_want_bind_front) */ +#undef __glibcxx_want_bind_front + +// from version.def line 763 +#if !defined(__cpp_lib_starts_ends_with) +# if (__cplusplus >= 202002L) +# define __glibcxx_starts_ends_with 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_starts_ends_with) +# define __cpp_lib_starts_ends_with 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_starts_ends_with) && defined(__glibcxx_want_starts_ends_with) */ +#undef __glibcxx_want_starts_ends_with + +// from version.def line 771 +#if !defined(__cpp_lib_bit_cast) +# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_bit_cast)) +# define __glibcxx_bit_cast 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bit_cast) +# define __cpp_lib_bit_cast 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_bit_cast) && defined(__glibcxx_want_bit_cast) */ +#undef __glibcxx_want_bit_cast + +// from version.def line 780 +#if !defined(__cpp_lib_bitops) +# if (__cplusplus >= 202002L) +# define __glibcxx_bitops 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bitops) +# define __cpp_lib_bitops 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_bitops) && defined(__glibcxx_want_bitops) */ +#undef __glibcxx_want_bitops + +// from version.def line 788 +#if !defined(__cpp_lib_bounded_array_traits) +# if (__cplusplus >= 202002L) +# define __glibcxx_bounded_array_traits 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bounded_array_traits) +# define __cpp_lib_bounded_array_traits 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_bounded_array_traits) && defined(__glibcxx_want_bounded_array_traits) */ +#undef __glibcxx_want_bounded_array_traits + +// from version.def line 796 +#if !defined(__cpp_lib_concepts) +# if (__cplusplus >= 202002L) && (__cpp_concepts >= 201907L) +# define __glibcxx_concepts 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_concepts) +# define __cpp_lib_concepts 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_concepts) && defined(__glibcxx_want_concepts) */ +#undef __glibcxx_want_concepts + +// from version.def line 806 +#if !defined(__cpp_lib_optional) +# if (__cplusplus > 202002L) && (__glibcxx_concepts) +# define __glibcxx_optional 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional) +# define __cpp_lib_optional 202110L +# endif +# elif (__cplusplus >= 202002L) +# define __glibcxx_optional 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional) +# define __cpp_lib_optional 202106L +# endif +# elif (__cplusplus >= 201703L) +# define __glibcxx_optional 201606L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional) +# define __cpp_lib_optional 201606L +# endif +# endif +#endif /* !defined(__cpp_lib_optional) && defined(__glibcxx_want_optional) */ +#undef __glibcxx_want_optional + +// from version.def line 823 +#if !defined(__cpp_lib_destroying_delete) +# if (__cplusplus >= 202002L) && (__cpp_impl_destroying_delete) +# define __glibcxx_destroying_delete 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_destroying_delete) +# define __cpp_lib_destroying_delete 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_destroying_delete) && defined(__glibcxx_want_destroying_delete) */ +#undef __glibcxx_want_destroying_delete + +// from version.def line 832 +#if !defined(__cpp_lib_constexpr_string_view) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_string_view 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string_view) +# define __cpp_lib_constexpr_string_view 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_string_view) && defined(__glibcxx_want_constexpr_string_view) */ +#undef __glibcxx_want_constexpr_string_view + +// from version.def line 840 +#if !defined(__cpp_lib_endian) +# if (__cplusplus >= 202002L) +# define __glibcxx_endian 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_endian) +# define __cpp_lib_endian 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_endian) && defined(__glibcxx_want_endian) */ +#undef __glibcxx_want_endian + +// from version.def line 848 +#if !defined(__cpp_lib_int_pow2) +# if (__cplusplus >= 202002L) +# define __glibcxx_int_pow2 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_int_pow2) +# define __cpp_lib_int_pow2 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_int_pow2) && defined(__glibcxx_want_int_pow2) */ +#undef __glibcxx_want_int_pow2 + +// from version.def line 856 +#if !defined(__cpp_lib_integer_comparison_functions) +# if (__cplusplus >= 202002L) +# define __glibcxx_integer_comparison_functions 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_comparison_functions) +# define __cpp_lib_integer_comparison_functions 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_integer_comparison_functions) && defined(__glibcxx_want_integer_comparison_functions) */ +#undef __glibcxx_want_integer_comparison_functions + +// from version.def line 864 +#if !defined(__cpp_lib_is_constant_evaluated) +# if (__cplusplus >= 202002L) && (defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)) +# define __glibcxx_is_constant_evaluated 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_constant_evaluated) +# define __cpp_lib_is_constant_evaluated 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_is_constant_evaluated) && defined(__glibcxx_want_is_constant_evaluated) */ +#undef __glibcxx_want_is_constant_evaluated + +// from version.def line 874 +#if !defined(__cpp_lib_constexpr_char_traits) +# if (__cplusplus >= 202002L) && (defined(__glibcxx_is_constant_evaluated)) +# define __glibcxx_constexpr_char_traits 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits) +# define __cpp_lib_constexpr_char_traits 201811L +# endif +# elif (__cplusplus >= 201703L) && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED) +# define __glibcxx_constexpr_char_traits 201611L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits) +# define __cpp_lib_constexpr_char_traits 201611L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_char_traits) && defined(__glibcxx_want_constexpr_char_traits) */ +#undef __glibcxx_want_constexpr_char_traits + +// from version.def line 890 +#if !defined(__cpp_lib_is_layout_compatible) +# if (__cplusplus >= 202002L) && (__has_builtin(__is_layout_compatible) && __has_builtin(__builtin_is_corresponding_member)) +# define __glibcxx_is_layout_compatible 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_layout_compatible) +# define __cpp_lib_is_layout_compatible 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_is_layout_compatible) && defined(__glibcxx_want_is_layout_compatible) */ +#undef __glibcxx_want_is_layout_compatible + +// from version.def line 900 +#if !defined(__cpp_lib_is_nothrow_convertible) +# if (__cplusplus >= 202002L) +# define __glibcxx_is_nothrow_convertible 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_nothrow_convertible) +# define __cpp_lib_is_nothrow_convertible 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_is_nothrow_convertible) && defined(__glibcxx_want_is_nothrow_convertible) */ +#undef __glibcxx_want_is_nothrow_convertible + +// from version.def line 908 +#if !defined(__cpp_lib_is_pointer_interconvertible) +# if (__cplusplus >= 202002L) && (__has_builtin(__is_pointer_interconvertible_base_of) && __has_builtin(__builtin_is_pointer_interconvertible_with_class)) +# define __glibcxx_is_pointer_interconvertible 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_pointer_interconvertible) +# define __cpp_lib_is_pointer_interconvertible 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_is_pointer_interconvertible) && defined(__glibcxx_want_is_pointer_interconvertible) */ +#undef __glibcxx_want_is_pointer_interconvertible + +// from version.def line 919 +#if !defined(__cpp_lib_math_constants) +# if (__cplusplus >= 202002L) +# define __glibcxx_math_constants 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_constants) +# define __cpp_lib_math_constants 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_math_constants) && defined(__glibcxx_want_math_constants) */ +#undef __glibcxx_want_math_constants + +// from version.def line 927 +#if !defined(__cpp_lib_make_obj_using_allocator) +# if (__cplusplus >= 202002L) && (__cpp_concepts) +# define __glibcxx_make_obj_using_allocator 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_obj_using_allocator) +# define __cpp_lib_make_obj_using_allocator 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_make_obj_using_allocator) && defined(__glibcxx_want_make_obj_using_allocator) */ +#undef __glibcxx_want_make_obj_using_allocator + +// from version.def line 937 +#if !defined(__cpp_lib_remove_cvref) +# if (__cplusplus >= 202002L) +# define __glibcxx_remove_cvref 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_remove_cvref) +# define __cpp_lib_remove_cvref 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_remove_cvref) && defined(__glibcxx_want_remove_cvref) */ +#undef __glibcxx_want_remove_cvref + +// from version.def line 945 +#if !defined(__cpp_lib_source_location) +# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_source_location)) +# define __glibcxx_source_location 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_source_location) +# define __cpp_lib_source_location 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_source_location) && defined(__glibcxx_want_source_location) */ +#undef __glibcxx_want_source_location + +// from version.def line 954 +#if !defined(__cpp_lib_span) +# if (__cplusplus >= 202002L) && (__glibcxx_concepts) +# define __glibcxx_span 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_span) +# define __cpp_lib_span 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_span) && defined(__glibcxx_want_span) */ +#undef __glibcxx_want_span + +// from version.def line 963 +#if !defined(__cpp_lib_ssize) +# if (__cplusplus >= 202002L) +# define __glibcxx_ssize 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ssize) +# define __cpp_lib_ssize 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_ssize) && defined(__glibcxx_want_ssize) */ +#undef __glibcxx_want_ssize + +// from version.def line 971 +#if !defined(__cpp_lib_three_way_comparison) +# if (__cplusplus >= 202002L) && (__cpp_impl_three_way_comparison >= 201907L && __glibcxx_concepts) +# define __glibcxx_three_way_comparison 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_three_way_comparison) +# define __cpp_lib_three_way_comparison 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_three_way_comparison) && defined(__glibcxx_want_three_way_comparison) */ +#undef __glibcxx_want_three_way_comparison + +// from version.def line 981 +#if !defined(__cpp_lib_to_address) +# if (__cplusplus >= 202002L) +# define __glibcxx_to_address 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_address) +# define __cpp_lib_to_address 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_to_address) && defined(__glibcxx_want_to_address) */ +#undef __glibcxx_want_to_address + +// from version.def line 989 +#if !defined(__cpp_lib_to_array) +# if (__cplusplus >= 202002L) && (__cpp_generic_lambdas >= 201707L) +# define __glibcxx_to_array 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_array) +# define __cpp_lib_to_array 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_to_array) && defined(__glibcxx_want_to_array) */ +#undef __glibcxx_want_to_array + +// from version.def line 998 +#if !defined(__cpp_lib_type_identity) +# if (__cplusplus >= 202002L) +# define __glibcxx_type_identity 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_identity) +# define __cpp_lib_type_identity 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_type_identity) && defined(__glibcxx_want_type_identity) */ +#undef __glibcxx_want_type_identity + +// from version.def line 1006 +#if !defined(__cpp_lib_unwrap_ref) +# if (__cplusplus >= 202002L) +# define __glibcxx_unwrap_ref 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unwrap_ref) +# define __cpp_lib_unwrap_ref 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_unwrap_ref) && defined(__glibcxx_want_unwrap_ref) */ +#undef __glibcxx_want_unwrap_ref + +// from version.def line 1014 +#if !defined(__cpp_lib_constexpr_iterator) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_iterator 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_iterator) +# define __cpp_lib_constexpr_iterator 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_iterator) && defined(__glibcxx_want_constexpr_iterator) */ +#undef __glibcxx_want_constexpr_iterator + +// from version.def line 1022 +#if !defined(__cpp_lib_interpolate) +# if (__cplusplus >= 202002L) +# define __glibcxx_interpolate 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_interpolate) +# define __cpp_lib_interpolate 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_interpolate) && defined(__glibcxx_want_interpolate) */ +#undef __glibcxx_want_interpolate + +// from version.def line 1030 +#if !defined(__cpp_lib_constexpr_utility) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_utility 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_utility) +# define __cpp_lib_constexpr_utility 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_utility) && defined(__glibcxx_want_constexpr_utility) */ +#undef __glibcxx_want_constexpr_utility + +// from version.def line 1038 +#if !defined(__cpp_lib_shift) +# if (__cplusplus >= 202002L) +# define __glibcxx_shift 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shift) +# define __cpp_lib_shift 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_shift) && defined(__glibcxx_want_shift) */ +#undef __glibcxx_want_shift + +// from version.def line 1046 +#if !defined(__cpp_lib_ranges) +# if (__cplusplus > 202002L) && (__glibcxx_concepts) +# define __glibcxx_ranges 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges) +# define __cpp_lib_ranges 202202L +# endif +# elif (__cplusplus >= 202002L) && (__glibcxx_concepts) +# define __glibcxx_ranges 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges) +# define __cpp_lib_ranges 202110L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges) && defined(__glibcxx_want_ranges) */ +#undef __glibcxx_want_ranges + +// from version.def line 1060 +#if !defined(__cpp_lib_constexpr_numeric) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_numeric 201911L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_numeric) +# define __cpp_lib_constexpr_numeric 201911L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_numeric) && defined(__glibcxx_want_constexpr_numeric) */ +#undef __glibcxx_want_constexpr_numeric + +// from version.def line 1068 +#if !defined(__cpp_lib_constexpr_functional) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_functional 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_functional) +# define __cpp_lib_constexpr_functional 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_functional) && defined(__glibcxx_want_constexpr_functional) */ +#undef __glibcxx_want_constexpr_functional + +// from version.def line 1076 +#if !defined(__cpp_lib_constexpr_algorithms) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_algorithms 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_algorithms) +# define __cpp_lib_constexpr_algorithms 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_algorithms) && defined(__glibcxx_want_constexpr_algorithms) */ +#undef __glibcxx_want_constexpr_algorithms + +// from version.def line 1084 +#if !defined(__cpp_lib_constexpr_tuple) +# if (__cplusplus >= 202002L) +# define __glibcxx_constexpr_tuple 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_tuple) +# define __cpp_lib_constexpr_tuple 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_tuple) && defined(__glibcxx_want_constexpr_tuple) */ +#undef __glibcxx_want_constexpr_tuple + +// from version.def line 1092 +#if !defined(__cpp_lib_constexpr_memory) +# if (__cplusplus > 202002L) && (__cpp_constexpr_dynamic_alloc) +# define __glibcxx_constexpr_memory 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory) +# define __cpp_lib_constexpr_memory 202202L +# endif +# elif (__cplusplus >= 202002L) +# define __glibcxx_constexpr_memory 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory) +# define __cpp_lib_constexpr_memory 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_memory) && defined(__glibcxx_want_constexpr_memory) */ +#undef __glibcxx_want_constexpr_memory + +// from version.def line 1105 +#if !defined(__cpp_lib_atomic_shared_ptr) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_atomic_shared_ptr 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_shared_ptr) +# define __cpp_lib_atomic_shared_ptr 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_shared_ptr) && defined(__glibcxx_want_atomic_shared_ptr) */ +#undef __glibcxx_want_atomic_shared_ptr + +// from version.def line 1114 +#if !defined(__cpp_lib_atomic_wait) +# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_atomic_wait 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait) +# define __cpp_lib_atomic_wait 201907L +# endif +# elif (__cplusplus >= 202002L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED && (defined(_GLIBCXX_HAVE_LINUX_FUTEX)) +# define __glibcxx_atomic_wait 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait) +# define __cpp_lib_atomic_wait 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_atomic_wait) && defined(__glibcxx_want_atomic_wait) */ +#undef __glibcxx_want_atomic_wait + +// from version.def line 1132 +#if !defined(__cpp_lib_barrier) +# if (__cplusplus >= 202002L) && (__cpp_aligned_new && __glibcxx_atomic_wait) +# define __glibcxx_barrier 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_barrier) +# define __cpp_lib_barrier 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_barrier) && defined(__glibcxx_want_barrier) */ +#undef __glibcxx_want_barrier + +// from version.def line 1149 +#if !defined(__cpp_lib_format) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_format 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_format) +# define __cpp_lib_format 202106L +# endif +# endif +#endif /* !defined(__cpp_lib_format) && defined(__glibcxx_want_format) */ +#undef __glibcxx_want_format + +// from version.def line 1162 +#if !defined(__cpp_lib_constexpr_complex) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_constexpr_complex 201711L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_complex) +# define __cpp_lib_constexpr_complex 201711L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_complex) && defined(__glibcxx_want_constexpr_complex) */ +#undef __glibcxx_want_constexpr_complex + +// from version.def line 1171 +#if !defined(__cpp_lib_constexpr_dynamic_alloc) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_constexpr_dynamic_alloc 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_dynamic_alloc) +# define __cpp_lib_constexpr_dynamic_alloc 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_dynamic_alloc) && defined(__glibcxx_want_constexpr_dynamic_alloc) */ +#undef __glibcxx_want_constexpr_dynamic_alloc + +// from version.def line 1180 +#if !defined(__cpp_lib_constexpr_string) +# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated)) +# define __glibcxx_constexpr_string 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string) +# define __cpp_lib_constexpr_string 201907L +# endif +# elif (__cplusplus >= 202002L) && !_GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated)) +# define __glibcxx_constexpr_string 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string) +# define __cpp_lib_constexpr_string 201811L +# endif +# elif (__cplusplus >= 201703L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED) +# define __glibcxx_constexpr_string 201611L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string) +# define __cpp_lib_constexpr_string 201611L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_string) && defined(__glibcxx_want_constexpr_string) */ +#undef __glibcxx_want_constexpr_string + +// from version.def line 1204 +#if !defined(__cpp_lib_constexpr_vector) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_constexpr_vector 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_vector) +# define __cpp_lib_constexpr_vector 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_vector) && defined(__glibcxx_want_constexpr_vector) */ +#undef __glibcxx_want_constexpr_vector + +// from version.def line 1213 +#if !defined(__cpp_lib_erase_if) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_erase_if 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_erase_if) +# define __cpp_lib_erase_if 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_erase_if) && defined(__glibcxx_want_erase_if) */ +#undef __glibcxx_want_erase_if + +// from version.def line 1222 +#if !defined(__cpp_lib_generic_unordered_lookup) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_generic_unordered_lookup 201811L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_unordered_lookup) +# define __cpp_lib_generic_unordered_lookup 201811L +# endif +# endif +#endif /* !defined(__cpp_lib_generic_unordered_lookup) && defined(__glibcxx_want_generic_unordered_lookup) */ +#undef __glibcxx_want_generic_unordered_lookup + +// from version.def line 1231 +#if !defined(__cpp_lib_jthread) +# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED +# define __glibcxx_jthread 201911L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_jthread) +# define __cpp_lib_jthread 201911L +# endif +# endif +#endif /* !defined(__cpp_lib_jthread) && defined(__glibcxx_want_jthread) */ +#undef __glibcxx_want_jthread + +// from version.def line 1241 +#if !defined(__cpp_lib_latch) +# if (__cplusplus >= 202002L) && (__glibcxx_atomic_wait) +# define __glibcxx_latch 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_latch) +# define __cpp_lib_latch 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_latch) && defined(__glibcxx_want_latch) */ +#undef __glibcxx_want_latch + +// from version.def line 1250 +#if !defined(__cpp_lib_list_remove_return_type) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_list_remove_return_type 201806L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_list_remove_return_type) +# define __cpp_lib_list_remove_return_type 201806L +# endif +# endif +#endif /* !defined(__cpp_lib_list_remove_return_type) && defined(__glibcxx_want_list_remove_return_type) */ +#undef __glibcxx_want_list_remove_return_type + +// from version.def line 1259 +#if !defined(__cpp_lib_polymorphic_allocator) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_polymorphic_allocator 201902L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_polymorphic_allocator) +# define __cpp_lib_polymorphic_allocator 201902L +# endif +# endif +#endif /* !defined(__cpp_lib_polymorphic_allocator) && defined(__glibcxx_want_polymorphic_allocator) */ +#undef __glibcxx_want_polymorphic_allocator + +// from version.def line 1268 +#if !defined(__cpp_lib_move_iterator_concept) +# if (__cplusplus >= 202002L) && (__glibcxx_concepts) +# define __glibcxx_move_iterator_concept 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_iterator_concept) +# define __cpp_lib_move_iterator_concept 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_move_iterator_concept) && defined(__glibcxx_want_move_iterator_concept) */ +#undef __glibcxx_want_move_iterator_concept + +// from version.def line 1278 +#if !defined(__cpp_lib_semaphore) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED && (__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE) +# define __glibcxx_semaphore 201907L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_semaphore) +# define __cpp_lib_semaphore 201907L +# endif +# endif +#endif /* !defined(__cpp_lib_semaphore) && defined(__glibcxx_want_semaphore) */ +#undef __glibcxx_want_semaphore + +// from version.def line 1288 +#if !defined(__cpp_lib_smart_ptr_for_overwrite) +# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_smart_ptr_for_overwrite 202002L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_smart_ptr_for_overwrite) +# define __cpp_lib_smart_ptr_for_overwrite 202002L +# endif +# endif +#endif /* !defined(__cpp_lib_smart_ptr_for_overwrite) && defined(__glibcxx_want_smart_ptr_for_overwrite) */ +#undef __glibcxx_want_smart_ptr_for_overwrite + +// from version.def line 1297 +#if !defined(__cpp_lib_syncbuf) +# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED +# define __glibcxx_syncbuf 201803L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_syncbuf) +# define __cpp_lib_syncbuf 201803L +# endif +# endif +#endif /* !defined(__cpp_lib_syncbuf) && defined(__glibcxx_want_syncbuf) */ +#undef __glibcxx_want_syncbuf + +// from version.def line 1307 +#if !defined(__cpp_lib_byteswap) +# if (__cplusplus > 202002L) +# define __glibcxx_byteswap 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byteswap) +# define __cpp_lib_byteswap 202110L +# endif +# endif +#endif /* !defined(__cpp_lib_byteswap) && defined(__glibcxx_want_byteswap) */ +#undef __glibcxx_want_byteswap + +// from version.def line 1315 +#if !defined(__cpp_lib_constexpr_charconv) +# if (__cplusplus > 202002L) +# define __glibcxx_constexpr_charconv 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_charconv) +# define __cpp_lib_constexpr_charconv 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_charconv) && defined(__glibcxx_want_constexpr_charconv) */ +#undef __glibcxx_want_constexpr_charconv + +// from version.def line 1323 +#if !defined(__cpp_lib_constexpr_typeinfo) +# if (__cplusplus > 202002L) +# define __glibcxx_constexpr_typeinfo 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_typeinfo) +# define __cpp_lib_constexpr_typeinfo 202106L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_typeinfo) && defined(__glibcxx_want_constexpr_typeinfo) */ +#undef __glibcxx_want_constexpr_typeinfo + +// from version.def line 1331 +#if !defined(__cpp_lib_expected) +# if (__cplusplus > 202002L) && (__cpp_concepts >= 202002L) +# define __glibcxx_expected 202211L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_expected) +# define __cpp_lib_expected 202211L +# endif +# endif +#endif /* !defined(__cpp_lib_expected) && defined(__glibcxx_want_expected) */ +#undef __glibcxx_want_expected + +// from version.def line 1340 +#if !defined(__cpp_lib_invoke_r) +# if (__cplusplus > 202002L) +# define __glibcxx_invoke_r 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke_r) +# define __cpp_lib_invoke_r 202106L +# endif +# endif +#endif /* !defined(__cpp_lib_invoke_r) && defined(__glibcxx_want_invoke_r) */ +#undef __glibcxx_want_invoke_r + +// from version.def line 1348 +#if !defined(__cpp_lib_is_scoped_enum) +# if (__cplusplus > 202002L) +# define __glibcxx_is_scoped_enum 202011L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_scoped_enum) +# define __cpp_lib_is_scoped_enum 202011L +# endif +# endif +#endif /* !defined(__cpp_lib_is_scoped_enum) && defined(__glibcxx_want_is_scoped_enum) */ +#undef __glibcxx_want_is_scoped_enum + +// from version.def line 1356 +#if !defined(__cpp_lib_reference_from_temporary) +# if (__cplusplus > 202002L) && (__has_builtin(__reference_constructs_from_temporary) && __has_builtin(__reference_converts_from_temporary)) +# define __glibcxx_reference_from_temporary 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_reference_from_temporary) +# define __cpp_lib_reference_from_temporary 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_reference_from_temporary) && defined(__glibcxx_want_reference_from_temporary) */ +#undef __glibcxx_want_reference_from_temporary + +// from version.def line 1367 +#if !defined(__cpp_lib_to_underlying) +# if (__cplusplus > 202002L) +# define __glibcxx_to_underlying 202102L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_underlying) +# define __cpp_lib_to_underlying 202102L +# endif +# endif +#endif /* !defined(__cpp_lib_to_underlying) && defined(__glibcxx_want_to_underlying) */ +#undef __glibcxx_want_to_underlying + +// from version.def line 1375 +#if !defined(__cpp_lib_unreachable) +# if (__cplusplus > 202002L) +# define __glibcxx_unreachable 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unreachable) +# define __cpp_lib_unreachable 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_unreachable) && defined(__glibcxx_want_unreachable) */ +#undef __glibcxx_want_unreachable + +// from version.def line 1383 +#if !defined(__cpp_lib_ranges_zip) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_zip 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_zip) +# define __cpp_lib_ranges_zip 202110L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_zip) && defined(__glibcxx_want_ranges_zip) */ +#undef __glibcxx_want_ranges_zip + +// from version.def line 1391 +#if !defined(__cpp_lib_ranges_chunk) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_chunk 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk) +# define __cpp_lib_ranges_chunk 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_chunk) && defined(__glibcxx_want_ranges_chunk) */ +#undef __glibcxx_want_ranges_chunk + +// from version.def line 1399 +#if !defined(__cpp_lib_ranges_slide) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_slide 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_slide) +# define __cpp_lib_ranges_slide 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_slide) && defined(__glibcxx_want_ranges_slide) */ +#undef __glibcxx_want_ranges_slide + +// from version.def line 1407 +#if !defined(__cpp_lib_ranges_chunk_by) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_chunk_by 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk_by) +# define __cpp_lib_ranges_chunk_by 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_chunk_by) && defined(__glibcxx_want_ranges_chunk_by) */ +#undef __glibcxx_want_ranges_chunk_by + +// from version.def line 1415 +#if !defined(__cpp_lib_ranges_join_with) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_join_with 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_join_with) +# define __cpp_lib_ranges_join_with 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_join_with) && defined(__glibcxx_want_ranges_join_with) */ +#undef __glibcxx_want_ranges_join_with + +// from version.def line 1423 +#if !defined(__cpp_lib_ranges_repeat) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_repeat 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_repeat) +# define __cpp_lib_ranges_repeat 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_repeat) && defined(__glibcxx_want_ranges_repeat) */ +#undef __glibcxx_want_ranges_repeat + +// from version.def line 1431 +#if !defined(__cpp_lib_ranges_stride) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_stride 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_stride) +# define __cpp_lib_ranges_stride 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_stride) && defined(__glibcxx_want_ranges_stride) */ +#undef __glibcxx_want_ranges_stride + +// from version.def line 1439 +#if !defined(__cpp_lib_ranges_cartesian_product) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_cartesian_product 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_cartesian_product) +# define __cpp_lib_ranges_cartesian_product 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_cartesian_product) && defined(__glibcxx_want_ranges_cartesian_product) */ +#undef __glibcxx_want_ranges_cartesian_product + +// from version.def line 1447 +#if !defined(__cpp_lib_ranges_as_rvalue) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_as_rvalue 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_rvalue) +# define __cpp_lib_ranges_as_rvalue 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_as_rvalue) && defined(__glibcxx_want_ranges_as_rvalue) */ +#undef __glibcxx_want_ranges_as_rvalue + +// from version.def line 1455 +#if !defined(__cpp_lib_ranges_as_const) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_as_const 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_const) +# define __cpp_lib_ranges_as_const 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_as_const) && defined(__glibcxx_want_ranges_as_const) */ +#undef __glibcxx_want_ranges_as_const + +// from version.def line 1463 +#if !defined(__cpp_lib_ranges_enumerate) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_enumerate 202302L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_enumerate) +# define __cpp_lib_ranges_enumerate 202302L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_enumerate) && defined(__glibcxx_want_ranges_enumerate) */ +#undef __glibcxx_want_ranges_enumerate + +// from version.def line 1471 +#if !defined(__cpp_lib_ranges_fold) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_fold 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_fold) +# define __cpp_lib_ranges_fold 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_fold) && defined(__glibcxx_want_ranges_fold) */ +#undef __glibcxx_want_ranges_fold + +// from version.def line 1479 +#if !defined(__cpp_lib_ranges_contains) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_contains 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_contains) +# define __cpp_lib_ranges_contains 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_contains) && defined(__glibcxx_want_ranges_contains) */ +#undef __glibcxx_want_ranges_contains + +// from version.def line 1487 +#if !defined(__cpp_lib_ranges_iota) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_iota 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_iota) +# define __cpp_lib_ranges_iota 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_iota) && defined(__glibcxx_want_ranges_iota) */ +#undef __glibcxx_want_ranges_iota + +// from version.def line 1495 +#if !defined(__cpp_lib_ranges_find_last) +# if (__cplusplus > 202002L) +# define __glibcxx_ranges_find_last 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_find_last) +# define __cpp_lib_ranges_find_last 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ranges_find_last) && defined(__glibcxx_want_ranges_find_last) */ +#undef __glibcxx_want_ranges_find_last + +// from version.def line 1503 +#if !defined(__cpp_lib_constexpr_bitset) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__cpp_constexpr_dynamic_alloc) +# define __glibcxx_constexpr_bitset 202202L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_bitset) +# define __cpp_lib_constexpr_bitset 202202L +# endif +# endif +#endif /* !defined(__cpp_lib_constexpr_bitset) && defined(__glibcxx_want_constexpr_bitset) */ +#undef __glibcxx_want_constexpr_bitset + +// from version.def line 1513 +#if !defined(__cpp_lib_stdatomic_h) +# if (__cplusplus > 202002L) +# define __glibcxx_stdatomic_h 202011L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stdatomic_h) +# define __cpp_lib_stdatomic_h 202011L +# endif +# endif +#endif /* !defined(__cpp_lib_stdatomic_h) && defined(__glibcxx_want_stdatomic_h) */ +#undef __glibcxx_want_stdatomic_h + +// from version.def line 1521 +#if !defined(__cpp_lib_adaptor_iterator_pair_constructor) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_adaptor_iterator_pair_constructor 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_adaptor_iterator_pair_constructor) +# define __cpp_lib_adaptor_iterator_pair_constructor 202106L +# endif +# endif +#endif /* !defined(__cpp_lib_adaptor_iterator_pair_constructor) && defined(__glibcxx_want_adaptor_iterator_pair_constructor) */ +#undef __glibcxx_want_adaptor_iterator_pair_constructor + +// from version.def line 1530 +#if !defined(__cpp_lib_ios_noreplace) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_ios_noreplace 202207L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ios_noreplace) +# define __cpp_lib_ios_noreplace 202207L +# endif +# endif +#endif /* !defined(__cpp_lib_ios_noreplace) && defined(__glibcxx_want_ios_noreplace) */ +#undef __glibcxx_want_ios_noreplace + +// from version.def line 1539 +#if !defined(__cpp_lib_move_only_function) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_move_only_function 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_only_function) +# define __cpp_lib_move_only_function 202110L +# endif +# endif +#endif /* !defined(__cpp_lib_move_only_function) && defined(__glibcxx_want_move_only_function) */ +#undef __glibcxx_want_move_only_function + +// from version.def line 1548 +#if !defined(__cpp_lib_spanstream) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__glibcxx_span) +# define __glibcxx_spanstream 202106L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_spanstream) +# define __cpp_lib_spanstream 202106L +# endif +# endif +#endif /* !defined(__cpp_lib_spanstream) && defined(__glibcxx_want_spanstream) */ +#undef __glibcxx_want_spanstream + +// from version.def line 1558 +#if !defined(__cpp_lib_stacktrace) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_STACKTRACE) +# define __glibcxx_stacktrace 202011L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stacktrace) +# define __cpp_lib_stacktrace 202011L +# endif +# endif +#endif /* !defined(__cpp_lib_stacktrace) && defined(__glibcxx_want_stacktrace) */ +#undef __glibcxx_want_stacktrace + +// from version.def line 1568 +#if !defined(__cpp_lib_string_contains) +# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED +# define __glibcxx_string_contains 202011L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_contains) +# define __cpp_lib_string_contains 202011L +# endif +# endif +#endif /* !defined(__cpp_lib_string_contains) && defined(__glibcxx_want_string_contains) */ +#undef __glibcxx_want_string_contains + +// from version.def line 1577 +#if !defined(__cpp_lib_string_resize_and_overwrite) +# if (__cplusplus > 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED +# define __glibcxx_string_resize_and_overwrite 202110L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_resize_and_overwrite) +# define __cpp_lib_string_resize_and_overwrite 202110L +# endif +# endif +#endif /* !defined(__cpp_lib_string_resize_and_overwrite) && defined(__glibcxx_want_string_resize_and_overwrite) */ +#undef __glibcxx_want_string_resize_and_overwrite + +#undef __glibcxx_want_all diff --git a/libstdc++-v3/include/bits/version.tpl b/libstdc++-v3/include/bits/version.tpl new file mode 100644 index 0000000..0b15eed --- /dev/null +++ b/libstdc++-v3/include/bits/version.tpl @@ -0,0 +1,210 @@ +/*{ AutoGen5 template -*- C++ -*- +h +(use-modules (srfi srfi-1)) +}*/ +// Copyright (C) 2023 Free Software Foundation, Inc. + +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/*{ (dne "// ") }*/ + +/** @file bits/version.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{version} + */ + +// Usage guide: +// +// In your usual header, do something like: +// +// #define __glibcxx_want_ranges +// #define __glibcxx_want_concepts +// #include <bits/version.h> +// +// This will generate the FTMs you named, and let you use them in your code as +// if it was user code. All macros are also exposed under __glibcxx_NAME even +// if unwanted, to permit bits and other FTMs to depend on them for condtional +// computation without exposing extra FTMs to user code. + +#pragma GCC system_header + +#include <bits/c++config.h> +/*{ + +;; Helper for dealing with autogens redefined (error) +(define (ferror msg . args) + (error (apply format (cons* #f msg args)))) + + ;; Helper function that, in the context of a single FTM value, generates the +;; condition expression that fulfills the specification of this value. See the +;; comment block in version.def for an explanation of the format this +;; function parses. +(define (generate-cond) + (define c++min #f) + (define gnu++min #f) + (define gthread #f) + (define hosted #f) + (define c++11-abi #f) + (define extra-cond (get "extra_cond")) + + (define conds '()) + (define (prepend x) + (if x (set! conds (cons x conds)))) + + (if (string-null? extra-cond) + (set! extra-cond #f)) + + (let ((cxxmin (get "cxxmin")) + (gnuxxmin (get "gnuxxmin")) + (getstdcond + (lambda (var) + (let ((ver (get var))) + (if (not (string-null? ver)) + (let ((std-cond (get (format #f "stds[~a]" ver)))) + (if (string-null? std-cond) + (ferror "Standard ~s invalid." ver)) + std-cond) + #f))))) + (set! c++min (getstdcond "cxxmin")) + (set! gnu++min (getstdcond "gnuxxmin"))) + + (let ((process-tristate + (lambda (name) + (let ((val (get name))) + (cond + ((equal? val "") #f) ; Don't test + ((equal? val "yes") "") ; Test directly + ((equal? val "no") "!") ; Invert + (else (ferror "Bad ~a value ~a." name val))))))) + (set! gthread (process-tristate "gthread")) + (set! c++11-abi (process-tristate "cxx11abi")) + (set! hosted (process-tristate "hosted"))) + + (prepend (if extra-cond (format #f "(~a)" extra-cond) #f)) + (prepend (if hosted (format #f "~a~a" hosted "_GLIBCXX_HOSTED") #f)) + (prepend (if gthread (format #f "~a~a" gthread "defined(_GLIBCXX_HAS_GTHREADS)") #f)) + (prepend (if c++11-abi (format #f "~a~a" c++11-abi "_GLIBCXX_USE_CXX11_ABI") #f)) + + (prepend + (let ((strict "defined(__STRICT_ANSI__)") + (c++ "__cplusplus")) + (cond + ((or (and (equal? c++min gnu++min) c++min) + (and (not gnu++min) c++min)) + ;; If we have both values, and they are equal, or we only have gnu++min, + ;; we want to output a simple check. + (format #f "(~a ~a)" c++ c++min)) + ((and gnu++min c++min) + ;; We have differing cases for strict and non-strict modes. + (format #f "((~a && ~a ~a) || (!~a && ~a ~a))" + strict c++ c++min + strict c++ gnu++min)) + ((and gnu++min (not c++min)) + (format #f "(!~a && (~a ~a))" strict c++ gnu++min)) + (else #f)))) + (string-join conds " && " 'strict-infix)) + + + }*/ +/*{ FOR ftms + }*/// /*{ (def-file-line "name") }*/ +#if !defined(__cpp_lib_/*{name}*/) +/*{ FOR values }*//*{ # + + This macro block defines two versions of each FTM: + + 1. __glibcxx_NAME, which is defined unconditionally, and + 2. __cpp_lib_NAME, which is defined only if marked as wanted. + + This allows FTMs to depend on eachother in their definitions without messing + with the exported values. + + This can also be used by bits that do not want to expose FTMs that they can't + implement. + +}*/# /*{(unless (first-for?) "el")}*/if /*{(generate-cond)}*/ +# define __glibcxx_/*{name}*/ /*{v}*/L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_/*{name}*/) +# define /*{ +;; Compute the name for this FTM based on stdname/name. +(if (exist? "stdname") + (get "stdname") + (format #f "__cpp_lib_~a" (get "name"))) +}*/ /*{v}*/L +# endif +/*{ ENDFOR values + }*/# endif +#endif /* !defined(__cpp_lib_/*{name}*/) && defined(__glibcxx_want_/*{name}*/) */ +#undef __glibcxx_want_/*{name +}*//*{ (unless (last-for?) "\n\n" "\n")}*/ +/*{ ENDFOR ftms }*//*{ + +;; Helper that generates [LO, HI]. +(define (closed-int-set lo hi) + (iota (+ (- hi lo) 1) lo)) + +;; Sanity checking for duplicates and for value order. +(let ((ht (make-hash-table (count "ftms")))) + (for-each + (lambda (idx) + (let ((name (get (format #f "ftms[~a].name" idx)))) + (if (string-null? name) (ferror "No name for FTM ~a" idx)) + (let ((cur (cdr (or (hash-get-handle ht name) '(1 . 0))))) + (hash-set! ht name (+ cur 1))))) + (closed-int-set (low-lim "ftms") (high-lim "ftms"))) + (if (hash-fold + (lambda (name count prior) + (if (= 1 count) + prior + (begin + (printf "FTM %s appears %d times.\n" name count) + #t))) + #f ht) + (error "Duplicates found."))) + +(define (check-value-order ftm key order) + (let ((valmin 999999)) ; TODO(arsen): bump before year 10000 + (for-each + (lambda (vidx) + (let* ((sval (get (format #f "values[~a].~a" vidx key))) + (val (string->number sval))) + (unless (string-null? sval) + (unless val (ferror "Bad value in FTM ~a" ftm)) + (if (order val valmin) + (ferror "Found inverted ~s value in FTM ~a: ~a" key ftm sval)) + (set! valmin val)))) + (closed-int-set (low-lim "values") (high-lim "values"))))) + +}*//*{ FOR ftms }*//*{# + Check for values that are in ascending order. Because it is generally the + case that FTMs increase as the values of tests they probe for do, we check + them to prevent simple, silly errors. + + We're iterating in a separate FOR block rather than in pure Guile since, for + some reason, high-lim and low-lim do not work with complex names that include + periods and indices (whereas exist? and others do). +}*//*{ +(let ((ftm (get "name"))) + (check-value-order (get "name") "v" >) + (check-value-order (get "name") "cxxmin" >) + (check-value-order (get "name") "gnuxxmin" >)) +}*//*{ ENDFOR ftms }*/ +#undef __glibcxx_want_all diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index 5264c8b..4963e40 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -30,353 +30,9 @@ #ifndef _GLIBCXX_VERSION_INCLUDED #define _GLIBCXX_VERSION_INCLUDED -// To facilitate testsuite/17_intro/versionconflict.cc -#ifndef _GLIBCXX_TESTING_SYSHDR -# pragma GCC system_header -#endif +#pragma GCC system_header -#include <bits/c++config.h> - -// c++03 -#if _GLIBCXX_HOSTED -# define __cpp_lib_incomplete_container_elements 201505L -#endif - -#if !defined(__STRICT_ANSI__) -// gnu++03 -# define __cpp_lib_uncaught_exceptions 201411L -#endif - -#if __cplusplus >= 201103L -// c++11 -#define __cpp_lib_allocator_traits_is_always_equal 201411L -#define __cpp_lib_is_null_pointer 201309L -#define __cpp_lib_result_of_sfinae 201210L - -#if _GLIBCXX_HOSTED -#if __cplusplus <= 201703L // N.B. updated value in C++20 -# define __cpp_lib_shared_ptr_arrays 201611L -#endif -#endif - -#if !defined(__STRICT_ANSI__) -// gnu++11 -# define __cpp_lib_is_swappable 201603L -# define __cpp_lib_void_t 201411L -# if _GLIBCXX_HOSTED -# define __cpp_lib_enable_shared_from_this 201603L -# endif -#endif - -// For C++11 and later we support ISO/IEC 29124 Mathematical Special Functions -#define __STDCPP_MATH_SPEC_FUNCS__ 201003L - -#if __cplusplus >= 201402L -// c++14 -#if __cpp_impl_coroutine -# define __cpp_lib_coroutine 201902L -#endif -#define __cpp_lib_exchange_function 201304L -#define __cpp_lib_integer_sequence 201304L -#define __cpp_lib_integral_constant_callable 201304L -#define __cpp_lib_is_final 201402L -#define __cpp_lib_make_reverse_iterator 201402L -#ifndef _GLIBCXX_DEBUG // PR libstdc++/70303 -# define __cpp_lib_null_iterators 201304L -#endif -#define __cpp_lib_robust_nonmodifying_seq_ops 201304L -#define __cpp_lib_transformation_trait_aliases 201304L -#define __cpp_lib_transparent_operators 201510L -#define __cpp_lib_tuple_element_t 201402L -#define __cpp_lib_tuples_by_type 201304L - -#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \ - && __SIZE_WIDTH__ >= 32 -# define __cpp_lib_to_chars 201611L -#endif - -#if _GLIBCXX_HOSTED -# define __cpp_lib_chrono_udls 201304L -# define __cpp_lib_complex_udls 201309L -# define __cpp_lib_generic_associative_lookup 201304L -# define __cpp_lib_make_unique 201304L -# define __cpp_lib_quoted_string_io 201304L -# ifdef _GLIBCXX_HAS_GTHREADS -# define __cpp_lib_shared_timed_mutex 201402L -# endif -# define __cpp_lib_string_udls 201304L -#endif - -#if __cplusplus >= 201703L -// c++17 -#define __cpp_lib_addressof_constexpr 201603L -#define __cpp_lib_any 201606L -#define __cpp_lib_apply 201603L -#define __cpp_lib_as_const 201510L -#define __cpp_lib_atomic_is_always_lock_free 201603L -#define __cpp_lib_bool_constant 201505L -#define __cpp_lib_byte 201603L -#define __cpp_lib_clamp 201603L -#define __cpp_lib_gcd 201606L -#define __cpp_lib_gcd_lcm 201606L -#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP -# define __cpp_lib_has_unique_object_representations 201606L -#endif -#ifdef __GCC_DESTRUCTIVE_SIZE -# define __cpp_lib_hardware_interference_size 201703L -#endif -#define __cpp_lib_invoke 201411L -#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE -# define __cpp_lib_is_aggregate 201703L -#endif -#define __cpp_lib_is_invocable 201703L -#define __cpp_lib_is_swappable 201603L -#ifdef _GLIBCXX_HAVE_BUILTIN_LAUNDER -# define __cpp_lib_launder 201606L -#endif -#define __cpp_lib_lcm 201606L -#define __cpp_lib_logical_traits 201510L -#define __cpp_lib_make_from_tuple 201606L -#define __cpp_lib_nonmember_container_access 201411L -#define __cpp_lib_not_fn 201603L -#if __cplusplus == 201703L // N.B. updated value in C++20 -# define __cpp_lib_optional 201606L -#endif -#define __cpp_lib_raw_memory_algorithms 201606L -#define __cpp_lib_sample 201603L -#define __cpp_lib_type_trait_variable_templates 201510L -#define __cpp_lib_uncaught_exceptions 201411L -#if !(__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L) -// N.B. updated value in C++20 -# define __cpp_lib_variant 202102L -#endif -#define __cpp_lib_void_t 201411L -#if __cplusplus == 201703L // N.B. updated value in C++20 -# define __cpp_lib_array_constexpr 201803L -#endif -#if __cplusplus == 201703L // N.B. updated value in C++20 -# if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED -# define __cpp_lib_constexpr_char_traits 201611L -# define __cpp_lib_constexpr_string 201611L -# endif -#endif - -#if _GLIBCXX_HOSTED -#define __cpp_lib_boyer_moore_searcher 201603L -#define __cpp_lib_chrono 201611L -#define __cpp_lib_enable_shared_from_this 201603L -#define __cpp_lib_execution 201902L // FIXME: should be 201603L -#define __cpp_lib_filesystem 201703L -#define __cpp_lib_hypot 201603L -#define __cpp_lib_map_try_emplace 201411L -#define __cpp_lib_math_special_functions 201603L -#ifdef _GLIBCXX_HAS_GTHREADS -# define __cpp_lib_memory_resource 201603L -#else -# define __cpp_lib_memory_resource 1 -#endif -#define __cpp_lib_node_extract 201606L -#define __cpp_lib_parallel_algorithm 201603L -#ifdef _GLIBCXX_HAS_GTHREADS -# define __cpp_lib_scoped_lock 201703L -# define __cpp_lib_shared_mutex 201505L -#endif -#define __cpp_lib_shared_ptr_weak_type 201606L -#define __cpp_lib_string_view 201803L -#define __cpp_lib_unordered_map_try_emplace 201411L -#endif - -#if __cplusplus >= 202002L -// c++20 -#define __cpp_lib_assume_aligned 201811L -#define __cpp_lib_atomic_flag_test 201907L -#define __cpp_lib_atomic_float 201711L -#define __cpp_lib_atomic_lock_free_type_aliases 201907L -#define __cpp_lib_atomic_ref 201806L -#define __cpp_lib_atomic_value_initialization 201911L -#define __cpp_lib_bind_front 201907L -#define __cpp_lib_starts_ends_with 201711L -#if __has_builtin(__builtin_bit_cast) -# define __cpp_lib_bit_cast 201806L -#endif -#define __cpp_lib_bitops 201907L -#define __cpp_lib_bounded_array_traits 201902L -// __cpp_lib_char8_t is defined in <bits/c++config.h> -#if __cpp_concepts >= 201907L -# define __cpp_lib_concepts 202002L -#endif -#if __cpp_impl_destroying_delete -# define __cpp_lib_destroying_delete 201806L -#endif -#define __cpp_lib_constexpr_string_view 201811L -#define __cpp_lib_endian 201907L -#define __cpp_lib_int_pow2 202002L -#define __cpp_lib_integer_comparison_functions 202002L -#ifdef _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED -# define __cpp_lib_is_constant_evaluated 201811L -#endif -#if __has_builtin(__is_layout_compatible) \ - && __has_builtin(__builtin_is_corresponding_member) -# define __cpp_lib_is_layout_compatible 201907L -#endif -#define __cpp_lib_is_nothrow_convertible 201806L -#if __has_builtin(__is_pointer_interconvertible_base_of) \ - && __has_builtin(__builtin_is_pointer_interconvertible_with_class) -# define __cpp_lib_is_pointer_interconvertible 201907L -#endif -#define __cpp_lib_math_constants 201907L -#if __cpp_lib_concepts -# define __cpp_lib_make_obj_using_allocator 201811L -#endif -#if __cplusplus <= 202002L // N.B. updated value in C++23 -# define __cpp_lib_optional 202106L -#endif -#define __cpp_lib_remove_cvref 201711L -#if __has_builtin(__builtin_source_location) -# define __cpp_lib_source_location 201907L -#endif -#if __cpp_lib_concepts -# define __cpp_lib_span 202002L -#endif -#define __cpp_lib_ssize 201902L -#if __cpp_impl_three_way_comparison >= 201907L && __cpp_lib_concepts -# define __cpp_lib_three_way_comparison 201907L -#endif -#define __cpp_lib_to_address 201711L -#define __cpp_lib_to_array 201907L -#define __cpp_lib_type_identity 201806L -#define __cpp_lib_unwrap_ref 201811L -#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L -# define __cpp_lib_variant 202106L -#endif -#define __cpp_lib_constexpr_algorithms 201806L -#define __cpp_lib_constexpr_functional 201907L -#if __cplusplus <= 202002L // N.B. updated value in C++23 -# define __cpp_lib_constexpr_memory 201811L -#endif // C++20 -#define __cpp_lib_constexpr_numeric 201911L -#define __cpp_lib_constexpr_tuple 201811L -#define __cpp_lib_array_constexpr 201811L -#ifdef __cpp_lib_is_constant_evaluated -# define __cpp_lib_constexpr_char_traits 201811L -#endif -#define __cpp_lib_constexpr_iterator 201811L -#define __cpp_lib_constexpr_utility 201811L -#define __cpp_lib_interpolate 201902L -#if __cpp_lib_concepts -# define __cpp_lib_move_iterator_concept 202207L -#if __cplusplus <= 202002L // N.B. updated value in C++23 -# define __cpp_lib_ranges 202110L -#endif -#endif -#define __cpp_lib_shift 201806L - -#if _GLIBCXX_HOSTED -#define __cpp_lib_atomic_shared_ptr 201711L -#if defined _GLIBCXX_HAS_GTHREADS || defined _GLIBCXX_HAVE_LINUX_FUTEX -# define __cpp_lib_atomic_wait 201907L -# if __cpp_aligned_new -# define __cpp_lib_barrier 201907L -# endif -#endif -#undef __cpp_lib_chrono -#define __cpp_lib_chrono 201907L -// FIXME: #define __cpp_lib_execution 201902L -#define __cpp_lib_constexpr_complex 201711L -#define __cpp_lib_constexpr_dynamic_alloc 201907L -#define __cpp_lib_constexpr_tuple 201811L -#ifdef __cpp_lib_is_constant_evaluated -# if _GLIBCXX_USE_CXX11_ABI -# define __cpp_lib_constexpr_string 201907L -# else -# define __cpp_lib_constexpr_string 201811L -# endif -#endif -#define __cpp_lib_constexpr_vector 201907L -#define __cpp_lib_erase_if 202002L -#define __cpp_lib_format 202106L -#define __cpp_lib_generic_unordered_lookup 201811L -#ifdef _GLIBCXX_HAS_GTHREADS -# define __cpp_lib_jthread 201911L -#endif -#if __cpp_lib_atomic_wait -# define __cpp_lib_latch 201907L -#endif -#define __cpp_lib_list_remove_return_type 201806L -#define __cpp_lib_polymorphic_allocator 201902L -#if __cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE -# define __cpp_lib_semaphore 201907L -#endif -#define __cpp_lib_shared_ptr_arrays 201707L -#define __cpp_lib_smart_ptr_for_overwrite 202002L -# if _GLIBCXX_USE_CXX11_ABI -// Only supported with cxx11-abi -# define __cpp_lib_syncbuf 201803L -# endif -#endif - -#if __cplusplus > 202002L -// c++23 -#define __cpp_lib_byteswap 202110L -#define __cpp_lib_constexpr_charconv 202207L -#define __cpp_lib_constexpr_typeinfo 202106L -#if __cpp_concepts >= 202002L -# define __cpp_lib_expected 202211L -#endif -#define __cpp_lib_invoke_r 202106L -#define __cpp_lib_is_scoped_enum 202011L -#if __cpp_lib_concepts -# undef __cpp_lib_optional -# define __cpp_lib_optional 202110L -#endif -#define __cpp_lib_reference_from_temporary 202202L -#define __cpp_lib_to_underlying 202102L -#define __cpp_lib_unreachable 202202L -#define __cpp_lib_ranges 202202L -#define __cpp_lib_ranges_zip 202110L -#define __cpp_lib_ranges_chunk 202202L -#define __cpp_lib_ranges_slide 202202L -#define __cpp_lib_ranges_chunk_by 202202L -#define __cpp_lib_ranges_join_with 202202L -#define __cpp_lib_ranges_repeat 202207L -#define __cpp_lib_ranges_stride 202207L -#define __cpp_lib_ranges_cartesian_product 202207L -#define __cpp_lib_ranges_as_rvalue 202207L -#define __cpp_lib_ranges_as_const 202207L -#define __cpp_lib_ranges_enumerate 202302L -#define __cpp_lib_ranges_contains 202207L -#define __cpp_lib_ranges_iota 202202L -#define __cpp_lib_ranges_find_last 202207L -#define __cpp_lib_ranges_fold 202207L -#if __cpp_constexpr_dynamic_alloc -# if _GLIBCXX_HOSTED -# define __cpp_lib_constexpr_bitset 202202L -# endif -# undef __cpp_lib_constexpr_memory -# define __cpp_lib_constexpr_memory 202202L -#endif -#define __cpp_lib_stdatomic_h 202011L - -#if _GLIBCXX_HOSTED -#define __cpp_lib_adaptor_iterator_pair_constructor 202106L -#define __cpp_lib_ios_noreplace 202207L -#define __cpp_lib_move_only_function 202110L -#if __cpp_lib_span -# define __cpp_lib_spanstream 202106L -#endif -#if _GLIBCXX_HAVE_STACKTRACE -# define __cpp_lib_stacktrace 202011L -#endif -#define __cpp_lib_stdatomic_h 202011L -#define __cpp_lib_string_contains 202011L -#if _GLIBCXX_USE_CXX11_ABI // Only supported with cxx11-abi -# define __cpp_lib_string_resize_and_overwrite 202110L -#endif -#endif -#endif // C++23 -#endif // C++20 -#endif // C++17 -#endif // C++14 -#endif // C++11 +#define __glibcxx_want_all +#include <bits/version.h> #endif // _GLIBCXX_VERSION_INCLUDED |