Index: clangd/StdGen/.gitignore =================================================================== --- /dev/null +++ clangd/StdGen/.gitignore @@ -0,0 +1,2 @@ +node_modules +reference Index: clangd/StdGen/Readme.md =================================================================== --- /dev/null +++ clangd/StdGen/Readme.md @@ -0,0 +1,18 @@ +# StdGen + +StdGen is a tool to generate headers for C++ Standard Library symbols by parsing +archieved HTML files from [cppreference](http://cppreference.com/). + +## Usage + +### Requriement + +* Download the cppreference [offline HTML files](https://en.cppreference.com/w/Cppreference:Archives), +and unzip it to the `/reference` directory. + +### Step + +```shell +$ npm install +$ node lib/main.js > Symbols.inc +``` Index: clangd/StdGen/lib/config.js =================================================================== --- /dev/null +++ clangd/StdGen/lib/config.js @@ -0,0 +1,17 @@ +const fs = require('fs') +const path = require('path') + +const srcDir = path.dirname(__dirname) +const cppReferenceRoot = path.join(srcDir, 'reference'); +const cppSymbolRoot = path.join(cppReferenceRoot, 'en/cpp/') +const cppSymbolIndexPath = path.join(cppSymbolRoot, 'symbol_index.html') + +if (!fs.existsSync(cppReferenceRoot)) { + console.error('Please download the cppreference offline copy.') + process.exit(1); +} + +module.exports = { + cppSymbolIndexPath, + cppSymbolRoot, +} Index: clangd/StdGen/lib/main.js =================================================================== --- /dev/null +++ clangd/StdGen/lib/main.js @@ -0,0 +1,85 @@ +const $ = require('cheerio') +const fs = require('fs') +const path = require('path') + +const { cppSymbolRoot, cppSymbolIndexPath } = require('./config') +const { retrieveDefinedHeaders, parseSymbolIndexPage } = require('./parse') + +class Symbol { + constructor(name, namespace, headers) { + this.name = name // unqualifed name, e.g. std::move + this.namespace = namespace // namespace, e.g. std::, std::pmr + this.headers = headers // array of headers + } +} + +function readFile(path) { + return new Promise((resolve, reject) => { + fs.readFile(path, (err, data) => { + if (err) reject(err) + else resolve(data) + }) + }) +} + +async function process() { + // Workflow steps: + // 1. Parse the index page which lists all symbols, and extract symbol + // name (unqualified name) and its href link to the detailed page which + // contains the defined header. + // 2. Parse the detailed page to get the defined header. + let indexPageHTML = await readFile(cppSymbolIndexPath) + const symbolData = parseSymbolIndexPage(indexPageHTML) + // A map from symbol name to its headers. + const Symbols = new Map() + for (let symbol of symbolData) { + const symbolName = symbol.name + const symbolPagePath = symbol.pagePath + + const symbolPageHTML = await readFile(symbolPagePath) + const headers = retrieveDefinedHeaders(symbolPageHTML) + if (headers.length == 0) { + console.error(new Error('No header found for symbol: ' + symbolName + ` at ` + symbolPagePath)) + continue + } + // FIXME: support ambiguous symbols. + if (headers.length != 1) { + continue + } + + let symbolHeaders = Symbols.get(symbolName) + if (!symbolHeaders) { + symbolHeaders = new Set(headers) + Symbols.set(symbolName, symbolHeaders) + } + for (let header of headers) + symbolHeaders.add(header) + } + const Results = [] + Symbols.forEach((headers, symbolName) => { + Results.push(new Symbol(symbolName, 'std::', Array.from(headers))) + }) + emitResults(Results) +} + +function emitResults(symbols) { + console.log(`//===-- StdGen'erated file --------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// Used to build a map (qualified names => include headers) for all symbols from +// C++ Standard Library (up to C++17). +// +// Automatically generated file, do not edit. +//===----------------------------------------------------------------------===// +`) + symbols.filter(symbol => symbol.headers.length == 1).forEach(sym => { + for (let header of sym.headers) + console.log(`SYMBOL(%s, %s, %s)`, sym.name, sym.namespace, header) + }) +} + +process() Index: clangd/StdGen/lib/parse.js =================================================================== --- /dev/null +++ clangd/StdGen/lib/parse.js @@ -0,0 +1,65 @@ +const $ = require('cheerio') +const path = require('path') + +const { cppSymbolRoot } = require('./config') + +function retrieveDefinedHeaders(htmlContent) { + // In the symbol detailed page, we have canonical "Defined in header <...>" + // words, which is defined in /. + // so we try to retrieve the header from this HTML element. + const headerSelector = 'tr.t-dcl-header, tr.t-dsc-header:contains("Defined in header ")' + const headerTrElements = $.load(htmlContent)(headerSelector) + const headers = [] + headerTrElements.each((_, element) => { + // The interesting header content (e.g. ) is wrapped in tag. + headers.push($('code', element).text()) + }) + return headers +} + +function retrieveSymbolData(ttElement) { + if (ttElement.name != 'tt') { + console.error('The input parameter should be element: ' + ttElement) + return null + } + + const hrefElement = ttElement.parent + // Iterate following sibling elements to see whether there is + // a revision label like "since C++11" after the symbol name. + let revision = "" + $(hrefElement).nextUntil('br', (_, spanElement) => { + // An element contains the symbol revision. + if ($(spanElement).hasClass('t-mark-rev')) { + const matched = $(spanElement).text().match(/since (C\+\+[\d]{2})/) + if (matched) { + revision = matched[1] + } + } + }) + // Skip C++20 symbols as C++20 is not finalized yet. + if (revision == 'C++20') + return null + return { + name: $(ttElement).text().match(/\w+/g)[0], + pagePath: path.join(cppSymbolRoot, hrefElement.attribs['href']) + } +} + +// Parse the symbol index page. Returns an array of +// {name: , pagePath: } objects. +function parseSymbolIndexPage(htmlContent) { + let results = [] + const allSymbolTtElements = $.load(htmlContent)('a[title] > tt').get() + for (let symbolTtElement of allSymbolTtElements) { + const symbolData = retrieveSymbolData(symbolTtElement) + if (!symbolData) + continue + results.push(symbolData) + } + return results +} + +module.exports = { + parseSymbolIndexPage, + retrieveDefinedHeaders, +} Index: clangd/StdGen/package.json =================================================================== --- /dev/null +++ clangd/StdGen/package.json @@ -0,0 +1,20 @@ +{ + "name": "StlGen", + "version": "0.0.1", + "description": "generate headers for C++ Standard Library symbols from cppreference", + "scripts": { + "gen": "node lib/main.js", + "test": "./node_modules/mocha/bin/mocha spec/*.js" + }, + "keywords": [ + "C++", + "cppreference", + "STL" + ], + "dependencies": { + "cheerio": "^1.0.0-rc.2" + }, + "devDependencies": { + "mocha": "^6.0.0" + } +} Index: clangd/StdGen/spec/test.js =================================================================== --- /dev/null +++ clangd/StdGen/spec/test.js @@ -0,0 +1,80 @@ +const assert = require("assert") +const { retrieveDefinedHeaders, parseSymbolIndexPage } = require('../lib/parse') + +describe('generate std symbol', () => { + describe('parse symbol index page', () => { + it('should parse index page', () => { + // A fake symbol index page: + // abs() (int) + // abs<>() (std::complex) + // acos() + // acosh() (since C++11) + // as_bytes() (since C++20) <-- ignored + const symbolIndexPageHTML = ` + abs() (int)
+ abs<>() (std::complex)
+ acos()
+ acosh() (since C++11)
+ as_bytes<>() (since C++20)
+ ` + const SymbolData = parseSymbolIndexPage(symbolIndexPageHTML) + assert.equal(4, SymbolData.length); + const expected = [ + { name: 'abs', pagePath: 'abs.html' }, + { name: 'abs', pagePath: 'complex/abs.html' }, + { name: 'acos', pagePath: 'acos.html' }, + { name: 'acosh', pagePath: 'acosh.html' } + ] + for (let i = 0; i < SymbolData.length; ++i) { + assert.equal(SymbolData[i].name, expected[i].name) + assert.ok(SymbolData[i].pagePath.endsWith(expected[i].pagePath)) + } + }); + }) + + describe('parse symbol page', () => { + it('should get single header', () => { + // Defined in header + const symbolPageHTML = ` + + + + + + +
Defined in header <cmath> +
` + const headers = retrieveDefinedHeaders(symbolPageHTML) + assert.deepEqual(headers, ['']) + }) + it('should get multiple headers', () => { + // Defined in header + // Defined in header + // Defined in header + const symbolPageHTML = ` + + + + + + + + + + + + + + + + +
Defined in header <cstddef> +
Defined in header <cstdio> +
Defined in header <cstdlib> +
+ ` + assert.deepEqual(retrieveDefinedHeaders(symbolPageHTML), + ['', '', '']) + }) + }) +}) Index: clangd/StdSymbolMap.inc =================================================================== --- /dev/null +++ clangd/StdSymbolMap.inc @@ -0,0 +1,1022 @@ +//===-- StdGen'erated file --------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// Used to build a map (qualified names => include headers) for all symbols from +// C++ Standard Library (up to C++17). +// +// Automatically generated file, do not edit. +//===----------------------------------------------------------------------===// + +SYMBOL(_Exit, std::, ) +SYMBOL(accumulate, std::, ) +SYMBOL(add_const, std::, ) +SYMBOL(add_const_t, std::, ) +SYMBOL(add_cv, std::, ) +SYMBOL(add_cv_t, std::, ) +SYMBOL(add_pointer, std::, ) +SYMBOL(add_pointer_t, std::, ) +SYMBOL(add_lvalue_reference, std::, ) +SYMBOL(add_lvalue_reference_t, std::, ) +SYMBOL(addressof, std::, ) +SYMBOL(add_rvalue_reference, std::, ) +SYMBOL(add_rvalue_reference_t, std::, ) +SYMBOL(add_volatile, std::, ) +SYMBOL(add_volatile_t, std::, ) +SYMBOL(adjacent_difference, std::, ) +SYMBOL(adjacent_find, std::, ) +SYMBOL(adopt_lock, std::, ) +SYMBOL(adopt_lock_t, std::, ) +SYMBOL(advance, std::, ) +SYMBOL(align, std::, ) +SYMBOL(aligned_alloc, std::, ) +SYMBOL(aligned_storage, std::, ) +SYMBOL(aligned_storage_t, std::, ) +SYMBOL(aligned_union, std::, ) +SYMBOL(aligned_union_t, std::, ) +SYMBOL(alignment_of, std::, ) +SYMBOL(alignment_of_v, std::, ) +SYMBOL(align_val_t, std::, ) +SYMBOL(all_of, std::, ) +SYMBOL(allocate_shared, std::, ) +SYMBOL(allocator, std::, ) +SYMBOL(allocator_arg, std::, ) +SYMBOL(allocator_arg_t, std::, ) +SYMBOL(allocator_traits, std::, ) +SYMBOL(any, std::, ) +SYMBOL(any_of, std::, ) +SYMBOL(apply, std::, ) +SYMBOL(arg, std::, ) +SYMBOL(array, std::, ) +SYMBOL(as_const, std::, ) +SYMBOL(asctime, std::, ) +SYMBOL(async, std::, ) +SYMBOL(at_quick_exit, std::, ) +SYMBOL(atexit, std::, ) +SYMBOL(atof, std::, ) +SYMBOL(atoi, std::, ) +SYMBOL(atol, std::, ) +SYMBOL(atoll, std::, ) +SYMBOL(atomic_compare_exchange_strong, std::, ) +SYMBOL(atomic_compare_exchange_strong_explicit, std::, ) +SYMBOL(atomic_compare_exchange_weak, std::, ) +SYMBOL(atomic_compare_exchange_weak_explicit, std::, ) +SYMBOL(atomic_exchange, std::, ) +SYMBOL(atomic_exchange_explicit, std::, ) +SYMBOL(atomic_fetch_add, std::, ) +SYMBOL(atomic_fetch_add_explicit, std::, ) +SYMBOL(atomic_fetch_and, std::, ) +SYMBOL(atomic_fetch_and_explicit, std::, ) +SYMBOL(atomic_fetch_or, std::, ) +SYMBOL(atomic_fetch_or_explicit, std::, ) +SYMBOL(atomic_fetch_sub, std::, ) +SYMBOL(atomic_fetch_sub_explicit, std::, ) +SYMBOL(atomic_fetch_xor, std::, ) +SYMBOL(atomic_fetch_xor_explicit, std::, ) +SYMBOL(atomic_flag, std::, ) +SYMBOL(atomic_flag_clear, std::, ) +SYMBOL(atomic_flag_clear_explicit, std::, ) +SYMBOL(atomic_flag_test_and_set, std::, ) +SYMBOL(atomic_flag_test_and_set_explicit, std::, ) +SYMBOL(atomic_init, std::, ) +SYMBOL(atomic_is_lockfree, std::, ) +SYMBOL(atomic_load, std::, ) +SYMBOL(atomic_load_explicit, std::, ) +SYMBOL(atomic_signal_fence, std::, ) +SYMBOL(atomic_store, std::, ) +SYMBOL(atomic_store_explicit, std::, ) +SYMBOL(atomic_thread_fence, std::, ) +SYMBOL(auto_ptr, std::, ) +SYMBOL(back_inserter, std::, ) +SYMBOL(back_insert_iterator, std::, ) +SYMBOL(bad_alloc, std::, ) +SYMBOL(bad_any_cast, std::, ) +SYMBOL(bad_array_new_length, std::, ) +SYMBOL(bad_cast, std::, ) +SYMBOL(bad_exception, std::, ) +SYMBOL(bad_function_call, std::, ) +SYMBOL(bad_optional_access, std::, ) +SYMBOL(bad_typeid, std::, ) +SYMBOL(bad_variant_access, std::, ) +SYMBOL(bad_weak_ptr, std::, ) +SYMBOL(basic_ios, std::, ) +SYMBOL(begin, std::, ) +SYMBOL(bernoulli_distribution, std::, ) +SYMBOL(bidirectional_iterator_tag, std::, ) +SYMBOL(binary_search, std::, ) +SYMBOL(bind, std::, ) +SYMBOL(binomial_distribution, std::, ) +SYMBOL(bit_and, std::, ) +SYMBOL(bit_or, std::, ) +SYMBOL(bit_not, std::, ) +SYMBOL(bit_xor, std::, ) +SYMBOL(bitset, std::, ) +SYMBOL(boolalpha, std::, ) +SYMBOL(boyer_moore_horspool_searcher, std::, ) +SYMBOL(boyer_moore_searcher, std::, ) +SYMBOL(bsearch, std::, ) +SYMBOL(btowc, std::, ) +SYMBOL(byte, std::, ) +SYMBOL(c16rtomb, std::, ) +SYMBOL(c32rtomb, std::, ) +SYMBOL(call_once, std::, ) +SYMBOL(calloc, std::, ) +SYMBOL(cauchy_distribution, std::, ) +SYMBOL(cbegin, std::, ) +SYMBOL(cbrt, std::, ) +SYMBOL(ceil, std::, ) +SYMBOL(cend, std::, ) +SYMBOL(cerr, std::, ) +SYMBOL(char_traits, std::, ) +SYMBOL(chars_format, std::, ) +SYMBOL(chi_squared_distribution, std::, ) +SYMBOL(cin, std::, ) +SYMBOL(clamp, std::, ) +SYMBOL(clearerr, std::, ) +SYMBOL(clock, std::, ) +SYMBOL(clock_t, std::, ) +SYMBOL(clog, std::, ) +SYMBOL(codecvt_base, std::, ) +SYMBOL(codecvt_utf16, std::, ) +SYMBOL(codecvt_utf8, std::, ) +SYMBOL(codecvt_utf8_utf16, std::, ) +SYMBOL(common_type, std::, ) +SYMBOL(common_type_t, std::, ) +SYMBOL(complex, std::, ) +SYMBOL(conditional, std::, ) +SYMBOL(conditional_t, std::, ) +SYMBOL(condition_variable, std::, ) +SYMBOL(condition_variable_any, std::, ) +SYMBOL(conjunction, std::, ) +SYMBOL(conjunction_v, std::, ) +SYMBOL(conj, std::, ) +SYMBOL(copy, std::, ) +SYMBOL(copy_backward, std::, ) +SYMBOL(copy_if, std::, ) +SYMBOL(copy_n, std::, ) +SYMBOL(copysign, std::, ) +SYMBOL(const_pointer_cast, std::, ) +SYMBOL(count, std::, ) +SYMBOL(count_if, std::, ) +SYMBOL(cout, std::, ) +SYMBOL(crbegin, std::, ) +SYMBOL(cref, std::, ) +SYMBOL(cregex_iterator, std::, ) +SYMBOL(crend, std::, ) +SYMBOL(ctime, std::, ) +SYMBOL(ctype_base, std::, ) +SYMBOL(current_exception, std::, ) +SYMBOL(cv_status, std::, ) +SYMBOL(data, std::, ) +SYMBOL(dec, std::, ) +SYMBOL(decay, std::, ) +SYMBOL(decay_t, std::, ) +SYMBOL(declare_no_pointers, std::, ) +SYMBOL(declare_reachable, std::, ) +SYMBOL(declval, std::, ) +SYMBOL(default_delete, std::, ) +SYMBOL(default_searcher, std::, ) +SYMBOL(defaultfloat, std::, ) +SYMBOL(defer_lock, std::, ) +SYMBOL(defer_lock_t, std::, ) +SYMBOL(denorm_absent, std::, ) +SYMBOL(denorm_indeterminate, std::, ) +SYMBOL(denorm_present, std::, ) +SYMBOL(deque, std::, ) +SYMBOL(destroy, std::, ) +SYMBOL(destroy_at, std::, ) +SYMBOL(destroy_n, std::, ) +SYMBOL(difftime, std::, ) +SYMBOL(discrete_distribution, std::, ) +SYMBOL(discard_block_engine, std::, ) +SYMBOL(disjunction, std::, ) +SYMBOL(disjunction_v, std::, ) +SYMBOL(distance, std::, ) +SYMBOL(divides, std::, ) +SYMBOL(domain_error, std::, ) +SYMBOL(dynamic_pointer_cast, std::, ) +SYMBOL(empty, std::, ) +SYMBOL(enable_if, std::, ) +SYMBOL(enable_if_t, std::, ) +SYMBOL(enable_shared_from_this, std::, ) +SYMBOL(end, std::, ) +SYMBOL(endl, std::, ) +SYMBOL(ends, std::, ) +SYMBOL(equal, std::, ) +SYMBOL(equal_range, std::, ) +SYMBOL(equal_to, std::, ) +SYMBOL(erf, std::, ) +SYMBOL(erfc, std::, ) +SYMBOL(errc, std::, ) +SYMBOL(error_category, std::, ) +SYMBOL(error_code, std::, ) +SYMBOL(error_condition, std::, ) +SYMBOL(exception, std::, ) +SYMBOL(exception_ptr, std::, ) +SYMBOL(exchange, std::, ) +SYMBOL(exclusive_scan, std::, ) +SYMBOL(exit, std::, ) +SYMBOL(exp2, std::, ) +SYMBOL(expm1, std::, ) +SYMBOL(exponential_distribution, std::, ) +SYMBOL(extent, std::, ) +SYMBOL(extent_v, std::, ) +SYMBOL(extreme_value_distribution, std::, ) +SYMBOL(fclose, std::, ) +SYMBOL(fdim, std::, ) +SYMBOL(feclearexcept, std::, ) +SYMBOL(fegetenv, std::, ) +SYMBOL(fegetexceptflag, std::, ) +SYMBOL(fegetround, std::, ) +SYMBOL(feholdexcept, std::, ) +SYMBOL(fenv_t, std::, ) +SYMBOL(feof, std::, ) +SYMBOL(feraiseexcept, std::, ) +SYMBOL(ferror, std::, ) +SYMBOL(fesetenv, std::, ) +SYMBOL(fesetexceptflag, std::, ) +SYMBOL(fesetround, std::, ) +SYMBOL(fetestexcept, std::, ) +SYMBOL(feupdateenv, std::, ) +SYMBOL(fexcept_t, std::, ) +SYMBOL(fflush, std::, ) +SYMBOL(fgetc, std::, ) +SYMBOL(fgetpos, std::, ) +SYMBOL(fgets, std::, ) +SYMBOL(fgetwc, std::, ) +SYMBOL(fgetws, std::, ) +SYMBOL(fill, std::, ) +SYMBOL(fill_n, std::, ) +SYMBOL(find, std::, ) +SYMBOL(find_end, std::, ) +SYMBOL(find_first_of, std::, ) +SYMBOL(find_if, std::, ) +SYMBOL(find_if_not, std::, ) +SYMBOL(fisher_f_distribution, std::, ) +SYMBOL(fixed, std::, ) +SYMBOL(float_denorm_style, std::, ) +SYMBOL(float_round_style, std::, ) +SYMBOL(floor, std::, ) +SYMBOL(flush, std::, ) +SYMBOL(fma, std::, ) +SYMBOL(fmax, std::, ) +SYMBOL(fmin, std::, ) +SYMBOL(fmod, std::, ) +SYMBOL(fopen, std::, ) +SYMBOL(for_each, std::, ) +SYMBOL(for_each_n, std::, ) +SYMBOL(forward, std::, ) +SYMBOL(forward_as_tuple, std::, ) +SYMBOL(forward_iterator_tag, std::, ) +SYMBOL(forward_list, std::, ) +SYMBOL(fpclassify, std::, ) +SYMBOL(fpos, std::, ) +SYMBOL(fprintf, std::, ) +SYMBOL(fputc, std::, ) +SYMBOL(fputs, std::, ) +SYMBOL(fputwc, std::, ) +SYMBOL(fputws, std::, ) +SYMBOL(fread, std::, ) +SYMBOL(free, std::, ) +SYMBOL(freopen, std::, ) +SYMBOL(frexp, std::, ) +SYMBOL(front_inserter, std::, ) +SYMBOL(front_insert_iterator, std::, ) +SYMBOL(from_chars, std::, ) +SYMBOL(fscanf, std::, ) +SYMBOL(fseek, std::, ) +SYMBOL(fsetpos, std::, ) +SYMBOL(ftell, std::, ) +SYMBOL(function, std::, ) +SYMBOL(future, std::, ) +SYMBOL(future_category, std::, ) +SYMBOL(future_errc, std::, ) +SYMBOL(future_error, std::, ) +SYMBOL(future_status, std::, ) +SYMBOL(fwide, std::, ) +SYMBOL(fwprintf, std::, ) +SYMBOL(fwrite, std::, ) +SYMBOL(fwscanf, std::, ) +SYMBOL(gamma_distribution, std::, ) +SYMBOL(gcd, std::, ) +SYMBOL(generate, std::, ) +SYMBOL(generate_canonical, std::, ) +SYMBOL(generate_n, std::, ) +SYMBOL(generic_category, std::, ) +SYMBOL(geometric_distribution, std::, ) +SYMBOL(get_if, std::, ) +SYMBOL(get_money, std::, ) +SYMBOL(get_new_handler, std::, ) +SYMBOL(get_pointer_safety, std::, ) +SYMBOL(get_terminate, std::, ) +SYMBOL(get_time, std::, ) +SYMBOL(getc, std::, ) +SYMBOL(getchar, std::, ) +SYMBOL(getenv, std::, ) +SYMBOL(gets, std::, ) +SYMBOL(getwc, std::, ) +SYMBOL(getwchar, std::, ) +SYMBOL(gmtime, std::, ) +SYMBOL(greater, std::, ) +SYMBOL(greater_equal, std::, ) +SYMBOL(gslice, std::, ) +SYMBOL(gslice_array, std::, ) +SYMBOL(hardware_constructive_interference_size, std::, ) +SYMBOL(hardware_destructive_interference_size, std::, ) +SYMBOL(has_facet, std::, ) +SYMBOL(has_unique_object_representations, std::, ) +SYMBOL(has_unique_object_representations_v, std::, ) +SYMBOL(has_virtual_destructor, std::, ) +SYMBOL(has_virtual_destructor_v, std::, ) +SYMBOL(hex, std::, ) +SYMBOL(hexfloat, std::, ) +SYMBOL(holds_alternative, std::, ) +SYMBOL(hypot, std::, ) +SYMBOL(ignore, std::, ) +SYMBOL(ilogb, std::, ) +SYMBOL(imag, std::, ) +SYMBOL(includes, std::, ) +SYMBOL(inclusive_scan, std::, ) +SYMBOL(independent_bits_engine, std::, ) +SYMBOL(indirect_array, std::, ) +SYMBOL(inner_product, std::, ) +SYMBOL(in_place, std::, ) +SYMBOL(in_place_index, std::, ) +SYMBOL(in_place_index_t, std::, ) +SYMBOL(in_place_t, std::, ) +SYMBOL(inplace_merge, std::, ) +SYMBOL(in_place_type, std::, ) +SYMBOL(in_place_type_t, std::, ) +SYMBOL(input_iterator_tag, std::, ) +SYMBOL(inserter, std::, ) +SYMBOL(insert_iterator, std::, ) +SYMBOL(integer_sequence, std::, ) +SYMBOL(internal, std::, ) +SYMBOL(invalid_argument, std::, ) +SYMBOL(invoke, std::, ) +SYMBOL(invoke_result, std::, ) +SYMBOL(invoke_result_t, std::, ) +SYMBOL(ios, std::, ) +SYMBOL(io_errc, std::, ) +SYMBOL(ios_base, std::, ) +SYMBOL(iostream_category, std::, ) +SYMBOL(iota, std::, ) +SYMBOL(is_abstract, std::, ) +SYMBOL(is_abstract_v, std::, ) +SYMBOL(is_aggregate, std::, ) +SYMBOL(is_aggregate_v, std::, ) +SYMBOL(is_arithmetic, std::, ) +SYMBOL(is_arithmetic_v, std::, ) +SYMBOL(is_array, std::, ) +SYMBOL(is_array_v, std::, ) +SYMBOL(is_assignable, std::, ) +SYMBOL(is_assignable_v, std::, ) +SYMBOL(is_base_of, std::, ) +SYMBOL(is_base_of_v, std::, ) +SYMBOL(is_bind_expression, std::, ) +SYMBOL(is_bind_expression_v, std::, ) +SYMBOL(is_class, std::, ) +SYMBOL(is_class_v, std::, ) +SYMBOL(is_compound, std::, ) +SYMBOL(is_compound_v, std::, ) +SYMBOL(is_const, std::, ) +SYMBOL(is_constructible, std::, ) +SYMBOL(is_constructible_v, std::, ) +SYMBOL(is_const_v, std::, ) +SYMBOL(is_convertible, std::, ) +SYMBOL(is_convertible_v, std::, ) +SYMBOL(is_copy_assignable, std::, ) +SYMBOL(is_copy_assignable_v, std::, ) +SYMBOL(is_copy_constructible, std::, ) +SYMBOL(is_copy_constructible_v, std::, ) +SYMBOL(is_default_constructible, std::, ) +SYMBOL(is_default_constructible_v, std::, ) +SYMBOL(is_destructible, std::, ) +SYMBOL(is_destructible_v, std::, ) +SYMBOL(is_empty, std::, ) +SYMBOL(is_empty_v, std::, ) +SYMBOL(is_enum, std::, ) +SYMBOL(is_enum_v, std::, ) +SYMBOL(is_error_code_enum, std::, ) +SYMBOL(is_error_condition_enum, std::, ) +SYMBOL(is_error_condition_enum_v, std::, ) +SYMBOL(is_final, std::, ) +SYMBOL(is_final_v, std::, ) +SYMBOL(is_floating_point, std::, ) +SYMBOL(is_floating_point_v, std::, ) +SYMBOL(is_function, std::, ) +SYMBOL(is_function_v, std::, ) +SYMBOL(is_fundamental, std::, ) +SYMBOL(is_fundamental_v, std::, ) +SYMBOL(is_heap, std::, ) +SYMBOL(is_heap_until, std::, ) +SYMBOL(is_integral, std::, ) +SYMBOL(is_integral_v, std::, ) +SYMBOL(is_lvalue_reference, std::, ) +SYMBOL(is_lvalue_reference_v, std::, ) +SYMBOL(is_member_function_pointer, std::, ) +SYMBOL(is_member_function_pointer_v, std::, ) +SYMBOL(is_member_object_pointer, std::, ) +SYMBOL(is_member_object_pointer_v, std::, ) +SYMBOL(is_member_pointer, std::, ) +SYMBOL(is_member_pointer_v, std::, ) +SYMBOL(is_move_assignable, std::, ) +SYMBOL(is_move_assignable_v, std::, ) +SYMBOL(is_move_constructible, std::, ) +SYMBOL(is_move_constructible_v, std::, ) +SYMBOL(is_nothrow_assignable, std::, ) +SYMBOL(is_nothrow_assignable_v, std::, ) +SYMBOL(is_nothrow_constructible, std::, ) +SYMBOL(is_nothrow_constructible_v, std::, ) +SYMBOL(is_nothrow_copy_assignable, std::, ) +SYMBOL(is_nothrow_copy_assignable_v, std::, ) +SYMBOL(is_nothrow_copy_constructible, std::, ) +SYMBOL(is_nothrow_copy_constructible_v, std::, ) +SYMBOL(is_nothrow_default_constructible, std::, ) +SYMBOL(is_nothrow_default_constructible_v, std::, ) +SYMBOL(is_nothrow_destructible, std::, ) +SYMBOL(is_nothrow_destructible_v, std::, ) +SYMBOL(is_nothrow_move_assignable, std::, ) +SYMBOL(is_nothrow_move_assignable_v, std::, ) +SYMBOL(is_nothrow_move_constructible, std::, ) +SYMBOL(is_nothrow_move_constructible_v, std::, ) +SYMBOL(is_nothrow_swappable, std::, ) +SYMBOL(is_nothrow_swappable_v, std::, ) +SYMBOL(is_nothrow_swappable_with, std::, ) +SYMBOL(is_nothrow_swappable_with_v, std::, ) +SYMBOL(is_null_pointer, std::, ) +SYMBOL(is_null_pointer_v, std::, ) +SYMBOL(is_object, std::, ) +SYMBOL(is_object_v, std::, ) +SYMBOL(is_partitioned, std::, ) +SYMBOL(is_permutation, std::, ) +SYMBOL(is_placeholder, std::, ) +SYMBOL(is_placeholder_v, std::, ) +SYMBOL(is_pod, std::, ) +SYMBOL(is_pod_v, std::, ) +SYMBOL(is_pointer, std::, ) +SYMBOL(is_pointer_v, std::, ) +SYMBOL(is_polymorphic, std::, ) +SYMBOL(is_polymorphic_v, std::, ) +SYMBOL(is_reference, std::, ) +SYMBOL(is_reference_v, std::, ) +SYMBOL(is_rvalue_reference, std::, ) +SYMBOL(is_rvalue_reference_v, std::, ) +SYMBOL(is_same, std::, ) +SYMBOL(is_same_v, std::, ) +SYMBOL(is_scalar, std::, ) +SYMBOL(is_scalar_v, std::, ) +SYMBOL(is_signed, std::, ) +SYMBOL(is_signed_v, std::, ) +SYMBOL(is_sorted, std::, ) +SYMBOL(is_sorted_until, std::, ) +SYMBOL(is_standard_layout, std::, ) +SYMBOL(is_standard_layout_v, std::, ) +SYMBOL(is_swappable, std::, ) +SYMBOL(is_swappable_v, std::, ) +SYMBOL(is_swappable_with, std::, ) +SYMBOL(is_swappable_with_v, std::, ) +SYMBOL(is_trivial, std::, ) +SYMBOL(is_trivially_assignable, std::, ) +SYMBOL(is_trivially_assignable_v, std::, ) +SYMBOL(is_trivially_constructible, std::, ) +SYMBOL(is_trivially_constructible_v, std::, ) +SYMBOL(is_trivially_copyable, std::, ) +SYMBOL(is_trivially_copyable_v, std::, ) +SYMBOL(is_trivially_copy_assignable, std::, ) +SYMBOL(is_trivially_copy_assignable_v, std::, ) +SYMBOL(is_trivially_copy_constructible, std::, ) +SYMBOL(is_trivially_copy_constructible_v, std::, ) +SYMBOL(is_trivially_default_constructible, std::, ) +SYMBOL(is_trivially_default_constructible_v, std::, ) +SYMBOL(is_trivially_destructible, std::, ) +SYMBOL(is_trivially_destructible_v, std::, ) +SYMBOL(is_trivially_move_assignable, std::, ) +SYMBOL(is_trivially_move_assignable_v, std::, ) +SYMBOL(is_trivially_move_constructible, std::, ) +SYMBOL(is_trivially_move_constructible_v, std::, ) +SYMBOL(is_trivial_v, std::, ) +SYMBOL(is_union, std::, ) +SYMBOL(is_union_v, std::, ) +SYMBOL(is_unsigned, std::, ) +SYMBOL(is_unsigned_v, std::, ) +SYMBOL(is_void, std::, ) +SYMBOL(is_void_v, std::, ) +SYMBOL(is_volatile, std::, ) +SYMBOL(is_volatile_v, std::, ) +SYMBOL(isfinite, std::, ) +SYMBOL(isgreater, std::, ) +SYMBOL(isgreaterequal, std::, ) +SYMBOL(isinf, std::, ) +SYMBOL(isless, std::, ) +SYMBOL(islessequal, std::, ) +SYMBOL(islessgreater, std::, ) +SYMBOL(isnan, std::, ) +SYMBOL(isnormal, std::, ) +SYMBOL(istreambuf_iterator, std::, ) +SYMBOL(istream_iterator, std::, ) +SYMBOL(isunordered, std::, ) +SYMBOL(iswalnum, std::, ) +SYMBOL(iswalpha, std::, ) +SYMBOL(iswblank, std::, ) +SYMBOL(iswcntrl, std::, ) +SYMBOL(iswctype, std::, ) +SYMBOL(iswdigit, std::, ) +SYMBOL(iswgraph, std::, ) +SYMBOL(iswlower, std::, ) +SYMBOL(iswprint, std::, ) +SYMBOL(iswpunct, std::, ) +SYMBOL(iswspace, std::, ) +SYMBOL(iswupper, std::, ) +SYMBOL(iswxdigit, std::, ) +SYMBOL(iterator, std::, ) +SYMBOL(iterator_traits, std::, ) +SYMBOL(iter_swap, std::, ) +SYMBOL(jmp_buf, std::, ) +SYMBOL(kill_dependency, std::, ) +SYMBOL(launch, std::, ) +SYMBOL(launder, std::, ) +SYMBOL(lcm, std::, ) +SYMBOL(lconv, std::, ) +SYMBOL(ldexp, std::, ) +SYMBOL(left, std::, ) +SYMBOL(length_error, std::, ) +SYMBOL(less, std::, ) +SYMBOL(less_equal, std::, ) +SYMBOL(lexicographical_compare, std::, ) +SYMBOL(lgamma, std::, ) +SYMBOL(list, std::, ) +SYMBOL(llrint, std::, ) +SYMBOL(llround, std::, ) +SYMBOL(locale, std::, ) +SYMBOL(localeconv, std::, ) +SYMBOL(localtime, std::, ) +SYMBOL(lock, std::, ) +SYMBOL(lock_guard, std::, ) +SYMBOL(logb, std::, ) +SYMBOL(log1p, std::, ) +SYMBOL(log2, std::, ) +SYMBOL(logical_and, std::, ) +SYMBOL(logic_error, std::, ) +SYMBOL(lognormal_distribution, std::, ) +SYMBOL(logical_not, std::, ) +SYMBOL(logical_or, std::, ) +SYMBOL(longjmp, std::, ) +SYMBOL(lower_bound, std::, ) +SYMBOL(lrint, std::, ) +SYMBOL(lround, std::, ) +SYMBOL(make_exception_ptr, std::, ) +SYMBOL(make_from_tuple, std::, ) +SYMBOL(make_heap, std::, ) +SYMBOL(make_move_iterator, std::, ) +SYMBOL(make_optional, std::, ) +SYMBOL(make_pair, std::, ) +SYMBOL(make_reverse_iterator, std::, ) +SYMBOL(make_shared, std::, ) +SYMBOL(make_signed, std::, ) +SYMBOL(make_signed_t, std::, ) +SYMBOL(make_tuple, std::, ) +SYMBOL(make_unique, std::, ) +SYMBOL(make_unsigned, std::, ) +SYMBOL(make_unsigned_t, std::, ) +SYMBOL(malloc, std::, ) +SYMBOL(map, std::, ) +SYMBOL(mask_array, std::, ) +SYMBOL(max, std::, ) +SYMBOL(max_align_t, std::, ) +SYMBOL(max_element, std::, ) +SYMBOL(mblen, std::, ) +SYMBOL(mbrlen, std::, ) +SYMBOL(mbrtoc16, std::, ) +SYMBOL(mbrtoc32, std::, ) +SYMBOL(mbrtowc, std::, ) +SYMBOL(mbsinit, std::, ) +SYMBOL(mbsrtowcs, std::, ) +SYMBOL(mbstowcs, std::, ) +SYMBOL(mbtowc, std::, ) +SYMBOL(mem_fn, std::, ) +SYMBOL(memchr, std::, ) +SYMBOL(memcmp, std::, ) +SYMBOL(memcpy, std::, ) +SYMBOL(memmove, std::, ) +SYMBOL(memset, std::, ) +SYMBOL(merge, std::, ) +SYMBOL(messages_base, std::, ) +SYMBOL(min, std::, ) +SYMBOL(min_element, std::, ) +SYMBOL(minmax, std::, ) +SYMBOL(minmax_element, std::, ) +SYMBOL(minus, std::, ) +SYMBOL(mismatch, std::, ) +SYMBOL(mktime, std::, ) +SYMBOL(modf, std::, ) +SYMBOL(modulus, std::, ) +SYMBOL(money_base, std::, ) +SYMBOL(monostate, std::, ) +SYMBOL(move_backward, std::, ) +SYMBOL(move_if_noexcept, std::, ) +SYMBOL(move_iterator, std::, ) +SYMBOL(multimap, std::, ) +SYMBOL(multiplies, std::, ) +SYMBOL(multiset, std::, ) +SYMBOL(mutex, std::, ) +SYMBOL(nan, std::, ) +SYMBOL(nanf, std::, ) +SYMBOL(nanl, std::, ) +SYMBOL(nearbyint, std::, ) +SYMBOL(negate, std::, ) +SYMBOL(negation, std::, ) +SYMBOL(negation_v, std::, ) +SYMBOL(negative_binomial_distribution, std::, ) +SYMBOL(nested_exception, std::, ) +SYMBOL(new_handler, std::, ) +SYMBOL(next, std::, ) +SYMBOL(nextafter, std::, ) +SYMBOL(next_permutation, std::, ) +SYMBOL(nexttoward, std::, ) +SYMBOL(noboolalpha, std::, ) +SYMBOL(none_of, std::, ) +SYMBOL(norm, std::, ) +SYMBOL(normal_distribution, std::, ) +SYMBOL(noshowbase, std::, ) +SYMBOL(noshowpoint, std::, ) +SYMBOL(noshowpos, std::, ) +SYMBOL(noskipws, std::, ) +SYMBOL(not_equal_to, std::, ) +SYMBOL(not_fn, std::, ) +SYMBOL(nothrow, std::, ) +SYMBOL(nothrow_t, std::, ) +SYMBOL(notify_all_at_thread_exit, std::, ) +SYMBOL(nounitbuf, std::, ) +SYMBOL(nouppercase, std::, ) +SYMBOL(nth_element, std::, ) +SYMBOL(nullopt, std::, ) +SYMBOL(nullopt_t, std::, ) +SYMBOL(nullptr_t, std::, ) +SYMBOL(oct, std::, ) +SYMBOL(once_flag, std::, ) +SYMBOL(optional, std::, ) +SYMBOL(ostreambuf_iterator, std::, ) +SYMBOL(ostream_iterator, std::, ) +SYMBOL(out_of_range, std::, ) +SYMBOL(output_iterator_tag, std::, ) +SYMBOL(overflow_error, std::, ) +SYMBOL(owner_less, std::, ) +SYMBOL(packaged_task, std::, ) +SYMBOL(pair, std::, ) +SYMBOL(partial_sort, std::, ) +SYMBOL(partial_sort_copy, std::, ) +SYMBOL(partial_sum, std::, ) +SYMBOL(partition, std::, ) +SYMBOL(partition_copy, std::, ) +SYMBOL(partition_point, std::, ) +SYMBOL(perror, std::, ) +SYMBOL(piecewise_constant_distribution, std::, ) +SYMBOL(piecewise_construct_t, std::, ) +SYMBOL(piecewise_linear_distribution, std::, ) +SYMBOL(plus, std::, ) +SYMBOL(pointer_safety, std::, ) +SYMBOL(pointer_traits, std::, ) +SYMBOL(poisson_distribution, std::, ) +SYMBOL(polymorphic_allocator, std::, ) +SYMBOL(polar, std::, ) +SYMBOL(pop_heap, std::, ) +SYMBOL(prev, std::, ) +SYMBOL(prev_permutation, std::, ) +SYMBOL(printf, std::, ) +SYMBOL(priority_queue, std::, ) +SYMBOL(proj, std::, ) +SYMBOL(promise, std::, ) +SYMBOL(ptrdiff_t, std::, ) +SYMBOL(push_heap, std::, ) +SYMBOL(put_money, std::, ) +SYMBOL(put_time, std::, ) +SYMBOL(putc, std::, ) +SYMBOL(putchar, std::, ) +SYMBOL(puts, std::, ) +SYMBOL(putwc, std::, ) +SYMBOL(putwchar, std::, ) +SYMBOL(qsort, std::, ) +SYMBOL(queue, std::, ) +SYMBOL(quick_exit, std::, ) +SYMBOL(quoted, std::, ) +SYMBOL(raise, std::, ) +SYMBOL(rand, std::, ) +SYMBOL(random_access_iterator_tag, std::, ) +SYMBOL(random_device, std::, ) +SYMBOL(random_shuffle, std::, ) +SYMBOL(range_error, std::, ) +SYMBOL(rank, std::, ) +SYMBOL(rank_v, std::, ) +SYMBOL(ratio_add, std::, ) +SYMBOL(ratio_divide, std::, ) +SYMBOL(ratio_equal, std::, ) +SYMBOL(ratio_equal_v, std::, ) +SYMBOL(ratio_greater, std::, ) +SYMBOL(ratio_greater_equal, std::, ) +SYMBOL(ratio_greater_equal_v, std::, ) +SYMBOL(ratio_greater_v, std::, ) +SYMBOL(ratio_less, std::, ) +SYMBOL(ratio_less_equal, std::, ) +SYMBOL(ratio_less_equal_v, std::, ) +SYMBOL(ratio_less_v, std::, ) +SYMBOL(ratio_multiply, std::, ) +SYMBOL(ratio_not_equal, std::, ) +SYMBOL(ratio_not_equal_v, std::, ) +SYMBOL(ratio_subtract, std::, ) +SYMBOL(rbegin, std::, ) +SYMBOL(real, std::, ) +SYMBOL(realloc, std::, ) +SYMBOL(recursive_mutex, std::, ) +SYMBOL(recursive_timed_mutex, std::, ) +SYMBOL(reduce, std::, ) +SYMBOL(ref, std::, ) +SYMBOL(reference_wrapper, std::, ) +SYMBOL(regex_error, std::, ) +SYMBOL(regex_iterator, std::, ) +SYMBOL(regex_match, std::, ) +SYMBOL(regex_replace, std::, ) +SYMBOL(regex_search, std::, ) +SYMBOL(regex_traits, std::, ) +SYMBOL(reinterpret_pointer_cast, std::, ) +SYMBOL(remainder, std::, ) +SYMBOL(remove_all_extents, std::, ) +SYMBOL(remove_all_extents_t, std::, ) +SYMBOL(remove_const, std::, ) +SYMBOL(remove_const_t, std::, ) +SYMBOL(remove_copy, std::, ) +SYMBOL(remove_copy_if, std::, ) +SYMBOL(remove_cv, std::, ) +SYMBOL(remove_cv_t, std::, ) +SYMBOL(remove_extent, std::, ) +SYMBOL(remove_extent_t, std::, ) +SYMBOL(remove_pointer, std::, ) +SYMBOL(remove_pointer_t, std::, ) +SYMBOL(remove_reference, std::, ) +SYMBOL(remove_reference_t, std::, ) +SYMBOL(remove_volatile, std::, ) +SYMBOL(remove_volatile_t, std::, ) +SYMBOL(remquo, std::, ) +SYMBOL(rend, std::, ) +SYMBOL(rename, std::, ) +SYMBOL(replace, std::, ) +SYMBOL(replace_copy, std::, ) +SYMBOL(replace_copy_if, std::, ) +SYMBOL(replace_if, std::, ) +SYMBOL(resetiosflags, std::, ) +SYMBOL(result_of, std::, ) +SYMBOL(result_of_t, std::, ) +SYMBOL(rethrow_exception, std::, ) +SYMBOL(rethrow_if_nested, std::, ) +SYMBOL(reverse, std::, ) +SYMBOL(reverse_copy, std::, ) +SYMBOL(reverse_iterator, std::, ) +SYMBOL(rewind, std::, ) +SYMBOL(right, std::, ) +SYMBOL(rint, std::, ) +SYMBOL(rotate, std::, ) +SYMBOL(rotate_copy, std::, ) +SYMBOL(round, std::, ) +SYMBOL(round_indeterminate, std::, ) +SYMBOL(round_to_nearest, std::, ) +SYMBOL(round_toward_infinity, std::, ) +SYMBOL(round_toward_neg_infinity, std::, ) +SYMBOL(round_toward_zero, std::, ) +SYMBOL(runtime_error, std::, ) +SYMBOL(sample, std::, ) +SYMBOL(scalbln, std::, ) +SYMBOL(scalbn, std::, ) +SYMBOL(scanf, std::, ) +SYMBOL(scientific, std::, ) +SYMBOL(scoped_allocator_adaptor, std::, ) +SYMBOL(search, std::, ) +SYMBOL(search_n, std::, ) +SYMBOL(seed_seq, std::, ) +SYMBOL(set, std::, ) +SYMBOL(set_difference, std::, ) +SYMBOL(set_intersection, std::, ) +SYMBOL(set_new_handler, std::, ) +SYMBOL(set_symmetric_difference, std::, ) +SYMBOL(set_terminate, std::, ) +SYMBOL(set_union, std::, ) +SYMBOL(setbase, std::, ) +SYMBOL(setbuf, std::, ) +SYMBOL(setfill, std::, ) +SYMBOL(setiosflags, std::, ) +SYMBOL(setlocale, std::, ) +SYMBOL(setprecision, std::, ) +SYMBOL(setvbuf, std::, ) +SYMBOL(setw, std::, ) +SYMBOL(shared_future, std::, ) +SYMBOL(shared_lock, std::, ) +SYMBOL(shared_mutex, std::, ) +SYMBOL(shared_ptr, std::, ) +SYMBOL(shared_timed_mutex, std::, ) +SYMBOL(showbase, std::, ) +SYMBOL(showpoint, std::, ) +SYMBOL(showpos, std::, ) +SYMBOL(shuffle, std::, ) +SYMBOL(sig_atomic_t, std::, ) +SYMBOL(signal, std::, ) +SYMBOL(signbit, std::, ) +SYMBOL(size, std::, ) +SYMBOL(skipws, std::, ) +SYMBOL(slice, std::, ) +SYMBOL(slice_array, std::, ) +SYMBOL(snprintf, std::, ) +SYMBOL(sort, std::, ) +SYMBOL(sort_heap, std::, ) +SYMBOL(sprintf, std::, ) +SYMBOL(srand, std::, ) +SYMBOL(sregex_iterator, std::, ) +SYMBOL(sscanf, std::, ) +SYMBOL(stable_partition, std::, ) +SYMBOL(stable_sort, std::, ) +SYMBOL(stack, std::, ) +SYMBOL(static_pointer_cast, std::, ) +SYMBOL(strcat, std::, ) +SYMBOL(strchr, std::, ) +SYMBOL(strcmp, std::, ) +SYMBOL(strcoll, std::, ) +SYMBOL(strcpy, std::, ) +SYMBOL(strcspn, std::, ) +SYMBOL(streamoff, std::, ) +SYMBOL(streampos, std::, ) +SYMBOL(streamsize, std::, ) +SYMBOL(strerror, std::, ) +SYMBOL(strftime, std::, ) +SYMBOL(strlen, std::, ) +SYMBOL(strncat, std::, ) +SYMBOL(strncmp, std::, ) +SYMBOL(strncpy, std::, ) +SYMBOL(strpbrk, std::, ) +SYMBOL(strrchr, std::, ) +SYMBOL(strspn, std::, ) +SYMBOL(strstr, std::, ) +SYMBOL(strtod, std::, ) +SYMBOL(strtof, std::, ) +SYMBOL(strtoimax, std::, ) +SYMBOL(strtok, std::, ) +SYMBOL(strtol, std::, ) +SYMBOL(strtold, std::, ) +SYMBOL(strtoll, std::, ) +SYMBOL(strtoul, std::, ) +SYMBOL(strtoull, std::, ) +SYMBOL(strtoumax, std::, ) +SYMBOL(strxfrm, std::, ) +SYMBOL(student_t_distribution, std::, ) +SYMBOL(swap, std::, ) +SYMBOL(swap_ranges, std::, ) +SYMBOL(swprintf, std::, ) +SYMBOL(swscanf, std::, ) +SYMBOL(system, std::, ) +SYMBOL(system_category, std::, ) +SYMBOL(system_error, std::, ) +SYMBOL(terminate, std::, ) +SYMBOL(terminate_handler, std::, ) +SYMBOL(tgamma, std::, ) +SYMBOL(thread, std::, ) +SYMBOL(throw_with_nested, std::, ) +SYMBOL(tie, std::, ) +SYMBOL(time, std::, ) +SYMBOL(time_base, std::, ) +SYMBOL(time_t, std::, ) +SYMBOL(timed_mutex, std::, ) +SYMBOL(timespec, std::, ) +SYMBOL(timespec_get, std::, ) +SYMBOL(tm, std::, ) +SYMBOL(tmpfile, std::, ) +SYMBOL(tmpnam, std::, ) +SYMBOL(to_integer, std::, ) +SYMBOL(to_chars, std::, ) +SYMBOL(to_string, std::, ) +SYMBOL(towctrans, std::, ) +SYMBOL(towlower, std::, ) +SYMBOL(towupper, std::, ) +SYMBOL(transform, std::, ) +SYMBOL(transform_exclusive_scan, std::, ) +SYMBOL(transform_inclusive_scan, std::, ) +SYMBOL(transform_reduce, std::, ) +SYMBOL(trunc, std::, ) +SYMBOL(try_lock, std::, ) +SYMBOL(try_to_lock, std::, ) +SYMBOL(try_to_lock_t, std::, ) +SYMBOL(tuple, std::, ) +SYMBOL(tuple_cat, std::, ) +SYMBOL(type_index, std::, ) +SYMBOL(type_info, std::, ) +SYMBOL(u16streampos, std::, ) +SYMBOL(u32streampos, std::, ) +SYMBOL(uncaught_exceptions, std::, ) +SYMBOL(undeclare_no_pointers, std::, ) +SYMBOL(undeclare_reachable, std::, ) +SYMBOL(underflow_error, std::, ) +SYMBOL(underlying_type, std::, ) +SYMBOL(underlying_type_t, std::, ) +SYMBOL(ungetc, std::, ) +SYMBOL(ungetwc, std::, ) +SYMBOL(uniform_int_distribution, std::, ) +SYMBOL(uniform_real_distribution, std::, ) +SYMBOL(uninitialized_copy, std::, ) +SYMBOL(uninitialized_copy_n, std::, ) +SYMBOL(uninitialized_default_construct, std::, ) +SYMBOL(uninitialized_default_construct_n, std::, ) +SYMBOL(uninitialized_fill, std::, ) +SYMBOL(uninitialized_fill_n, std::, ) +SYMBOL(uninitialized_move, std::, ) +SYMBOL(uninitialized_move_n, std::, ) +SYMBOL(uninitialized_value_construct, std::, ) +SYMBOL(uninitialized_value_construct_n, std::, ) +SYMBOL(unique, std::, ) +SYMBOL(unique_copy, std::, ) +SYMBOL(unique_lock, std::, ) +SYMBOL(unique_ptr, std::, ) +SYMBOL(unitbuf, std::, ) +SYMBOL(unordered_map, std::, ) +SYMBOL(unordered_multimap, std::, ) +SYMBOL(unordered_multiset, std::, ) +SYMBOL(unordered_set, std::, ) +SYMBOL(upper_bound, std::, ) +SYMBOL(uppercase, std::, ) +SYMBOL(use_facet, std::, ) +SYMBOL(uses_allocator_v, std::, ) +SYMBOL(va_list, std::, ) +SYMBOL(valarray, std::, ) +SYMBOL(variant, std::, ) +SYMBOL(variant_alternative, std::, ) +SYMBOL(variant_alternative_t, std::, ) +SYMBOL(variant_npos, std::, ) +SYMBOL(variant_size, std::, ) +SYMBOL(variant_size_v, std::, ) +SYMBOL(vector, std::, ) +SYMBOL(vfprintf, std::, ) +SYMBOL(vfscanf, std::, ) +SYMBOL(vfwprintf, std::, ) +SYMBOL(vfwscanf, std::, ) +SYMBOL(visit, std::, ) +SYMBOL(void_t, std::, ) +SYMBOL(vprintf, std::, ) +SYMBOL(vscanf, std::, ) +SYMBOL(vsnprintf, std::, ) +SYMBOL(vsprintf, std::, ) +SYMBOL(vsscanf, std::, ) +SYMBOL(vswprintf, std::, ) +SYMBOL(vswscanf, std::, ) +SYMBOL(vwprintf, std::, ) +SYMBOL(vwscanf, std::, ) +SYMBOL(wbuffer_convert, std::, ) +SYMBOL(wcerr, std::, ) +SYMBOL(wcin, std::, ) +SYMBOL(wclog, std::, ) +SYMBOL(wcout, std::, ) +SYMBOL(wcregex_iterator, std::, ) +SYMBOL(wcrtomb, std::, ) +SYMBOL(wcscat, std::, ) +SYMBOL(wcschr, std::, ) +SYMBOL(wcscmp, std::, ) +SYMBOL(wcscoll, std::, ) +SYMBOL(wcscpy, std::, ) +SYMBOL(wcscspn, std::, ) +SYMBOL(wcsftime, std::, ) +SYMBOL(wcslen, std::, ) +SYMBOL(wcsncat, std::, ) +SYMBOL(wcsncmp, std::, ) +SYMBOL(wcsncpy, std::, ) +SYMBOL(wcspbrk, std::, ) +SYMBOL(wcsrchr, std::, ) +SYMBOL(wcsrtombs, std::, ) +SYMBOL(wcsspn, std::, ) +SYMBOL(wcsstr, std::, ) +SYMBOL(wcstod, std::, ) +SYMBOL(wcstof, std::, ) +SYMBOL(wcstoimax, std::, ) +SYMBOL(wcstok, std::, ) +SYMBOL(wcstol, std::, ) +SYMBOL(wcstold, std::, ) +SYMBOL(wcstoll, std::, ) +SYMBOL(wcstombs, std::, ) +SYMBOL(wcstoul, std::, ) +SYMBOL(wcstoull, std::, ) +SYMBOL(wcstoumax, std::, ) +SYMBOL(wcsxfrm, std::, ) +SYMBOL(wctob, std::, ) +SYMBOL(wctomb, std::, ) +SYMBOL(wctrans, std::, ) +SYMBOL(wctype, std::, ) +SYMBOL(weak_ptr, std::, ) +SYMBOL(weibull_distribution, std::, ) +SYMBOL(wios, std::, ) +SYMBOL(wmemchr, std::, ) +SYMBOL(wmemcmp, std::, ) +SYMBOL(wmemcpy, std::, ) +SYMBOL(wmemmove, std::, ) +SYMBOL(wmemset, std::, ) +SYMBOL(ws, std::, ) +SYMBOL(wstreampos, std::, ) +SYMBOL(wprintf, std::, ) +SYMBOL(wscanf, std::, ) +SYMBOL(wsregex_iterator, std::, ) +SYMBOL(wstring_convert, std::, ) Index: clangd/index/CanonicalIncludes.cpp =================================================================== --- clangd/index/CanonicalIncludes.cpp +++ clangd/index/CanonicalIncludes.cpp @@ -154,6 +154,9 @@ {"std::uint_least16_t", ""}, // redeclares these {"std::uint_least32_t", ""}, {"std::declval", ""}, +#define SYMBOL(Name, NameSpace, Header) { #NameSpace#Name, #Header }, + #include "StdSymbolMap.inc" +#undef SYMBOL }; for (const auto &Pair : SymbolMap) Includes->addSymbolMapping(Pair.first, Pair.second);