#!/usr/bin/env python import os from builtins import range from dataclasses import dataclass from functools import reduce from typing import ( Any, Dict, List, # Needed for python 3.8 compatibility. NewType, Optional, Set, ) import functools import json from libcxx.header_information import module_c_headers, module_headers, header_restrictions, headers_not_available, libcxx_root def get_libcxx_paths(): utils_path = os.path.dirname(os.path.abspath(__file__)) script_name = os.path.basename(__file__) assert os.path.exists(utils_path) src_root = os.path.dirname(utils_path) include_path = os.path.join(src_root, "include") assert os.path.exists(include_path) docs_path = os.path.join(src_root, "docs") assert os.path.exists(docs_path) macro_test_path = os.path.join( src_root, "test", "std", "language.support", "support.limits", "support.limits.general", ) assert os.path.exists(macro_test_path) assert os.path.exists( os.path.join(macro_test_path, "version.version.compile.pass.cpp") ) return script_name, src_root, include_path, docs_path, macro_test_path script_name, source_root, include_path, docs_path, macro_test_path = get_libcxx_paths() def has_header(h): h_path = os.path.join(include_path, h) return os.path.exists(h_path) def add_version_header(tc): tc["headers"].append("version") return tc # ================ ============================================================ # Field Description # ================ ============================================================ # name The name of the feature-test macro. # values A dict whose keys are C++ versions and whose values are the # value of the feature-test macro for that C++ version. # (TODO: This isn't a very clean model for feature-test # macros affected by multiple papers.) # headers An array with the headers that should provide the # feature-test macro. # test_suite_guard An optional string field. When this field is provided, # `libcxx_guard` must also be provided. This field is used # only to generate the unit tests for the feature-test macros. # It can't depend on macros defined in <__config> because the # `test/std/` parts of the test suite are intended to be # portable to any C++ standard library implementation, not # just libc++. It may depend on # * macros defined by the compiler itself, or # * macros generated by CMake. # In some cases we add also depend on macros defined in # <__configuration/availability.h>. # libcxx_guard An optional string field. When this field is provided, # `test_suite_guard` must also be provided. This field is used # only to guard the feature-test macro in . It may # be the same as `test_suite_guard`, or it may depend on # macros defined in <__config>. # unimplemented An optional Boolean field with the value `True`. This field # is only used when a feature isn't fully implemented. Once # you've fully implemented the feature, you should remove # this field. # ================ ============================================================ feature_test_macros = [ add_version_header(x) for x in [ { "name": "__cpp_lib_adaptor_iterator_pair_constructor", "values": {"c++23": 202106}, "headers": ["queue", "stack"], }, { "name": "__cpp_lib_addressof_constexpr", "values": {"c++17": 201603}, "headers": ["memory"], }, { "name": "__cpp_lib_aligned_accessor", "values": {"c++26": 202411}, "headers": ["mdspan"], }, { "name": "__cpp_lib_allocate_at_least", "values": { # Note LWG3887 Version macro for allocate_at_least "c++23": 202302, # P2652R2 Disallow User Specialization of allocator_traits }, "headers": ["memory"], }, { "name": "__cpp_lib_allocator_traits_is_always_equal", "values": {"c++17": 201411}, "headers": [ "deque", "forward_list", "list", "map", "memory", "scoped_allocator", "set", "string", "unordered_map", "unordered_set", "vector", ], }, { "name": "__cpp_lib_any", "values": {"c++17": 201606}, "headers": ["any"], }, { "name": "__cpp_lib_apply", "values": {"c++17": 201603}, "headers": ["tuple"], }, { "name": "__cpp_lib_array_constexpr", "values": {"c++17": 201603, "c++20": 201811}, "headers": ["array", "iterator"], }, { "name": "__cpp_lib_as_const", "values": {"c++17": 201510}, "headers": ["utility"], }, { "name": "__cpp_lib_associative_heterogeneous_erasure", "values": {"c++23": 202110}, "headers": ["map", "set", "unordered_map", "unordered_set"], "unimplemented": True, }, { "name": "__cpp_lib_associative_heterogeneous_insertion", "values": { "c++26": 202306 # P2363R5 Extending associative containers with the remaining heterogeneous overloads }, "headers": ["map", "set", "unordered_map", "unordered_set"], "unimplemented": True, }, { "name": "__cpp_lib_assume_aligned", "values": {"c++20": 201811}, "headers": ["memory"], }, { "name": "__cpp_lib_atomic_flag_test", "values": {"c++20": 201907}, "headers": ["atomic"], }, { "name": "__cpp_lib_atomic_float", "values": {"c++20": 201711}, "headers": ["atomic"], }, { "name": "__cpp_lib_atomic_is_always_lock_free", "values": {"c++17": 201603}, "headers": ["atomic"], }, { "name": "__cpp_lib_atomic_lock_free_type_aliases", "values": {"c++20": 201907}, "headers": ["atomic"], }, { "name": "__cpp_lib_atomic_min_max", "values": {"c++26": 202403}, # P0493R5: Atomic minimum/maximum "headers": ["atomic"], "unimplemented": True, }, { "name": "__cpp_lib_atomic_ref", "values": {"c++20": 201806}, "headers": ["atomic"], }, { "name": "__cpp_lib_atomic_shared_ptr", "values": {"c++20": 201711}, "headers": ["atomic"], "unimplemented": True, }, { "name": "__cpp_lib_atomic_value_initialization", "values": {"c++20": 201911}, "headers": ["atomic", "memory"], }, { "name": "__cpp_lib_atomic_wait", "values": {"c++20": 201907}, "headers": ["atomic"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_SYNC", "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_SYNC", }, { "name": "__cpp_lib_barrier", "values": {"c++20": 201907}, "headers": ["barrier"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC)", "libcxx_guard": "_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC", }, { "name": "__cpp_lib_bind_back", "values": { "c++23": 202202, # "c++26": 202306, # P2714R1 Bind front and back to NTTP callables }, "headers": ["functional"], }, { "name": "__cpp_lib_bind_front", "values": { "c++20": 201907, "c++26": 202306, # P2714R1 Bind front and back to NTTP callables }, "headers": ["functional"], }, { "name": "__cpp_lib_bit_cast", "values": {"c++20": 201806}, "headers": ["bit"], }, { "name": "__cpp_lib_bitops", "values": {"c++20": 201907}, "headers": ["bit"], }, { "name": "__cpp_lib_bitset", "values": {"c++26": 202306}, # P2697R1 Interfacing bitset with string_view "headers": ["bitset"], }, { "name": "__cpp_lib_bool_constant", "values": {"c++17": 201505}, "headers": ["type_traits"], }, { "name": "__cpp_lib_bounded_array_traits", "values": {"c++20": 201902}, "headers": ["type_traits"], }, { "name": "__cpp_lib_boyer_moore_searcher", "values": {"c++17": 201603}, "headers": ["functional"], }, { "name": "__cpp_lib_byte", "values": {"c++17": 201603}, "headers": ["cstddef"], }, { "name": "__cpp_lib_byteswap", "values": {"c++23": 202110}, "headers": ["bit"], }, { "name": "__cpp_lib_char8_t", "values": {"c++20": 201907}, "headers": [ "atomic", "filesystem", "istream", "limits", "locale", "ostream", "string", "string_view", ], "test_suite_guard": "defined(__cpp_char8_t)", "libcxx_guard": "_LIBCPP_HAS_CHAR8_T", }, { "name": "__cpp_lib_chrono", "values": { "c++17": 201611, # "c++26": 202306, # P2592R3 Hashing support for std::chrono value classes }, "headers": ["chrono"], }, { "name": "__cpp_lib_chrono_udls", "values": {"c++14": 201304}, "headers": ["chrono"], }, { "name": "__cpp_lib_clamp", "values": {"c++17": 201603}, "headers": ["algorithm"], }, { "name": "__cpp_lib_common_reference", "values": {"c++20": 202302}, "headers": ["type_traits"], }, { "name": "__cpp_lib_common_reference_wrapper", "values": {"c++20": 202302}, "headers": ["functional"], }, { "name": "__cpp_lib_complex_udls", "values": {"c++14": 201309}, "headers": ["complex"], }, { "name": "__cpp_lib_concepts", "values": {"c++20": 202002}, "headers": ["concepts"], }, { "name": "__cpp_lib_constexpr_algorithms", "values": { "c++20": 201806, "c++26": 202306, }, "headers": ["algorithm", "utility"], }, { "name": "__cpp_lib_constexpr_bitset", "values": {"c++23": 202207}, "headers": ["bitset"], }, { "name": "__cpp_lib_constexpr_charconv", "values": {"c++23": 202207}, "headers": ["charconv"], }, { "name": "__cpp_lib_constexpr_cmath", "values": {"c++23": 202202}, "headers": ["cmath", "cstdlib"], "unimplemented": True, }, { "name": "__cpp_lib_constexpr_complex", "values": {"c++20": 201711}, "headers": ["complex"], }, { "name": "__cpp_lib_constexpr_dynamic_alloc", "values": {"c++20": 201907}, "headers": ["memory"], }, { "name": "__cpp_lib_constexpr_forward_list", "values": {"c++26": 202502}, "headers": ["forward_list"], }, { "name": "__cpp_lib_constexpr_functional", "values": {"c++20": 201907}, "headers": ["functional"], }, { "name": "__cpp_lib_constexpr_iterator", "values": {"c++20": 201811}, "headers": ["iterator"], }, { "name": "__cpp_lib_constexpr_list", "values": {"c++26": 202502}, "headers": ["list"], }, { "name": "__cpp_lib_constexpr_memory", "values": {"c++20": 201811, "c++23": 202202}, "headers": ["memory"], }, { "name": "__cpp_lib_constexpr_new", "values": {"c++26": 202406}, # P2747R2 constexpr placement new "headers": ["new"], "test_suite_guard": "!defined(_LIBCPP_ABI_VCRUNTIME)", "libcxx_guard": "!defined(_LIBCPP_ABI_VCRUNTIME)", }, { "name": "__cpp_lib_constexpr_numeric", "values": {"c++20": 201911}, "headers": ["numeric"], }, { "name": "__cpp_lib_constexpr_queue", "values": {"c++26": 202502}, "headers": ["queue"], }, { "name": "__cpp_lib_constexpr_string", "values": {"c++20": 201907}, "headers": ["string"], }, { "name": "__cpp_lib_constexpr_string_view", "values": {"c++20": 201811}, "headers": ["string_view"], }, { "name": "__cpp_lib_constexpr_tuple", "values": {"c++20": 201811}, "headers": ["tuple"], }, { "name": "__cpp_lib_constexpr_typeinfo", "values": {"c++23": 202106}, "headers": ["typeinfo"], }, { "name": "__cpp_lib_constexpr_utility", "values": {"c++20": 201811}, "headers": ["utility"], }, { "name": "__cpp_lib_constexpr_vector", "values": {"c++20": 201907}, "headers": ["vector"], }, { "name": "__cpp_lib_constrained_equality", "values": { # "c++26": 202403, # P2944R3: Comparisons for reference_wrapper "c++26": 202411, # P3379R0: Constrain std::expected equality operators }, "headers": ["expected", "optional", "tuple", "utility", "variant"], "unimplemented": True, }, { "name": "__cpp_lib_containers_ranges", "values": {"c++23": 202202}, "headers": [ "deque", "forward_list", "list", "map", "queue", "set", "stack", "string", "unordered_map", "unordered_set", "vector", ], }, { "name": "__cpp_lib_copyable_function", "values": {"c++26": 202306}, # P2548R6 copyable_function "headers": ["functional"], "unimplemented": True, }, { "name": "__cpp_lib_coroutine", "values": {"c++20": 201902}, "headers": ["coroutine"], }, { "name": "__cpp_lib_debugging", "values": { "c++26": 202311, # P2546R5 Debugging Support # "c++26": 202403, # P2810R4: is_debugger_present is_replaceable }, "headers": ["debugging"], "unimplemented": True, }, { "name": "__cpp_lib_default_template_type_for_algorithm_values", "values": {"c++26": 202403}, # P2248R8: Enabling list-initialization for algorithms "headers": ["algorithm", "deque", "forward_list", "list", "ranges", "string", "vector"], "unimplemented": True, }, { "name": "__cpp_lib_destroying_delete", "values": {"c++20": 201806}, "headers": ["new"], "test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", "libcxx_guard": "_LIBCPP_STD_VER >= 20 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", }, { "name": "__cpp_lib_enable_shared_from_this", "values": {"c++17": 201603}, "headers": ["memory"], }, { "name": "__cpp_lib_endian", "values": {"c++20": 201907}, "headers": ["bit"], }, { "name": "__cpp_lib_erase_if", "values": {"c++20": 202002}, "headers": [ "deque", "forward_list", "list", "map", "set", "string", "unordered_map", "unordered_set", "vector", ], }, { "name": "__cpp_lib_exchange_function", "values": {"c++14": 201304}, "headers": ["utility"], }, { "name": "__cpp_lib_execution", "values": {"c++17": 201603, "c++20": 201902}, "headers": ["execution"], "unimplemented": True, }, { "name": "__cpp_lib_expected", "values": {"c++23": 202211}, "headers": ["expected"], }, { "name": "__cpp_lib_filesystem", "values": {"c++17": 201703}, "headers": ["filesystem"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_FILESYSTEM && _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY)", "libcxx_guard": "_LIBCPP_HAS_FILESYSTEM && _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY", }, { "name": "__cpp_lib_flat_map", "values": {"c++23": 202207}, "headers": ["flat_map"], }, { "name": "__cpp_lib_flat_set", "values": {"c++23": 202207}, "headers": ["flat_set"], }, { "name": "__cpp_lib_format", "values": { "c++20": 202110, # "c++23": 202207, Not implemented P2419R2 Clarify handling of encodings in localized formatting of chrono types # "c++26": 202306, P2637R3 Member Visit (implemented) # "c++26": 202311, P2918R2 Runtime format strings II (implemented) }, # Note these three papers are adopted at the June 2023 meeting and have sequential numbering # 202304 P2510R3 Formatting pointers (Implemented) # 202305 P2757R3 Type-checking format args # 202306 P2637R3 Member Visit "headers": ["format"], # Trying to use `std::format` where to_chars floating-point is not # available causes compilation errors, even with non floating-point types. # https://github.com/llvm/llvm-project/issues/125353 "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT", "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT", }, { "name": "__cpp_lib_format_path", "values": {"c++26": 202403}, # P2845R8: Formatting of std::filesystem::path "headers": ["filesystem"], "unimplemented": True, }, { "name": "__cpp_lib_format_ranges", "values": {"c++23": 202207}, "headers": ["format"], }, { "name": "__cpp_lib_format_uchar", "values": { "c++20": 202311 # DR P2909R4 Fix formatting of code units as integers }, "headers": [ "format" # TODO verify this entry since the paper was underspecified. ], }, { "name": "__cpp_lib_formatters", "values": {"c++23": 202302}, "headers": ["stacktrace", "thread"], "unimplemented": True, }, { "name": "__cpp_lib_forward_like", "values": {"c++23": 202207}, "headers": ["utility"], }, { "name": "__cpp_lib_freestanding_algorithm", "values": { "c++26": 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["algorithm"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_array", "values": { "c++26": 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["array"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_cstring", "values": { "c++26": 202306 # P2338R4 Freestanding Library: Character primitives and the C library # 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["cstring"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_expected", "values": { "c++26": 202311 # P2833R2 Freestanding Library: inout expected span }, "headers": ["expected"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_mdspan", "values": { "c++26": 202311 # P2833R2 Freestanding Library: inout expected span }, "headers": ["mdspan"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_optional", "values": { "c++26": 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["optional"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_string_view", "values": { "c++26": 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["string_view"], "unimplemented": True, }, { "name": "__cpp_lib_freestanding_variant", "values": { "c++26": 202311 # P2407R5 Freestanding Library: Partial Classes }, "headers": ["variant"], "unimplemented": True, }, { "name": "__cpp_lib_fstream_native_handle", "values": {"c++26": 202306}, # P1759R6 Native handles and file streams "headers": ["fstream"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION)", "libcxx_guard": "_LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION", }, { "name": "__cpp_lib_function_ref", "values": { "c++26": 202306 # P0792R14 function_ref: a type-erased callable reference }, "headers": ["functional"], "unimplemented": True, }, { "name": "__cpp_lib_gcd_lcm", "values": {"c++17": 201606}, "headers": ["numeric"], }, { "name": "__cpp_lib_generate_random", "values": {"c++26": 202403}, # P1068R11: Vector API for random number generation "headers": ["random"], "unimplemented": True, }, { "name": "__cpp_lib_generic_associative_lookup", "values": {"c++14": 201304}, "headers": ["map", "set"], }, { "name": "__cpp_lib_generic_unordered_lookup", "values": {"c++20": 201811}, "headers": ["unordered_map", "unordered_set"], }, { "name": "__cpp_lib_hardware_interference_size", "values": {"c++17": 201703}, "test_suite_guard": "!defined(_LIBCPP_VERSION) || (defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE))", "libcxx_guard": "defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)", "headers": ["new"], }, { "name": "__cpp_lib_has_unique_object_representations", "values": {"c++17": 201606}, "headers": ["type_traits"], }, { "name": "__cpp_lib_hazard_pointer", "values": {"c++26": 202306}, # P2530R3 Hazard Pointers for C++26 "headers": [ "hazard_pointer" # TODO verify this entry since the paper was underspecified. ], "unimplemented": True, }, { "name": "__cpp_lib_hypot", "values": {"c++17": 201603}, "headers": ["cmath"], }, { "name": "__cpp_lib_incomplete_container_elements", "values": {"c++17": 201505}, "headers": ["forward_list", "list", "vector"], }, { "name": "__cpp_lib_inplace_vector", "values": {"c++26": 202406}, # P0843R14 inplace_vector "headers": ["inplace_vector"], "unimplemented": True, }, { "name": "__cpp_lib_int_pow2", "values": {"c++20": 202002}, "headers": ["bit"], }, { "name": "__cpp_lib_integer_comparison_functions", "values": {"c++20": 202002}, "headers": ["utility"], }, { "name": "__cpp_lib_integer_sequence", "values": {"c++14": 201304}, "headers": ["utility"], }, { "name": "__cpp_lib_integral_constant_callable", "values": {"c++14": 201304}, "headers": ["type_traits"], }, { "name": "__cpp_lib_interpolate", "values": {"c++20": 201902}, "headers": ["cmath", "numeric"], }, { "name": "__cpp_lib_invoke", "values": {"c++17": 201411}, "headers": ["functional"], }, { "name": "__cpp_lib_invoke_r", "values": {"c++23": 202106}, "headers": ["functional"], }, { "name": "__cpp_lib_ios_noreplace", "values": {"c++23": 202207}, "headers": ["ios"], }, { "name": "__cpp_lib_is_aggregate", "values": {"c++17": 201703}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_constant_evaluated", "values": {"c++20": 201811}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_final", "values": {"c++14": 201402}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_implicit_lifetime", "values": {"c++23": 202302}, "headers": ["type_traits"], "test_suite_guard": "__has_builtin(__builtin_is_implicit_lifetime)", "libcxx_guard": "__has_builtin(__builtin_is_implicit_lifetime)", }, { "name": "__cpp_lib_is_invocable", "values": {"c++17": 201703}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_layout_compatible", "values": {"c++20": 201907}, "headers": ["type_traits"], "unimplemented": True, }, { "name": "__cpp_lib_is_nothrow_convertible", "values": {"c++20": 201806}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_null_pointer", "values": {"c++14": 201309}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_pointer_interconvertible", "values": {"c++20": 201907}, "headers": ["type_traits"], "unimplemented": True, }, { "name": "__cpp_lib_is_scoped_enum", "values": {"c++23": 202011}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_sufficiently_aligned", "values": {"c++26": 202411}, "headers": ["memory"], }, { "name": "__cpp_lib_is_swappable", "values": {"c++17": 201603}, "headers": ["type_traits"], }, { "name": "__cpp_lib_is_virtual_base_of", "values": { "c++26": 202406 # P2985R0 A type trait for detecting virtual base classes }, "headers": ["type_traits"], "test_suite_guard": "__has_builtin(__builtin_is_virtual_base_of)", "libcxx_guard": "__has_builtin(__builtin_is_virtual_base_of)", }, { "name": "__cpp_lib_is_within_lifetime", # Note this name was changed from "__cpp_lib_within_lifetime" when the paper was adopted # https://github.com/cplusplus/draft/commit/0facada4cadd97e1ba15bfaea76a804f1dc5c309 "values": { "c++26": 202306 # P2641R4 Checking if a union alternative is active }, "headers": ["type_traits"], "unimplemented": True, }, { "name": "__cpp_lib_jthread", "values": {"c++20": 201911}, "headers": ["stop_token", "thread"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC)", "libcxx_guard": "_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC", }, { "name": "__cpp_lib_latch", "values": {"c++20": 201907}, "headers": ["latch"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC)", "libcxx_guard": "_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC", }, { "name": "__cpp_lib_launder", "values": {"c++17": 201606}, "headers": ["new"], }, { "name": "__cpp_lib_linalg", "values": { "c++26": 202311 # P1673 A free function linear algebra interface based on the BLAS }, "headers": ["linalg"], "unimplemented": True, }, { "name": "__cpp_lib_list_remove_return_type", "values": {"c++20": 201806}, "headers": ["forward_list", "list"], }, { "name": "__cpp_lib_logical_traits", "values": {"c++17": 201510}, "headers": ["type_traits"], }, { "name": "__cpp_lib_make_from_tuple", "values": {"c++17": 201606}, "headers": ["tuple"], }, { "name": "__cpp_lib_make_reverse_iterator", "values": {"c++14": 201402}, "headers": ["iterator"], }, { "name": "__cpp_lib_make_unique", "values": {"c++14": 201304}, "headers": ["memory"], }, { "name": "__cpp_lib_map_try_emplace", "values": {"c++17": 201411}, "headers": ["map"], }, { "name": "__cpp_lib_math_constants", "values": {"c++20": 201907}, "headers": ["numbers"], }, { "name": "__cpp_lib_math_special_functions", "values": {"c++17": 201603}, "headers": ["cmath"], "unimplemented": True, }, { "name": "__cpp_lib_mdspan", "values": { "c++23": 202207, "c++26": 202406, # P2389R2 dextents Index Type Parameter }, "headers": ["mdspan"], }, { "name": "__cpp_lib_memory_resource", "values": {"c++17": 201603}, "headers": ["memory_resource"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_PMR", "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_PMR", }, { "name": "__cpp_lib_modules", "values": {"c++23": 202207}, "headers": [], }, { "name": "__cpp_lib_move_iterator_concept", "values": {"c++20": 202207}, "headers": ["iterator"], }, { "name": "__cpp_lib_move_only_function", "values": {"c++23": 202110}, "headers": ["functional"], "unimplemented": True, }, { "name": "__cpp_lib_node_extract", "values": {"c++17": 201606}, "headers": ["map", "set", "unordered_map", "unordered_set"], }, { "name": "__cpp_lib_nonmember_container_access", "values": {"c++17": 201411}, "headers": [ "array", "deque", "forward_list", "iterator", "list", "map", "regex", "set", "string", "unordered_map", "unordered_set", "vector", ], }, { "name": "__cpp_lib_not_fn", "values": { "c++17": 201603, "c++26": 202306, # P2714R1 Bind front and back to NTTP callables }, "headers": ["functional"], }, { "name": "__cpp_lib_null_iterators", "values": {"c++14": 201304}, "headers": ["iterator"], }, { "name": "__cpp_lib_optional", "values": { "c++17": 201606, "c++20": 202106, # P2231R1 Missing constexpr in std::optional and std::variant "c++23": 202110, # P0798R8 Monadic operations for std::optional + LWG3621 Remove feature-test macro __cpp_lib_monadic_optional }, "headers": ["optional"], }, { "name": "__cpp_lib_optional_range_support", "values": {"c++26": 202406}, # P3168R2 Give std::optional Range Support "headers": ["optional"], "unimplemented": True, }, { "name": "__cpp_lib_out_ptr", "values": { "c++23": 202106, "c++26": 202311, # P2833R2 Freestanding Library: inout expected span }, "headers": ["memory"], }, { "name": "__cpp_lib_parallel_algorithm", "values": {"c++17": 201603}, "headers": ["algorithm", "numeric"], "unimplemented": True, }, { "name": "__cpp_lib_philox_engine", "values": { "c++26": 202406 }, # P2075R6 Philox as an extension of the C++ RNG engines # Note the paper mentions 202310L as value, which differs from the typical procedure. "headers": ["random"], "unimplemented": True, }, { "name": "__cpp_lib_polymorphic_allocator", "values": {"c++20": 201902}, "headers": ["memory_resource"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_PMR", "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_PMR", }, { "name": "__cpp_lib_print", "values": { "c++23": 202207, # "c++26": 202403, # P3107R5: Permit an efficient implementation of std::print # "c++26": 202406, # P3235R3 std::print more types faster with less memory }, "headers": ["ostream", "print"], # Trying to use `std::print` where to_chars floating-point is not # available causes compilation errors, even with non floating-point types. # https://github.com/llvm/llvm-project/issues/125353 "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT", "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT", }, { "name": "__cpp_lib_quoted_string_io", "values": {"c++14": 201304}, "headers": ["iomanip"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_HAS_LOCALIZATION", "libcxx_guard": "_LIBCPP_HAS_LOCALIZATION", }, { "name": "__cpp_lib_ranges", "values": { "c++20": 202110, # P2415R2 What is a view? "c++23": 202406, # P2997R1 Removing the common reference requirement from the indirectly invocable concepts (implemented as a DR against C++20) }, "headers": ["algorithm", "functional", "iterator", "memory", "ranges"], }, { "name": "__cpp_lib_ranges_as_const", "values": { "c++23": 202207 # P2278R4 cbegin should always return a constant iterator # 202311 # DR P2836R1 std::basic_const_iterator should follow its underlying type’s convertibility }, "headers": ["ranges"], "unimplemented": True, }, { "name": "__cpp_lib_ranges_as_rvalue", "values": {"c++23": 202207}, "headers": ["ranges"], }, { "name": "__cpp_lib_ranges_chunk", "values": {"c++23": 202202}, "headers": ["ranges"], "unimplemented": True, }, { "name": "__cpp_lib_ranges_chunk_by", "values": {"c++23": 202202}, "headers": ["ranges"], }, { "name": "__cpp_lib_ranges_concat", "values": {"c++26": 202403}, # P2542R8: views::concat "headers": ["ranges"], "unimplemented": True, }, { "name": "__cpp_lib_ranges_contains", "values": {"c++23": 202207}, "headers": ["algorithm"], }, { "name": "__cpp_lib_ranges_find_last", "values": {"c++23": 202207}, "headers": ["algorithm"], }, { "name": "__cpp_lib_ranges_iota", "values": {"c++23": 202202}, "headers": ["numeric"], }, { "name": "__cpp_lib_ranges_join_with", "values": {"c++23": 202202}, "headers": ["ranges"], }, { "name": "__cpp_lib_ranges_repeat", "values": {"c++23": 202207}, "headers": ["ranges"], }, { "name": "__cpp_lib_ranges_slide", "values": {"c++23": 202202}, "headers": ["ranges"], "unimplemented": True, }, { "name": "__cpp_lib_ranges_starts_ends_with", "values": {"c++23": 202106}, "headers": ["algorithm"], }, { "name": "__cpp_lib_ranges_to_container", "values": {"c++23": 202202}, "headers": ["ranges"], }, { "name": "__cpp_lib_ranges_zip", "values": {"c++23": 202110}, "headers": ["ranges", "tuple", "utility"], "unimplemented": True, }, { "name": "__cpp_lib_ratio", "values": {"c++26": 202306}, # P2734R0 Adding the new SI prefixes "headers": ["ratio"], }, { "name": "__cpp_lib_raw_memory_algorithms", "values": {"c++17": 201606}, "headers": ["memory"], }, { "name": "__cpp_lib_rcu", "values": {"c++26": 202306}, # P2545R4 Read-Copy Update (RCU) "headers": [ "rcu" # TODO verify this entry since the paper was underspecified. ], "unimplemented": True, }, { "name": "__cpp_lib_reference_from_temporary", "values": {"c++23": 202202}, "headers": ["type_traits"], "unimplemented": True, }, { "name": "__cpp_lib_reference_wrapper", "values": {"c++26": 202403}, # P2944R3: Comparisons for reference_wrapper "headers": ["functional"], }, { "name": "__cpp_lib_remove_cvref", "values": {"c++20": 201711}, "headers": ["type_traits"], }, { "name": "__cpp_lib_result_of_sfinae", "values": {"c++14": 201210}, "headers": ["functional", "type_traits"], }, { "name": "__cpp_lib_robust_nonmodifying_seq_ops", "values": {"c++14": 201304}, "headers": ["algorithm"], }, { "name": "__cpp_lib_sample", "values": {"c++17": 201603}, "headers": ["algorithm"], }, { "name": "__cpp_lib_saturation_arithmetic", "values": {"c++26": 202311}, # P0543R3 Saturation arithmetic "headers": ["numeric"], }, { "name": "__cpp_lib_scoped_lock", "values": {"c++17": 201703}, "headers": ["mutex"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_HAS_THREADS", "libcxx_guard": "_LIBCPP_HAS_THREADS", }, { "name": "__cpp_lib_semaphore", "values": {"c++20": 201907}, "headers": ["semaphore"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || (_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC)", "libcxx_guard": "_LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC", }, { "name": "__cpp_lib_senders", "values": {"c++26": 202406}, # P2300R10 std::execution "headers": ["execution"], "unimplemented": True, }, { "name": "__cpp_lib_shared_mutex", "values": {"c++17": 201505}, "headers": ["shared_mutex"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_HAS_THREADS", "libcxx_guard": "_LIBCPP_HAS_THREADS", }, { "name": "__cpp_lib_shared_ptr_arrays", "values": {"c++17": 201611, "c++20": 201707}, "headers": ["memory"], }, { "name": "__cpp_lib_shared_ptr_weak_type", "values": {"c++17": 201606}, "headers": ["memory"], }, { "name": "__cpp_lib_shared_timed_mutex", "values": {"c++14": 201402}, "headers": ["shared_mutex"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_HAS_THREADS", "libcxx_guard": "_LIBCPP_HAS_THREADS", }, { "name": "__cpp_lib_shift", "values": {"c++20": 201806}, "headers": ["algorithm"], }, { "name": "__cpp_lib_smart_ptr_for_overwrite", "values": {"c++20": 202002}, "headers": ["memory"], }, { "name": "__cpp_lib_smart_ptr_owner_equality", "values": { "c++26": 202306 # P1901R2 Enabling the Use of weak_ptr as Keys in Unordered Associative Containers }, "headers": ["memory"], "unimplemented": True, }, { "name": "__cpp_lib_source_location", "values": {"c++20": 201907}, "headers": ["source_location"], }, { "name": "__cpp_lib_span", "values": { "c++20": 202002, # "c++26": 202311, # P2821R5 span.at() # 202311 # P2833R2 Freestanding Library: inout expected span }, "headers": ["span"], }, { "name": "__cpp_lib_span_at", "values": {"c++26": 202311}, # P2821R3 span.at() "headers": ["span"], }, { "name": "__cpp_lib_span_initializer_list", "values": {"c++26": 202311}, # P2447R6 std::span over an initializer list "headers": ["span"], }, { "name": "__cpp_lib_spanstream", "values": {"c++23": 202106}, "headers": ["spanstream"], "unimplemented": True, }, { "name": "__cpp_lib_ssize", "values": {"c++20": 201902}, "headers": ["iterator"], }, { "name": "__cpp_lib_sstream_from_string_view", "values": { "c++26": 202306 # P2495R3 Interfacing stringstreams with string_view }, "headers": ["sstream"], }, { "name": "__cpp_lib_stacktrace", "values": {"c++23": 202011}, "headers": ["stacktrace"], "unimplemented": True, }, { "name": "__cpp_lib_starts_ends_with", "values": {"c++20": 201711}, "headers": ["string", "string_view"], }, { "name": "__cpp_lib_stdatomic_h", "values": {"c++23": 202011}, "headers": ["stdatomic.h"], }, { "name": "__cpp_lib_string_contains", "values": {"c++23": 202011}, "headers": ["string", "string_view"], }, { "name": "__cpp_lib_string_resize_and_overwrite", "values": {"c++23": 202110}, "headers": ["string"], }, { "name": "__cpp_lib_string_udls", "values": {"c++14": 201304}, "headers": ["string"], }, { "name": "__cpp_lib_string_view", "values": { "c++17": 201606, "c++20": 201803, "c++26": 202403, # P2591R5: Concatenation of strings and string views }, "headers": ["string", "string_view"], }, { "name": "__cpp_lib_submdspan", "values": { "c++26": 202306, # P2630R4: submdspan # "c++26": 202403, # P2642R6: Padded mdspan layouts }, "headers": ["mdspan"], "unimplemented": True, }, { "name": "__cpp_lib_syncbuf", "values": {"c++20": 201803}, "headers": ["syncstream"], "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_HAS_EXPERIMENTAL_SYNCSTREAM", "libcxx_guard": "_LIBCPP_HAS_EXPERIMENTAL_SYNCSTREAM", }, { "name": "__cpp_lib_text_encoding", "values": { "c++26": 202306 # P1885R12 Naming Text Encodings to Demystify Them }, "headers": ["text_encoding"], "unimplemented": True, }, { "name": "__cpp_lib_three_way_comparison", "values": {"c++20": 201907}, "headers": ["compare"], }, { "name": "__cpp_lib_to_address", "values": {"c++20": 201711}, "headers": ["memory"], }, { "name": "__cpp_lib_to_array", "values": {"c++20": 201907}, "headers": ["array"], }, { "name": "__cpp_lib_to_chars", "values": { "c++17": 201611, "c++26": 202306, # P2497R0 Testing for success or failure of functions }, "headers": ["charconv"], "unimplemented": True, }, { "name": "__cpp_lib_to_string", "values": {"c++26": 202306}, # P2587R3 to_string or not to_string "headers": ["string"], "unimplemented": True, }, { "name": "__cpp_lib_to_underlying", "values": {"c++23": 202102}, "headers": ["utility"], }, { "name": "__cpp_lib_transformation_trait_aliases", "values": {"c++14": 201304}, "headers": ["type_traits"], }, { "name": "__cpp_lib_transparent_operators", "values": {"c++14": 201210, "c++17": 201510}, "headers": ["functional", "memory"], }, { "name": "__cpp_lib_tuple_element_t", "values": {"c++14": 201402}, "headers": ["tuple"], }, { "name": "__cpp_lib_tuple_like", "values": { "c++23": 202207, # P2165R4 Compatibility between tuple, pair and tuple-like objects "c++26": 202311, # P2819R2 Add tuple protocol to complex (implemented) }, "headers": ["map", "tuple", "unordered_map", "utility"], "unimplemented": True, }, { "name": "__cpp_lib_tuples_by_type", "values": {"c++14": 201304}, "headers": ["tuple", "utility"], }, { "name": "__cpp_lib_type_identity", "values": {"c++20": 201806}, "headers": ["type_traits"], }, { "name": "__cpp_lib_type_trait_variable_templates", "values": {"c++17": 201510}, "headers": ["type_traits"], }, { "name": "__cpp_lib_uncaught_exceptions", "values": {"c++17": 201411}, "headers": ["exception"], }, { "name": "__cpp_lib_unordered_map_try_emplace", "values": {"c++17": 201411}, "headers": ["unordered_map"], }, { "name": "__cpp_lib_unreachable", "values": {"c++23": 202202}, "headers": ["utility"], }, { "name": "__cpp_lib_unwrap_ref", "values": {"c++20": 201811}, "headers": ["functional"], }, { "name": "__cpp_lib_variant", "values": { "c++17": 202102, # std::visit for classes derived from std::variant "c++20": 202106, # P2231R1 Missing constexpr in std::optional and std::variant "c++26": 202306, # P2637R3 Member visit }, "headers": ["variant"], }, { "name": "__cpp_lib_void_t", "values": {"c++17": 201411}, "headers": ["type_traits"], }, ] ] assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"]) for tc in feature_test_macros: assert tc["headers"] == sorted(tc["headers"]), tc assert ("libcxx_guard" in tc) == ("test_suite_guard" in tc), tc valid_keys = ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented"] assert all(key in valid_keys for key in tc.keys()), tc # Map from each header to the Lit annotations that should be used for # tests that include that header. # # For example, when threads are not supported, any test that includes # should be marked as UNSUPPORTED, because including # is a hard error in that case. lit_markup = { "barrier": ["UNSUPPORTED: no-threads"], "filesystem": ["UNSUPPORTED: no-filesystem"], "fstream": ["UNSUPPORTED: no-localization"], "iomanip": ["UNSUPPORTED: no-localization"], "ios": ["UNSUPPORTED: no-localization"], "iostream": ["UNSUPPORTED: no-localization"], "istream": ["UNSUPPORTED: no-localization"], "latch": ["UNSUPPORTED: no-threads"], "locale": ["UNSUPPORTED: no-localization"], "mutex": ["UNSUPPORTED: no-threads"], "ostream": ["UNSUPPORTED: no-localization"], "print": ["UNSUPPORTED: no-filesystem"], "regex": ["UNSUPPORTED: no-localization"], "semaphore": ["UNSUPPORTED: no-threads"], "shared_mutex": ["UNSUPPORTED: no-threads"], "sstream": ["UNSUPPORTED: no-localization"], "syncstream": ["UNSUPPORTED: no-localization"], "stdatomic.h": ["UNSUPPORTED: no-threads"], "stop_token": ["UNSUPPORTED: no-threads"], "thread": ["UNSUPPORTED: no-threads"], } def get_std_dialects(): std_dialects = ["c++14", "c++17", "c++20", "c++23", "c++26"] return list(std_dialects) def get_first_std(d): for s in get_std_dialects(): if s in d.keys(): return s return None def get_last_std(d): rev_dialects = get_std_dialects() rev_dialects.reverse() for s in rev_dialects: if s in d.keys(): return s return None def get_std_before(d, std): std_dialects = get_std_dialects() candidates = std_dialects[0 : std_dialects.index(std)] candidates.reverse() for cand in candidates: if cand in d.keys(): return cand return None def get_value_before(d, std): new_std = get_std_before(d, std) if new_std is None: return None return d[new_std] def get_for_std(d, std): # This catches the C++11 case for which there should be no defined feature # test macros. std_dialects = get_std_dialects() if std not in std_dialects: return None # Find the value for the newest C++ dialect between C++14 and std std_list = list(std_dialects[0 : std_dialects.index(std) + 1]) std_list.reverse() for s in std_list: if s in d.keys(): return d[s] return None def get_std_number(std): return std.replace("c++", "") """ Functions to produce the header """ def produce_macros_definition_for_std(std): result = "" indent = 55 for tc in feature_test_macros: if std not in tc["values"]: continue inner_indent = 1 if "test_suite_guard" in tc.keys(): result += "# if %s\n" % tc["libcxx_guard"] inner_indent += 2 if get_value_before(tc["values"], std) is not None: assert "test_suite_guard" not in tc.keys() result += "# undef %s\n" % tc["name"] line = "#%sdefine %s" % ((" " * inner_indent), tc["name"]) line += " " * (indent - len(line)) line += " %sL" % tc["values"][std] if "unimplemented" in tc.keys(): line = "// " + line result += line result += "\n" if "test_suite_guard" in tc.keys(): result += "# endif\n" return result.strip() def produce_macros_definitions(): macro_definition_template = """#if _LIBCPP_STD_VER >= {std_number} {macro_definition} #endif""" macros_definitions = [] for std in get_std_dialects(): macros_definitions.append( macro_definition_template.format( std_number=get_std_number(std), macro_definition=produce_macros_definition_for_std(std), ) ) return "\n\n".join(macros_definitions) def chunks(l, n): """Yield successive n-sized chunks from l.""" for i in range(0, len(l), n): yield l[i : i + n] def produce_version_synopsis(): indent = 56 header_indent = 56 + len("20XXYYL ") result = "" def indent_to(s, val): if len(s) >= val: return s s += " " * (val - len(s)) return s line = indent_to("Macro name", indent) + "Value" line = indent_to(line, header_indent) + "Headers" result += line + "\n" for tc in feature_test_macros: prev_defined_std = get_last_std(tc["values"]) line = "{name: <{indent}}{value}L ".format( name=tc["name"], indent=indent, value=tc["values"][prev_defined_std] ) headers = list(tc["headers"]) headers.remove("version") for chunk in chunks(headers, 3): line = indent_to(line, header_indent) chunk = ["<%s>" % header for header in chunk] line += " ".join(chunk) result += line result += "\n" line = "" while True: prev_defined_std = get_std_before(tc["values"], prev_defined_std) if prev_defined_std is None: break result += "%s%sL // %s\n" % ( indent_to("", indent), tc["values"][prev_defined_std], prev_defined_std.replace("c++", "C++"), ) return result def produce_version_header(): template = """// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_VERSIONH #define _LIBCPP_VERSIONH /* version synopsis {synopsis} */ #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) # include <__cxx03/version> #else # include <__config> # if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header # endif // clang-format off {cxx_macros} #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) // clang-format on #endif // _LIBCPP_VERSIONH """ version_str = template.format( synopsis=produce_version_synopsis().strip(), cxx_macros=produce_macros_definitions(), ) version_header_path = os.path.join(include_path, "version") with open(version_header_path, "w", newline="\n") as f: f.write(version_str) """ Functions to produce test files """ test_types = { "undefined": """ # ifdef {name} # error "{name} should not be defined before {std_first}" # endif """, "test_suite_guard": """ # if {test_suite_guard} # ifndef {name} # error "{name} should be defined in {std}" # endif # if {name} != {value} # error "{name} should have the value {value} in {std}" # endif # else # ifdef {name} # error "{name} should not be defined when the requirement '{test_suite_guard}' is not met!" # endif # endif """, "unimplemented": """ # if !defined(_LIBCPP_VERSION) # ifndef {name} # error "{name} should be defined in {std}" # endif # if {name} != {value} # error "{name} should have the value {value} in {std}" # endif # else # ifdef {name} # error "{name} should not be defined because it is unimplemented in libc++!" # endif # endif """, "defined": """ # ifndef {name} # error "{name} should be defined in {std}" # endif # if {name} != {value} # error "{name} should have the value {value} in {std}" # endif """, } def generate_std_test(test_list, std): result = "" for tc in test_list: val = get_for_std(tc["values"], std) if val is not None: val = "%sL" % val if val is None: result += test_types["undefined"].format( name=tc["name"], std_first=get_first_std(tc["values"]) ) elif "unimplemented" in tc.keys(): result += test_types["unimplemented"].format( name=tc["name"], value=val, std=std ) elif "test_suite_guard" in tc.keys(): result += test_types["test_suite_guard"].format( name=tc["name"], value=val, std=std, test_suite_guard=tc["test_suite_guard"], ) else: result += test_types["defined"].format(name=tc["name"], value=val, std=std) return result.strip() def generate_std_tests(test_list): std_tests_template = """#if TEST_STD_VER < {first_std_number} {pre_std_test} {other_std_tests} #elif TEST_STD_VER > {penultimate_std_number} {last_std_test} #endif // TEST_STD_VER > {penultimate_std_number}""" std_dialects = get_std_dialects() other_std_tests = [] for std in std_dialects[:-1]: other_std_tests.append("#elif TEST_STD_VER == " + get_std_number(std)) other_std_tests.append(generate_std_test(test_list, std)) std_tests = std_tests_template.format( first_std_number=get_std_number(std_dialects[0]), pre_std_test=generate_std_test(test_list, "c++11"), other_std_tests="\n\n".join(other_std_tests), penultimate_std_number=get_std_number(std_dialects[-2]), last_std_test=generate_std_test(test_list, std_dialects[-1]), ) return std_tests def generate_synopsis(test_list): max_name_len = max([len(tc["name"]) for tc in test_list]) indent = max_name_len + 8 def mk_line(prefix, suffix): return "{prefix: <{max_len}}{suffix}\n".format( prefix=prefix, suffix=suffix, max_len=indent ) result = "" result += mk_line("/* Constant", "Value") for tc in test_list: prefix = " %s" % tc["name"] for std in [s for s in get_std_dialects() if s in tc["values"].keys()]: result += mk_line( prefix, "%sL [%s]" % (tc["values"][std], std.replace("c++", "C++")) ) prefix = "" result += "*/" return result def produce_tests(): headers = set([h for tc in feature_test_macros for h in tc["headers"]]) for h in headers: test_list = [tc for tc in feature_test_macros if h in tc["headers"]] if not has_header(h): for tc in test_list: assert "unimplemented" in tc.keys() continue markup = "\n".join("// " + tag for tag in lit_markup.get(h, [])) test_body = """//===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // WARNING: This test was generated by {script_name} // and should not be edited manually. {markup} // <{header}> // Test the feature test macros defined by <{header}> // clang-format off #include <{header}> #include "test_macros.h" {cxx_tests} // clang-format on """.format( script_name=script_name, header=h, markup=("\n{}\n".format(markup) if markup else ""), cxx_tests=generate_std_tests(test_list), ) test_name = "{header}.version.compile.pass.cpp".format(header=h) out_path = os.path.join(macro_test_path, test_name) with open(out_path, "w", newline="\n") as f: f.write(test_body) """ Produce documentation for the feature test macros """ def make_widths(grid): widths = [] for i in range(0, len(grid[0])): cell_width = 2 + max( reduce(lambda x, y: x + y, [[len(row[i])] for row in grid], []) ) widths += [cell_width] return widths def create_table(grid, indent): indent_str = " " * indent col_widths = make_widths(grid) result = [indent_str + add_divider(col_widths, 2)] header_flag = 2 for row_i in range(0, len(grid)): row = grid[row_i] line = indent_str + " ".join( [pad_cell(row[i], col_widths[i]) for i in range(0, len(row))] ) result.append(line.rstrip()) if row_i == len(grid) - 1: header_flag = 2 if row[0].startswith("**"): header_flag += 1 separator = indent_str + add_divider(col_widths, header_flag) result.append(separator.rstrip()) header_flag = 0 return "\n".join(result) def add_divider(widths, header_flag): if header_flag == 3: return "=".join(["=" * w for w in widths]) if header_flag == 2: return " ".join(["=" * w for w in widths]) if header_flag == 1: return "-".join(["-" * w for w in widths]) else: return " ".join(["-" * w for w in widths]) def pad_cell(s, length, left_align=True): padding = (length - len(s)) * " " return s + padding def get_status_table(): table = [["Macro Name", "Value"]] for std in get_std_dialects(): table += [["**" + std.replace("c++", "C++") + "**", ""]] for tc in feature_test_macros: if std not in tc["values"].keys(): continue value = "``%sL``" % tc["values"][std] if "unimplemented" in tc.keys(): value = "*unimplemented*" table += [["``%s``" % tc["name"], value]] return table def produce_docs(): doc_str = """.. _FeatureTestMacroTable: ========================== Feature Test Macro Support ========================== .. contents:: :local: Overview ======== This file documents the feature test macros currently supported by libc++. .. _feature-status: Status ====== .. table:: Current Status :name: feature-status-table :widths: auto {status_tables} """.format( status_tables=create_table(get_status_table(), 4) ) table_doc_path = os.path.join(docs_path, "FeatureTestMacroTable.rst") with open(table_doc_path, "w", newline="\n") as f: f.write(doc_str) Std = NewType("Std", str) # Standard version number Ftm = NewType("Ftm", str) # The name of a feature test macro Value = NewType("Value", str) # The value of a feature test macro including the L suffix @dataclass class Metadata: headers: List[str] = None available_since: Std = None test_suite_guard: str = None libcxx_guard: str = None @dataclass class VersionHeader: value: Value = None implemented: bool = None need_undef: bool = None condition: str = None @dataclass class FtmHeaderTest: value: Value = None implemented: bool = None condition: str = None def get_ftms( data, std_dialects: List[Std], use_implemented_status: bool ) -> Dict[Ftm, Dict[Std, Optional[Value]]]: """Impementation for FeatureTestMacros.(standard|implemented)_ftms().""" result = dict() for feature in data: last = None entry = dict() implemented = True for std in std_dialects: if std not in feature["values"].keys(): if last == None: continue else: entry[std] = last else: if implemented: values = feature["values"][std] assert len(values) > 0, f"{feature['name']}[{std}] has no entries" for value in values: papers = list(values[value]) assert ( len(papers) > 0 ), f"{feature['name']}[{std}][{value}] has no entries" for paper in papers: if use_implemented_status and not paper["implemented"]: implemented = False break if implemented: last = f"{value}L" else: break if last: entry[std] = last result[feature["name"]] = entry return result def generate_version_header_dialect_block(data: Dict[Ftm, VersionHeader]) -> str: """Generates the contents of the version header for a dialect. This generates the contents of a #if _LIBCPP_STD_VER >= XY #endif // _LIBCPP_STD_VER >= XY block. """ result = "" for element in data: for ftm, entry in element.items(): if not entry.implemented: # When a FTM is not implemented don't add the guards # or undefine the (possibly) defined macro. result += f"// define {ftm} {entry.value}\n" else: need_undef = entry.need_undef if entry.condition: result += f"# if {entry.condition}\n" if entry.need_undef: result += f"# undef {ftm}\n" result += f"# define {ftm} {entry.value}\n" result += f"# endif\n" else: if entry.need_undef: result += f"# undef {ftm}\n" result += f"# define {ftm} {entry.value}\n" return result def generate_version_header_implementation( data: Dict[Std, Dict[Ftm, VersionHeader]] ) -> str: """Generates the body of the version header.""" template = """#if _LIBCPP_STD_VER >= {dialect} {feature_test_macros}#endif // _LIBCPP_STD_VER >= {dialect}""" result = [] for std, ftms in data.items(): result.append( template.format( dialect=std, feature_test_macros=generate_version_header_dialect_block(ftms), ) ) return "\n\n".join(result) # # The templates used to create a FTM test file # ftm_header_test_file_contents = """//===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // WARNING: This test was generated by {script_name} // and should not be edited manually. {lit_markup}// <{header}> // Test the feature test macros defined by <{header}> // clang-format off {include} #include "test_macros.h" {data} // clang-format on """ ftm_header_test_file_include_unconditional = """\ #include <{header}>\ """ # On Windows the Windows SDK is on the include path, that means the MSVC STL # headers can be found as well, tricking __has_include into thinking that # libc++ provides the header. This means the test is also not executed when # using this test with MSVC and MSVC STL. ftm_header_test_file_include_conditional = """\ #if !defined(_WIN32) && __has_include(<{header}>) # include <{header}> #endif\ """ ftm_header_test_file_dialect_block = """ #{pp_if} TEST_STD_VER {operator} {dialect} {tests}\ """ class FeatureTestMacros: """Provides all feature-test macro (FTM) output components. The class has several generators to use the feature-test macros in libc++: - FTM status page - The version header and its tests This class is not intended to duplicate https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros SD-FeatureTest: Feature-Test Macros and Policies Historically libc++ did not list all papers affecting a FTM, the new data structure is able to do that. However there is no intention to add the historical data. After papers have been implemented this information can be removed. For example, __cpp_lib_format's value 201907 requires 3 papers, once implemented it can be reduced to 1 paper and remove the paper number and title. This would reduce the size of the data. The input data is stored in the following JSON format: [ # A list with multiple feature-test macro entries. { # required # The name of the feature test macro. These names should be unique and # sorted in the list. "name": "__cpp_lib_any", # required # A map with the value of the FTM based on the language standard. Only # the versions in which the value of the FTM changes are listed. For # example, this macro's value does not change in C++20 so it does not # list C++20. If it changes in C++26, it will have entries for C++17 and # C++26. "values": { # required # The language standard, also named dialect in this class. "c++17": { # required # The value of the feature test macro. This contains an array with # one or more papers that need to be implemented before this value # is considered implemented. "201606": [ { # optional # Contains the paper number that is part of the FTM version. "number": "P0220R1", # optional # Contains the title of the paper that is part of the FTM # version. "title": "Adopt Library Fundamentals V1 TS Components for C++17" # required # The implementation status of the paper. "implemented": true } ] } }, # required # A sorted list of headers that should provide the FTM. The header # is automatically added to this list. This list could be # empty. For example, __cpp_lib_modules is only present in version. # Requiring the field makes it easier to detect accidental omission. "headers": [ "any" ], # optional, required when libcxx_guard is present # This field is used only to generate the unit tests for the # feature-test macros. It can't depend on macros defined in <__config> # because the `test/std/` parts of the test suite are intended to be # portable to any C++ standard library implementation, not just libc++. # It may depend on # * macros defined by the compiler itself, or # * macros generated by CMake. # In some cases we add also depend on macros defined in # <__availability>. "test_suite_guard": "!defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_PMR" # optional, required when test_suite_guard is present # This field is used only to guard the feature-test macro in # . It may be the same as `test_suite_guard`, or it may # depend on macros defined in <__config>. "libcxx_guard": "_LIBCPP_AVAILABILITY_HAS_PMR" }, ] """ # The JSON data structure. __data = None # The headers not available in libc++. # # This could be detected based on FTM status, however that gives some odd # results. For example, at the moment __cpp_lib_constexpr_cmath is not # implemented, which flags `` as not implemented. The availability # of headers is maintained for the C++ Standard Library modules. __unavailable_headers = None def __init__(self, filename: str, unavailable_headers: List[str]): """Initializes the class with the JSON data in the file 'filename'.""" with open(filename) as f: self.__data = json.load(f) self.__unavailable_headers = set(unavailable_headers) @functools.cached_property def std_dialects(self) -> List[Std]: """Returns the C++ dialects avaiable. The available dialects are based on the 'c++xy' keys found the 'values' entries in '__data'. So when WG21 starts to feature-test macros for a future C++ Standard this dialect will automatically be available. The return value is a sorted list with the C++ dialects used. Since FTM were added in C++14 the list will not contain C++03 or C++11. """ dialects = set() for feature in self.__data: keys = feature["values"].keys() assert len(keys) > 0, "'values' is empty" dialects |= keys return sorted(list(dialects)) @functools.cached_property def standard_ftms(self) -> Dict[Ftm, Dict[Std, Optional[Value]]]: """Returns the FTM versions per dialect in the Standard. This function does not use the 'implemented' flag. The output contains the versions used in the Standard. When a FTM in libc++ is not implemented according to the Standard to output may opt to show the expected value. """ return get_ftms(self.__data, self.std_dialects, False) @functools.cached_property def standard_library_headers(self) -> Set[str]: """Returns a list of headers that contain at least one FTM.""" result = set() for value in self.ftm_metadata.values(): for header in value.headers: result.add(header) return list(result) @functools.cached_property def implemented_ftms(self) -> Dict[Ftm, Dict[Std, Optional[Value]]]: """Returns the FTM versions per dialect implemented in libc++. Unlike `get_std_dialect_versions` this function uses the 'implemented' flag. This returns the actual implementation status in libc++. """ return get_ftms(self.__data, self.std_dialects, True) def is_implemented(self, ftm: Ftm, std: Std) -> bool: """Has the FTM `ftm` been implemented in the dialect `std`?""" # When a paper for C++20 has not been implemented in libc++, then there will be no # FTM entry in implemented_ftms for C++23 and later. Similarly, a paper like # has no entry in standard_ftms for e.g. C++11. if not std in self.implemented_ftms[ftm].keys() or not std in self.standard_ftms[ftm].keys(): return False return self.implemented_ftms[ftm][std] == self.standard_ftms[ftm][std] @functools.cached_property def ftm_metadata(self) -> Dict[Ftm, Metadata]: """Returns the metadata of the FTMs defined in the Standard. The metadata does not depend on the C++ dialect used. """ result = dict() for feature in self.__data: result[feature["name"]] = Metadata( feature["headers"], list(feature["values"])[0], feature.get("test_suite_guard", None), feature.get("libcxx_guard", None), ) return result @property def version_header_implementation(self) -> Dict[Std, Dict[Ftm, VersionHeader]]: """Generates the body of the version header.""" result = dict() for std in self.std_dialects: result[get_std_number(std)] = list() for ftm, values in self.standard_ftms.items(): last_value = None last_entry = None for std, value in values.items(): # When a newer Standard does not change the value of the macro # there is no need to redefine it with the same value. if last_value and value == last_value: continue last_value = value implemented = self.is_implemented(ftm, std) entry = VersionHeader( value, implemented, last_entry is not None and last_entry.implemented and implemented, self.ftm_metadata[ftm].libcxx_guard, ) last_entry = entry result[get_std_number(std)].append(dict({ftm: entry})) return result @property def version_header(self) -> str: """Generates the version header.""" template = """// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_VERSIONH #define _LIBCPP_VERSIONH #include <__config> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif {feature_test_macros} #endif // _LIBCPP_VERSIONH """ return template.format( feature_test_macros=generate_version_header_implementation( self.version_header_implementation ) ) def header_ftm_data(self, header: str) -> Dict[Std, List[Dict[Ftm, FtmHeaderTest]]]: """Generates the FTM information for a `header`.""" result = dict() for std in self.std_dialects: result[get_std_number(std)] = list() for ftm, values in self.standard_ftms.items(): if not header in self.ftm_metadata[ftm].headers: continue last_value = None last_entry = None for std in self.std_dialects: if not std in values.keys(): result[get_std_number(std)].append({ftm: None}) continue result[get_std_number(std)].append( { ftm: FtmHeaderTest( values[std], self.is_implemented(ftm, std), self.ftm_metadata[ftm].test_suite_guard, ) } ) return result def generate_ftm_test(self, std: Std, ftm: Ftm, value: FtmHeaderTest) -> str: """Adds a single `ftm` test for C++ `std` based on the status information in `value`. When std == None this test is generating the TEST_STD_VER < MIN. Where MIN is the minimum version that has a FTM defined. (In the real data this is 14, since FTM have been introduced in C++14.) """ ftm_unavailable_in_dialect = """ # ifdef {ftm} # error "{ftm} should not be defined before {dialect}" # endif """ ftm_not_implemented = """ # if !defined(_LIBCPP_VERSION) # ifndef {ftm} # error "{ftm} should be defined in {dialect}" # endif # if {ftm} != {value} # error "{ftm} should have the value {value} in {dialect}" # endif # else # ifdef {ftm} # error "{ftm} should not be defined because it is unimplemented in libc++!" # endif # endif """ ftm_conditionally_implemented = """ # if {condition} # ifndef {ftm} # error "{ftm} should be defined in {dialect}" # endif # if {ftm} != {value} # error "{ftm} should have the value {value} in {dialect}" # endif # else # ifdef {ftm} # error "{ftm} should not be defined when the requirement '{condition}' is not met!" # endif # endif """ ftm_implemented = """ # ifndef {ftm} # error "{ftm} should be defined in {dialect}" # endif # if {ftm} != {value} # error "{ftm} should have the value {value} in {dialect}" # endif """ if std == None or value == None: return ftm_unavailable_in_dialect.format( ftm=ftm, dialect=self.ftm_metadata[ftm].available_since ) if not value.implemented: return ftm_not_implemented.format( ftm=ftm, value=value.value, dialect=std ) if self.ftm_metadata[ftm].test_suite_guard: return ftm_conditionally_implemented.format( ftm=ftm, value=value.value, dialect=std, condition=self.ftm_metadata[ftm].test_suite_guard, ) return ftm_implemented.format(ftm=ftm, value=value.value, dialect=std) def generate_header_test_dialect( self, std: Std, data: List[Dict[Ftm, FtmHeaderTest]] ) -> str: """Returns the body a single `std` for the FTM test of a `header`.""" return "".join( self.generate_ftm_test(std, ftm, value) for element in data for ftm, value in element.items() ) def generate_lit_markup(self, header:str) -> str: if not header in lit_markup.keys(): return "" return "\n".join(f"// {markup}" for markup in lit_markup[header]) + "\n\n" def generate_header_test_file(self, header: str) -> str: """Returns the body for the FTM test of a `header`.""" # FTM block before the first Standard that introduced them. # This test the macros are not available before this version. data = ftm_header_test_file_dialect_block.format( pp_if="if", operator="<", dialect=get_std_number(self.std_dialects[0]), tests=self.generate_header_test_dialect( None, next(iter(self.header_ftm_data(header).values())) ), ) # FTM for all Standards that have FTM defined. # Note in libc++ the TEST_STD_VER contains 99 for the Standard # in development, therefore the last entry uses a different #elif. data += "".join( ftm_header_test_file_dialect_block.format( pp_if="elif", operator="==" if std != get_std_number(self.std_dialects[-1]) else ">", dialect=std if std != get_std_number(self.std_dialects[-1]) else get_std_number(self.std_dialects[-2]), tests=self.generate_header_test_dialect(f"c++{std}", values), ) for std, values in self.header_ftm_data(header).items() ) # The final #endif for the last #elif block. data += f"\n#endif // TEST_STD_VER > {get_std_number(self.std_dialects[-2])}" # Generate the test for the requested header. return ftm_header_test_file_contents.format( script_name=script_name, lit_markup=self.generate_lit_markup(header), header=header, include=( ftm_header_test_file_include_conditional.format(header=header) if header in self.__unavailable_headers else ftm_header_test_file_include_unconditional.format(header=header) ), data=data ) def generate_header_test_directory(self, path: os.path) -> None: """Generates all FTM tests in the directory `path`.""" if not os.path.exists(path): os.makedirs(path) for header in self.standard_library_headers: with open( os.path.join(path, f"{header}.version.compile.pass.cpp"), "w", newline="\n", ) as f: f.write(self.generate_header_test_file(header)) def main(): produce_version_header() produce_tests() produce_docs() # Example how to use the new generator to generate the output. if False: ftm = FeatureTestMacros( os.path.join( source_root, "test", "libcxx", "feature_test_macro", "test_data.json" ), headers_not_available ) version_header_path = os.path.join(include_path, "version") with open(version_header_path, "w", newline="\n") as f: f.write(ftm.version_header) ftm.generate_header_test_directory(macro_test_path) if __name__ == "__main__": main()