[clang-tools-extra] r356134 - [clangd] Using symbol name to map includes for STL symbols.
Haojian Wu via cfe-commits
cfe-commits at lists.llvm.org
Thu Mar 14 04:25:26 PDT 2019
Author: hokein
Date: Thu Mar 14 04:25:26 2019
New Revision: 356134
URL: http://llvm.org/viewvc/llvm-project?rev=356134&view=rev
Log:
[clangd] Using symbol name to map includes for STL symbols.
Summary:
Using suffix path mapping relies on the STL implementations, and it is
not portable. This patch is using symbol name mapping, which should
work with different STL implementations, fix clangd/clangd#9.
To generate the symbol mapping, we parse the cppreference symbol index
page to build a lookup table.
The mapping is not completed, a few TODOs:
- support symbols from different headers (e.g. std::move)
- support STL macros
- support symbols from std's sub-namespaces (e.g. chrono)
Reviewers: ioeric, jfb, serge-sans-paille
Reviewed By: ioeric
Subscribers: sammccall, klimek, ilya-biryukov, ioeric, MaskRay, jkorous, mgrang, arphaman, kadircet, jfb, jdoerfert, cfe-commits
Tags: #clang-tools-extra, #clang
Differential Revision: https://reviews.llvm.org/D58345
Added:
clang-tools-extra/trunk/clangd/StdSymbolMap.inc
clang-tools-extra/trunk/clangd/include-mapping/
clang-tools-extra/trunk/clangd/include-mapping/gen_std.py (with props)
clang-tools-extra/trunk/clangd/include-mapping/test.py (with props)
Modified:
clang-tools-extra/trunk/clangd/index/CanonicalIncludes.cpp
Added: clang-tools-extra/trunk/clangd/StdSymbolMap.inc
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/StdSymbolMap.inc?rev=356134&view=auto
==============================================================================
--- clang-tools-extra/trunk/clangd/StdSymbolMap.inc (added)
+++ clang-tools-extra/trunk/clangd/StdSymbolMap.inc Thu Mar 14 04:25:26 2019
@@ -0,0 +1,1226 @@
+//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
+//
+// Used to build a lookup table (qualified names => include headers) for C++
+// Standard Library symbols.
+//
+// Automatically generated file, DO NOT EDIT!
+//
+// Generated from cppreference offline HTML book (modified on 2018-10-28).
+//===----------------------------------------------------------------------===//
+
+SYMBOL(Assignable, std::, <concepts>)
+SYMBOL(Boolean, std::, <concepts>)
+SYMBOL(Common, std::, <concepts>)
+SYMBOL(CommonReference, std::, <concepts>)
+SYMBOL(Constructible, std::, <concepts>)
+SYMBOL(ConvertibleTo, std::, <concepts>)
+SYMBOL(CopyConstructible, std::, <concepts>)
+SYMBOL(Copyable, std::, <concepts>)
+SYMBOL(DefaultConstructible, std::, <concepts>)
+SYMBOL(DerivedFrom, std::, <concepts>)
+SYMBOL(Destructible, std::, <concepts>)
+SYMBOL(EqualityComparable, std::, <concepts>)
+SYMBOL(EqualityComparableWith, std::, <concepts>)
+SYMBOL(FILE, std::, <cstdio>)
+SYMBOL(Integral, std::, <concepts>)
+SYMBOL(Invocable, std::, <concepts>)
+SYMBOL(Movable, std::, <concepts>)
+SYMBOL(MoveConstructible, std::, <concepts>)
+SYMBOL(Predicate, std::, <concepts>)
+SYMBOL(Regular, std::, <concepts>)
+SYMBOL(RegularInvocable, std::, <concepts>)
+SYMBOL(Relation, std::, <concepts>)
+SYMBOL(Same, std::, <concepts>)
+SYMBOL(Semiregular, std::, <concepts>)
+SYMBOL(SignedIntegral, std::, <concepts>)
+SYMBOL(StrictTotallyOrdered, std::, <concepts>)
+SYMBOL(StrictTotallyOrderedWith, std::, <concepts>)
+SYMBOL(StrictWeakOrder, std::, <concepts>)
+SYMBOL(Swappable, std::, <concepts>)
+SYMBOL(SwappableWith, std::, <concepts>)
+SYMBOL(UniformRandomBitGenerator, std::, <random>)
+SYMBOL(UnsignedIntegral, std::, <concepts>)
+SYMBOL(_Exit, std::, <cstdlib>)
+SYMBOL(accumulate, std::, <numeric>)
+SYMBOL(add_const, std::, <type_traits>)
+SYMBOL(add_const_t, std::, <type_traits>)
+SYMBOL(add_cv, std::, <type_traits>)
+SYMBOL(add_cv_t, std::, <type_traits>)
+SYMBOL(add_lvalue_reference, std::, <type_traits>)
+SYMBOL(add_lvalue_reference_t, std::, <type_traits>)
+SYMBOL(add_pointer, std::, <type_traits>)
+SYMBOL(add_pointer_t, std::, <type_traits>)
+SYMBOL(add_rvalue_reference, std::, <type_traits>)
+SYMBOL(add_rvalue_reference_t, std::, <type_traits>)
+SYMBOL(add_volatile, std::, <type_traits>)
+SYMBOL(add_volatile_t, std::, <type_traits>)
+SYMBOL(addressof, std::, <memory>)
+SYMBOL(adjacent_difference, std::, <numeric>)
+SYMBOL(adjacent_find, std::, <algorithm>)
+SYMBOL(adopt_lock, std::, <mutex>)
+SYMBOL(adopt_lock_t, std::, <mutex>)
+SYMBOL(advance, std::, <iterator>)
+SYMBOL(align, std::, <memory>)
+SYMBOL(align_val_t, std::, <new>)
+SYMBOL(aligned_alloc, std::, <cstdlib>)
+SYMBOL(aligned_storage, std::, <type_traits>)
+SYMBOL(aligned_storage_t, std::, <type_traits>)
+SYMBOL(aligned_union, std::, <type_traits>)
+SYMBOL(aligned_union_t, std::, <type_traits>)
+SYMBOL(alignment_of, std::, <type_traits>)
+SYMBOL(alignment_of_v, std::, <type_traits>)
+SYMBOL(all_of, std::, <algorithm>)
+SYMBOL(allocate_shared, std::, <memory>)
+SYMBOL(allocator, std::, <memory>)
+SYMBOL(allocator_arg, std::, <memory>)
+SYMBOL(allocator_arg_t, std::, <memory>)
+SYMBOL(allocator_traits, std::, <memory>)
+SYMBOL(any, std::, <any>)
+SYMBOL(any_of, std::, <algorithm>)
+SYMBOL(apply, std::, <tuple>)
+SYMBOL(arg, std::, <complex>)
+SYMBOL(array, std::, <array>)
+SYMBOL(as_const, std::, <utility>)
+SYMBOL(asctime, std::, <ctime>)
+SYMBOL(async, std::, <future>)
+SYMBOL(at_quick_exit, std::, <cstdlib>)
+SYMBOL(atexit, std::, <cstdlib>)
+SYMBOL(atof, std::, <cstdlib>)
+SYMBOL(atoi, std::, <cstdlib>)
+SYMBOL(atol, std::, <cstdlib>)
+SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>)
+SYMBOL(atomic_exchange, std::, <atomic>)
+SYMBOL(atomic_exchange_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_add, std::, <atomic>)
+SYMBOL(atomic_fetch_add_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_and, std::, <atomic>)
+SYMBOL(atomic_fetch_and_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_or, std::, <atomic>)
+SYMBOL(atomic_fetch_or_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_sub, std::, <atomic>)
+SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>)
+SYMBOL(atomic_fetch_xor, std::, <atomic>)
+SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>)
+SYMBOL(atomic_flag, std::, <atomic>)
+SYMBOL(atomic_flag_clear, std::, <atomic>)
+SYMBOL(atomic_flag_clear_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
+SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
+SYMBOL(atomic_init, std::, <atomic>)
+SYMBOL(atomic_is_lockfree, std::, <atomic>)
+SYMBOL(atomic_load, std::, <atomic>)
+SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_ref, std::, <atomic>)
+SYMBOL(atomic_signal_fence, std::, <atomic>)
+SYMBOL(atomic_store, std::, <atomic>)
+SYMBOL(atomic_store_explicit, std::, <atomic>)
+SYMBOL(atomic_thread_fence, std::, <atomic>)
+SYMBOL(atto, std::, <ratio>)
+SYMBOL(auto_ptr, std::, <memory>)
+SYMBOL(back_insert_iterator, std::, <iterator>)
+SYMBOL(back_inserter, std::, <iterator>)
+SYMBOL(bad_alloc, std::, <new>)
+SYMBOL(bad_any_cast, std::, <any>)
+SYMBOL(bad_array_new_length, std::, <new>)
+SYMBOL(bad_cast, std::, <typeinfo>)
+SYMBOL(bad_exception, std::, <exception>)
+SYMBOL(bad_function_call, std::, <functional>)
+SYMBOL(bad_optional_access, std::, <optional>)
+SYMBOL(bad_typeid, std::, <typeinfo>)
+SYMBOL(bad_variant_access, std::, <variant>)
+SYMBOL(bad_weak_ptr, std::, <memory>)
+SYMBOL(basic_common_reference, std::, <type_traits>)
+SYMBOL(basic_fstream, std::, <fstream>)
+SYMBOL(basic_ifstream, std::, <fstream>)
+SYMBOL(basic_ios, std::, <ios>)
+SYMBOL(basic_iostream, std::, <istream>)
+SYMBOL(basic_istringstream, std::, <sstream>)
+SYMBOL(basic_ofstream, std::, <fstream>)
+SYMBOL(basic_ostringstream, std::, <sstream>)
+SYMBOL(basic_osyncstream, std::, <syncstream>)
+SYMBOL(basic_regex, std::, <regex>)
+SYMBOL(basic_streambuf, std::, <streambuf>)
+SYMBOL(basic_string, std::, <string>)
+SYMBOL(basic_string_view, std::, <string_view>)
+SYMBOL(basic_stringbuf, std::, <sstream>)
+SYMBOL(basic_stringstream, std::, <sstream>)
+SYMBOL(basic_syncbuf, std::, <syncstream>)
+SYMBOL(begin, std::, <iterator>)
+SYMBOL(bernoulli_distribution, std::, <random>)
+SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
+SYMBOL(binary_search, std::, <algorithm>)
+SYMBOL(bind, std::, <functional>)
+SYMBOL(binomial_distribution, std::, <random>)
+SYMBOL(bit_and, std::, <functional>)
+SYMBOL(bit_cast, std::, <bit>)
+SYMBOL(bit_not, std::, <functional>)
+SYMBOL(bit_or, std::, <functional>)
+SYMBOL(bit_xor, std::, <functional>)
+SYMBOL(bitset, std::, <bitset>)
+SYMBOL(bool_constant, std::, <type_traits>)
+SYMBOL(boolalpha, std::, <ios>)
+SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
+SYMBOL(boyer_moore_searcher, std::, <functional>)
+SYMBOL(bsearch, std::, <cstdlib>)
+SYMBOL(btowc, std::, <cwchar>)
+SYMBOL(byte, std::, <cstddef>)
+SYMBOL(c16rtomb, std::, <cuchar>)
+SYMBOL(c32rtomb, std::, <cuchar>)
+SYMBOL(call_once, std::, <mutex>)
+SYMBOL(calloc, std::, <cstdlib>)
+SYMBOL(cauchy_distribution, std::, <random>)
+SYMBOL(cbegin, std::, <iterator>)
+SYMBOL(cbrt, std::, <cmath>)
+SYMBOL(ceil, std::, <cmath>)
+SYMBOL(ceil2, std::, <bit>)
+SYMBOL(cend, std::, <iterator>)
+SYMBOL(centi, std::, <ratio>)
+SYMBOL(cerr, std::, <iostream>)
+SYMBOL(char_traits, std::, <string>)
+SYMBOL(chars_format, std::, <charconv>)
+SYMBOL(chi_squared_distribution, std::, <random>)
+SYMBOL(cin, std::, <iostream>)
+SYMBOL(clamp, std::, <algorithm>)
+SYMBOL(clearerr, std::, <cstdio>)
+SYMBOL(clock, std::, <ctime>)
+SYMBOL(clock_t, std::, <ctime>)
+SYMBOL(clog, std::, <iostream>)
+SYMBOL(cmatch, std::, <regex>)
+SYMBOL(codecvt, std::, <locale>)
+SYMBOL(codecvt_base, std::, <locale>)
+SYMBOL(codecvt_byname, std::, <locale>)
+SYMBOL(codecvt_utf16, std::, <codecvt>)
+SYMBOL(codecvt_utf8, std::, <codecvt>)
+SYMBOL(codecvt_utf8_utf16, std::, <codecvt>)
+SYMBOL(collate, std::, <locale>)
+SYMBOL(collate_byname, std::, <locale>)
+SYMBOL(common_comparison_category, std::, <compare>)
+SYMBOL(common_comparison_category_t, std::, <compare>)
+SYMBOL(common_reference, std::, <type_traits>)
+SYMBOL(common_reference_t, std::, <type_traits>)
+SYMBOL(common_type, std::, <type_traits>)
+SYMBOL(common_type_t, std::, <type_traits>)
+SYMBOL(compare_3way, std::, <algorithm>)
+SYMBOL(complex, std::, <complex>)
+SYMBOL(condition_variable, std::, <condition_variable>)
+SYMBOL(condition_variable_any, std::, <condition_variable>)
+SYMBOL(conditional, std::, <type_traits>)
+SYMBOL(conditional_t, std::, <type_traits>)
+SYMBOL(conj, std::, <complex>)
+SYMBOL(conjunction, std::, <type_traits>)
+SYMBOL(conjunction_v, std::, <type_traits>)
+SYMBOL(const_pointer_cast, std::, <memory>)
+SYMBOL(contract_violation, std::, <contract>)
+SYMBOL(copy, std::, <algorithm>)
+SYMBOL(copy_backward, std::, <algorithm>)
+SYMBOL(copy_if, std::, <algorithm>)
+SYMBOL(copy_n, std::, <algorithm>)
+SYMBOL(copysign, std::, <cmath>)
+SYMBOL(count, std::, <algorithm>)
+SYMBOL(count_if, std::, <algorithm>)
+SYMBOL(cout, std::, <iostream>)
+SYMBOL(crbegin, std::, <iterator>)
+SYMBOL(cref, std::, <functional>)
+SYMBOL(cregex_iterator, std::, <regex>)
+SYMBOL(cregex_token_iterator, std::, <regex>)
+SYMBOL(crend, std::, <iterator>)
+SYMBOL(csub_match, std::, <regex>)
+SYMBOL(ctime, std::, <ctime>)
+SYMBOL(ctype, std::, <locale>)
+SYMBOL(ctype_base, std::, <locale>)
+SYMBOL(ctype_byname, std::, <locale>)
+SYMBOL(current_exception, std::, <exception>)
+SYMBOL(cv_status, std::, <condition_variable>)
+SYMBOL(data, std::, <iterator>)
+SYMBOL(dec, std::, <ios>)
+SYMBOL(deca, std::, <ratio>)
+SYMBOL(decay, std::, <type_traits>)
+SYMBOL(decay_t, std::, <type_traits>)
+SYMBOL(deci, std::, <ratio>)
+SYMBOL(declare_no_pointers, std::, <memory>)
+SYMBOL(declare_reachable, std::, <memory>)
+SYMBOL(declval, std::, <utility>)
+SYMBOL(default_delete, std::, <memory>)
+SYMBOL(default_searcher, std::, <functional>)
+SYMBOL(defaultfloat, std::, <ios>)
+SYMBOL(defer_lock, std::, <mutex>)
+SYMBOL(defer_lock_t, std::, <mutex>)
+SYMBOL(denorm_absent, std::, <limits>)
+SYMBOL(denorm_indeterminate, std::, <limits>)
+SYMBOL(denorm_present, std::, <limits>)
+SYMBOL(deque, std::, <deque>)
+SYMBOL(destroy, std::, <memory>)
+SYMBOL(destroy_at, std::, <memory>)
+SYMBOL(destroy_n, std::, <memory>)
+SYMBOL(destroying_delete, std::, <new>)
+SYMBOL(destroying_delete_t, std::, <new>)
+SYMBOL(difftime, std::, <ctime>)
+SYMBOL(discard_block_engine, std::, <random>)
+SYMBOL(discrete_distribution, std::, <random>)
+SYMBOL(disjunction, std::, <type_traits>)
+SYMBOL(disjunction_v, std::, <type_traits>)
+SYMBOL(distance, std::, <iterator>)
+SYMBOL(divides, std::, <functional>)
+SYMBOL(domain_error, std::, <stdexcept>)
+SYMBOL(dynamic_extent, std::, <span>)
+SYMBOL(dynamic_pointer_cast, std::, <memory>)
+SYMBOL(emit_on_flush, std::, <ostream>)
+SYMBOL(empty, std::, <iterator>)
+SYMBOL(enable_if, std::, <type_traits>)
+SYMBOL(enable_if_t, std::, <type_traits>)
+SYMBOL(enable_shared_from_this, std::, <memory>)
+SYMBOL(end, std::, <iterator>)
+SYMBOL(endian, std::, <type_traits>)
+SYMBOL(endl, std::, <ostream>)
+SYMBOL(ends, std::, <ostream>)
+SYMBOL(equal, std::, <algorithm>)
+SYMBOL(equal_range, std::, <algorithm>)
+SYMBOL(equal_to, std::, <functional>)
+SYMBOL(erf, std::, <cmath>)
+SYMBOL(erfc, std::, <cmath>)
+SYMBOL(errc, std::, <system_error>)
+SYMBOL(error_category, std::, <system_error>)
+SYMBOL(error_code, std::, <system_error>)
+SYMBOL(error_condition, std::, <system_error>)
+SYMBOL(exa, std::, <ratio>)
+SYMBOL(exception, std::, <exception>)
+SYMBOL(exception_ptr, std::, <exception>)
+SYMBOL(exchange, std::, <utility>)
+SYMBOL(exclusive_scan, std::, <numeric>)
+SYMBOL(exit, std::, <cstdlib>)
+SYMBOL(exp2, std::, <cmath>)
+SYMBOL(expm1, std::, <cmath>)
+SYMBOL(exponential_distribution, std::, <random>)
+SYMBOL(extent, std::, <type_traits>)
+SYMBOL(extent_v, std::, <type_traits>)
+SYMBOL(extreme_value_distribution, std::, <random>)
+SYMBOL(false_type, std::, <type_traits>)
+SYMBOL(fclose, std::, <cstdio>)
+SYMBOL(fdim, std::, <cmath>)
+SYMBOL(feclearexcept, std::, <cfenv>)
+SYMBOL(fegetenv, std::, <cfenv>)
+SYMBOL(fegetexceptflag, std::, <cfenv>)
+SYMBOL(fegetround, std::, <cfenv>)
+SYMBOL(feholdexcept, std::, <cfenv>)
+SYMBOL(femto, std::, <ratio>)
+SYMBOL(fenv_t, std::, <cfenv>)
+SYMBOL(feof, std::, <cstdio>)
+SYMBOL(feraiseexcept, std::, <cfenv>)
+SYMBOL(ferror, std::, <cstdio>)
+SYMBOL(fesetenv, std::, <cfenv>)
+SYMBOL(fesetexceptflag, std::, <cfenv>)
+SYMBOL(fesetround, std::, <cfenv>)
+SYMBOL(fetestexcept, std::, <cfenv>)
+SYMBOL(feupdateenv, std::, <cfenv>)
+SYMBOL(fexcept_t, std::, <cfenv>)
+SYMBOL(fflush, std::, <cstdio>)
+SYMBOL(fgetc, std::, <cstdio>)
+SYMBOL(fgetpos, std::, <cstdio>)
+SYMBOL(fgets, std::, <cstdio>)
+SYMBOL(fgetwc, std::, <cwchar>)
+SYMBOL(fgetws, std::, <cwchar>)
+SYMBOL(fill, std::, <algorithm>)
+SYMBOL(fill_n, std::, <algorithm>)
+SYMBOL(find, std::, <algorithm>)
+SYMBOL(find_end, std::, <algorithm>)
+SYMBOL(find_first_of, std::, <algorithm>)
+SYMBOL(find_if, std::, <algorithm>)
+SYMBOL(find_if_not, std::, <algorithm>)
+SYMBOL(fisher_f_distribution, std::, <random>)
+SYMBOL(fixed, std::, <ios>)
+SYMBOL(float_denorm_style, std::, <limits>)
+SYMBOL(float_round_style, std::, <limits>)
+SYMBOL(floor, std::, <cmath>)
+SYMBOL(floor2, std::, <bit>)
+SYMBOL(flush, std::, <ostream>)
+SYMBOL(flush_emit, std::, <ostream>)
+SYMBOL(fma, std::, <cmath>)
+SYMBOL(fmax, std::, <cmath>)
+SYMBOL(fmin, std::, <cmath>)
+SYMBOL(fmod, std::, <cmath>)
+SYMBOL(fopen, std::, <cstdio>)
+SYMBOL(for_each, std::, <algorithm>)
+SYMBOL(for_each_n, std::, <algorithm>)
+SYMBOL(forward, std::, <utility>)
+SYMBOL(forward_as_tuple, std::, <tuple>)
+SYMBOL(forward_iterator_tag, std::, <iterator>)
+SYMBOL(forward_list, std::, <forward_list>)
+SYMBOL(fpclassify, std::, <cmath>)
+SYMBOL(fpos, std::, <ios>)
+SYMBOL(fpos_t, std::, <cstdio>)
+SYMBOL(fprintf, std::, <cstdio>)
+SYMBOL(fputc, std::, <cstdio>)
+SYMBOL(fputs, std::, <cstdio>)
+SYMBOL(fputwc, std::, <cwchar>)
+SYMBOL(fputws, std::, <cwchar>)
+SYMBOL(fread, std::, <cstdio>)
+SYMBOL(free, std::, <cstdlib>)
+SYMBOL(freopen, std::, <cstdio>)
+SYMBOL(frexp, std::, <cmath>)
+SYMBOL(from_chars, std::, <charconv>)
+SYMBOL(front_insert_iterator, std::, <iterator>)
+SYMBOL(front_inserter, std::, <iterator>)
+SYMBOL(fscanf, std::, <cstdio>)
+SYMBOL(fseek, std::, <cstdio>)
+SYMBOL(fsetpos, std::, <cstdio>)
+SYMBOL(fstream, std::, <fstream>)
+SYMBOL(ftell, std::, <cstdio>)
+SYMBOL(function, std::, <functional>)
+SYMBOL(future, std::, <future>)
+SYMBOL(future_category, std::, <future>)
+SYMBOL(future_errc, std::, <future>)
+SYMBOL(future_error, std::, <future>)
+SYMBOL(future_status, std::, <future>)
+SYMBOL(fwide, std::, <cwchar>)
+SYMBOL(fwprintf, std::, <cwchar>)
+SYMBOL(fwrite, std::, <cstdio>)
+SYMBOL(fwscanf, std::, <cwchar>)
+SYMBOL(gamma_distribution, std::, <random>)
+SYMBOL(gcd, std::, <numeric>)
+SYMBOL(generate, std::, <algorithm>)
+SYMBOL(generate_canonical, std::, <random>)
+SYMBOL(generate_n, std::, <algorithm>)
+SYMBOL(generic_category, std::, <system_error>)
+SYMBOL(geometric_distribution, std::, <random>)
+SYMBOL(get_if, std::, <variant>)
+SYMBOL(get_money, std::, <iomanip>)
+SYMBOL(get_new_handler, std::, <new>)
+SYMBOL(get_pointer_safety, std::, <memory>)
+SYMBOL(get_terminate, std::, <exception>)
+SYMBOL(get_time, std::, <iomanip>)
+SYMBOL(getc, std::, <cstdio>)
+SYMBOL(getchar, std::, <cstdio>)
+SYMBOL(getenv, std::, <cstdlib>)
+SYMBOL(gets, std::, <cstdio>)
+SYMBOL(getwc, std::, <cwchar>)
+SYMBOL(getwchar, std::, <cwchar>)
+SYMBOL(giga, std::, <ratio>)
+SYMBOL(gmtime, std::, <ctime>)
+SYMBOL(greater, std::, <functional>)
+SYMBOL(greater_equal, std::, <functional>)
+SYMBOL(gslice, std::, <valarray>)
+SYMBOL(gslice_array, std::, <valarray>)
+SYMBOL(hardware_constructive_interference_size, std::, <new>)
+SYMBOL(hardware_destructive_interference_size, std::, <new>)
+SYMBOL(has_facet, std::, <locale>)
+SYMBOL(has_unique_object_representations, std::, <type_traits>)
+SYMBOL(has_unique_object_representations_v, std::, <type_traits>)
+SYMBOL(has_virtual_destructor, std::, <type_traits>)
+SYMBOL(has_virtual_destructor_v, std::, <type_traits>)
+SYMBOL(hash, std::, <functional>)
+SYMBOL(hecto, std::, <ratio>)
+SYMBOL(hex, std::, <ios>)
+SYMBOL(hexfloat, std::, <ios>)
+SYMBOL(holds_alternative, std::, <variant>)
+SYMBOL(hypot, std::, <cmath>)
+SYMBOL(identity, std::, <functional>)
+SYMBOL(ifstream, std::, <fstream>)
+SYMBOL(ignore, std::, <tuple>)
+SYMBOL(ilogb, std::, <cmath>)
+SYMBOL(imag, std::, <complex>)
+SYMBOL(in_place, std::, <utility>)
+SYMBOL(in_place_index, std::, <utility>)
+SYMBOL(in_place_index_t, std::, <utility>)
+SYMBOL(in_place_t, std::, <utility>)
+SYMBOL(in_place_type, std::, <utility>)
+SYMBOL(in_place_type_t, std::, <utility>)
+SYMBOL(includes, std::, <algorithm>)
+SYMBOL(inclusive_scan, std::, <numeric>)
+SYMBOL(independent_bits_engine, std::, <random>)
+SYMBOL(indirect_array, std::, <valarray>)
+SYMBOL(inner_product, std::, <numeric>)
+SYMBOL(inplace_merge, std::, <algorithm>)
+SYMBOL(input_iterator_tag, std::, <iterator>)
+SYMBOL(insert_iterator, std::, <iterator>)
+SYMBOL(inserter, std::, <iterator>)
+SYMBOL(integer_sequence, std::, <utility>)
+SYMBOL(integral_constant, std::, <type_traits>)
+SYMBOL(internal, std::, <ios>)
+SYMBOL(invalid_argument, std::, <stdexcept>)
+SYMBOL(invoke, std::, <functional>)
+SYMBOL(invoke_result, std::, <type_traits>)
+SYMBOL(invoke_result_t, std::, <type_traits>)
+SYMBOL(io_errc, std::, <ios>)
+SYMBOL(ios, std::, <ios>)
+SYMBOL(ios_base, std::, <ios>)
+SYMBOL(iostream, std::, <istream>)
+SYMBOL(iostream_category, std::, <ios>)
+SYMBOL(iota, std::, <numeric>)
+SYMBOL(is_abstract, std::, <type_traits>)
+SYMBOL(is_abstract_v, std::, <type_traits>)
+SYMBOL(is_aggregate, std::, <type_traits>)
+SYMBOL(is_aggregate_v, std::, <type_traits>)
+SYMBOL(is_arithmetic, std::, <type_traits>)
+SYMBOL(is_arithmetic_v, std::, <type_traits>)
+SYMBOL(is_array, std::, <type_traits>)
+SYMBOL(is_array_v, std::, <type_traits>)
+SYMBOL(is_assignable, std::, <type_traits>)
+SYMBOL(is_assignable_v, std::, <type_traits>)
+SYMBOL(is_base_of, std::, <type_traits>)
+SYMBOL(is_base_of_v, std::, <type_traits>)
+SYMBOL(is_bind_expression, std::, <functional>)
+SYMBOL(is_bind_expression_v, std::, <functional>)
+SYMBOL(is_class, std::, <type_traits>)
+SYMBOL(is_class_v, std::, <type_traits>)
+SYMBOL(is_compound, std::, <type_traits>)
+SYMBOL(is_compound_v, std::, <type_traits>)
+SYMBOL(is_const, std::, <type_traits>)
+SYMBOL(is_const_v, std::, <type_traits>)
+SYMBOL(is_constructible, std::, <type_traits>)
+SYMBOL(is_constructible_v, std::, <type_traits>)
+SYMBOL(is_convertible, std::, <type_traits>)
+SYMBOL(is_convertible_v, std::, <type_traits>)
+SYMBOL(is_copy_assignable, std::, <type_traits>)
+SYMBOL(is_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_copy_constructible, std::, <type_traits>)
+SYMBOL(is_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_default_constructible, std::, <type_traits>)
+SYMBOL(is_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_destructible, std::, <type_traits>)
+SYMBOL(is_destructible_v, std::, <type_traits>)
+SYMBOL(is_empty, std::, <type_traits>)
+SYMBOL(is_empty_v, std::, <type_traits>)
+SYMBOL(is_enum, std::, <type_traits>)
+SYMBOL(is_enum_v, std::, <type_traits>)
+SYMBOL(is_eq, std::, <compare>)
+SYMBOL(is_error_code_enum, std::, <system_error>)
+SYMBOL(is_error_condition_enum, std::, <system_error>)
+SYMBOL(is_error_condition_enum_v, std::, <system_error>)
+SYMBOL(is_execution_policy, std::, <execution>)
+SYMBOL(is_execution_policy_v, std::, <execution>)
+SYMBOL(is_final, std::, <type_traits>)
+SYMBOL(is_final_v, std::, <type_traits>)
+SYMBOL(is_floating_point, std::, <type_traits>)
+SYMBOL(is_floating_point_v, std::, <type_traits>)
+SYMBOL(is_function, std::, <type_traits>)
+SYMBOL(is_function_v, std::, <type_traits>)
+SYMBOL(is_fundamental, std::, <type_traits>)
+SYMBOL(is_fundamental_v, std::, <type_traits>)
+SYMBOL(is_gt, std::, <compare>)
+SYMBOL(is_gteq, std::, <compare>)
+SYMBOL(is_heap, std::, <algorithm>)
+SYMBOL(is_heap_until, std::, <algorithm>)
+SYMBOL(is_integral, std::, <type_traits>)
+SYMBOL(is_integral_v, std::, <type_traits>)
+SYMBOL(is_invocable, std::, <type_traits>)
+SYMBOL(is_invocable_r, std::, <type_traits>)
+SYMBOL(is_invocable_r_v, std::, <type_traits>)
+SYMBOL(is_invocable_v, std::, <type_traits>)
+SYMBOL(is_lt, std::, <compare>)
+SYMBOL(is_lteq, std::, <compare>)
+SYMBOL(is_lvalue_reference, std::, <type_traits>)
+SYMBOL(is_lvalue_reference_v, std::, <type_traits>)
+SYMBOL(is_member_function_pointer, std::, <type_traits>)
+SYMBOL(is_member_function_pointer_v, std::, <type_traits>)
+SYMBOL(is_member_object_pointer, std::, <type_traits>)
+SYMBOL(is_member_object_pointer_v, std::, <type_traits>)
+SYMBOL(is_member_pointer, std::, <type_traits>)
+SYMBOL(is_member_pointer_v, std::, <type_traits>)
+SYMBOL(is_move_assignable, std::, <type_traits>)
+SYMBOL(is_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_move_constructible, std::, <type_traits>)
+SYMBOL(is_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_neq, std::, <compare>)
+SYMBOL(is_nothrow_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_default_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_destructible, std::, <type_traits>)
+SYMBOL(is_nothrow_destructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_r, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_r_v, std::, <type_traits>)
+SYMBOL(is_nothrow_invocable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_move_assignable, std::, <type_traits>)
+SYMBOL(is_nothrow_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_move_constructible, std::, <type_traits>)
+SYMBOL(is_nothrow_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_v, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_with, std::, <type_traits>)
+SYMBOL(is_nothrow_swappable_with_v, std::, <type_traits>)
+SYMBOL(is_null_pointer, std::, <type_traits>)
+SYMBOL(is_null_pointer_v, std::, <type_traits>)
+SYMBOL(is_object, std::, <type_traits>)
+SYMBOL(is_object_v, std::, <type_traits>)
+SYMBOL(is_partitioned, std::, <algorithm>)
+SYMBOL(is_permutation, std::, <algorithm>)
+SYMBOL(is_placeholder, std::, <functional>)
+SYMBOL(is_placeholder_v, std::, <functional>)
+SYMBOL(is_pod, std::, <type_traits>)
+SYMBOL(is_pod_v, std::, <type_traits>)
+SYMBOL(is_pointer, std::, <type_traits>)
+SYMBOL(is_pointer_v, std::, <type_traits>)
+SYMBOL(is_polymorphic, std::, <type_traits>)
+SYMBOL(is_polymorphic_v, std::, <type_traits>)
+SYMBOL(is_reference, std::, <type_traits>)
+SYMBOL(is_reference_v, std::, <type_traits>)
+SYMBOL(is_rvalue_reference, std::, <type_traits>)
+SYMBOL(is_rvalue_reference_v, std::, <type_traits>)
+SYMBOL(is_same, std::, <type_traits>)
+SYMBOL(is_same_v, std::, <type_traits>)
+SYMBOL(is_scalar, std::, <type_traits>)
+SYMBOL(is_scalar_v, std::, <type_traits>)
+SYMBOL(is_signed, std::, <type_traits>)
+SYMBOL(is_signed_v, std::, <type_traits>)
+SYMBOL(is_sorted, std::, <algorithm>)
+SYMBOL(is_sorted_until, std::, <algorithm>)
+SYMBOL(is_standard_layout, std::, <type_traits>)
+SYMBOL(is_standard_layout_v, std::, <type_traits>)
+SYMBOL(is_swappable, std::, <type_traits>)
+SYMBOL(is_swappable_v, std::, <type_traits>)
+SYMBOL(is_swappable_with, std::, <type_traits>)
+SYMBOL(is_swappable_with_v, std::, <type_traits>)
+SYMBOL(is_trivial, std::, <type_traits>)
+SYMBOL(is_trivial_v, std::, <type_traits>)
+SYMBOL(is_trivially_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_copy_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_copy_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_copy_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_copyable, std::, <type_traits>)
+SYMBOL(is_trivially_copyable_v, std::, <type_traits>)
+SYMBOL(is_trivially_default_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_default_constructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_destructible, std::, <type_traits>)
+SYMBOL(is_trivially_destructible_v, std::, <type_traits>)
+SYMBOL(is_trivially_move_assignable, std::, <type_traits>)
+SYMBOL(is_trivially_move_assignable_v, std::, <type_traits>)
+SYMBOL(is_trivially_move_constructible, std::, <type_traits>)
+SYMBOL(is_trivially_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_union, std::, <type_traits>)
+SYMBOL(is_union_v, std::, <type_traits>)
+SYMBOL(is_unsigned, std::, <type_traits>)
+SYMBOL(is_unsigned_v, std::, <type_traits>)
+SYMBOL(is_void, std::, <type_traits>)
+SYMBOL(is_void_v, std::, <type_traits>)
+SYMBOL(is_volatile, std::, <type_traits>)
+SYMBOL(is_volatile_v, std::, <type_traits>)
+SYMBOL(isfinite, std::, <cmath>)
+SYMBOL(isgreater, std::, <cmath>)
+SYMBOL(isgreaterequal, std::, <cmath>)
+SYMBOL(isinf, std::, <cmath>)
+SYMBOL(isless, std::, <cmath>)
+SYMBOL(islessequal, std::, <cmath>)
+SYMBOL(islessgreater, std::, <cmath>)
+SYMBOL(isnan, std::, <cmath>)
+SYMBOL(isnormal, std::, <cmath>)
+SYMBOL(ispow2, std::, <bit>)
+SYMBOL(istream_iterator, std::, <iterator>)
+SYMBOL(istreambuf_iterator, std::, <iterator>)
+SYMBOL(istringstream, std::, <sstream>)
+SYMBOL(isunordered, std::, <cmath>)
+SYMBOL(iswalnum, std::, <cwctype>)
+SYMBOL(iswalpha, std::, <cwctype>)
+SYMBOL(iswblank, std::, <cwctype>)
+SYMBOL(iswcntrl, std::, <cwctype>)
+SYMBOL(iswctype, std::, <cwctype>)
+SYMBOL(iswdigit, std::, <cwctype>)
+SYMBOL(iswgraph, std::, <cwctype>)
+SYMBOL(iswlower, std::, <cwctype>)
+SYMBOL(iswprint, std::, <cwctype>)
+SYMBOL(iswpunct, std::, <cwctype>)
+SYMBOL(iswspace, std::, <cwctype>)
+SYMBOL(iswupper, std::, <cwctype>)
+SYMBOL(iswxdigit, std::, <cwctype>)
+SYMBOL(iter_swap, std::, <algorithm>)
+SYMBOL(iterator, std::, <iterator>)
+SYMBOL(iterator_traits, std::, <iterator>)
+SYMBOL(jmp_buf, std::, <csetjmp>)
+SYMBOL(kill_dependency, std::, <atomic>)
+SYMBOL(kilo, std::, <ratio>)
+SYMBOL(launch, std::, <future>)
+SYMBOL(launder, std::, <new>)
+SYMBOL(lcm, std::, <numeric>)
+SYMBOL(lconv, std::, <clocale>)
+SYMBOL(ldexp, std::, <cmath>)
+SYMBOL(left, std::, <ios>)
+SYMBOL(length_error, std::, <stdexcept>)
+SYMBOL(less, std::, <functional>)
+SYMBOL(less_equal, std::, <functional>)
+SYMBOL(lexicographical_compare, std::, <algorithm>)
+SYMBOL(lexicographical_compare_3way, std::, <algorithm>)
+SYMBOL(lgamma, std::, <cmath>)
+SYMBOL(linear_congruential_engine, std::, <random>)
+SYMBOL(list, std::, <list>)
+SYMBOL(llrint, std::, <cmath>)
+SYMBOL(llround, std::, <cmath>)
+SYMBOL(locale, std::, <locale>)
+SYMBOL(localeconv, std::, <clocale>)
+SYMBOL(localtime, std::, <ctime>)
+SYMBOL(lock, std::, <mutex>)
+SYMBOL(lock_guard, std::, <mutex>)
+SYMBOL(log1p, std::, <cmath>)
+SYMBOL(log2, std::, <cmath>)
+SYMBOL(log2p1, std::, <bit>)
+SYMBOL(logb, std::, <cmath>)
+SYMBOL(logic_error, std::, <stdexcept>)
+SYMBOL(logical_and, std::, <functional>)
+SYMBOL(logical_not, std::, <functional>)
+SYMBOL(logical_or, std::, <functional>)
+SYMBOL(lognormal_distribution, std::, <random>)
+SYMBOL(longjmp, std::, <csetjmp>)
+SYMBOL(lower_bound, std::, <algorithm>)
+SYMBOL(lrint, std::, <cmath>)
+SYMBOL(lround, std::, <cmath>)
+SYMBOL(make_exception_ptr, std::, <exception>)
+SYMBOL(make_from_tuple, std::, <tuple>)
+SYMBOL(make_heap, std::, <algorithm>)
+SYMBOL(make_move_iterator, std::, <iterator>)
+SYMBOL(make_optional, std::, <optional>)
+SYMBOL(make_pair, std::, <utility>)
+SYMBOL(make_reverse_iterator, std::, <iterator>)
+SYMBOL(make_shared, std::, <memory>)
+SYMBOL(make_signed, std::, <type_traits>)
+SYMBOL(make_signed_t, std::, <type_traits>)
+SYMBOL(make_tuple, std::, <tuple>)
+SYMBOL(make_unique, std::, <memory>)
+SYMBOL(make_unsigned, std::, <type_traits>)
+SYMBOL(make_unsigned_t, std::, <type_traits>)
+SYMBOL(malloc, std::, <cstdlib>)
+SYMBOL(map, std::, <map>)
+SYMBOL(mask_array, std::, <valarray>)
+SYMBOL(match_results, std::, <regex>)
+SYMBOL(max, std::, <algorithm>)
+SYMBOL(max_align_t, std::, <cstddef>)
+SYMBOL(max_element, std::, <algorithm>)
+SYMBOL(mblen, std::, <cstdlib>)
+SYMBOL(mbrlen, std::, <cwchar>)
+SYMBOL(mbrtoc16, std::, <cuchar>)
+SYMBOL(mbrtoc32, std::, <cuchar>)
+SYMBOL(mbrtowc, std::, <cwchar>)
+SYMBOL(mbsinit, std::, <cwchar>)
+SYMBOL(mbsrtowcs, std::, <cwchar>)
+SYMBOL(mbstowcs, std::, <cstdlib>)
+SYMBOL(mbtowc, std::, <cstdlib>)
+SYMBOL(mega, std::, <ratio>)
+SYMBOL(mem_fn, std::, <functional>)
+SYMBOL(memchr, std::, <cstring>)
+SYMBOL(memcmp, std::, <cstring>)
+SYMBOL(memcpy, std::, <cstring>)
+SYMBOL(memmove, std::, <cstring>)
+SYMBOL(memory_order, std::, <atomic>)
+SYMBOL(memory_order_acq_rel, std::, <atomic>)
+SYMBOL(memory_order_acquire, std::, <atomic>)
+SYMBOL(memory_order_consume, std::, <atomic>)
+SYMBOL(memory_order_relaxed, std::, <atomic>)
+SYMBOL(memory_order_release, std::, <atomic>)
+SYMBOL(memory_order_seq_cst, std::, <atomic>)
+SYMBOL(memset, std::, <cstring>)
+SYMBOL(merge, std::, <algorithm>)
+SYMBOL(mersenne_twister_engine, std::, <random>)
+SYMBOL(messages, std::, <locale>)
+SYMBOL(messages_base, std::, <locale>)
+SYMBOL(messages_byname, std::, <locale>)
+SYMBOL(micro, std::, <ratio>)
+SYMBOL(milli, std::, <ratio>)
+SYMBOL(min, std::, <algorithm>)
+SYMBOL(min_element, std::, <algorithm>)
+SYMBOL(minmax, std::, <algorithm>)
+SYMBOL(minmax_element, std::, <algorithm>)
+SYMBOL(minus, std::, <functional>)
+SYMBOL(mismatch, std::, <algorithm>)
+SYMBOL(mktime, std::, <ctime>)
+SYMBOL(modf, std::, <cmath>)
+SYMBOL(modulus, std::, <functional>)
+SYMBOL(money_base, std::, <locale>)
+SYMBOL(money_get, std::, <locale>)
+SYMBOL(money_put, std::, <locale>)
+SYMBOL(moneypunct, std::, <locale>)
+SYMBOL(moneypunct_byname, std::, <locale>)
+SYMBOL(monostate, std::, <variant>)
+SYMBOL(move_backward, std::, <algorithm>)
+SYMBOL(move_if_noexcept, std::, <utility>)
+SYMBOL(move_iterator, std::, <iterator>)
+SYMBOL(multimap, std::, <map>)
+SYMBOL(multiplies, std::, <functional>)
+SYMBOL(multiset, std::, <set>)
+SYMBOL(mutex, std::, <mutex>)
+SYMBOL(nan, std::, <cmath>)
+SYMBOL(nanf, std::, <cmath>)
+SYMBOL(nanl, std::, <cmath>)
+SYMBOL(nano, std::, <ratio>)
+SYMBOL(nearbyint, std::, <cmath>)
+SYMBOL(negate, std::, <functional>)
+SYMBOL(negation, std::, <type_traits>)
+SYMBOL(negation_v, std::, <type_traits>)
+SYMBOL(negative_binomial_distribution, std::, <random>)
+SYMBOL(nested_exception, std::, <exception>)
+SYMBOL(new_handler, std::, <new>)
+SYMBOL(next, std::, <iterator>)
+SYMBOL(next_permutation, std::, <algorithm>)
+SYMBOL(nextafter, std::, <cmath>)
+SYMBOL(nexttoward, std::, <cmath>)
+SYMBOL(no_emit_on_flush, std::, <ostream>)
+SYMBOL(noboolalpha, std::, <ios>)
+SYMBOL(none_of, std::, <algorithm>)
+SYMBOL(norm, std::, <complex>)
+SYMBOL(normal_distribution, std::, <random>)
+SYMBOL(noshowbase, std::, <ios>)
+SYMBOL(noshowpoint, std::, <ios>)
+SYMBOL(noshowpos, std::, <ios>)
+SYMBOL(noskipws, std::, <ios>)
+SYMBOL(not_equal_to, std::, <functional>)
+SYMBOL(not_fn, std::, <functional>)
+SYMBOL(nothrow, std::, <new>)
+SYMBOL(nothrow_t, std::, <new>)
+SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>)
+SYMBOL(nounitbuf, std::, <ios>)
+SYMBOL(nouppercase, std::, <ios>)
+SYMBOL(nth_element, std::, <algorithm>)
+SYMBOL(nullopt, std::, <optional>)
+SYMBOL(nullopt_t, std::, <optional>)
+SYMBOL(nullptr_t, std::, <cstddef>)
+SYMBOL(num_get, std::, <locale>)
+SYMBOL(num_put, std::, <locale>)
+SYMBOL(numeric_limits, std::, <limits>)
+SYMBOL(numpunct, std::, <locale>)
+SYMBOL(numpunct_byname, std::, <locale>)
+SYMBOL(oct, std::, <ios>)
+SYMBOL(ofstream, std::, <fstream>)
+SYMBOL(once_flag, std::, <mutex>)
+SYMBOL(optional, std::, <optional>)
+SYMBOL(ostream_iterator, std::, <iterator>)
+SYMBOL(ostreambuf_iterator, std::, <iterator>)
+SYMBOL(ostringstream, std::, <sstream>)
+SYMBOL(osyncstream, std::, <syncstream>)
+SYMBOL(out_of_range, std::, <stdexcept>)
+SYMBOL(output_iterator_tag, std::, <iterator>)
+SYMBOL(overflow_error, std::, <stdexcept>)
+SYMBOL(owner_less, std::, <memory>)
+SYMBOL(packaged_task, std::, <future>)
+SYMBOL(pair, std::, <utility>)
+SYMBOL(partial_order, std::, <compare>)
+SYMBOL(partial_ordering, std::, <compare>)
+SYMBOL(partial_sort, std::, <algorithm>)
+SYMBOL(partial_sort_copy, std::, <algorithm>)
+SYMBOL(partial_sum, std::, <numeric>)
+SYMBOL(partition, std::, <algorithm>)
+SYMBOL(partition_copy, std::, <algorithm>)
+SYMBOL(partition_point, std::, <algorithm>)
+SYMBOL(perror, std::, <cstdio>)
+SYMBOL(peta, std::, <ratio>)
+SYMBOL(pico, std::, <ratio>)
+SYMBOL(piecewise_constant_distribution, std::, <random>)
+SYMBOL(piecewise_construct_t, std::, <utility>)
+SYMBOL(piecewise_linear_distribution, std::, <random>)
+SYMBOL(plus, std::, <functional>)
+SYMBOL(pointer_safety, std::, <memory>)
+SYMBOL(pointer_traits, std::, <memory>)
+SYMBOL(poisson_distribution, std::, <random>)
+SYMBOL(polar, std::, <complex>)
+SYMBOL(polymorphic_allocator, std::, <memory_resource>)
+SYMBOL(pop_heap, std::, <algorithm>)
+SYMBOL(prev, std::, <iterator>)
+SYMBOL(prev_permutation, std::, <algorithm>)
+SYMBOL(printf, std::, <cstdio>)
+SYMBOL(priority_queue, std::, <queue>)
+SYMBOL(proj, std::, <complex>)
+SYMBOL(promise, std::, <future>)
+SYMBOL(ptrdiff_t, std::, <cstddef>)
+SYMBOL(push_heap, std::, <algorithm>)
+SYMBOL(put_money, std::, <iomanip>)
+SYMBOL(put_time, std::, <iomanip>)
+SYMBOL(putc, std::, <cstdio>)
+SYMBOL(putchar, std::, <cstdio>)
+SYMBOL(puts, std::, <cstdio>)
+SYMBOL(putwc, std::, <cwchar>)
+SYMBOL(putwchar, std::, <cwchar>)
+SYMBOL(qsort, std::, <cstdlib>)
+SYMBOL(queue, std::, <queue>)
+SYMBOL(quick_exit, std::, <cstdlib>)
+SYMBOL(quoted, std::, <iomanip>)
+SYMBOL(raise, std::, <csignal>)
+SYMBOL(rand, std::, <cstdlib>)
+SYMBOL(random_access_iterator_tag, std::, <iterator>)
+SYMBOL(random_device, std::, <random>)
+SYMBOL(random_shuffle, std::, <algorithm>)
+SYMBOL(range_error, std::, <stdexcept>)
+SYMBOL(rank, std::, <type_traits>)
+SYMBOL(rank_v, std::, <type_traits>)
+SYMBOL(ratio, std::, <ratio>)
+SYMBOL(ratio_add, std::, <ratio>)
+SYMBOL(ratio_divide, std::, <ratio>)
+SYMBOL(ratio_equal, std::, <ratio>)
+SYMBOL(ratio_equal_v, std::, <ratio>)
+SYMBOL(ratio_greater, std::, <ratio>)
+SYMBOL(ratio_greater_equal, std::, <ratio>)
+SYMBOL(ratio_greater_equal_v, std::, <ratio>)
+SYMBOL(ratio_greater_v, std::, <ratio>)
+SYMBOL(ratio_less, std::, <ratio>)
+SYMBOL(ratio_less_equal, std::, <ratio>)
+SYMBOL(ratio_less_equal_v, std::, <ratio>)
+SYMBOL(ratio_less_v, std::, <ratio>)
+SYMBOL(ratio_multiply, std::, <ratio>)
+SYMBOL(ratio_not_equal, std::, <ratio>)
+SYMBOL(ratio_not_equal_v, std::, <ratio>)
+SYMBOL(ratio_subtract, std::, <ratio>)
+SYMBOL(rbegin, std::, <iterator>)
+SYMBOL(real, std::, <complex>)
+SYMBOL(realloc, std::, <cstdlib>)
+SYMBOL(recursive_mutex, std::, <mutex>)
+SYMBOL(recursive_timed_mutex, std::, <mutex>)
+SYMBOL(reduce, std::, <numeric>)
+SYMBOL(ref, std::, <functional>)
+SYMBOL(reference_wrapper, std::, <functional>)
+SYMBOL(regex, std::, <regex>)
+SYMBOL(regex_error, std::, <regex>)
+SYMBOL(regex_iterator, std::, <regex>)
+SYMBOL(regex_match, std::, <regex>)
+SYMBOL(regex_replace, std::, <regex>)
+SYMBOL(regex_search, std::, <regex>)
+SYMBOL(regex_token_iterator, std::, <regex>)
+SYMBOL(regex_traits, std::, <regex>)
+SYMBOL(reinterpret_pointer_cast, std::, <memory>)
+SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remove_all_extents, std::, <type_traits>)
+SYMBOL(remove_all_extents_t, std::, <type_traits>)
+SYMBOL(remove_const, std::, <type_traits>)
+SYMBOL(remove_const_t, std::, <type_traits>)
+SYMBOL(remove_copy, std::, <algorithm>)
+SYMBOL(remove_copy_if, std::, <algorithm>)
+SYMBOL(remove_cv, std::, <type_traits>)
+SYMBOL(remove_cv_t, std::, <type_traits>)
+SYMBOL(remove_cvref, std::, <type_traits>)
+SYMBOL(remove_cvref_t, std::, <type_traits>)
+SYMBOL(remove_extent, std::, <type_traits>)
+SYMBOL(remove_extent_t, std::, <type_traits>)
+SYMBOL(remove_pointer, std::, <type_traits>)
+SYMBOL(remove_pointer_t, std::, <type_traits>)
+SYMBOL(remove_reference, std::, <type_traits>)
+SYMBOL(remove_reference_t, std::, <type_traits>)
+SYMBOL(remove_volatile, std::, <type_traits>)
+SYMBOL(remove_volatile_t, std::, <type_traits>)
+SYMBOL(remquo, std::, <cmath>)
+SYMBOL(rename, std::, <cstdio>)
+SYMBOL(rend, std::, <iterator>)
+SYMBOL(replace, std::, <algorithm>)
+SYMBOL(replace_copy, std::, <algorithm>)
+SYMBOL(replace_copy_if, std::, <algorithm>)
+SYMBOL(replace_if, std::, <algorithm>)
+SYMBOL(resetiosflags, std::, <iomanip>)
+SYMBOL(result_of, std::, <type_traits>)
+SYMBOL(result_of_t, std::, <type_traits>)
+SYMBOL(rethrow_exception, std::, <exception>)
+SYMBOL(rethrow_if_nested, std::, <exception>)
+SYMBOL(reverse, std::, <algorithm>)
+SYMBOL(reverse_copy, std::, <algorithm>)
+SYMBOL(reverse_iterator, std::, <iterator>)
+SYMBOL(rewind, std::, <cstdio>)
+SYMBOL(right, std::, <ios>)
+SYMBOL(rint, std::, <cmath>)
+SYMBOL(rotate, std::, <algorithm>)
+SYMBOL(rotate_copy, std::, <algorithm>)
+SYMBOL(round, std::, <cmath>)
+SYMBOL(round_indeterminate, std::, <limits>)
+SYMBOL(round_to_nearest, std::, <limits>)
+SYMBOL(round_toward_infinity, std::, <limits>)
+SYMBOL(round_toward_neg_infinity, std::, <limits>)
+SYMBOL(round_toward_zero, std::, <limits>)
+SYMBOL(runtime_error, std::, <stdexcept>)
+SYMBOL(sample, std::, <algorithm>)
+SYMBOL(scalbln, std::, <cmath>)
+SYMBOL(scalbn, std::, <cmath>)
+SYMBOL(scanf, std::, <cstdio>)
+SYMBOL(scientific, std::, <ios>)
+SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
+SYMBOL(search, std::, <algorithm>)
+SYMBOL(search_n, std::, <algorithm>)
+SYMBOL(seed_seq, std::, <random>)
+SYMBOL(set, std::, <set>)
+SYMBOL(set_difference, std::, <algorithm>)
+SYMBOL(set_intersection, std::, <algorithm>)
+SYMBOL(set_new_handler, std::, <new>)
+SYMBOL(set_symmetric_difference, std::, <algorithm>)
+SYMBOL(set_terminate, std::, <exception>)
+SYMBOL(set_union, std::, <algorithm>)
+SYMBOL(setbase, std::, <iomanip>)
+SYMBOL(setbuf, std::, <cstdio>)
+SYMBOL(setfill, std::, <iomanip>)
+SYMBOL(setiosflags, std::, <iomanip>)
+SYMBOL(setlocale, std::, <clocale>)
+SYMBOL(setprecision, std::, <iomanip>)
+SYMBOL(setvbuf, std::, <cstdio>)
+SYMBOL(setw, std::, <iomanip>)
+SYMBOL(shared_future, std::, <future>)
+SYMBOL(shared_lock, std::, <shared_mutex>)
+SYMBOL(shared_mutex, std::, <shared_mutex>)
+SYMBOL(shared_ptr, std::, <memory>)
+SYMBOL(shared_timed_mutex, std::, <shared_mutex>)
+SYMBOL(shift_left, std::, <algorithm>)
+SYMBOL(shift_right, std::, <algorithm>)
+SYMBOL(showbase, std::, <ios>)
+SYMBOL(showpoint, std::, <ios>)
+SYMBOL(showpos, std::, <ios>)
+SYMBOL(shuffle, std::, <algorithm>)
+SYMBOL(shuffle_order_engine, std::, <random>)
+SYMBOL(sig_atomic_t, std::, <csignal>)
+SYMBOL(signal, std::, <csignal>)
+SYMBOL(signbit, std::, <cmath>)
+SYMBOL(size, std::, <iterator>)
+SYMBOL(skipws, std::, <ios>)
+SYMBOL(slice, std::, <valarray>)
+SYMBOL(slice_array, std::, <valarray>)
+SYMBOL(smatch, std::, <regex>)
+SYMBOL(snprintf, std::, <cstdio>)
+SYMBOL(sort, std::, <algorithm>)
+SYMBOL(sort_heap, std::, <algorithm>)
+SYMBOL(span, std::, <span>)
+SYMBOL(sprintf, std::, <cstdio>)
+SYMBOL(srand, std::, <cstdlib>)
+SYMBOL(sregex_iterator, std::, <regex>)
+SYMBOL(sregex_token_iterator, std::, <regex>)
+SYMBOL(sscanf, std::, <cstdio>)
+SYMBOL(ssub_match, std::, <regex>)
+SYMBOL(stable_partition, std::, <algorithm>)
+SYMBOL(stable_sort, std::, <algorithm>)
+SYMBOL(stack, std::, <stack>)
+SYMBOL(static_pointer_cast, std::, <memory>)
+SYMBOL(strcat, std::, <cstring>)
+SYMBOL(strchr, std::, <cstring>)
+SYMBOL(strcmp, std::, <cstring>)
+SYMBOL(strcoll, std::, <cstring>)
+SYMBOL(strcpy, std::, <cstring>)
+SYMBOL(strcspn, std::, <cstring>)
+SYMBOL(streambuf, std::, <streambuf>)
+SYMBOL(streamoff, std::, <ios>)
+SYMBOL(streampos, std::, <ios>)
+SYMBOL(streamsize, std::, <ios>)
+SYMBOL(strerror, std::, <cstring>)
+SYMBOL(strftime, std::, <ctime>)
+SYMBOL(string, std::, <string>)
+SYMBOL(string_view, std::, <string_view>)
+SYMBOL(stringbuf, std::, <sstream>)
+SYMBOL(stringstream, std::, <sstream>)
+SYMBOL(strlen, std::, <cstring>)
+SYMBOL(strncat, std::, <cstring>)
+SYMBOL(strncmp, std::, <cstring>)
+SYMBOL(strncpy, std::, <cstring>)
+SYMBOL(strong_equal, std::, <compare>)
+SYMBOL(strong_equality, std::, <compare>)
+SYMBOL(strong_order, std::, <compare>)
+SYMBOL(strong_ordering, std::, <compare>)
+SYMBOL(strpbrk, std::, <cstring>)
+SYMBOL(strrchr, std::, <cstring>)
+SYMBOL(strspn, std::, <cstring>)
+SYMBOL(strstr, std::, <cstring>)
+SYMBOL(strtod, std::, <cstdlib>)
+SYMBOL(strtof, std::, <cstdlib>)
+SYMBOL(strtoimax, std::, <cinttypes>)
+SYMBOL(strtok, std::, <cstring>)
+SYMBOL(strtol, std::, <cstdlib>)
+SYMBOL(strtold, std::, <cstdlib>)
+SYMBOL(strtoll, std::, <cstdlib>)
+SYMBOL(strtoul, std::, <cstdlib>)
+SYMBOL(strtoull, std::, <cstdlib>)
+SYMBOL(strtoumax, std::, <cinttypes>)
+SYMBOL(strxfrm, std::, <cstring>)
+SYMBOL(student_t_distribution, std::, <random>)
+SYMBOL(sub_match, std::, <regex>)
+SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(swap_ranges, std::, <algorithm>)
+SYMBOL(swprintf, std::, <cwchar>)
+SYMBOL(swscanf, std::, <cwchar>)
+SYMBOL(syncbuf, std::, <syncstream>)
+SYMBOL(system, std::, <cstdlib>)
+SYMBOL(system_category, std::, <system_error>)
+SYMBOL(system_error, std::, <system_error>)
+SYMBOL(tera, std::, <ratio>)
+SYMBOL(terminate, std::, <exception>)
+SYMBOL(terminate_handler, std::, <exception>)
+SYMBOL(tgamma, std::, <cmath>)
+SYMBOL(thread, std::, <thread>)
+SYMBOL(throw_with_nested, std::, <exception>)
+SYMBOL(tie, std::, <tuple>)
+SYMBOL(time, std::, <ctime>)
+SYMBOL(time_base, std::, <locale>)
+SYMBOL(time_get, std::, <locale>)
+SYMBOL(time_get_byname, std::, <locale>)
+SYMBOL(time_put, std::, <locale>)
+SYMBOL(time_put_byname, std::, <locale>)
+SYMBOL(time_t, std::, <ctime>)
+SYMBOL(timed_mutex, std::, <mutex>)
+SYMBOL(timespec, std::, <ctime>)
+SYMBOL(timespec_get, std::, <ctime>)
+SYMBOL(tm, std::, <ctime>)
+SYMBOL(tmpfile, std::, <cstdio>)
+SYMBOL(tmpnam, std::, <cstdio>)
+SYMBOL(to_address, std::, <memory>)
+SYMBOL(to_chars, std::, <charconv>)
+SYMBOL(to_integer, std::, <cstddef>)
+SYMBOL(to_string, std::, <string>)
+SYMBOL(towctrans, std::, <cwctype>)
+SYMBOL(towlower, std::, <cwctype>)
+SYMBOL(towupper, std::, <cwctype>)
+SYMBOL(transform, std::, <algorithm>)
+SYMBOL(transform_exclusive_scan, std::, <numeric>)
+SYMBOL(transform_inclusive_scan, std::, <numeric>)
+SYMBOL(transform_reduce, std::, <numeric>)
+SYMBOL(true_type, std::, <type_traits>)
+SYMBOL(trunc, std::, <cmath>)
+SYMBOL(try_lock, std::, <mutex>)
+SYMBOL(try_to_lock, std::, <mutex>)
+SYMBOL(try_to_lock_t, std::, <mutex>)
+SYMBOL(tuple, std::, <tuple>)
+SYMBOL(tuple_cat, std::, <tuple>)
+SYMBOL(type_identity, std::, <type_traits>)
+SYMBOL(type_identity_t, std::, <type_traits>)
+SYMBOL(type_index, std::, <typeindex>)
+SYMBOL(type_info, std::, <typeinfo>)
+SYMBOL(u16streampos, std::, <ios>)
+SYMBOL(u16string, std::, <string>)
+SYMBOL(u16string_view, std::, <string_view>)
+SYMBOL(u32streampos, std::, <ios>)
+SYMBOL(u32string, std::, <string>)
+SYMBOL(u32string_view, std::, <string_view>)
+SYMBOL(uncaught_exceptions, std::, <exception>)
+SYMBOL(undeclare_no_pointers, std::, <memory>)
+SYMBOL(undeclare_reachable, std::, <memory>)
+SYMBOL(underflow_error, std::, <stdexcept>)
+SYMBOL(underlying_type, std::, <type_traits>)
+SYMBOL(underlying_type_t, std::, <type_traits>)
+SYMBOL(ungetc, std::, <cstdio>)
+SYMBOL(ungetwc, std::, <cwchar>)
+SYMBOL(uniform_int_distribution, std::, <random>)
+SYMBOL(uniform_real_distribution, std::, <random>)
+SYMBOL(uninitialized_copy, std::, <memory>)
+SYMBOL(uninitialized_copy_n, std::, <memory>)
+SYMBOL(uninitialized_default_construct, std::, <memory>)
+SYMBOL(uninitialized_default_construct_n, std::, <memory>)
+SYMBOL(uninitialized_fill, std::, <memory>)
+SYMBOL(uninitialized_fill_n, std::, <memory>)
+SYMBOL(uninitialized_move, std::, <memory>)
+SYMBOL(uninitialized_move_n, std::, <memory>)
+SYMBOL(uninitialized_value_construct, std::, <memory>)
+SYMBOL(uninitialized_value_construct_n, std::, <memory>)
+SYMBOL(unique, std::, <algorithm>)
+SYMBOL(unique_copy, std::, <algorithm>)
+SYMBOL(unique_lock, std::, <mutex>)
+SYMBOL(unique_ptr, std::, <memory>)
+SYMBOL(unitbuf, std::, <ios>)
+SYMBOL(unordered_map, std::, <unordered_map>)
+SYMBOL(unordered_multimap, std::, <unordered_map>)
+SYMBOL(unordered_multiset, std::, <unordered_set>)
+SYMBOL(unordered_set, std::, <unordered_set>)
+SYMBOL(upper_bound, std::, <algorithm>)
+SYMBOL(uppercase, std::, <ios>)
+SYMBOL(use_facet, std::, <locale>)
+SYMBOL(uses_allocator_v, std::, <memory>)
+SYMBOL(va_list, std::, <cstdarg>)
+SYMBOL(valarray, std::, <valarray>)
+SYMBOL(variant, std::, <variant>)
+SYMBOL(variant_alternative, std::, <variant>)
+SYMBOL(variant_alternative_t, std::, <variant>)
+SYMBOL(variant_npos, std::, <variant>)
+SYMBOL(variant_size, std::, <variant>)
+SYMBOL(variant_size_v, std::, <variant>)
+SYMBOL(vector, std::, <vector>)
+SYMBOL(vfprintf, std::, <cstdio>)
+SYMBOL(vfscanf, std::, <cstdio>)
+SYMBOL(vfwprintf, std::, <cwchar>)
+SYMBOL(vfwscanf, std::, <cwchar>)
+SYMBOL(visit, std::, <variant>)
+SYMBOL(void_t, std::, <type_traits>)
+SYMBOL(vprintf, std::, <cstdio>)
+SYMBOL(vscanf, std::, <cstdio>)
+SYMBOL(vsnprintf, std::, <cstdio>)
+SYMBOL(vsprintf, std::, <cstdio>)
+SYMBOL(vsscanf, std::, <cstdio>)
+SYMBOL(vswprintf, std::, <cwchar>)
+SYMBOL(vswscanf, std::, <cwchar>)
+SYMBOL(vwprintf, std::, <cwchar>)
+SYMBOL(vwscanf, std::, <cwchar>)
+SYMBOL(wbuffer_convert, std::, <locale>)
+SYMBOL(wcerr, std::, <iostream>)
+SYMBOL(wcin, std::, <iostream>)
+SYMBOL(wclog, std::, <iostream>)
+SYMBOL(wcmatch, std::, <regex>)
+SYMBOL(wcout, std::, <iostream>)
+SYMBOL(wcregex_iterator, std::, <regex>)
+SYMBOL(wcregex_token_iterator, std::, <regex>)
+SYMBOL(wcrtomb, std::, <cwchar>)
+SYMBOL(wcscat, std::, <cwchar>)
+SYMBOL(wcschr, std::, <cwchar>)
+SYMBOL(wcscmp, std::, <cwchar>)
+SYMBOL(wcscoll, std::, <cwchar>)
+SYMBOL(wcscpy, std::, <cwchar>)
+SYMBOL(wcscspn, std::, <cwchar>)
+SYMBOL(wcsftime, std::, <cwchar>)
+SYMBOL(wcslen, std::, <cwchar>)
+SYMBOL(wcsncat, std::, <cwchar>)
+SYMBOL(wcsncmp, std::, <cwchar>)
+SYMBOL(wcsncpy, std::, <cwchar>)
+SYMBOL(wcspbrk, std::, <cwchar>)
+SYMBOL(wcsrchr, std::, <cwchar>)
+SYMBOL(wcsrtombs, std::, <cwchar>)
+SYMBOL(wcsspn, std::, <cwchar>)
+SYMBOL(wcsstr, std::, <cwchar>)
+SYMBOL(wcstod, std::, <cwchar>)
+SYMBOL(wcstof, std::, <cwchar>)
+SYMBOL(wcstoimax, std::, <cinttypes>)
+SYMBOL(wcstok, std::, <cwchar>)
+SYMBOL(wcstol, std::, <cwchar>)
+SYMBOL(wcstold, std::, <cwchar>)
+SYMBOL(wcstoll, std::, <cwchar>)
+SYMBOL(wcstombs, std::, <cstdlib>)
+SYMBOL(wcstoul, std::, <cwchar>)
+SYMBOL(wcstoull, std::, <cwchar>)
+SYMBOL(wcstoumax, std::, <cinttypes>)
+SYMBOL(wcsub_match, std::, <regex>)
+SYMBOL(wcsxfrm, std::, <cwchar>)
+SYMBOL(wctob, std::, <cwchar>)
+SYMBOL(wctomb, std::, <cstdlib>)
+SYMBOL(wctrans, std::, <cwctype>)
+SYMBOL(wctype, std::, <cwctype>)
+SYMBOL(weak_equal, std::, <compare>)
+SYMBOL(weak_equality, std::, <compare>)
+SYMBOL(weak_order, std::, <compare>)
+SYMBOL(weak_ordering, std::, <compare>)
+SYMBOL(weak_ptr, std::, <memory>)
+SYMBOL(weibull_distribution, std::, <random>)
+SYMBOL(wfstream, std::, <fstream>)
+SYMBOL(wifstream, std::, <fstream>)
+SYMBOL(wios, std::, <ios>)
+SYMBOL(wiostream, std::, <istream>)
+SYMBOL(wistringstream, std::, <sstream>)
+SYMBOL(wmemchr, std::, <cwchar>)
+SYMBOL(wmemcmp, std::, <cwchar>)
+SYMBOL(wmemcpy, std::, <cwchar>)
+SYMBOL(wmemmove, std::, <cwchar>)
+SYMBOL(wmemset, std::, <cwchar>)
+SYMBOL(wofstream, std::, <fstream>)
+SYMBOL(wostringstream, std::, <sstream>)
+SYMBOL(wosyncstream, std::, <syncstream>)
+SYMBOL(wprintf, std::, <cwchar>)
+SYMBOL(wregex, std::, <regex>)
+SYMBOL(ws, std::, <istream>)
+SYMBOL(wscanf, std::, <cwchar>)
+SYMBOL(wsmatch, std::, <regex>)
+SYMBOL(wsregex_iterator, std::, <regex>)
+SYMBOL(wsregex_token_iterator, std::, <regex>)
+SYMBOL(wssub_match, std::, <regex>)
+SYMBOL(wstreambuf, std::, <streambuf>)
+SYMBOL(wstreampos, std::, <ios>)
+SYMBOL(wstring, std::, <string>)
+SYMBOL(wstring_convert, std::, <locale>)
+SYMBOL(wstring_view, std::, <string_view>)
+SYMBOL(wstringbuf, std::, <sstream>)
+SYMBOL(wstringstream, std::, <sstream>)
+SYMBOL(wsyncbuf, std::, <syncstream>)
+SYMBOL(yocto, std::, <ratio>)
+SYMBOL(yotta, std::, <ratio>)
+SYMBOL(zepto, std::, <ratio>)
+SYMBOL(zetta, std::, <ratio>)
Added: clang-tools-extra/trunk/clangd/include-mapping/gen_std.py
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/include-mapping/gen_std.py?rev=356134&view=auto
==============================================================================
--- clang-tools-extra/trunk/clangd/include-mapping/gen_std.py (added)
+++ clang-tools-extra/trunk/clangd/include-mapping/gen_std.py Thu Mar 14 04:25:26 2019
@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+#===- gen_std.py - ------------------------------------------*- python -*--===#
+#
+# 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
+#
+#===------------------------------------------------------------------------===#
+
+"""gen_std.py is a tool to generate a lookup table (from qualified names to
+include headers) for C++ Standard Library symbols by parsing archieved HTML
+files from cppreference.
+
+Caveats and FIXMEs:
+ - only symbols directly in "std" namespace are added, we should also add std's
+ subnamespace symbols (e.g. chrono).
+ - symbols with multiple variants or defined in multiple headers aren't added,
+ e.g. std::move, std::swap
+
+Usage:
+ 1. Install BeautifulSoup dependency, see instruction:
+ https://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-beautiful-soup
+ 2. Download cppreference offline HTML files (e.g. html_book_20181028.zip) at
+ https://en.cppreference.com/w/Cppreference:Archives
+ 3. Unzip the zip file from step 2 to directory </cppreference>, you should
+ get a "reference" directory in </cppreference>
+ 4. Run the command:
+ gen_std.py -cppreference </cppreference/reference> > StdSymbolMap.inc
+"""
+
+from bs4 import BeautifulSoup
+
+import argparse
+import datetime
+import os
+import sys
+
+STDGEN_CODE_PREFIX = """\
+//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
+//
+// Used to build a lookup table (qualified names => include headers) for C++
+// Standard Library symbols.
+//
+// Automatically generated file, DO NOT EDIT!
+//
+// Generated from cppreference offline HTML book (modified on %s).
+//===----------------------------------------------------------------------===//
+"""
+
+def ParseSymbolPage(symbol_page_html):
+ """Parse symbol page and retrieve the include header defined in this page.
+ The symbol page provides header for the symbol, specifically in
+ "Defined in header <header>" section. An example:
+
+ <tr class="t-dsc-header">
+ <td colspan="2"> <div>Defined in header <code><ratio></code> </div>
+ </td></tr>
+
+ Returns a list of headers.
+ """
+ headers = []
+
+ soup = BeautifulSoup(symbol_page_html, "html.parser")
+ # "Defined in header " are defined in <tr class="t-dsc-header"> or
+ # <tr class="t-dcl-header">.
+ for header_tr in soup.select('tr.t-dcl-header,tr.t-dsc-header'):
+ if "Defined in header " in header_tr.text:
+ # The interesting header content (e.g. <cstdlib>) is wrapped in <code>.
+ for header_code in header_tr.find_all("code"):
+ headers.append(header_code.text)
+ return headers
+
+
+def ParseIndexPage(index_page_html):
+ """Parse index page.
+ The index page lists all std symbols and hrefs to their detailed pages
+ (which contain the defined header). An example:
+
+ <a href="abs.html" title="abs"><tt>abs()</tt></a> (int) <br>
+ <a href="acos.html" title="acos"><tt>acos()</tt></a> <br>
+
+ Returns a list of tuple (symbol_name, relative_path_to_symbol_page).
+ """
+ symbols = []
+ soup = BeautifulSoup(index_page_html, "html.parser")
+ for symbol_href in soup.select("a[title]"):
+ symbol_tt = symbol_href.find("tt")
+ if symbol_tt:
+ symbols.append((symbol_tt.text.rstrip("<>()"), # strip any trailing <>()
+ symbol_href["href"]))
+ return symbols
+
+
+def ParseArg():
+ parser = argparse.ArgumentParser(description='Generate StdGen file')
+ parser.add_argument('-cppreference', metavar='PATH',
+ default='',
+ help='path to the cppreference offline HTML directory',
+ required=True
+ )
+ return parser.parse_args()
+
+
+def main():
+ args = ParseArg()
+ cpp_reference_root = args.cppreference
+ cpp_symbol_root = os.path.join(cpp_reference_root, "en", "cpp")
+ index_page_path = os.path.join(cpp_symbol_root, "symbol_index.html")
+ if not os.path.exists(index_page_path):
+ exit("Path %s doesn't exist!" % index_page_path)
+
+ # We don't have version information from the unzipped offline HTML files.
+ # so we use the modified time of the symbol_index.html as the version.
+ cppreference_modified_date = datetime.datetime.fromtimestamp(
+ os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
+
+ # Workflow steps:
+ # 1. Parse index page which lists all symbols to get symbol
+ # name (unqualified name) and its href link to the symbol page which
+ # contains the defined header.
+ # 2. Parse the symbol page to get the defined header.
+
+ # A map from symbol name to a set of headers.
+ symbols = {}
+ with open(index_page_path, "r") as f:
+ for symbol_name, symbol_page_path in ParseIndexPage(f.read()):
+ with open(os.path.join(cpp_symbol_root, symbol_page_path), "r") as f:
+ headers = ParseSymbolPage(f.read())
+ if not headers:
+ sys.stderr.write("No header found for symbol %s at %s\n" % (symbol_name,
+ symbol_page_path))
+ continue
+
+ if symbol_name not in symbols:
+ symbols[symbol_name] = set()
+ symbols[symbol_name].update(headers)
+
+ # Emit results to stdout.
+ print STDGEN_CODE_PREFIX % cppreference_modified_date
+ for name, headers in sorted(symbols.items(), key=lambda t : t[0]):
+ if len(headers) > 1:
+ # FIXME: support symbols with multiple headers (e.g. std::move).
+ continue
+ # SYMBOL(unqualified_name, namespace, header)
+ print "SYMBOL(%s, %s, %s)" % (name, "std::", list(headers)[0])
+
+
+if __name__ == '__main__':
+ main()
Propchange: clang-tools-extra/trunk/clangd/include-mapping/gen_std.py
------------------------------------------------------------------------------
svn:executable = *
Added: clang-tools-extra/trunk/clangd/include-mapping/test.py
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/include-mapping/test.py?rev=356134&view=auto
==============================================================================
--- clang-tools-extra/trunk/clangd/include-mapping/test.py (added)
+++ clang-tools-extra/trunk/clangd/include-mapping/test.py Thu Mar 14 04:25:26 2019
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+#===- test.py - ---------------------------------------------*- python -*--===#
+#
+# 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
+#
+#===------------------------------------------------------------------------===#
+
+from gen_std import ParseSymbolPage, ParseIndexPage
+
+import unittest
+
+class TestStdGen(unittest.TestCase):
+
+ def testParseIndexPage(self):
+ html = """
+ <a href="abs.html" title="abs"><tt>abs()</tt></a> (int) <br>
+ <a href="complex/abs.html" title="abs"><tt>abs<>()</tt></a> (std::complex) <br>
+ <a href="acos.html" title="acos"><tt>acos()</tt></a> <br>
+ <a href="acosh.html" title="acosh"><tt>acosh()</tt></a> <span class="t-mark-rev">(since C++11)</span> <br>
+ <a href="as_bytes.html" title="as bytes"><tt>as_bytes<>()</tt></a> <span class="t-mark-rev t-since-cxx20">(since C++20)</span> <br>
+ """
+
+ actual = ParseIndexPage(html)
+ expected = [
+ ("abs", "abs.html"),
+ ("abs", "complex/abs.html"),
+ ("acos", "acos.html"),
+ ("acosh", "acosh.html"),
+ ("as_bytes", "as_bytes.html"),
+ ]
+ self.assertEqual(len(actual), len(expected))
+ for i in range(0, len(actual)):
+ self.assertEqual(expected[i][0], actual[i][0])
+ self.assertTrue(actual[i][1].endswith(expected[i][1]))
+
+
+ def testParseSymbolPage_SingleHeader(self):
+ # Defined in header <cmath>
+ html = """
+ <table class="t-dcl-begin"><tbody>
+ <tr class="t-dsc-header">
+ <td> <div>Defined in header <code><a href="cmath.html" title="cmath"><cmath></a></code>
+ </div></td>
+ <td></td>
+ <td></td>
+ </tr>
+</tbody></table>
+"""
+ self.assertEqual(ParseSymbolPage(html), ['<cmath>'])
+
+
+ def testParseSymbolPage_MulHeaders(self):
+ # Defined in header <cstddef>
+ # Defined in header <cstdio>
+ # Defined in header <cstdlib>
+ html = """
+<table class="t-dcl-begin"><tbody>
+ <tr class="t-dsc-header">
+ <td> <div>Defined in header <code><a href="cstddef.html" title="cstddef"><cstddef></a></code>
+ </div></td>
+ <td></td>
+ <td></td>
+ </tr>
+ <tr class="t-dsc-header">
+ <td> <div>Defined in header <code><a href="cstdio.html" title="cstdio"><cstdio></a></code>
+ </div></td>
+ <td></td>
+ <td></td>
+ </tr>
+ <tr class="t-dsc-header">
+ <td> <div>Defined in header <code><a href=".cstdlib.html" title="ccstdlib"><cstdlib></a></code>
+ </div></td>
+ <td></td>
+ <td></td>
+ </tr>
+</tbody></table>
+"""
+ self.assertEqual(ParseSymbolPage(html),
+ ['<cstddef>', '<cstdio>', '<cstdlib>'])
+
+
+ def testParseSymbolPage_MulHeadersInSameDiv(self):
+ # Multile <code> blocks in a Div.
+ # Defined in header <algorithm>
+ # Defined in header <utility>
+ html = """
+<tr class="t-dsc-header">
+<td><div>
+ Defined in header <code><a href="../header/algorithm.html" title="cpp/header/algorithm"><algorithm></a></code><br>
+ Defined in header <code><a href="../header/utility.html" title="cpp/header/utility"><utility></a></code>
+</div></td>
+<td></td>
+</tr>
+"""
+ self.assertEqual(ParseSymbolPage(html), ['<algorithm>', '<utility>'])
+
+
+if __name__ == '__main__':
+ unittest.main()
Propchange: clang-tools-extra/trunk/clangd/include-mapping/test.py
------------------------------------------------------------------------------
svn:executable = *
Modified: clang-tools-extra/trunk/clangd/index/CanonicalIncludes.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/index/CanonicalIncludes.cpp?rev=356134&r1=356133&r2=356134&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/index/CanonicalIncludes.cpp (original)
+++ clang-tools-extra/trunk/clangd/index/CanonicalIncludes.cpp Thu Mar 14 04:25:26 2019
@@ -107,57 +107,30 @@ collectIWYUHeaderMaps(CanonicalIncludes
void addSystemHeadersMapping(CanonicalIncludes *Includes) {
static const std::vector<std::pair<const char *, const char *>> SymbolMap = {
- {"std::addressof", "<memory>"},
// Map symbols in <iosfwd> to their preferred includes.
{"std::basic_filebuf", "<fstream>"},
- {"std::basic_fstream", "<fstream>"},
- {"std::basic_ifstream", "<fstream>"},
- {"std::basic_ofstream", "<fstream>"},
{"std::filebuf", "<fstream>"},
- {"std::fstream", "<fstream>"},
- {"std::ifstream", "<fstream>"},
- {"std::ofstream", "<fstream>"},
{"std::wfilebuf", "<fstream>"},
- {"std::wfstream", "<fstream>"},
- {"std::wifstream", "<fstream>"},
- {"std::wofstream", "<fstream>"},
- {"std::basic_ios", "<ios>"},
- {"std::ios", "<ios>"},
- {"std::wios", "<ios>"},
- {"std::basic_iostream", "<iostream>"},
- {"std::iostream", "<iostream>"},
- {"std::wiostream", "<iostream>"},
{"std::basic_istream", "<istream>"},
{"std::istream", "<istream>"},
{"std::wistream", "<istream>"},
- {"std::istreambuf_iterator", "<iterator>"},
- {"std::ostreambuf_iterator", "<iterator>"},
{"std::basic_ostream", "<ostream>"},
{"std::ostream", "<ostream>"},
{"std::wostream", "<ostream>"},
- {"std::basic_istringstream", "<sstream>"},
- {"std::basic_ostringstream", "<sstream>"},
- {"std::basic_stringbuf", "<sstream>"},
- {"std::basic_stringstream", "<sstream>"},
- {"std::istringstream", "<sstream>"},
- {"std::ostringstream", "<sstream>"},
- {"std::string", "<string>"},
- {"std::stringbuf", "<sstream>"},
- {"std::stringstream", "<sstream>"},
- {"std::wistringstream", "<sstream>"},
- {"std::wostringstream", "<sstream>"},
- {"std::wstringbuf", "<sstream>"},
- {"std::wstringstream", "<sstream>"},
- {"std::basic_streambuf", "<streambuf>"},
- {"std::streambuf", "<streambuf>"},
- {"std::wstreambuf", "<streambuf>"},
{"std::uint_least16_t", "<cstdint>"}, // <type_traits> redeclares these
{"std::uint_least32_t", "<cstdint>"},
- {"std::declval", "<utility>"},
+#define SYMBOL(Name, NameSpace, Header) { #NameSpace#Name, #Header },
+ #include "StdSymbolMap.inc"
+#undef SYMBOL
};
for (const auto &Pair : SymbolMap)
Includes->addSymbolMapping(Pair.first, Pair.second);
+ // FIXME: remove the std header mapping once we support ambiguous symbols, now
+ // it serves as a fallback to disambiguate:
+ // - symbols with mulitiple headers (e.g. std::move)
+ // - symbols with a primary template in one header and a specialization in
+ // another (std::abs)
static const std::vector<std::pair<const char *, const char *>>
SystemHeaderMap = {
{"include/__stddef_max_align_t.h", "<cstddef>"},
More information about the cfe-commits
mailing list