| //===-- StdSpecialSymbolMap.inc ---------------------------------*- C++ -*-===// |
| // |
| // This is a hand-curated list for C++ symbols that cannot be parsed/extracted |
| // via the include-mapping tool (gen_std.py). |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // Symbols that can be provided by any of the headers, ordered by the header |
| // preference. |
| // cppreference mentions the <locale> header is an alternative for these symbols, |
| // but they are not per the standard. |
| SYMBOL(consume_header, std::, <codecvt>) |
| SYMBOL(generate_header, std::, <codecvt>) |
| SYMBOL(little_endian, std::, <codecvt>) |
| |
| SYMBOL(mbstate_t, std::, <cwchar>) |
| SYMBOL(mbstate_t, std::, <cuchar>) |
| SYMBOL(size_t, std::, <cstddef>) |
| SYMBOL(size_t, std::, <cstdlib>) |
| SYMBOL(size_t, std::, <cstring>) |
| SYMBOL(size_t, std::, <cwchar>) |
| SYMBOL(size_t, std::, <cuchar>) |
| SYMBOL(size_t, std::, <ctime>) |
| SYMBOL(size_t, std::, <cstdio>) |
| SYMBOL(size_t, None, <cstddef>) |
| SYMBOL(size_t, None, <cstdlib>) |
| SYMBOL(size_t, None, <cstring>) |
| SYMBOL(size_t, None, <cwchar>) |
| SYMBOL(size_t, None, <cuchar>) |
| SYMBOL(size_t, None, <ctime>) |
| SYMBOL(size_t, None, <cstdio>) |
| SYMBOL(size_t, None, <stddef.h>) |
| SYMBOL(size_t, None, <stdlib.h>) |
| SYMBOL(size_t, None, <string.h>) |
| SYMBOL(size_t, None, <wchar.h>) |
| SYMBOL(size_t, None, <uchar.h>) |
| SYMBOL(size_t, None, <time.h>) |
| SYMBOL(size_t, None, <stdio.h>) |
| SYMBOL(unwrap_ref_decay, std::, <type_traits>) |
| SYMBOL(unwrap_ref_decay, std::, <functional>) |
| SYMBOL(unwrap_reference, std::, <type_traits>) |
| SYMBOL(unwrap_reference, std::, <functional>) |
| SYMBOL(unwrap_ref_decay_t, std::, <type_traits>) |
| SYMBOL(unwrap_ref_decay_t, std::, <functional>) |
| SYMBOL(wint_t, std::, <cwctype>) |
| SYMBOL(wint_t, std::, <cwchar>) |
| SYMBOL(swap, std::, <utility>) |
| SYMBOL(swap, std::, <algorithm>) // until C++11 |
| // C++ [string.view.synop 23.3.2]: The function templates defined in |
| // [utility.swap] ... are available when <string_view> is included. |
| SYMBOL(swap, std::, <string_view>) // since C++17 |
| // C++ [tuple.helper 22.4.7]: In addition to being available via inclusion of |
| // the <tuple> header, ... any of the headers <array>, <ranges>, or <utility> |
| // are included. |
| SYMBOL(tuple_size, std::, <tuple>) |
| SYMBOL(tuple_size, std::, <array>) |
| SYMBOL(tuple_size, std::, <ranges>) |
| SYMBOL(tuple_size, std::, <utility>) |
| SYMBOL(tuple_element, std::, <tuple>) |
| SYMBOL(tuple_element, std::, <array>) |
| SYMBOL(tuple_element, std::, <ranges>) |
| SYMBOL(tuple_element, std::, <utility>) |
| // C++ [iterator.range 25.7]: In addition to being available via inclusion of |
| // the <iterator> header, the function templates in [iterator.range] are |
| // available when any of the following headers are included: <array>, <deque>, |
| // <forward_list>, ... and <vector>. |
| SYMBOL(begin, std::, <iterator>) |
| SYMBOL(begin, std::, <array>) |
| SYMBOL(begin, std::, <deque>) |
| SYMBOL(begin, std::, <forward_list>) |
| SYMBOL(begin, std::, <list>) |
| SYMBOL(begin, std::, <map>) |
| SYMBOL(begin, std::, <regex>) |
| SYMBOL(begin, std::, <set>) |
| SYMBOL(begin, std::, <span>) |
| SYMBOL(begin, std::, <string>) |
| SYMBOL(begin, std::, <string_view>) |
| SYMBOL(begin, std::, <unordered_map>) |
| SYMBOL(begin, std::, <unordered_set>) |
| SYMBOL(begin, std::, <vector>) |
| SYMBOL(cbegin, std::, <iterator>) |
| SYMBOL(cbegin, std::, <array>) |
| SYMBOL(cbegin, std::, <deque>) |
| SYMBOL(cbegin, std::, <forward_list>) |
| SYMBOL(cbegin, std::, <list>) |
| SYMBOL(cbegin, std::, <map>) |
| SYMBOL(cbegin, std::, <regex>) |
| SYMBOL(cbegin, std::, <set>) |
| SYMBOL(cbegin, std::, <span>) |
| SYMBOL(cbegin, std::, <string>) |
| SYMBOL(cbegin, std::, <string_view>) |
| SYMBOL(cbegin, std::, <unordered_map>) |
| SYMBOL(cbegin, std::, <unordered_set>) |
| SYMBOL(cbegin, std::, <vector>) |
| SYMBOL(cend, std::, <iterator>) |
| SYMBOL(cend, std::, <array>) |
| SYMBOL(cend, std::, <deque>) |
| SYMBOL(cend, std::, <forward_list>) |
| SYMBOL(cend, std::, <list>) |
| SYMBOL(cend, std::, <map>) |
| SYMBOL(cend, std::, <regex>) |
| SYMBOL(cend, std::, <set>) |
| SYMBOL(cend, std::, <span>) |
| SYMBOL(cend, std::, <string>) |
| SYMBOL(cend, std::, <string_view>) |
| SYMBOL(cend, std::, <unordered_map>) |
| SYMBOL(cend, std::, <unordered_set>) |
| SYMBOL(cend, std::, <vector>) |
| SYMBOL(crbegin, std::, <iterator>) |
| SYMBOL(crbegin, std::, <array>) |
| SYMBOL(crbegin, std::, <deque>) |
| SYMBOL(crbegin, std::, <forward_list>) |
| SYMBOL(crbegin, std::, <list>) |
| SYMBOL(crbegin, std::, <map>) |
| SYMBOL(crbegin, std::, <regex>) |
| SYMBOL(crbegin, std::, <set>) |
| SYMBOL(crbegin, std::, <span>) |
| SYMBOL(crbegin, std::, <string>) |
| SYMBOL(crbegin, std::, <string_view>) |
| SYMBOL(crbegin, std::, <unordered_map>) |
| SYMBOL(crbegin, std::, <unordered_set>) |
| SYMBOL(crbegin, std::, <vector>) |
| SYMBOL(crend, std::, <iterator>) |
| SYMBOL(crend, std::, <array>) |
| SYMBOL(crend, std::, <deque>) |
| SYMBOL(crend, std::, <forward_list>) |
| SYMBOL(crend, std::, <list>) |
| SYMBOL(crend, std::, <map>) |
| SYMBOL(crend, std::, <regex>) |
| SYMBOL(crend, std::, <set>) |
| SYMBOL(crend, std::, <span>) |
| SYMBOL(crend, std::, <string>) |
| SYMBOL(crend, std::, <string_view>) |
| SYMBOL(crend, std::, <unordered_map>) |
| SYMBOL(crend, std::, <unordered_set>) |
| SYMBOL(crend, std::, <vector>) |
| SYMBOL(data, std::, <iterator>) |
| SYMBOL(data, std::, <array>) |
| SYMBOL(data, std::, <deque>) |
| SYMBOL(data, std::, <forward_list>) |
| SYMBOL(data, std::, <list>) |
| SYMBOL(data, std::, <map>) |
| SYMBOL(data, std::, <regex>) |
| SYMBOL(data, std::, <set>) |
| SYMBOL(data, std::, <span>) |
| SYMBOL(data, std::, <string>) |
| SYMBOL(data, std::, <string_view>) |
| SYMBOL(data, std::, <unordered_map>) |
| SYMBOL(data, std::, <unordered_set>) |
| SYMBOL(data, std::, <vector>) |
| SYMBOL(empty, std::, <iterator>) |
| SYMBOL(empty, std::, <array>) |
| SYMBOL(empty, std::, <deque>) |
| SYMBOL(empty, std::, <forward_list>) |
| SYMBOL(empty, std::, <list>) |
| SYMBOL(empty, std::, <map>) |
| SYMBOL(empty, std::, <regex>) |
| SYMBOL(empty, std::, <set>) |
| SYMBOL(empty, std::, <span>) |
| SYMBOL(empty, std::, <string>) |
| SYMBOL(empty, std::, <string_view>) |
| SYMBOL(empty, std::, <unordered_map>) |
| SYMBOL(empty, std::, <unordered_set>) |
| SYMBOL(empty, std::, <vector>) |
| SYMBOL(end, std::, <iterator>) |
| SYMBOL(end, std::, <array>) |
| SYMBOL(end, std::, <deque>) |
| SYMBOL(end, std::, <forward_list>) |
| SYMBOL(end, std::, <list>) |
| SYMBOL(end, std::, <map>) |
| SYMBOL(end, std::, <regex>) |
| SYMBOL(end, std::, <set>) |
| SYMBOL(end, std::, <span>) |
| SYMBOL(end, std::, <string>) |
| SYMBOL(end, std::, <string_view>) |
| SYMBOL(end, std::, <unordered_map>) |
| SYMBOL(end, std::, <unordered_set>) |
| SYMBOL(end, std::, <vector>) |
| SYMBOL(rbegin, std::, <iterator>) |
| SYMBOL(rbegin, std::, <array>) |
| SYMBOL(rbegin, std::, <deque>) |
| SYMBOL(rbegin, std::, <forward_list>) |
| SYMBOL(rbegin, std::, <list>) |
| SYMBOL(rbegin, std::, <map>) |
| SYMBOL(rbegin, std::, <regex>) |
| SYMBOL(rbegin, std::, <set>) |
| SYMBOL(rbegin, std::, <span>) |
| SYMBOL(rbegin, std::, <string>) |
| SYMBOL(rbegin, std::, <string_view>) |
| SYMBOL(rbegin, std::, <unordered_map>) |
| SYMBOL(rbegin, std::, <unordered_set>) |
| SYMBOL(rbegin, std::, <vector>) |
| SYMBOL(rend, std::, <iterator>) |
| SYMBOL(rend, std::, <array>) |
| SYMBOL(rend, std::, <deque>) |
| SYMBOL(rend, std::, <forward_list>) |
| SYMBOL(rend, std::, <list>) |
| SYMBOL(rend, std::, <map>) |
| SYMBOL(rend, std::, <regex>) |
| SYMBOL(rend, std::, <set>) |
| SYMBOL(rend, std::, <span>) |
| SYMBOL(rend, std::, <string>) |
| SYMBOL(rend, std::, <string_view>) |
| SYMBOL(rend, std::, <unordered_map>) |
| SYMBOL(rend, std::, <unordered_set>) |
| SYMBOL(rend, std::, <vector>) |
| SYMBOL(size, std::, <iterator>) |
| SYMBOL(size, std::, <array>) |
| SYMBOL(size, std::, <deque>) |
| SYMBOL(size, std::, <forward_list>) |
| SYMBOL(size, std::, <list>) |
| SYMBOL(size, std::, <map>) |
| SYMBOL(size, std::, <regex>) |
| SYMBOL(size, std::, <set>) |
| SYMBOL(size, std::, <span>) |
| SYMBOL(size, std::, <string>) |
| SYMBOL(size, std::, <string_view>) |
| SYMBOL(size, std::, <unordered_map>) |
| SYMBOL(size, std::, <unordered_set>) |
| SYMBOL(size, std::, <vector>) |
| SYMBOL(ssize, std::, <iterator>) |
| SYMBOL(ssize, std::, <array>) |
| SYMBOL(ssize, std::, <deque>) |
| SYMBOL(ssize, std::, <forward_list>) |
| SYMBOL(ssize, std::, <list>) |
| SYMBOL(ssize, std::, <map>) |
| SYMBOL(ssize, std::, <regex>) |
| SYMBOL(ssize, std::, <set>) |
| SYMBOL(ssize, std::, <span>) |
| SYMBOL(ssize, std::, <string>) |
| SYMBOL(ssize, std::, <string_view>) |
| SYMBOL(ssize, std::, <unordered_map>) |
| SYMBOL(ssize, std::, <unordered_set>) |
| SYMBOL(ssize, std::, <vector>) |
| |
| // Add headers for generic integer-type abs. |
| // Ignore other variants (std::complex, std::valarray, std::intmax_t) |
| SYMBOL(abs, std::, <cstdlib>) |
| SYMBOL(abs, std::, <cmath>) |
| SYMBOL(abs, None, <cstdlib>) |
| SYMBOL(abs, None, <stdlib.h>) |
| SYMBOL(abs, None, <cmath>) |
| SYMBOL(abs, None, <math.h>) |
| |
| // Only add headers for the generic atomic template. |
| // Ignore variants (std::weak_ptr, std::shared_ptr). |
| SYMBOL(atomic, std::, <atomic>) |
| // atomic_* family symbols. <stdatomic.h> is for C compatibility. |
| SYMBOL(atomic_bool, std::, <atomic>) |
| SYMBOL(atomic_bool, None, <stdatomic.h>) |
| SYMBOL(atomic_char, std::, <atomic>) |
| SYMBOL(atomic_char, None, <stdatomic.h>) |
| SYMBOL(atomic_char16_t, std::, <atomic>) |
| SYMBOL(atomic_char16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_char32_t, std::, <atomic>) |
| SYMBOL(atomic_char32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_char8_t, std::, <atomic>) |
| SYMBOL(atomic_char8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int, std::, <atomic>) |
| SYMBOL(atomic_int, None, <stdatomic.h>) |
| SYMBOL(atomic_int16_t, std::, <atomic>) |
| SYMBOL(atomic_int16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int32_t, std::, <atomic>) |
| SYMBOL(atomic_int32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int64_t, std::, <atomic>) |
| SYMBOL(atomic_int64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int8_t, std::, <atomic>) |
| SYMBOL(atomic_int8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_fast16_t, std::, <atomic>) |
| SYMBOL(atomic_int_fast16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_fast32_t, std::, <atomic>) |
| SYMBOL(atomic_int_fast32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_fast64_t, std::, <atomic>) |
| SYMBOL(atomic_int_fast64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_fast8_t, std::, <atomic>) |
| SYMBOL(atomic_int_fast8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_least16_t, std::, <atomic>) |
| SYMBOL(atomic_int_least16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_least32_t, std::, <atomic>) |
| SYMBOL(atomic_int_least32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_least64_t, std::, <atomic>) |
| SYMBOL(atomic_int_least64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_int_least8_t, std::, <atomic>) |
| SYMBOL(atomic_int_least8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_intmax_t, std::, <atomic>) |
| SYMBOL(atomic_intmax_t, None, <stdatomic.h>) |
| SYMBOL(atomic_intptr_t, std::, <atomic>) |
| SYMBOL(atomic_intptr_t, None, <stdatomic.h>) |
| SYMBOL(atomic_llong, std::, <atomic>) |
| SYMBOL(atomic_llong, None, <stdatomic.h>) |
| SYMBOL(atomic_long, std::, <atomic>) |
| SYMBOL(atomic_long, None, <stdatomic.h>) |
| SYMBOL(atomic_ptrdiff_t, std::, <atomic>) |
| SYMBOL(atomic_ptrdiff_t, None, <stdatomic.h>) |
| SYMBOL(atomic_schar, std::, <atomic>) |
| SYMBOL(atomic_schar, None, <stdatomic.h>) |
| SYMBOL(atomic_short, std::, <atomic>) |
| SYMBOL(atomic_short, None, <stdatomic.h>) |
| SYMBOL(atomic_signed_lock_free, std::, <atomic>) |
| SYMBOL(atomic_signed_lock_free, None, <stdatomic.h>) |
| SYMBOL(atomic_size_t, std::, <atomic>) |
| SYMBOL(atomic_size_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uchar, std::, <atomic>) |
| SYMBOL(atomic_uchar, None, <stdatomic.h>) |
| SYMBOL(atomic_uint, std::, <atomic>) |
| SYMBOL(atomic_uint, None, <stdatomic.h>) |
| SYMBOL(atomic_uint16_t, std::, <atomic>) |
| SYMBOL(atomic_uint16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint32_t, std::, <atomic>) |
| SYMBOL(atomic_uint32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint64_t, std::, <atomic>) |
| SYMBOL(atomic_uint64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint8_t, std::, <atomic>) |
| SYMBOL(atomic_uint8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_fast16_t, std::, <atomic>) |
| SYMBOL(atomic_uint_fast16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_fast32_t, std::, <atomic>) |
| SYMBOL(atomic_uint_fast32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_fast64_t, std::, <atomic>) |
| SYMBOL(atomic_uint_fast64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_fast8_t, std::, <atomic>) |
| SYMBOL(atomic_uint_fast8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_least16_t, std::, <atomic>) |
| SYMBOL(atomic_uint_least16_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_least32_t, std::, <atomic>) |
| SYMBOL(atomic_uint_least32_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_least64_t, std::, <atomic>) |
| SYMBOL(atomic_uint_least64_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uint_least8_t, std::, <atomic>) |
| SYMBOL(atomic_uint_least8_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uintmax_t, std::, <atomic>) |
| SYMBOL(atomic_uintmax_t, None, <stdatomic.h>) |
| SYMBOL(atomic_uintptr_t, std::, <atomic>) |
| SYMBOL(atomic_uintptr_t, None, <stdatomic.h>) |
| SYMBOL(atomic_ullong, std::, <atomic>) |
| SYMBOL(atomic_ullong, None, <stdatomic.h>) |
| SYMBOL(atomic_ulong, std::, <atomic>) |
| SYMBOL(atomic_ulong, None, <stdatomic.h>) |
| SYMBOL(atomic_unsigned_lock_free, std::, <atomic>) |
| SYMBOL(atomic_unsigned_lock_free, None, <stdatomic.h>) |
| SYMBOL(atomic_ushort, std::, <atomic>) |
| SYMBOL(atomic_ushort, None, <stdatomic.h>) |
| SYMBOL(atomic_wchar_t, std::, <atomic>) |
| SYMBOL(atomic_wchar_t, None, <stdatomic.h>) |
| |
| // std::get has a few variants for different types (tuple, array, pair etc) |
| // which is tricky to disambiguate without type information. |
| // Don't set any header for it, as it comes with the type header. |
| SYMBOL(get, std::, /*no headers*/) |
| // Similarly make_error_{code,condition} also have different overloads (errc, |
| // io_errc, future_errc) and each of them are provided by relevant headers |
| // providing the type. |
| SYMBOL(make_error_code, std::, /*no headers*/) |
| SYMBOL(make_error_condition, std::, /*no headers*/) |
| |
| // cppreference symbol index page was missing these symbols. |
| // Remove them when the cppreference offline archive catches up. |
| SYMBOL(index_sequence, std::, <utility>) |
| SYMBOL(index_sequence_for, std::, <utility>) |
| SYMBOL(make_index_sequence, std::, <utility>) |
| SYMBOL(make_integer_sequence, std::, <utility>) |
| |
| // Symbols missing from the generated symbol map as reported by users. |
| // Remove when the generator starts producing them. |
| SYMBOL(make_any, std::, <any>) |
| SYMBOL(any_cast, std::, <any>) |
| SYMBOL(div, std::, <cstdlib>) |
| SYMBOL(abort, std::, <cstdlib>) |
| |
| // These are C symbols that are not under std namespace. |
| SYMBOL(localtime_r, None, <ctime>) |
| SYMBOL(localtime_r, None, <time.h>) |
| SYMBOL(localtime_s, None, <ctime>) |
| SYMBOL(localtime_s, None, <time.h>) |
| SYMBOL(gmtime_r, None, <ctime>) |
| SYMBOL(gmtime_r, None, <time.h>) |
| SYMBOL(gmtime_s, None, <ctime>) |
| SYMBOL(gmtime_s, None, <time.h>) |
| |
| // The std::placeholder symbols (_1, ..., _N) are listed in the cppreference |
| // placeholder.html, but the index only contains a single entry with "_1, _2, ..., _N" |
| // text, which are not handled by the script. |
| // N is an implementation-defined number (10 for libc++; 29 for libstdc++). |
| SYMBOL(_1, std::placeholders::, <functional>) |
| SYMBOL(_2, std::placeholders::, <functional>) |
| SYMBOL(_3, std::placeholders::, <functional>) |
| SYMBOL(_4, std::placeholders::, <functional>) |
| SYMBOL(_5, std::placeholders::, <functional>) |
| SYMBOL(_6, std::placeholders::, <functional>) |
| SYMBOL(_7, std::placeholders::, <functional>) |
| SYMBOL(_8, std::placeholders::, <functional>) |
| SYMBOL(_9, std::placeholders::, <functional>) |
| SYMBOL(_10, std::placeholders::, <functional>) |
| SYMBOL(_11, std::placeholders::, <functional>) |
| SYMBOL(_12, std::placeholders::, <functional>) |
| SYMBOL(_13, std::placeholders::, <functional>) |
| SYMBOL(_14, std::placeholders::, <functional>) |
| SYMBOL(_15, std::placeholders::, <functional>) |
| SYMBOL(_16, std::placeholders::, <functional>) |
| SYMBOL(_17, std::placeholders::, <functional>) |
| SYMBOL(_18, std::placeholders::, <functional>) |
| SYMBOL(_19, std::placeholders::, <functional>) |
| SYMBOL(_20, std::placeholders::, <functional>) |
| SYMBOL(_21, std::placeholders::, <functional>) |
| SYMBOL(_22, std::placeholders::, <functional>) |
| SYMBOL(_23, std::placeholders::, <functional>) |
| SYMBOL(_24, std::placeholders::, <functional>) |
| SYMBOL(_25, std::placeholders::, <functional>) |
| SYMBOL(_26, std::placeholders::, <functional>) |
| SYMBOL(_27, std::placeholders::, <functional>) |
| SYMBOL(_28, std::placeholders::, <functional>) |
| SYMBOL(_29, std::placeholders::, <functional>) |
| |
| // Macros |
| SYMBOL(NULL, None, <cstddef>) |
| SYMBOL(NULL, None, <stddef.h>) |
| SYMBOL(NULL, None, <cstdlib>) |
| SYMBOL(NULL, None, <stdlib.h>) |
| SYMBOL(NULL, None, <cstring>) |
| SYMBOL(NULL, None, <string.h>) |
| SYMBOL(NULL, None, <cwchar>) |
| SYMBOL(NULL, None, <wchar.h>) |
| SYMBOL(NULL, None, <ctime>) |
| SYMBOL(NULL, None, <time.h>) |
| SYMBOL(NULL, None, <clocale>) |
| SYMBOL(NULL, None, <locale.h>) |
| SYMBOL(NULL, None, <cstdio>) |
| SYMBOL(NULL, None, <stdio.h>) |
| |
| // Theres are macros that not spelled out in page linked from the index. |
| // Extracted from https://en.cppreference.com/w/cpp/header/cinttypes |
| SYMBOL(PRId8, None, <cinttypes>) |
| SYMBOL(PRId8, None, <inttypes.h>) |
| SYMBOL(PRId16, None, <cinttypes>) |
| SYMBOL(PRId16, None, <inttypes.h>) |
| SYMBOL(PRId32, None, <cinttypes>) |
| SYMBOL(PRId32, None, <inttypes.h>) |
| SYMBOL(PRId64, None, <cinttypes>) |
| SYMBOL(PRId64, None, <inttypes.h>) |
| SYMBOL(PRIdLEAST8, None, <cinttypes>) |
| SYMBOL(PRIdLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIdLEAST16, None, <cinttypes>) |
| SYMBOL(PRIdLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIdLEAST32, None, <cinttypes>) |
| SYMBOL(PRIdLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIdLEAST64, None, <cinttypes>) |
| SYMBOL(PRIdLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIdFAST8, None, <cinttypes>) |
| SYMBOL(PRIdFAST8, None, <inttypes.h>) |
| SYMBOL(PRIdFAST16, None, <cinttypes>) |
| SYMBOL(PRIdFAST16, None, <inttypes.h>) |
| SYMBOL(PRIdFAST32, None, <cinttypes>) |
| SYMBOL(PRIdFAST32, None, <inttypes.h>) |
| SYMBOL(PRIdFAST64, None, <cinttypes>) |
| SYMBOL(PRIdFAST64, None, <inttypes.h>) |
| SYMBOL(PRIdMAX, None, <cinttypes>) |
| SYMBOL(PRIdMAX, None, <inttypes.h>) |
| SYMBOL(PRIdPTR, None, <cinttypes>) |
| SYMBOL(PRIdPTR, None, <inttypes.h>) |
| SYMBOL(PRIi8, None, <cinttypes>) |
| SYMBOL(PRIi8, None, <inttypes.h>) |
| SYMBOL(PRIi16, None, <cinttypes>) |
| SYMBOL(PRIi16, None, <inttypes.h>) |
| SYMBOL(PRIi32, None, <cinttypes>) |
| SYMBOL(PRIi32, None, <inttypes.h>) |
| SYMBOL(PRIi64, None, <cinttypes>) |
| SYMBOL(PRIi64, None, <inttypes.h>) |
| SYMBOL(PRIiLEAST8, None, <cinttypes>) |
| SYMBOL(PRIiLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIiLEAST16, None, <cinttypes>) |
| SYMBOL(PRIiLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIiLEAST32, None, <cinttypes>) |
| SYMBOL(PRIiLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIiLEAST64, None, <cinttypes>) |
| SYMBOL(PRIiLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIiFAST8, None, <cinttypes>) |
| SYMBOL(PRIiFAST8, None, <inttypes.h>) |
| SYMBOL(PRIiFAST16, None, <cinttypes>) |
| SYMBOL(PRIiFAST16, None, <inttypes.h>) |
| SYMBOL(PRIiFAST32, None, <cinttypes>) |
| SYMBOL(PRIiFAST32, None, <inttypes.h>) |
| SYMBOL(PRIiFAST64, None, <cinttypes>) |
| SYMBOL(PRIiFAST64, None, <inttypes.h>) |
| SYMBOL(PRIiMAX, None, <cinttypes>) |
| SYMBOL(PRIiMAX, None, <inttypes.h>) |
| SYMBOL(PRIiPTR, None, <cinttypes>) |
| SYMBOL(PRIiPTR, None, <inttypes.h>) |
| SYMBOL(PRIu8, None, <cinttypes>) |
| SYMBOL(PRIu8, None, <inttypes.h>) |
| SYMBOL(PRIu16, None, <cinttypes>) |
| SYMBOL(PRIu16, None, <inttypes.h>) |
| SYMBOL(PRIu32, None, <cinttypes>) |
| SYMBOL(PRIu32, None, <inttypes.h>) |
| SYMBOL(PRIu64, None, <cinttypes>) |
| SYMBOL(PRIu64, None, <inttypes.h>) |
| SYMBOL(PRIuLEAST8, None, <cinttypes>) |
| SYMBOL(PRIuLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIuLEAST16, None, <cinttypes>) |
| SYMBOL(PRIuLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIuLEAST32, None, <cinttypes>) |
| SYMBOL(PRIuLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIuLEAST64, None, <cinttypes>) |
| SYMBOL(PRIuLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIuFAST8, None, <cinttypes>) |
| SYMBOL(PRIuFAST8, None, <inttypes.h>) |
| SYMBOL(PRIuFAST16, None, <cinttypes>) |
| SYMBOL(PRIuFAST16, None, <inttypes.h>) |
| SYMBOL(PRIuFAST32, None, <cinttypes>) |
| SYMBOL(PRIuFAST32, None, <inttypes.h>) |
| SYMBOL(PRIuFAST64, None, <cinttypes>) |
| SYMBOL(PRIuFAST64, None, <inttypes.h>) |
| SYMBOL(PRIuMAX, None, <cinttypes>) |
| SYMBOL(PRIuMAX, None, <inttypes.h>) |
| SYMBOL(PRIuPTR, None, <cinttypes>) |
| SYMBOL(PRIuPTR, None, <inttypes.h>) |
| SYMBOL(PRIo8, None, <cinttypes>) |
| SYMBOL(PRIo8, None, <inttypes.h>) |
| SYMBOL(PRIo16, None, <cinttypes>) |
| SYMBOL(PRIo16, None, <inttypes.h>) |
| SYMBOL(PRIo32, None, <cinttypes>) |
| SYMBOL(PRIo32, None, <inttypes.h>) |
| SYMBOL(PRIo64, None, <cinttypes>) |
| SYMBOL(PRIo64, None, <inttypes.h>) |
| SYMBOL(PRIoLEAST8, None, <cinttypes>) |
| SYMBOL(PRIoLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIoLEAST16, None, <cinttypes>) |
| SYMBOL(PRIoLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIoLEAST32, None, <cinttypes>) |
| SYMBOL(PRIoLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIoLEAST64, None, <cinttypes>) |
| SYMBOL(PRIoLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIoFAST8, None, <cinttypes>) |
| SYMBOL(PRIoFAST8, None, <inttypes.h>) |
| SYMBOL(PRIoFAST16, None, <cinttypes>) |
| SYMBOL(PRIoFAST16, None, <inttypes.h>) |
| SYMBOL(PRIoFAST32, None, <cinttypes>) |
| SYMBOL(PRIoFAST32, None, <inttypes.h>) |
| SYMBOL(PRIoFAST64, None, <cinttypes>) |
| SYMBOL(PRIoFAST64, None, <inttypes.h>) |
| SYMBOL(PRIoMAX, None, <cinttypes>) |
| SYMBOL(PRIoMAX, None, <inttypes.h>) |
| SYMBOL(PRIoPTR, None, <cinttypes>) |
| SYMBOL(PRIoPTR, None, <inttypes.h>) |
| SYMBOL(PRIx8, None, <cinttypes>) |
| SYMBOL(PRIx8, None, <inttypes.h>) |
| SYMBOL(PRIx16, None, <cinttypes>) |
| SYMBOL(PRIx16, None, <inttypes.h>) |
| SYMBOL(PRIx32, None, <cinttypes>) |
| SYMBOL(PRIx32, None, <inttypes.h>) |
| SYMBOL(PRIx64, None, <cinttypes>) |
| SYMBOL(PRIx64, None, <inttypes.h>) |
| SYMBOL(PRIxLEAST8, None, <cinttypes>) |
| SYMBOL(PRIxLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIxLEAST16, None, <cinttypes>) |
| SYMBOL(PRIxLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIxLEAST32, None, <cinttypes>) |
| SYMBOL(PRIxLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIxLEAST64, None, <cinttypes>) |
| SYMBOL(PRIxLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIxFAST8, None, <cinttypes>) |
| SYMBOL(PRIxFAST8, None, <inttypes.h>) |
| SYMBOL(PRIxFAST16, None, <cinttypes>) |
| SYMBOL(PRIxFAST16, None, <inttypes.h>) |
| SYMBOL(PRIxFAST32, None, <cinttypes>) |
| SYMBOL(PRIxFAST32, None, <inttypes.h>) |
| SYMBOL(PRIxFAST64, None, <cinttypes>) |
| SYMBOL(PRIxFAST64, None, <inttypes.h>) |
| SYMBOL(PRIxMAX, None, <cinttypes>) |
| SYMBOL(PRIxMAX, None, <inttypes.h>) |
| SYMBOL(PRIxPTR, None, <cinttypes>) |
| SYMBOL(PRIxPTR, None, <inttypes.h>) |
| SYMBOL(PRIX8, None, <cinttypes>) |
| SYMBOL(PRIX8, None, <inttypes.h>) |
| SYMBOL(PRIX16, None, <cinttypes>) |
| SYMBOL(PRIX16, None, <inttypes.h>) |
| SYMBOL(PRIX32, None, <cinttypes>) |
| SYMBOL(PRIX32, None, <inttypes.h>) |
| SYMBOL(PRIX64, None, <cinttypes>) |
| SYMBOL(PRIX64, None, <inttypes.h>) |
| SYMBOL(PRIXLEAST8, None, <cinttypes>) |
| SYMBOL(PRIXLEAST8, None, <inttypes.h>) |
| SYMBOL(PRIXLEAST16, None, <cinttypes>) |
| SYMBOL(PRIXLEAST16, None, <inttypes.h>) |
| SYMBOL(PRIXLEAST32, None, <cinttypes>) |
| SYMBOL(PRIXLEAST32, None, <inttypes.h>) |
| SYMBOL(PRIXLEAST64, None, <cinttypes>) |
| SYMBOL(PRIXLEAST64, None, <inttypes.h>) |
| SYMBOL(PRIXFAST8, None, <cinttypes>) |
| SYMBOL(PRIXFAST8, None, <inttypes.h>) |
| SYMBOL(PRIXFAST16, None, <cinttypes>) |
| SYMBOL(PRIXFAST16, None, <inttypes.h>) |
| SYMBOL(PRIXFAST32, None, <cinttypes>) |
| SYMBOL(PRIXFAST32, None, <inttypes.h>) |
| SYMBOL(PRIXFAST64, None, <cinttypes>) |
| SYMBOL(PRIXFAST64, None, <inttypes.h>) |
| SYMBOL(PRIXMAX, None, <cinttypes>) |
| SYMBOL(PRIXMAX, None, <inttypes.h>) |
| SYMBOL(PRIXPTR, None, <cinttypes>) |
| SYMBOL(PRIXPTR, None, <inttypes.h>) |
| SYMBOL(SCNd8, None, <cinttypes>) |
| SYMBOL(SCNd8, None, <inttypes.h>) |
| SYMBOL(SCNd16, None, <cinttypes>) |
| SYMBOL(SCNd16, None, <inttypes.h>) |
| SYMBOL(SCNd32, None, <cinttypes>) |
| SYMBOL(SCNd32, None, <inttypes.h>) |
| SYMBOL(SCNd64, None, <cinttypes>) |
| SYMBOL(SCNd64, None, <inttypes.h>) |
| SYMBOL(SCNdLEAST8, None, <cinttypes>) |
| SYMBOL(SCNdLEAST8, None, <inttypes.h>) |
| SYMBOL(SCNdLEAST16, None, <cinttypes>) |
| SYMBOL(SCNdLEAST16, None, <inttypes.h>) |
| SYMBOL(SCNdLEAST32, None, <cinttypes>) |
| SYMBOL(SCNdLEAST32, None, <inttypes.h>) |
| SYMBOL(SCNdLEAST64, None, <cinttypes>) |
| SYMBOL(SCNdLEAST64, None, <inttypes.h>) |
| SYMBOL(SCNdFAST8, None, <cinttypes>) |
| SYMBOL(SCNdFAST8, None, <inttypes.h>) |
| SYMBOL(SCNdFAST16, None, <cinttypes>) |
| SYMBOL(SCNdFAST16, None, <inttypes.h>) |
| SYMBOL(SCNdFAST32, None, <cinttypes>) |
| SYMBOL(SCNdFAST32, None, <inttypes.h>) |
| SYMBOL(SCNdFAST64, None, <cinttypes>) |
| SYMBOL(SCNdFAST64, None, <inttypes.h>) |
| SYMBOL(SCNdMAX, None, <cinttypes>) |
| SYMBOL(SCNdMAX, None, <inttypes.h>) |
| SYMBOL(SCNdPTR, None, <cinttypes>) |
| SYMBOL(SCNdPTR, None, <inttypes.h>) |
| SYMBOL(SCNi8, None, <cinttypes>) |
| SYMBOL(SCNi8, None, <inttypes.h>) |
| SYMBOL(SCNi16, None, <cinttypes>) |
| SYMBOL(SCNi16, None, <inttypes.h>) |
| SYMBOL(SCNi32, None, <cinttypes>) |
| SYMBOL(SCNi32, None, <inttypes.h>) |
| SYMBOL(SCNi64, None, <cinttypes>) |
| SYMBOL(SCNi64, None, <inttypes.h>) |
| SYMBOL(SCNiLEAST8, None, <cinttypes>) |
| SYMBOL(SCNiLEAST8, None, <inttypes.h>) |
| SYMBOL(SCNiLEAST16, None, <cinttypes>) |
| SYMBOL(SCNiLEAST16, None, <inttypes.h>) |
| SYMBOL(SCNiLEAST32, None, <cinttypes>) |
| SYMBOL(SCNiLEAST32, None, <inttypes.h>) |
| SYMBOL(SCNiLEAST64, None, <cinttypes>) |
| SYMBOL(SCNiLEAST64, None, <inttypes.h>) |
| SYMBOL(SCNiFAST8, None, <cinttypes>) |
| SYMBOL(SCNiFAST8, None, <inttypes.h>) |
| SYMBOL(SCNiFAST16, None, <cinttypes>) |
| SYMBOL(SCNiFAST16, None, <inttypes.h>) |
| SYMBOL(SCNiFAST32, None, <cinttypes>) |
| SYMBOL(SCNiFAST32, None, <inttypes.h>) |
| SYMBOL(SCNiFAST64, None, <cinttypes>) |
| SYMBOL(SCNiFAST64, None, <inttypes.h>) |
| SYMBOL(SCNiMAX, None, <cinttypes>) |
| SYMBOL(SCNiMAX, None, <inttypes.h>) |
| SYMBOL(SCNiPTR, None, <cinttypes>) |
| SYMBOL(SCNiPTR, None, <inttypes.h>) |
| SYMBOL(SCNu8, None, <cinttypes>) |
| SYMBOL(SCNu8, None, <inttypes.h>) |
| SYMBOL(SCNu16, None, <cinttypes>) |
| SYMBOL(SCNu16, None, <inttypes.h>) |
| SYMBOL(SCNu32, None, <cinttypes>) |
| SYMBOL(SCNu32, None, <inttypes.h>) |
| SYMBOL(SCNu64, None, <cinttypes>) |
| SYMBOL(SCNu64, None, <inttypes.h>) |
| SYMBOL(SCNuLEAST8, None, <cinttypes>) |
| SYMBOL(SCNuLEAST8, None, <inttypes.h>) |
| SYMBOL(SCNuLEAST16, None, <cinttypes>) |
| SYMBOL(SCNuLEAST16, None, <inttypes.h>) |
| SYMBOL(SCNuLEAST32, None, <cinttypes>) |
| SYMBOL(SCNuLEAST32, None, <inttypes.h>) |
| SYMBOL(SCNuLEAST64, None, <cinttypes>) |
| SYMBOL(SCNuLEAST64, None, <inttypes.h>) |
| SYMBOL(SCNuFAST8, None, <cinttypes>) |
| SYMBOL(SCNuFAST8, None, <inttypes.h>) |
| SYMBOL(SCNuFAST16, None, <cinttypes>) |
| SYMBOL(SCNuFAST16, None, <inttypes.h>) |
| SYMBOL(SCNuFAST32, None, <cinttypes>) |
| SYMBOL(SCNuFAST32, None, <inttypes.h>) |
| SYMBOL(SCNuFAST64, None, <cinttypes>) |
| SYMBOL(SCNuFAST64, None, <inttypes.h>) |
| SYMBOL(SCNuMAX, None, <cinttypes>) |
| SYMBOL(SCNuMAX, None, <inttypes.h>) |
| SYMBOL(SCNuPTR, None, <cinttypes>) |
| SYMBOL(SCNuPTR, None, <inttypes.h>) |
| SYMBOL(SCNo8, None, <cinttypes>) |
| SYMBOL(SCNo8, None, <inttypes.h>) |
| SYMBOL(SCNo16, None, <cinttypes>) |
| SYMBOL(SCNo16, None, <inttypes.h>) |
| SYMBOL(SCNo32, None, <cinttypes>) |
| SYMBOL(SCNo32, None, <inttypes.h>) |
| SYMBOL(SCNo64, None, <cinttypes>) |
| SYMBOL(SCNo64, None, <inttypes.h>) |
| SYMBOL(SCNoLEAST8, None, <cinttypes>) |
| SYMBOL(SCNoLEAST8, None, <inttypes.h>) |
| SYMBOL(SCNoLEAST16, None, <cinttypes>) |
| SYMBOL(SCNoLEAST16, None, <inttypes.h>) |
| SYMBOL(SCNoLEAST32, None, <cinttypes>) |
| SYMBOL(SCNoLEAST32, None, <inttypes.h>) |
| SYMBOL(SCNoLEAST64, None, <cinttypes>) |
| SYMBOL(SCNoLEAST64, None, <inttypes.h>) |
| SYMBOL(SCNoFAST8, None, <cinttypes>) |
| SYMBOL(SCNoFAST8, None, <inttypes.h>) |
| SYMBOL(SCNoFAST16, None, <cinttypes>) |
| SYMBOL(SCNoFAST16, None, <inttypes.h>) |
| SYMBOL(SCNoFAST32, None, <cinttypes>) |
| SYMBOL(SCNoFAST32, None, <inttypes.h>) |
| SYMBOL(SCNoFAST64, None, <cinttypes>) |
| SYMBOL(SCNoFAST64, None, <inttypes.h>) |
| SYMBOL(SCNoMAX, None, <cinttypes>) |
| SYMBOL(SCNoMAX, None, <inttypes.h>) |
| SYMBOL(SCNoPTR, None, <cinttypes>) |
| SYMBOL(SCNoPTR, None, <inttypes.h>) |
| SYMBOL(SCNx8, None, <cinttypes>) |
| SYMBOL(SCNx8, None, <inttypes.h>) |
| SYMBOL(SCNx16, None, <cinttypes>) |
| SYMBOL(SCNx16, None, <inttypes.h>) |
| SYMBOL(SCNx32, None, <cinttypes>) |
| SYMBOL(SCNx32, None, <inttypes.h>) |
| SYMBOL(SCNx64, None, <cinttypes>) |
| SYMBOL(SCNx64, None, <inttypes.h>) |
| SYMBOL(SCNxLEAST8, None, <cinttypes>) |
| SYMBOL(SCNxLEAST8, None, <inttypes.h>) |
| SYMBOL(SCNxLEAST16, None, <cinttypes>) |
| SYMBOL(SCNxLEAST16, None, <inttypes.h>) |
| SYMBOL(SCNxLEAST32, None, <cinttypes>) |
| SYMBOL(SCNxLEAST32, None, <inttypes.h>) |
| SYMBOL(SCNxLEAST64, None, <cinttypes>) |
| SYMBOL(SCNxLEAST64, None, <inttypes.h>) |
| SYMBOL(SCNxFAST8, None, <cinttypes>) |
| SYMBOL(SCNxFAST8, None, <inttypes.h>) |
| SYMBOL(SCNxFAST16, None, <cinttypes>) |
| SYMBOL(SCNxFAST16, None, <inttypes.h>) |
| SYMBOL(SCNxFAST32, None, <cinttypes>) |
| SYMBOL(SCNxFAST32, None, <inttypes.h>) |
| SYMBOL(SCNxFAST64, None, <cinttypes>) |
| SYMBOL(SCNxFAST64, None, <inttypes.h>) |
| SYMBOL(SCNxMAX, None, <cinttypes>) |
| SYMBOL(SCNxMAX, None, <inttypes.h>) |
| SYMBOL(SCNxPTR, None, <cinttypes>) |
| SYMBOL(SCNxPTR, None, <inttypes.h>) |
