hokein created this revision.
hokein added a reviewer: kadircet.
Herald added subscribers: jfb, arphaman, jkorous, MaskRay, ilya-biryukov.
Herald added a project: clang.
This resolves the issue of introducing c++-style includes for C files.
- refactor the gen_std.py, make it reusable for parsing C symbols.
- add a language mode to the mapping method to use different mapping for C and
C++ files.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D63270
Files:
clang-tools-extra/clangd/CSymbolMap.inc
clang-tools-extra/clangd/ClangdUnit.cpp
clang-tools-extra/clangd/StdSymbolMap.inc
clang-tools-extra/clangd/include-mapping/cppreference_parser.py
clang-tools-extra/clangd/include-mapping/gen_std.py
clang-tools-extra/clangd/include-mapping/test.py
clang-tools-extra/clangd/index/CanonicalIncludes.cpp
clang-tools-extra/clangd/index/CanonicalIncludes.h
clang-tools-extra/clangd/index/IndexAction.cpp
clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp
clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
Index: clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
+++ clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
@@ -945,7 +945,9 @@
TEST_F(SymbolCollectorTest, CanonicalSTLHeader) {
CollectorOpts.CollectIncludePath = true;
CanonicalIncludes Includes;
- addSystemHeadersMapping(&Includes);
+ auto Language = LangOptions();
+ Language.CPlusPlus = true;
+ addSystemHeadersMapping(&Includes, Language);
CollectorOpts.Includes = &Includes;
runSymbolCollector("namespace std { class string {}; }", /*Main=*/"");
EXPECT_THAT(Symbols,
Index: clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp
+++ clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp
@@ -15,7 +15,9 @@
TEST(CanonicalIncludesTest, CXXStandardLibrary) {
CanonicalIncludes CI;
- addSystemHeadersMapping(&CI);
+ auto Language = LangOptions();
+ Language.CPlusPlus = true;
+ addSystemHeadersMapping(&CI, Language);
// Usual standard library symbols are mapped correctly.
EXPECT_EQ("<vector>", CI.mapHeader("path/vector.h", "std::vector"));
Index: clang-tools-extra/clangd/index/IndexAction.cpp
===================================================================
--- clang-tools-extra/clangd/index/IndexAction.cpp
+++ clang-tools-extra/clangd/index/IndexAction.cpp
@@ -126,6 +126,7 @@
std::unique_ptr<ASTConsumer>
CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
CI.getPreprocessor().addCommentHandler(PragmaHandler.get());
+ addSystemHeadersMapping(Includes.get(), CI.getLangOpts());
if (IncludeGraphCallback != nullptr)
CI.getPreprocessor().addPPCallbacks(
llvm::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
@@ -194,7 +195,6 @@
Opts.RefsInHeaders = true;
}
auto Includes = llvm::make_unique<CanonicalIncludes>();
- addSystemHeadersMapping(Includes.get());
Opts.Includes = Includes.get();
return llvm::make_unique<IndexAction>(
std::make_shared<SymbolCollector>(std::move(Opts)), std::move(Includes),
Index: clang-tools-extra/clangd/index/CanonicalIncludes.h
===================================================================
--- clang-tools-extra/clangd/index/CanonicalIncludes.h
+++ clang-tools-extra/clangd/index/CanonicalIncludes.h
@@ -84,7 +84,8 @@
/// - Compiler extensions, e.g. include/avx512bwintrin.h$ -> <immintrin.h>
/// The mapping is hardcoded and hand-maintained, so it might not cover all
/// headers.
-void addSystemHeadersMapping(CanonicalIncludes *Includes);
+void addSystemHeadersMapping(CanonicalIncludes *Includes,
+ const LangOptions &Language);
} // namespace clangd
} // namespace clang
Index: clang-tools-extra/clangd/index/CanonicalIncludes.cpp
===================================================================
--- clang-tools-extra/clangd/index/CanonicalIncludes.cpp
+++ clang-tools-extra/clangd/index/CanonicalIncludes.cpp
@@ -86,16 +86,25 @@
return llvm::make_unique<PragmaCommentHandler>(Includes);
}
-void addSystemHeadersMapping(CanonicalIncludes *Includes) {
+void addSystemHeadersMapping(CanonicalIncludes *Includes,
+ const LangOptions &Language) {
static const std::vector<std::pair<const char *, const char *>> SymbolMap = {
#define SYMBOL(Name, NameSpace, Header) { #NameSpace#Name, #Header },
#include "StdSymbolMap.inc"
#undef SYMBOL
};
-
- for (const auto &Pair : SymbolMap)
- Includes->addSymbolMapping(Pair.first, Pair.second);
-
+ static const std::vector<std::pair<const char *, const char *>> CSymbolMap = {
+#define SYMBOL(Name, NameSpace, Header) {#NameSpace #Name, #Header},
+ #include "CSymbolMap.inc"
+#undef SYMBOL
+ };
+ if (Language.CPlusPlus) {
+ for (const auto &Pair : SymbolMap)
+ Includes->addSymbolMapping(Pair.first, Pair.second);
+ } else if (Language.C11) {
+ for (const auto &Pair : CSymbolMap)
+ 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)
Index: clang-tools-extra/clangd/include-mapping/test.py
===================================================================
--- clang-tools-extra/clangd/include-mapping/test.py
+++ clang-tools-extra/clangd/include-mapping/test.py
@@ -7,7 +7,7 @@
#
#===------------------------------------------------------------------------===#
-from gen_std import ParseSymbolPage, ParseIndexPage
+from cppreference_parser import _ParseSymbolPage, _ParseIndexPage
import unittest
@@ -22,7 +22,7 @@
<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)
+ actual = _ParseIndexPage(html)
expected = [
("abs", "abs.html", True),
("abs", "complex/abs.html", True),
@@ -53,7 +53,7 @@
</tr>
</tbody></table>
"""
- self.assertEqual(ParseSymbolPage(html, 'foo'), set(['<cmath>']))
+ self.assertEqual(_ParseSymbolPage(html, 'foo'), set(['<cmath>']))
def testParseSymbolPage_MulHeaders(self):
@@ -94,7 +94,7 @@
</tr>
</tbody></table>
"""
- self.assertEqual(ParseSymbolPage(html, "foo"),
+ self.assertEqual(_ParseSymbolPage(html, "foo"),
set(['<cstdio>', '<cstdlib>']))
@@ -121,7 +121,7 @@
</tr>
</tbody></table>
"""
- self.assertEqual(ParseSymbolPage(html, "foo"),
+ self.assertEqual(_ParseSymbolPage(html, "foo"),
set(['<algorithm>', '<utility>']))
def testParseSymbolPage_MulSymbolsInSameTd(self):
@@ -145,9 +145,9 @@
</tr>
</tbody></table>
"""
- self.assertEqual(ParseSymbolPage(html, "int8_t"),
+ self.assertEqual(_ParseSymbolPage(html, "int8_t"),
set(['<cstdint>']))
- self.assertEqual(ParseSymbolPage(html, "int16_t"),
+ self.assertEqual(_ParseSymbolPage(html, "int16_t"),
set(['<cstdint>']))
Index: clang-tools-extra/clangd/include-mapping/gen_std.py
===================================================================
--- clang-tools-extra/clangd/include-mapping/gen_std.py
+++ clang-tools-extra/clangd/include-mapping/gen_std.py
@@ -8,7 +8,7 @@
#===------------------------------------------------------------------------===#
"""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
+include headers) for C/C++ Standard Library symbols by parsing archieved HTML
files from cppreference.
Caveats and FIXMEs:
@@ -25,24 +25,23 @@
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
+ // Generate C++ symbols
+ gen_std.py -cppreference </cppreference/reference> -language=cpp > StdSymbolMap.inc
+ // Generate C symbols
+ gen_std.py -cppreference </cppreference/reference> -language=c > CSymbolMap.inc
"""
-from bs4 import BeautifulSoup, NavigableString
+import cppreference_parser
import argparse
-import collections
import datetime
-import multiprocessing
import os
-import re
-import signal
import sys
-STDGEN_CODE_PREFIX = """\
+CODE_PREFIX = """\
//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
//
-// Used to build a lookup table (qualified names => include headers) for C++
+// Used to build a lookup table (qualified names => include headers) for %s
// Standard Library symbols.
//
// Automatically generated file, DO NOT EDIT!
@@ -51,189 +50,56 @@
//===----------------------------------------------------------------------===//
"""
-def HasClass(tag, *classes):
- for c in tag.get('class', []):
- if c in classes:
- return True
- return False
-
-def ParseSymbolPage(symbol_page_html, symbol_name):
- """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 = set()
- all_headers = set()
-
- soup = BeautifulSoup(symbol_page_html, "html.parser")
- # Rows in table are like:
- # Defined in header <foo> .t-dsc-header
- # Defined in header <bar> .t-dsc-header
- # decl1 .t-dcl
- # Defined in header <baz> .t-dsc-header
- # decl2 .t-dcl
- for table in soup.select('table.t-dcl-begin, table.t-dsc-begin'):
- current_headers = []
- was_decl = False
- for row in table.select('tr'):
- if HasClass(row, 't-dcl', 't-dsc'):
- was_decl = True
- # Symbols are in the first cell.
- found_symbols = row.find('td').stripped_strings
- if not symbol_name in found_symbols:
- continue
- headers.update(current_headers)
- elif HasClass(row, 't-dsc-header'):
- # If we saw a decl since the last header, this is a new block of headers
- # for a new block of decls.
- if was_decl:
- current_headers = []
- was_decl = False
- # There are also .t-dsc-header for "defined in namespace".
- if not "Defined in header " in row.text:
- continue
- # The interesting header content (e.g. <cstdlib>) is wrapped in <code>.
- for header_code in row.find_all("code"):
- current_headers.append(header_code.text)
- all_headers.add(header_code.text)
- # If the symbol was never named, consider all named headers.
- return headers or all_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, variant).
- """
- symbols = []
- soup = BeautifulSoup(index_page_html, "html.parser")
- for symbol_href in soup.select("a[title]"):
- # Ignore annotated symbols like "acos<>() (std::complex)".
- # These tend to be overloads, and we the primary is more useful.
- # This accidentally accepts begin/end despite the (iterator) caption: the
- # (since C++11) note is first. They are good symbols, so the bug is unfixed.
- caption = symbol_href.next_sibling
- variant = isinstance(caption, NavigableString) and "(" in caption
- symbol_tt = symbol_href.find("tt")
- if symbol_tt:
- symbols.append((symbol_tt.text.rstrip("<>()"), # strip any trailing <>()
- symbol_href["href"], variant))
- return symbols
-
-class Symbol:
-
- def __init__(self, name, namespace, headers):
- # unqualifed symbol name, e.g. "move"
- self.name = name
- # namespace of the symbol (with trailing "::"), e.g. "std::"
- self.namespace = namespace
- # a list of corresponding headers
- self.headers = headers
-
-
-def ReadSymbolPage(path, name):
- with open(path) as f:
- return ParseSymbolPage(f.read(), name)
-
-
-def GetSymbols(pool, root_dir, index_page_name, namespace):
- """Get all symbols listed in the index page. All symbols should be in the
- given namespace.
-
- Returns a list of Symbols.
- """
-
- # 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.
- index_page_path = os.path.join(root_dir, index_page_name)
- with open(index_page_path, "r") as f:
- # Read each symbol page in parallel.
- results = [] # (symbol_name, promise of [header...])
- for symbol_name, symbol_page_path, variant in ParseIndexPage(f.read()):
- # Variant symbols (e.g. the std::locale version of isalpha) add ambiguity.
- # FIXME: use these as a fallback rather than ignoring entirely.
- if variant:
- continue
- path = os.path.join(root_dir, symbol_page_path)
- results.append((symbol_name,
- pool.apply_async(ReadSymbolPage, (path, symbol_name))))
-
- # Build map from symbol name to a set of headers.
- symbol_headers = collections.defaultdict(set)
- for symbol_name, lazy_headers in results:
- symbol_headers[symbol_name].update(lazy_headers.get())
-
- symbols = []
- for name, headers in sorted(symbol_headers.items(), key=lambda t : t[0]):
- symbols.append(Symbol(name, namespace, list(headers)))
- 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
- )
+ )
+ parser.add_argument('-language',
+ default='cpp',
+ help='Generate c or cpp symbols',
+ required=True)
return parser.parse_args()
def main():
args = ParseArg()
- cpp_root = os.path.join(args.cppreference, "en", "cpp")
- symbol_index_root = os.path.join(cpp_root, "symbol_index")
+ if args.language == 'cpp':
+ page_root = os.path.join(args.cppreference, "en", "cpp")
+ symbol_index_root = os.path.join(page_root, "symbol_index")
+ parse_pages = [
+ (page_root, "symbol_index.html", "std::"),
+ # std sub-namespace symbols have separated pages.
+ # We don't index std literal operators (e.g.
+ # std::literals::chrono_literals::operator""d), these symbols can't be
+ # accessed by std::<symbol_name>.
+ # FIXME: index std::placeholders symbols, placeholders.html page is
+ # different (which contains one entry for _1, _2, ..., _N), we need special
+ # handling.
+ (symbol_index_root, "chrono.html", "std::chrono::"),
+ (symbol_index_root, "filesystem.html", "std::filesystem::"),
+ (symbol_index_root, "pmr.html", "std::pmr::"),
+ (symbol_index_root, "regex_constants.html", "std::regex_constants::"),
+ (symbol_index_root, "this_thread.html", "std::this_thread::"),
+ ]
+ elif args.language == 'c':
+ page_root = os.path.join(args.cppreference, "en", "c")
+ symbol_index_root = page_root
+ parse_pages = [(page_root, "index.html", "")]
+
if not os.path.exists(symbol_index_root):
exit("Path %s doesn't exist!" % symbol_index_root)
- parse_pages = [
- (cpp_root, "symbol_index.html", "std::"),
- # std sub-namespace symbols have separated pages.
- # We don't index std literal operators (e.g.
- # std::literals::chrono_literals::operator""d), these symbols can't be
- # accessed by std::<symbol_name>.
- # FIXME: index std::placeholders symbols, placeholders.html page is
- # different (which contains one entry for _1, _2, ..., _N), we need special
- # handling.
- (symbol_index_root, "chrono.html", "std::chrono::"),
- (symbol_index_root, "filesystem.html", "std::filesystem::"),
- (symbol_index_root, "pmr.html", "std::pmr::"),
- (symbol_index_root, "regex_constants.html", "std::regex_constants::"),
- (symbol_index_root, "this_thread.html", "std::this_thread::"),
- ]
-
- symbols = []
- # Run many workers to process individual symbol pages under the symbol index.
- # Don't allow workers to capture Ctrl-C.
- pool = multiprocessing.Pool(
- initializer=lambda: signal.signal(signal.SIGINT, signal.SIG_IGN))
- try:
- for root_dir, page_name, namespace in parse_pages:
- symbols.extend(GetSymbols(pool, root_dir, page_name, namespace))
- finally:
- pool.terminate()
- pool.join()
+ symbols = cppreference_parser.GetSymbols(parse_pages)
# 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.
- index_page_path = os.path.join(cpp_root, "symbol_index.html")
+ index_page_path = os.path.join(page_root, "index.html")
cppreference_modified_date = datetime.datetime.fromtimestamp(
os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
- print STDGEN_CODE_PREFIX % cppreference_modified_date
+ print CODE_PREFIX % (args.language.upper(), cppreference_modified_date)
for symbol in symbols:
if len(symbol.headers) == 1:
# SYMBOL(unqualified_name, namespace, header)
Index: clang-tools-extra/clangd/include-mapping/cppreference_parser.py
===================================================================
--- clang-tools-extra/clangd/include-mapping/cppreference_parser.py
+++ clang-tools-extra/clangd/include-mapping/cppreference_parser.py
@@ -1,63 +1,32 @@
-#!/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, NavigableString
-import argparse
import collections
-import datetime
import multiprocessing
import os
import re
import signal
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 HasClass(tag, *classes):
+
+class Symbol:
+
+ def __init__(self, name, namespace, headers):
+ # unqualifed symbol name, e.g. "move"
+ self.name = name
+ # namespace of the symbol (with trailing "::"), e.g. "std::", "" (global scope)
+ self.namespace = namespace
+ # a list of corresponding headers
+ self.headers = headers
+
+
+def _HasClass(tag, *classes):
for c in tag.get('class', []):
if c in classes:
return True
return False
-def ParseSymbolPage(symbol_page_html, symbol_name):
+
+def _ParseSymbolPage(symbol_page_html, symbol_name):
"""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:
@@ -82,14 +51,14 @@
current_headers = []
was_decl = False
for row in table.select('tr'):
- if HasClass(row, 't-dcl', 't-dsc'):
+ if _HasClass(row, 't-dcl', 't-dsc'):
was_decl = True
# Symbols are in the first cell.
found_symbols = row.find('td').stripped_strings
if not symbol_name in found_symbols:
continue
headers.update(current_headers)
- elif HasClass(row, 't-dsc-header'):
+ elif _HasClass(row, 't-dsc-header'):
# If we saw a decl since the last header, this is a new block of headers
# for a new block of decls.
if was_decl:
@@ -106,7 +75,7 @@
return headers or all_headers
-def ParseIndexPage(index_page_html):
+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:
@@ -131,23 +100,13 @@
symbol_href["href"], variant))
return symbols
-class Symbol:
-
- def __init__(self, name, namespace, headers):
- # unqualifed symbol name, e.g. "move"
- self.name = name
- # namespace of the symbol (with trailing "::"), e.g. "std::"
- self.namespace = namespace
- # a list of corresponding headers
- self.headers = headers
-
-def ReadSymbolPage(path, name):
+def _ReadSymbolPage(path, name):
with open(path) as f:
- return ParseSymbolPage(f.read(), name)
+ return _ParseSymbolPage(f.read(), name)
-def GetSymbols(pool, root_dir, index_page_name, namespace):
+def _GetSymbols(pool, root_dir, index_page_name, namespace):
"""Get all symbols listed in the index page. All symbols should be in the
given namespace.
@@ -163,14 +122,14 @@
with open(index_page_path, "r") as f:
# Read each symbol page in parallel.
results = [] # (symbol_name, promise of [header...])
- for symbol_name, symbol_page_path, variant in ParseIndexPage(f.read()):
+ for symbol_name, symbol_page_path, variant in _ParseIndexPage(f.read()):
# Variant symbols (e.g. the std::locale version of isalpha) add ambiguity.
# FIXME: use these as a fallback rather than ignoring entirely.
if variant:
continue
path = os.path.join(root_dir, symbol_page_path)
results.append((symbol_name,
- pool.apply_async(ReadSymbolPage, (path, symbol_name))))
+ pool.apply_async(_ReadSymbolPage, (path, symbol_name))))
# Build map from symbol name to a set of headers.
symbol_headers = collections.defaultdict(set)
@@ -183,39 +142,12 @@
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_root = os.path.join(args.cppreference, "en", "cpp")
- symbol_index_root = os.path.join(cpp_root, "symbol_index")
- if not os.path.exists(symbol_index_root):
- exit("Path %s doesn't exist!" % symbol_index_root)
-
- parse_pages = [
- (cpp_root, "symbol_index.html", "std::"),
- # std sub-namespace symbols have separated pages.
- # We don't index std literal operators (e.g.
- # std::literals::chrono_literals::operator""d), these symbols can't be
- # accessed by std::<symbol_name>.
- # FIXME: index std::placeholders symbols, placeholders.html page is
- # different (which contains one entry for _1, _2, ..., _N), we need special
- # handling.
- (symbol_index_root, "chrono.html", "std::chrono::"),
- (symbol_index_root, "filesystem.html", "std::filesystem::"),
- (symbol_index_root, "pmr.html", "std::pmr::"),
- (symbol_index_root, "regex_constants.html", "std::regex_constants::"),
- (symbol_index_root, "this_thread.html", "std::this_thread::"),
- ]
+def GetSymbols(parse_pages):
+ """Get all symbols by parsing the given pages.
+ Args:
+ parse_pages: a list of tuples (page_root_dir, index_page_name, namespace)
+ """
symbols = []
# Run many workers to process individual symbol pages under the symbol index.
# Don't allow workers to capture Ctrl-C.
@@ -223,29 +155,8 @@
initializer=lambda: signal.signal(signal.SIGINT, signal.SIG_IGN))
try:
for root_dir, page_name, namespace in parse_pages:
- symbols.extend(GetSymbols(pool, root_dir, page_name, namespace))
+ symbols.extend(_GetSymbols(pool, root_dir, page_name, namespace))
finally:
pool.terminate()
pool.join()
-
- # 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.
- index_page_path = os.path.join(cpp_root, "symbol_index.html")
- cppreference_modified_date = datetime.datetime.fromtimestamp(
- os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
- print STDGEN_CODE_PREFIX % cppreference_modified_date
- for symbol in symbols:
- if len(symbol.headers) == 1:
- # SYMBOL(unqualified_name, namespace, header)
- print "SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
- symbol.headers[0])
- elif len(symbol.headers) == 0:
- sys.stderr.write("No header found for symbol %s\n" % symbol.name)
- else:
- # FIXME: support symbols with multiple headers (e.g. std::move).
- sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
- symbol.name, ', '.join(symbol.headers)))
-
-
-if __name__ == '__main__':
- main()
+ return symbols
\ No newline at end of file
Index: clang-tools-extra/clangd/StdSymbolMap.inc
===================================================================
--- clang-tools-extra/clangd/StdSymbolMap.inc
+++ clang-tools-extra/clangd/StdSymbolMap.inc
@@ -1,6 +1,6 @@
//===-- gen_std.py generated file -------------------------------*- C++ -*-===//
//
-// Used to build a lookup table (qualified names => include headers) for C++
+// Used to build a lookup table (qualified names => include headers) for CPP
// Standard Library symbols.
//
// Automatically generated file, DO NOT EDIT!
Index: clang-tools-extra/clangd/ClangdUnit.cpp
===================================================================
--- clang-tools-extra/clangd/ClangdUnit.cpp
+++ clang-tools-extra/clangd/ClangdUnit.cpp
@@ -129,7 +129,6 @@
public:
CppFilePreambleCallbacks(PathRef File, PreambleParsedCallback ParsedCallback)
: File(File), ParsedCallback(ParsedCallback) {
- addSystemHeadersMapping(&CanonIncludes);
}
IncludeStructure takeIncludes() { return std::move(Includes); }
@@ -148,6 +147,7 @@
}
void BeforeExecute(CompilerInstance &CI) override {
+ addSystemHeadersMapping(&CanonIncludes, CI.getLangOpts());
SourceMgr = &CI.getSourceManager();
}
@@ -413,7 +413,7 @@
if (Preamble)
CanonIncludes = Preamble->CanonIncludes;
else
- addSystemHeadersMapping(&CanonIncludes);
+ addSystemHeadersMapping(&CanonIncludes, Clang->getLangOpts());
std::unique_ptr<CommentHandler> IWYUHandler =
collectIWYUHeaderMaps(&CanonIncludes);
Clang->getPreprocessor().addCommentHandler(IWYUHandler.get());
Index: clang-tools-extra/clangd/CSymbolMap.inc
===================================================================
--- /dev/null
+++ clang-tools-extra/clangd/CSymbolMap.inc
@@ -0,0 +1,944 @@
+//===-- 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(ATOMIC_BOOL_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_FLAG_INIT, , <stdatomic.h>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_LONG_LOGK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_VAR_INIT, , <stdatomic.h>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(BUFSIZ, , <stdio.h>)
+SYMBOL(CHAR_BIT, , <limits.h>)
+SYMBOL(CHAR_MAX, , <limits.h>)
+SYMBOL(CHAR_MIN, , <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, , <time.h>)
+SYMBOL(CMPLX, , <complex.h>)
+SYMBOL(CMPLXF, , <complex.h>)
+SYMBOL(CMPLXL, , <complex.h>)
+SYMBOL(DBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(DBL_DIG, , <float.h>)
+SYMBOL(DBL_EPSILON, , <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(DBL_MANT_DIG, , <float.h>)
+SYMBOL(DBL_MAX, , <float.h>)
+SYMBOL(DBL_MAX_10_EXP, , <float.h>)
+SYMBOL(DBL_MAX_EXP, , <float.h>)
+SYMBOL(DBL_MIN, , <float.h>)
+SYMBOL(DBL_MIN_10_EXP, , <float.h>)
+SYMBOL(DBL_MIN_EXP, , <float.h>)
+SYMBOL(DBL_TRUE_MIN, , <float.h>)
+SYMBOL(DECIMAL_DIG, , <float.h>)
+SYMBOL(EDOM, , <errno.h>)
+SYMBOL(EILSEQ, , <errno.h>)
+SYMBOL(EOF, , <stdio.h>)
+SYMBOL(ERANGE, , <errno.h>)
+SYMBOL(EXIT_FAILURE, , <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, , <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, , <fenv.h>)
+SYMBOL(FE_DFL_ENV, , <fenv.h>)
+SYMBOL(FE_DIVBYZERO, , <fenv.h>)
+SYMBOL(FE_DOWNWARD, , <fenv.h>)
+SYMBOL(FE_INEXACT, , <fenv.h>)
+SYMBOL(FE_INVALID, , <fenv.h>)
+SYMBOL(FE_OVERFLOW, , <fenv.h>)
+SYMBOL(FE_TONEAREST, , <fenv.h>)
+SYMBOL(FE_TOWARDZERO, , <fenv.h>)
+SYMBOL(FE_UNDERFLOW, , <fenv.h>)
+SYMBOL(FE_UPWARD, , <fenv.h>)
+SYMBOL(FILE, , <stdio.h>)
+SYMBOL(FILENAME_MAX, , <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, , <float.h>)
+SYMBOL(FLT_DIG, , <float.h>)
+SYMBOL(FLT_EPSILON, , <float.h>)
+SYMBOL(FLT_EVAL_METHOD, , <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, , <float.h>)
+SYMBOL(FLT_MANT_DIG, , <float.h>)
+SYMBOL(FLT_MAX, , <float.h>)
+SYMBOL(FLT_MAX_10_EXP, , <float.h>)
+SYMBOL(FLT_MAX_EXP, , <float.h>)
+SYMBOL(FLT_MIN, , <float.h>)
+SYMBOL(FLT_MIN_10_EXP, , <float.h>)
+SYMBOL(FLT_MIN_EXP, , <float.h>)
+SYMBOL(FLT_RADIX, , <float.h>)
+SYMBOL(FLT_ROUNDS, , <float.h>)
+SYMBOL(FLT_TRUE_MIN, , <float.h>)
+SYMBOL(FOPEN_MAX, , <stdio.h>)
+SYMBOL(FP_INFINITE, , <math.h>)
+SYMBOL(FP_NAN, , <math.h>)
+SYMBOL(FP_NORNAL, , <math.h>)
+SYMBOL(FP_SUBNORMAL, , <math.h>)
+SYMBOL(FP_ZERO, , <math.h>)
+SYMBOL(HUGE_VAL, , <math.h>)
+SYMBOL(HUGE_VALF, , <math.h>)
+SYMBOL(HUGE_VALL, , <math.h>)
+SYMBOL(I, , <complex.h>)
+SYMBOL(INFINITY, , <math.h>)
+SYMBOL(INT16_MAX, , <stdint.h>)
+SYMBOL(INT16_MIN, , <stdint.h>)
+SYMBOL(INT32_MAX, , <stdint.h>)
+SYMBOL(INT32_MIN, , <stdint.h>)
+SYMBOL(INT64_MAX, , <stdint.h>)
+SYMBOL(INT64_MIN, , <stdint.h>)
+SYMBOL(INT8_MAX, , <stdint.h>)
+SYMBOL(INT8_MIN, , <stdint.h>)
+SYMBOL(INTMAX_MAX, , <stdint.h>)
+SYMBOL(INTMAX_MIN, , <stdint.h>)
+SYMBOL(INTPTR_MAX, , <stdint.h>)
+SYMBOL(INTPTR_MIN, , <stdint.h>)
+SYMBOL(INT_FAST16_MAX, , <stdint.h>)
+SYMBOL(INT_FAST16_MIN, , <stdint.h>)
+SYMBOL(INT_FAST32_MAX, , <stdint.h>)
+SYMBOL(INT_FAST32_MIN, , <stdint.h>)
+SYMBOL(INT_FAST64_MAX, , <stdint.h>)
+SYMBOL(INT_FAST64_MIN, , <stdint.h>)
+SYMBOL(INT_FAST8_MAX, , <stdint.h>)
+SYMBOL(INT_FAST8_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, , <stdint.h>)
+SYMBOL(INT_MAX, , <limits.h>)
+SYMBOL(INT_MIN, , <limits.h>)
+SYMBOL(LC_ALL, , <locale.h>)
+SYMBOL(LC_COLLATE, , <locale.h>)
+SYMBOL(LC_CTYPE, , <locale.h>)
+SYMBOL(LC_MONETARY, , <locale.h>)
+SYMBOL(LC_NUMERIC, , <locale.h>)
+SYMBOL(LC_TIME, , <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(LDBL_DIG, , <float.h>)
+SYMBOL(LDBL_EPSILON, , <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(LDBL_MANT_DIG, , <float.h>)
+SYMBOL(LDBL_MAX, , <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, , <float.h>)
+SYMBOL(LDBL_MAX_EXP, , <float.h>)
+SYMBOL(LDBL_MIN, , <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, , <float.h>)
+SYMBOL(LDBL_MIN_EXP, , <float.h>)
+SYMBOL(LDBL_TRUE_MIN, , <float.h>)
+SYMBOL(LLONG_MAX, , <limits.h>)
+SYMBOL(LLONG_MIN, , <limits.h>)
+SYMBOL(LONG_MAX, , <limits.h>)
+SYMBOL(LONG_MIN, , <limits.h>)
+SYMBOL(L_tmpnam, , <stdio.h>)
+SYMBOL(L_tmpnam_s, , <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, , <math.h>)
+SYMBOL(MATH_ERRNO, , <math.h>)
+SYMBOL(MB_CUR_MAX, , <stdlib.h>)
+SYMBOL(MB_LEN_MAX, , <limits.h>)
+SYMBOL(NAN, , <math.h>)
+SYMBOL(ONCE_FLAG_INIT, , <threads.h>)
+SYMBOL(PTRDIFF_MAX, , <stdint.h>)
+SYMBOL(PTRDIFF_MIN, , <stdint.h>)
+SYMBOL(RAND_MAX, , <stdlib.h>)
+SYMBOL(RSIZE_MAX, , <stdint.h>)
+SYMBOL(SCHAR_MAX, , <limits.h>)
+SYMBOL(SCHAR_MIN, , <limits.h>)
+SYMBOL(SEEK_CUR, , <stdio.h>)
+SYMBOL(SEEK_END, , <stdio.h>)
+SYMBOL(SEEK_SET, , <stdio.h>)
+SYMBOL(SHRT_MAX, , <limits.h>)
+SYMBOL(SHRT_MIN, , <limits.h>)
+SYMBOL(SIGABRT, , <signal.h>)
+SYMBOL(SIGFPE, , <signal.h>)
+SYMBOL(SIGILL, , <signal.h>)
+SYMBOL(SIGINT, , <signal.h>)
+SYMBOL(SIGSEGV, , <signal.h>)
+SYMBOL(SIGTERM, , <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, , <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, , <stdint.h>)
+SYMBOL(SIG_DFL, , <signal.h>)
+SYMBOL(SIG_ERR, , <signal.h>)
+SYMBOL(SIG_IGN, , <signal.h>)
+SYMBOL(SIZE_MAX, , <stdint.h>)
+SYMBOL(TIME_UTC, , <time.h>)
+SYMBOL(TMP_MAX, , <stdio.h>)
+SYMBOL(TMP_MAX_S, , <stdio.h>)
+SYMBOL(TSS_DTOR_ITERATIONS, , <threads.h>)
+SYMBOL(UCHAR_MAX, , <limits.h>)
+SYMBOL(UINT16_MAX, , <stdint.h>)
+SYMBOL(UINT32_MAX, , <stdint.h>)
+SYMBOL(UINT64_MAX, , <stdint.h>)
+SYMBOL(UINT8_MAX, , <stdint.h>)
+SYMBOL(UINTMAX_MAX, , <stdint.h>)
+SYMBOL(UINTPTR_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_MAX, , <limits.h>)
+SYMBOL(ULLONG_MAX, , <limits.h>)
+SYMBOL(ULONG_MAX, , <limits.h>)
+SYMBOL(USHRT_MAX, , <limits.h>)
+SYMBOL(WCHAR_MAX, , <wchar.h>)
+SYMBOL(WCHAR_MIN, , <wchar.h>)
+SYMBOL(WEOF, , <wchar.h>)
+SYMBOL(WINT_MAX, , <stdint.h>)
+SYMBOL(WINT_MIN, , <stdint.h>)
+SYMBOL(_Complex_I, , <complex.h>)
+SYMBOL(_IOFBF, , <stdio.h>)
+SYMBOL(_IOLBF, , <stdio.h>)
+SYMBOL(_IONBF, , <stdio.h>)
+SYMBOL(_Imaginary_I, , <complex.h>)
+SYMBOL(__alignas_is_defined, , <stdalign.h>)
+SYMBOL(__alignof_is_defined, , <stdalign.h>)
+SYMBOL(abort_handler_s, , <stdlib.h>)
+SYMBOL(abs, , <stdlib.h>)
+SYMBOL(acos, , <math.h>)
+SYMBOL(acosf, , <math.h>)
+SYMBOL(acosh, , <math.h>)
+SYMBOL(acoshf, , <math.h>)
+SYMBOL(acoshl, , <math.h>)
+SYMBOL(acosl, , <math.h>)
+SYMBOL(alignas, , <stdalign.h>)
+SYMBOL(aligned_alloc, , <stdlib.h>)
+SYMBOL(alignof, , <stdalign.h>)
+SYMBOL(and, , <iso646.h>)
+SYMBOL(and_eq, , <iso646.h>)
+SYMBOL(asctime, , <time.h>)
+SYMBOL(asctime_s, , <time.h>)
+SYMBOL(asin, , <math.h>)
+SYMBOL(asinf, , <math.h>)
+SYMBOL(asinh, , <math.h>)
+SYMBOL(asinhf, , <math.h>)
+SYMBOL(asinhl, , <math.h>)
+SYMBOL(asinl, , <math.h>)
+SYMBOL(assert, , <assert.h>)
+SYMBOL(at_quick_exit, , <stdlib.h>)
+SYMBOL(atan, , <math.h>)
+SYMBOL(atan2, , <math.h>)
+SYMBOL(atan2f, , <math.h>)
+SYMBOL(atan2l, , <math.h>)
+SYMBOL(atanf, , <math.h>)
+SYMBOL(atanh, , <math.h>)
+SYMBOL(atanhf, , <math.h>)
+SYMBOL(atanhl, , <math.h>)
+SYMBOL(atanl, , <math.h>)
+SYMBOL(atexit, , <stdlib.h>)
+SYMBOL(atof, , <stdlib.h>)
+SYMBOL(atoi, , <stdlib.h>)
+SYMBOL(atol, , <stdlib.h>)
+SYMBOL(atoll, , <stdlib.h>)
+SYMBOL(atomic_bool, , <stdatomic.h>)
+SYMBOL(atomic_char, , <stdatomic.h>)
+SYMBOL(atomic_char16_t, , <stdatomic.h>)
+SYMBOL(atomic_char32_t, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong_explicit, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak_explicit, , <stdatomic.h>)
+SYMBOL(atomic_exchange, , <stdatomic.h>)
+SYMBOL(atomic_exchange_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_add, , <stdatomic.h>)
+SYMBOL(atomic_fetch_add_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_and, , <stdatomic.h>)
+SYMBOL(atomic_fetch_and_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_or, , <stdatomic.h>)
+SYMBOL(atomic_fetch_or_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_sub, , <stdatomic.h>)
+SYMBOL(atomic_fetch_sub_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_xor, , <stdatomic.h>)
+SYMBOL(atomic_fetch_xor_explicit, , <stdatomic.h>)
+SYMBOL(atomic_flag, , <stdatomic.h>)
+SYMBOL(atomic_flag_clear, , <stdatomic.h>)
+SYMBOL(atomic_flag_clear_explicit, , <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set, , <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set_explicit, , <stdatomic.h>)
+SYMBOL(atomic_init, , <stdatomic.h>)
+SYMBOL(atomic_int, , <stdatomic.h>)
+SYMBOL(atomic_int_fast16_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast32_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast64_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast8_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least16_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least32_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least64_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least8_t, , <stdatomic.h>)
+SYMBOL(atomic_intmax_t, , <stdatomic.h>)
+SYMBOL(atomic_intptr_t, , <stdatomic.h>)
+SYMBOL(atomic_is_lock_free, , <stdatomic.h>)
+SYMBOL(atomic_llong, , <stdatomic.h>)
+SYMBOL(atomic_load, , <stdatomic.h>)
+SYMBOL(atomic_load_explicit, , <stdatomic.h>)
+SYMBOL(atomic_long, , <stdatomic.h>)
+SYMBOL(atomic_ptrdiff_t, , <stdatomic.h>)
+SYMBOL(atomic_schar, , <stdatomic.h>)
+SYMBOL(atomic_short, , <stdatomic.h>)
+SYMBOL(atomic_signal_fence, , <stdatomic.h>)
+SYMBOL(atomic_size_t, , <stdatomic.h>)
+SYMBOL(atomic_store, , <stdatomic.h>)
+SYMBOL(atomic_store_explicit, , <stdatomic.h>)
+SYMBOL(atomic_thread_fence, , <stdatomic.h>)
+SYMBOL(atomic_uchar, , <stdatomic.h>)
+SYMBOL(atomic_uint, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast16_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast32_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast64_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast8_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least16_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least32_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least64_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least8_t, , <stdatomic.h>)
+SYMBOL(atomic_uintmax_t, , <stdatomic.h>)
+SYMBOL(atomic_uintptr_t, , <stdatomic.h>)
+SYMBOL(atomic_ullong, , <stdatomic.h>)
+SYMBOL(atomic_ulong, , <stdatomic.h>)
+SYMBOL(atomic_ushort, , <stdatomic.h>)
+SYMBOL(atomic_wchar_t, , <stdatomic.h>)
+SYMBOL(bitand, , <iso646.h>)
+SYMBOL(bitor, , <iso646.h>)
+SYMBOL(bsearch, , <stdlib.h>)
+SYMBOL(bsearch_s, , <stdlib.h>)
+SYMBOL(btowc, , <wchar.h>)
+SYMBOL(c16rtomb, , <uchar.h>)
+SYMBOL(c32rtomb, , <uchar.h>)
+SYMBOL(cabs, , <complex.h>)
+SYMBOL(cabsf, , <complex.h>)
+SYMBOL(cabsl, , <complex.h>)
+SYMBOL(cacos, , <complex.h>)
+SYMBOL(cacosf, , <complex.h>)
+SYMBOL(cacosh, , <complex.h>)
+SYMBOL(cacoshf, , <complex.h>)
+SYMBOL(cacoshl, , <complex.h>)
+SYMBOL(cacosl, , <complex.h>)
+SYMBOL(call_once, , <threads.h>)
+SYMBOL(calloc, , <stdlib.h>)
+SYMBOL(carg, , <complex.h>)
+SYMBOL(cargf, , <complex.h>)
+SYMBOL(cargl, , <complex.h>)
+SYMBOL(casin, , <complex.h>)
+SYMBOL(casinf, , <complex.h>)
+SYMBOL(casinh, , <complex.h>)
+SYMBOL(casinhf, , <complex.h>)
+SYMBOL(casinhl, , <complex.h>)
+SYMBOL(casinl, , <complex.h>)
+SYMBOL(catan, , <complex.h>)
+SYMBOL(catanf, , <complex.h>)
+SYMBOL(catanh, , <complex.h>)
+SYMBOL(catanhf, , <complex.h>)
+SYMBOL(catanhl, , <complex.h>)
+SYMBOL(catanl, , <complex.h>)
+SYMBOL(cbrt, , <math.h>)
+SYMBOL(cbrtf, , <math.h>)
+SYMBOL(cbrtl, , <math.h>)
+SYMBOL(ccos, , <complex.h>)
+SYMBOL(ccosf, , <complex.h>)
+SYMBOL(ccosh, , <complex.h>)
+SYMBOL(ccoshf, , <complex.h>)
+SYMBOL(ccoshl, , <complex.h>)
+SYMBOL(ccosl, , <complex.h>)
+SYMBOL(ceil, , <math.h>)
+SYMBOL(ceilf, , <math.h>)
+SYMBOL(ceill, , <math.h>)
+SYMBOL(cexp, , <complex.h>)
+SYMBOL(cexpf, , <complex.h>)
+SYMBOL(cexpl, , <complex.h>)
+SYMBOL(char16_t, , <uchar.h>)
+SYMBOL(char32_t, , <uchar.h>)
+SYMBOL(cimag, , <complex.h>)
+SYMBOL(cimagf, , <complex.h>)
+SYMBOL(cimagl, , <complex.h>)
+SYMBOL(clearerr, , <stdio.h>)
+SYMBOL(clock, , <time.h>)
+SYMBOL(clock_t, , <time.h>)
+SYMBOL(clog, , <complex.h>)
+SYMBOL(clogf, , <complex.h>)
+SYMBOL(clogl, , <complex.h>)
+SYMBOL(cnd_broadcast, , <threads.h>)
+SYMBOL(cnd_destroy, , <threads.h>)
+SYMBOL(cnd_init, , <threads.h>)
+SYMBOL(cnd_signal, , <threads.h>)
+SYMBOL(cnd_t, , <threads.h>)
+SYMBOL(cnd_timedwait, , <threads.h>)
+SYMBOL(cnd_wait, , <threads.h>)
+SYMBOL(compl, , <iso646.h>)
+SYMBOL(complex, , <complex.h>)
+SYMBOL(conj, , <complex.h>)
+SYMBOL(conjf, , <complex.h>)
+SYMBOL(conjl, , <complex.h>)
+SYMBOL(constraint_handler_t, , <stdlib.h>)
+SYMBOL(copysign, , <math.h>)
+SYMBOL(copysignf, , <math.h>)
+SYMBOL(copysignl, , <math.h>)
+SYMBOL(cos, , <math.h>)
+SYMBOL(cosf, , <math.h>)
+SYMBOL(cosh, , <math.h>)
+SYMBOL(coshf, , <math.h>)
+SYMBOL(coshl, , <math.h>)
+SYMBOL(cosl, , <math.h>)
+SYMBOL(cpow, , <complex.h>)
+SYMBOL(cpowf, , <complex.h>)
+SYMBOL(cpowl, , <complex.h>)
+SYMBOL(cproj, , <complex.h>)
+SYMBOL(cprojf, , <complex.h>)
+SYMBOL(cprojl, , <complex.h>)
+SYMBOL(creal, , <complex.h>)
+SYMBOL(crealf, , <complex.h>)
+SYMBOL(creall, , <complex.h>)
+SYMBOL(csin, , <complex.h>)
+SYMBOL(csinf, , <complex.h>)
+SYMBOL(csinh, , <complex.h>)
+SYMBOL(csinhf, , <complex.h>)
+SYMBOL(csinhl, , <complex.h>)
+SYMBOL(csinl, , <complex.h>)
+SYMBOL(csqrt, , <complex.h>)
+SYMBOL(csqrtf, , <complex.h>)
+SYMBOL(csqrtl, , <complex.h>)
+SYMBOL(ctan, , <complex.h>)
+SYMBOL(ctanf, , <complex.h>)
+SYMBOL(ctanh, , <complex.h>)
+SYMBOL(ctanhf, , <complex.h>)
+SYMBOL(ctanhl, , <complex.h>)
+SYMBOL(ctanl, , <complex.h>)
+SYMBOL(ctime, , <time.h>)
+SYMBOL(ctime_s, , <time.h>)
+SYMBOL(difftime, , <time.h>)
+SYMBOL(double_t, , <math.h>)
+SYMBOL(erf, , <math.h>)
+SYMBOL(erfc, , <math.h>)
+SYMBOL(erfcf, , <math.h>)
+SYMBOL(erfcl, , <math.h>)
+SYMBOL(erff, , <math.h>)
+SYMBOL(erfl, , <math.h>)
+SYMBOL(errno, , <errno.h>)
+SYMBOL(exit, , <stdlib.h>)
+SYMBOL(exp, , <math.h>)
+SYMBOL(exp2, , <math.h>)
+SYMBOL(exp2f, , <math.h>)
+SYMBOL(exp2l, , <math.h>)
+SYMBOL(expf, , <math.h>)
+SYMBOL(expl, , <math.h>)
+SYMBOL(expm1, , <math.h>)
+SYMBOL(expm1f, , <math.h>)
+SYMBOL(expm1l, , <math.h>)
+SYMBOL(fabs, , <math.h>)
+SYMBOL(fabsf, , <math.h>)
+SYMBOL(fabsl, , <math.h>)
+SYMBOL(fclose, , <stdio.h>)
+SYMBOL(fdim, , <math.h>)
+SYMBOL(fdimf, , <math.h>)
+SYMBOL(fdiml, , <math.h>)
+SYMBOL(feclearexcept, , <fenv.h>)
+SYMBOL(fegetenv, , <fenv.h>)
+SYMBOL(fegetexceptflag, , <fenv.h>)
+SYMBOL(fegetround, , <fenv.h>)
+SYMBOL(feholdexcept, , <fenv.h>)
+SYMBOL(fenv_t, , <fenv.h>)
+SYMBOL(feof, , <stdio.h>)
+SYMBOL(feraiseexcept, , <fenv.h>)
+SYMBOL(ferror, , <stdio.h>)
+SYMBOL(fesetenv, , <fenv.h>)
+SYMBOL(fesetexceptflag, , <fenv.h>)
+SYMBOL(fesetround, , <fenv.h>)
+SYMBOL(fetestexcept, , <fenv.h>)
+SYMBOL(feupdateenv, , <fenv.h>)
+SYMBOL(fexcept_t, , <fenv.h>)
+SYMBOL(fflush, , <stdio.h>)
+SYMBOL(fgetc, , <stdio.h>)
+SYMBOL(fgetpos, , <stdio.h>)
+SYMBOL(fgets, , <stdio.h>)
+SYMBOL(fgetwc, , <wchar.h>)
+SYMBOL(fgetws, , <wchar.h>)
+SYMBOL(float_t, , <math.h>)
+SYMBOL(floor, , <math.h>)
+SYMBOL(floorf, , <math.h>)
+SYMBOL(floorl, , <math.h>)
+SYMBOL(fma, , <math.h>)
+SYMBOL(fmaf, , <math.h>)
+SYMBOL(fmal, , <math.h>)
+SYMBOL(fmax, , <math.h>)
+SYMBOL(fmaxf, , <math.h>)
+SYMBOL(fmaxl, , <math.h>)
+SYMBOL(fmin, , <math.h>)
+SYMBOL(fminf, , <math.h>)
+SYMBOL(fminl, , <math.h>)
+SYMBOL(fmod, , <math.h>)
+SYMBOL(fmodf, , <math.h>)
+SYMBOL(fmodl, , <math.h>)
+SYMBOL(fopen, , <stdio.h>)
+SYMBOL(fopen_s, , <stdio.h>)
+SYMBOL(fpclassify, , <math.h>)
+SYMBOL(fpos_t, , <stdio.h>)
+SYMBOL(fprintf, , <stdio.h>)
+SYMBOL(fprintf_s, , <stdio.h>)
+SYMBOL(fputc, , <stdio.h>)
+SYMBOL(fputs, , <stdio.h>)
+SYMBOL(fputwc, , <wchar.h>)
+SYMBOL(fputws, , <wchar.h>)
+SYMBOL(fread, , <stdio.h>)
+SYMBOL(free, , <stdlib.h>)
+SYMBOL(freopen, , <stdio.h>)
+SYMBOL(freopen_s, , <stdio.h>)
+SYMBOL(frexp, , <math.h>)
+SYMBOL(frexpf, , <math.h>)
+SYMBOL(frexpl, , <math.h>)
+SYMBOL(fscanf, , <stdio.h>)
+SYMBOL(fscanf_s, , <stdio.h>)
+SYMBOL(fseek, , <stdio.h>)
+SYMBOL(fsetpos, , <stdio.h>)
+SYMBOL(ftell, , <stdio.h>)
+SYMBOL(fwide, , <wchar.h>)
+SYMBOL(fwprintf, , <wchar.h>)
+SYMBOL(fwprintf_s, , <wchar.h>)
+SYMBOL(fwrite, , <stdio.h>)
+SYMBOL(fwscanf, , <wchar.h>)
+SYMBOL(fwscanf_s, , <wchar.h>)
+SYMBOL(getc, , <stdio.h>)
+SYMBOL(getchar, , <stdio.h>)
+SYMBOL(getenv, , <stdlib.h>)
+SYMBOL(getenv_s, , <stdlib.h>)
+SYMBOL(gets, , <stdio.h>)
+SYMBOL(gets_s, , <stdio.h>)
+SYMBOL(getwc, , <wchar.h>)
+SYMBOL(getwchar, , <wchar.h>)
+SYMBOL(gmtime, , <time.h>)
+SYMBOL(gmtime_s, , <time.h>)
+SYMBOL(hypot, , <math.h>)
+SYMBOL(hypotf, , <math.h>)
+SYMBOL(hypotl, , <math.h>)
+SYMBOL(ignore_handler_s, , <stdlib.h>)
+SYMBOL(ilogb, , <math.h>)
+SYMBOL(ilogbf, , <math.h>)
+SYMBOL(ilogbl, , <math.h>)
+SYMBOL(imaginary, , <complex.h>)
+SYMBOL(imaxabs, , <inttypes.h>)
+SYMBOL(int16_t, , <stdint.h>)
+SYMBOL(int32_t, , <stdint.h>)
+SYMBOL(int64_t, , <stdint.h>)
+SYMBOL(int8_t, , <stdint.h>)
+SYMBOL(int_fast16_t, , <stdint.h>)
+SYMBOL(int_fast32_t, , <stdint.h>)
+SYMBOL(int_fast64_t, , <stdint.h>)
+SYMBOL(int_fast8_t, , <stdint.h>)
+SYMBOL(int_least16_t, , <stdint.h>)
+SYMBOL(int_least32_t, , <stdint.h>)
+SYMBOL(int_least64_t, , <stdint.h>)
+SYMBOL(int_least8_t, , <stdint.h>)
+SYMBOL(intmax_t, , <stdint.h>)
+SYMBOL(intptr_t, , <stdint.h>)
+SYMBOL(isalnum, , <ctype.h>)
+SYMBOL(isalpha, , <ctype.h>)
+SYMBOL(isblank, , <ctype.h>)
+SYMBOL(iscntrl, , <ctype.h>)
+SYMBOL(isdigit, , <ctype.h>)
+SYMBOL(isfinite, , <math.h>)
+SYMBOL(isgraph, , <ctype.h>)
+SYMBOL(isgreater, , <math.h>)
+SYMBOL(isgreaterequal, , <math.h>)
+SYMBOL(isinf, , <math.h>)
+SYMBOL(isless, , <math.h>)
+SYMBOL(islessequal, , <math.h>)
+SYMBOL(islessgreater, , <math.h>)
+SYMBOL(islower, , <ctype.h>)
+SYMBOL(isnan, , <math.h>)
+SYMBOL(isnormal, , <math.h>)
+SYMBOL(isprint, , <ctype.h>)
+SYMBOL(ispunct, , <ctype.h>)
+SYMBOL(isspace, , <ctype.h>)
+SYMBOL(isunordered, , <math.h>)
+SYMBOL(isupper, , <ctype.h>)
+SYMBOL(iswalnum, , <wctype.h>)
+SYMBOL(iswalpha, , <wctype.h>)
+SYMBOL(iswblank, , <wctype.h>)
+SYMBOL(iswcntrl, , <wctype.h>)
+SYMBOL(iswctype, , <wctype.h>)
+SYMBOL(iswdigit, , <wctype.h>)
+SYMBOL(iswgraph, , <wctype.h>)
+SYMBOL(iswlower, , <wctype.h>)
+SYMBOL(iswprint, , <wctype.h>)
+SYMBOL(iswpunct, , <wctype.h>)
+SYMBOL(iswspace, , <wctype.h>)
+SYMBOL(iswupper, , <wctype.h>)
+SYMBOL(iswxdigit, , <wctype.h>)
+SYMBOL(isxdigit, , <ctype.h>)
+SYMBOL(jmp_buf, , <setjmp.h>)
+SYMBOL(kill_dependency, , <stdatomic.h>)
+SYMBOL(labs, , <stdlib.h>)
+SYMBOL(lconv, , <locale.h>)
+SYMBOL(ldexp, , <math.h>)
+SYMBOL(ldexpf, , <math.h>)
+SYMBOL(ldexpl, , <math.h>)
+SYMBOL(lgamma, , <math.h>)
+SYMBOL(lgammaf, , <math.h>)
+SYMBOL(lgammal, , <math.h>)
+SYMBOL(llabs, , <stdlib.h>)
+SYMBOL(llrint, , <math.h>)
+SYMBOL(llrintf, , <math.h>)
+SYMBOL(llrintl, , <math.h>)
+SYMBOL(llround, , <math.h>)
+SYMBOL(llroundf, , <math.h>)
+SYMBOL(llroundl, , <math.h>)
+SYMBOL(localeconv, , <locale.h>)
+SYMBOL(localtime, , <time.h>)
+SYMBOL(localtime_s, , <time.h>)
+SYMBOL(log, , <math.h>)
+SYMBOL(log10, , <math.h>)
+SYMBOL(log10f, , <math.h>)
+SYMBOL(log10l, , <math.h>)
+SYMBOL(log1p, , <math.h>)
+SYMBOL(log1pf, , <math.h>)
+SYMBOL(log1pl, , <math.h>)
+SYMBOL(log2, , <math.h>)
+SYMBOL(log2f, , <math.h>)
+SYMBOL(log2l, , <math.h>)
+SYMBOL(logb, , <math.h>)
+SYMBOL(logbf, , <math.h>)
+SYMBOL(logbl, , <math.h>)
+SYMBOL(logf, , <math.h>)
+SYMBOL(logl, , <math.h>)
+SYMBOL(longjmp, , <setjmp.h>)
+SYMBOL(lrint, , <math.h>)
+SYMBOL(lrintf, , <math.h>)
+SYMBOL(lrintl, , <math.h>)
+SYMBOL(lround, , <math.h>)
+SYMBOL(lroundf, , <math.h>)
+SYMBOL(lroundl, , <math.h>)
+SYMBOL(malloc, , <stdlib.h>)
+SYMBOL(math_errhandling, , <math.h>)
+SYMBOL(max_align_t, , <stddef.h>)
+SYMBOL(mblen, , <stdlib.h>)
+SYMBOL(mbrlen, , <wchar.h>)
+SYMBOL(mbrtoc16, , <uchar.h>)
+SYMBOL(mbrtoc32, , <uchar.h>)
+SYMBOL(mbrtowc, , <wchar.h>)
+SYMBOL(mbsinit, , <wchar.h>)
+SYMBOL(mbsrtowcs, , <wchar.h>)
+SYMBOL(mbsrtowcs_s, , <wchar.h>)
+SYMBOL(mbstowcs, , <stdlib.h>)
+SYMBOL(mbstowcs_s, , <stdlib.h>)
+SYMBOL(mbtowc, , <stdlib.h>)
+SYMBOL(memchr, , <string.h>)
+SYMBOL(memcmp, , <string.h>)
+SYMBOL(memcpy, , <string.h>)
+SYMBOL(memcpy_s, , <string.h>)
+SYMBOL(memmove, , <string.h>)
+SYMBOL(memmove_s, , <string.h>)
+SYMBOL(memory_order, , <stdatomic.h>)
+SYMBOL(memory_order_acq_rel, , <stdatomic.h>)
+SYMBOL(memory_order_acquire, , <stdatomic.h>)
+SYMBOL(memory_order_consume, , <stdatomic.h>)
+SYMBOL(memory_order_relaxed, , <stdatomic.h>)
+SYMBOL(memory_order_release, , <stdatomic.h>)
+SYMBOL(memory_order_seq_cst, , <stdatomic.h>)
+SYMBOL(memset, , <string.h>)
+SYMBOL(memset_s, , <string.h>)
+SYMBOL(mktime, , <time.h>)
+SYMBOL(modf, , <math.h>)
+SYMBOL(modff, , <math.h>)
+SYMBOL(modfl, , <math.h>)
+SYMBOL(mtx_destroy, , <threads.h>)
+SYMBOL(mtx_init, , <threads.h>)
+SYMBOL(mtx_lock, , <threads.h>)
+SYMBOL(mtx_plain, , <threads.h>)
+SYMBOL(mtx_recursive, , <threads.h>)
+SYMBOL(mtx_t, , <threads.h>)
+SYMBOL(mtx_timed, , <threads.h>)
+SYMBOL(mtx_timedlock, , <threads.h>)
+SYMBOL(mtx_trylock, , <threads.h>)
+SYMBOL(mtx_unlock, , <threads.h>)
+SYMBOL(nan, , <math.h>)
+SYMBOL(nanf, , <math.h>)
+SYMBOL(nanl, , <math.h>)
+SYMBOL(nearbyint, , <math.h>)
+SYMBOL(nearbyintf, , <math.h>)
+SYMBOL(nearbyintl, , <math.h>)
+SYMBOL(nextafter, , <math.h>)
+SYMBOL(nextafterf, , <math.h>)
+SYMBOL(nextafterl, , <math.h>)
+SYMBOL(nexttoward, , <math.h>)
+SYMBOL(nexttowardf, , <math.h>)
+SYMBOL(nexttowardl, , <math.h>)
+SYMBOL(noreturn, , <stdnoreturn.h>)
+SYMBOL(not, , <iso646.h>)
+SYMBOL(not_eq, , <iso646.h>)
+SYMBOL(offsetof, , <stddef.h>)
+SYMBOL(once_flag, , <threads.h>)
+SYMBOL(or, , <iso646.h>)
+SYMBOL(or_eq, , <iso646.h>)
+SYMBOL(perror, , <stdio.h>)
+SYMBOL(pow, , <math.h>)
+SYMBOL(powf, , <math.h>)
+SYMBOL(powl, , <math.h>)
+SYMBOL(printf, , <stdio.h>)
+SYMBOL(printf_s, , <stdio.h>)
+SYMBOL(ptrdiff_t, , <stddef.h>)
+SYMBOL(putc, , <stdio.h>)
+SYMBOL(putchar, , <stdio.h>)
+SYMBOL(puts, , <stdio.h>)
+SYMBOL(putwc, , <wchar.h>)
+SYMBOL(putwchar, , <wchar.h>)
+SYMBOL(qsort, , <stdlib.h>)
+SYMBOL(qsort_s, , <stdlib.h>)
+SYMBOL(quick_exit, , <stdlib.h>)
+SYMBOL(raise, , <signal.h>)
+SYMBOL(rand, , <stdlib.h>)
+SYMBOL(realloc, , <stdlib.h>)
+SYMBOL(remainder, , <math.h>)
+SYMBOL(remainderf, , <math.h>)
+SYMBOL(remainderl, , <math.h>)
+SYMBOL(remove, , <stdio.h>)
+SYMBOL(remquo, , <math.h>)
+SYMBOL(remquof, , <math.h>)
+SYMBOL(remquol, , <math.h>)
+SYMBOL(rename, , <stdio.h>)
+SYMBOL(rewind, , <stdio.h>)
+SYMBOL(rint, , <math.h>)
+SYMBOL(rintf, , <math.h>)
+SYMBOL(rintl, , <math.h>)
+SYMBOL(round, , <math.h>)
+SYMBOL(roundf, , <math.h>)
+SYMBOL(roundl, , <math.h>)
+SYMBOL(rsize_t, , <stddef.h>)
+SYMBOL(scalbln, , <math.h>)
+SYMBOL(scalblnf, , <math.h>)
+SYMBOL(scalblnl, , <math.h>)
+SYMBOL(scalbn, , <math.h>)
+SYMBOL(scalbnf, , <math.h>)
+SYMBOL(scalbnl, , <math.h>)
+SYMBOL(scanf, , <stdio.h>)
+SYMBOL(scanf_s, , <stdio.h>)
+SYMBOL(set_constraint_handler_s, , <stdlib.h>)
+SYMBOL(setbuf, , <stdio.h>)
+SYMBOL(setjmp, , <setjmp.h>)
+SYMBOL(setlocale, , <locale.h>)
+SYMBOL(setvbuf, , <stdio.h>)
+SYMBOL(sig_atomic_t, , <signal.h>)
+SYMBOL(signal, , <signal.h>)
+SYMBOL(signbit, , <math.h>)
+SYMBOL(sin, , <math.h>)
+SYMBOL(sinf, , <math.h>)
+SYMBOL(sinh, , <math.h>)
+SYMBOL(sinhf, , <math.h>)
+SYMBOL(sinhl, , <math.h>)
+SYMBOL(sinl, , <math.h>)
+SYMBOL(snprintf, , <stdio.h>)
+SYMBOL(snprintf_s, , <stdio.h>)
+SYMBOL(snwprintf_s, , <wchar.h>)
+SYMBOL(sprintf, , <stdio.h>)
+SYMBOL(sprintf_s, , <stdio.h>)
+SYMBOL(sqrt, , <math.h>)
+SYMBOL(sqrtf, , <math.h>)
+SYMBOL(sqrtl, , <math.h>)
+SYMBOL(srand, , <stdlib.h>)
+SYMBOL(sscanf, , <stdio.h>)
+SYMBOL(sscanf_s, , <stdio.h>)
+SYMBOL(static_assert, , <assert.h>)
+SYMBOL(stderr, , <stdio.h>)
+SYMBOL(stdin, , <stdio.h>)
+SYMBOL(stdout, , <stdio.h>)
+SYMBOL(strcat, , <string.h>)
+SYMBOL(strcat_s, , <string.h>)
+SYMBOL(strchr, , <string.h>)
+SYMBOL(strcmp, , <string.h>)
+SYMBOL(strcoll, , <string.h>)
+SYMBOL(strcpy, , <string.h>)
+SYMBOL(strcpy_s, , <string.h>)
+SYMBOL(strcspn, , <string.h>)
+SYMBOL(strerror, , <string.h>)
+SYMBOL(strerror_s, , <string.h>)
+SYMBOL(strerrorlen_s, , <string.h>)
+SYMBOL(strftime, , <time.h>)
+SYMBOL(strlen, , <string.h>)
+SYMBOL(strncat, , <string.h>)
+SYMBOL(strncat_s, , <string.h>)
+SYMBOL(strncmp, , <string.h>)
+SYMBOL(strncpy, , <string.h>)
+SYMBOL(strncpy_s, , <string.h>)
+SYMBOL(strnlen_s, , <string.h>)
+SYMBOL(strpbrk, , <string.h>)
+SYMBOL(strrchr, , <string.h>)
+SYMBOL(strspn, , <string.h>)
+SYMBOL(strstr, , <string.h>)
+SYMBOL(strtod, , <stdlib.h>)
+SYMBOL(strtof, , <stdlib.h>)
+SYMBOL(strtoimax, , <inttypes.h>)
+SYMBOL(strtok, , <string.h>)
+SYMBOL(strtok_s, , <string.h>)
+SYMBOL(strtol, , <stdlib.h>)
+SYMBOL(strtold, , <stdlib.h>)
+SYMBOL(strtoll, , <stdlib.h>)
+SYMBOL(strtoul, , <stdlib.h>)
+SYMBOL(strtoull, , <stdlib.h>)
+SYMBOL(strtoumax, , <inttypes.h>)
+SYMBOL(strxfrm, , <string.h>)
+SYMBOL(swprintf, , <wchar.h>)
+SYMBOL(swprintf_s, , <wchar.h>)
+SYMBOL(swscanf, , <wchar.h>)
+SYMBOL(swscanf_s, , <wchar.h>)
+SYMBOL(system, , <stdlib.h>)
+SYMBOL(tan, , <math.h>)
+SYMBOL(tanf, , <math.h>)
+SYMBOL(tanh, , <math.h>)
+SYMBOL(tanhf, , <math.h>)
+SYMBOL(tanhl, , <math.h>)
+SYMBOL(tanl, , <math.h>)
+SYMBOL(tgamma, , <math.h>)
+SYMBOL(tgammaf, , <math.h>)
+SYMBOL(tgammal, , <math.h>)
+SYMBOL(thrd_busy, , <threads.h>)
+SYMBOL(thrd_create, , <threads.h>)
+SYMBOL(thrd_current, , <threads.h>)
+SYMBOL(thrd_detach, , <threads.h>)
+SYMBOL(thrd_equal, , <threads.h>)
+SYMBOL(thrd_error, , <threads.h>)
+SYMBOL(thrd_join, , <threads.h>)
+SYMBOL(thrd_nomem, , <threads.h>)
+SYMBOL(thrd_sleep, , <threads.h>)
+SYMBOL(thrd_start_t, , <threads.h>)
+SYMBOL(thrd_success, , <threads.h>)
+SYMBOL(thrd_t, , <threads.h>)
+SYMBOL(thrd_timedout, , <threads.h>)
+SYMBOL(thrd_yield, , <threads.h>)
+SYMBOL(thread_local, , <threads.h>)
+SYMBOL(time, , <time.h>)
+SYMBOL(time_t, , <time.h>)
+SYMBOL(timespec, , <time.h>)
+SYMBOL(timespec_get, , <time.h>)
+SYMBOL(tm, , <time.h>)
+SYMBOL(tmpfile, , <stdio.h>)
+SYMBOL(tmpfile_s, , <stdio.h>)
+SYMBOL(tmpnam, , <stdio.h>)
+SYMBOL(tmpnam_s, , <stdio.h>)
+SYMBOL(tolower, , <ctype.h>)
+SYMBOL(toupper, , <ctype.h>)
+SYMBOL(towctrans, , <wctype.h>)
+SYMBOL(towlower, , <wctype.h>)
+SYMBOL(towupper, , <wctype.h>)
+SYMBOL(trunc, , <math.h>)
+SYMBOL(truncf, , <math.h>)
+SYMBOL(truncl, , <math.h>)
+SYMBOL(tss_create, , <threads.h>)
+SYMBOL(tss_delete, , <threads.h>)
+SYMBOL(tss_dtor_t, , <threads.h>)
+SYMBOL(tss_get, , <threads.h>)
+SYMBOL(tss_set, , <threads.h>)
+SYMBOL(tss_t, , <threads.h>)
+SYMBOL(uint16_t, , <stdint.h>)
+SYMBOL(uint32_t, , <stdint.h>)
+SYMBOL(uint64_t, , <stdint.h>)
+SYMBOL(uint8_t, , <stdint.h>)
+SYMBOL(uint_fast16_t, , <stdint.h>)
+SYMBOL(uint_fast32_t, , <stdint.h>)
+SYMBOL(uint_fast64_t, , <stdint.h>)
+SYMBOL(uint_fast8_t, , <stdint.h>)
+SYMBOL(uint_least16_t, , <stdint.h>)
+SYMBOL(uint_least32_t, , <stdint.h>)
+SYMBOL(uint_least64_t, , <stdint.h>)
+SYMBOL(uint_least8_t, , <stdint.h>)
+SYMBOL(uintmax_t, , <stdint.h>)
+SYMBOL(uintptr_t, , <stdint.h>)
+SYMBOL(ungetc, , <stdio.h>)
+SYMBOL(ungetwc, , <wchar.h>)
+SYMBOL(va_arg, , <stdarg.h>)
+SYMBOL(va_copy, , <stdarg.h>)
+SYMBOL(va_end, , <stdarg.h>)
+SYMBOL(va_start, , <stdarg.h>)
+SYMBOL(vfprintf, , <stdio.h>)
+SYMBOL(vfprintf_s, , <stdio.h>)
+SYMBOL(vfscanf, , <stdio.h>)
+SYMBOL(vfscanf_s, , <stdio.h>)
+SYMBOL(vfwprintf, , <wchar.h>)
+SYMBOL(vfwprintf_s, , <wchar.h>)
+SYMBOL(vfwscanf, , <wchar.h>)
+SYMBOL(vfwscanf_s, , <wchar.h>)
+SYMBOL(vprintf, , <stdio.h>)
+SYMBOL(vprintf_s, , <stdio.h>)
+SYMBOL(vscanf, , <stdio.h>)
+SYMBOL(vscanf_s, , <stdio.h>)
+SYMBOL(vsnprintf, , <stdio.h>)
+SYMBOL(vsnprintf_s, , <stdio.h>)
+SYMBOL(vsnwprintf_s, , <wchar.h>)
+SYMBOL(vsprintf, , <stdio.h>)
+SYMBOL(vsprintf_s, , <stdio.h>)
+SYMBOL(vsscanf, , <stdio.h>)
+SYMBOL(vsscanf_s, , <stdio.h>)
+SYMBOL(vswprintf, , <wchar.h>)
+SYMBOL(vswprintf_s, , <wchar.h>)
+SYMBOL(vswscanf, , <wchar.h>)
+SYMBOL(vswscanf_s, , <wchar.h>)
+SYMBOL(vwprintf, , <wchar.h>)
+SYMBOL(vwprintf_s, , <wchar.h>)
+SYMBOL(vwscanf, , <wchar.h>)
+SYMBOL(vwscanf_s, , <wchar.h>)
+SYMBOL(wchar_t, , <wchar.h>)
+SYMBOL(wcrtomb, , <wchar.h>)
+SYMBOL(wcrtomb_s, , <wchar.h>)
+SYMBOL(wcscat, , <wchar.h>)
+SYMBOL(wcscat_s, , <wchar.h>)
+SYMBOL(wcschr, , <wchar.h>)
+SYMBOL(wcscmp, , <wchar.h>)
+SYMBOL(wcscoll, , <wchar.h>)
+SYMBOL(wcscpy, , <wchar.h>)
+SYMBOL(wcscpy_s, , <wchar.h>)
+SYMBOL(wcscspn, , <wchar.h>)
+SYMBOL(wcsftime, , <wchar.h>)
+SYMBOL(wcslen, , <wchar.h>)
+SYMBOL(wcsncat, , <wchar.h>)
+SYMBOL(wcsncat_s, , <wchar.h>)
+SYMBOL(wcsncmp, , <wchar.h>)
+SYMBOL(wcsncpy, , <wchar.h>)
+SYMBOL(wcsncpy_s, , <wchar.h>)
+SYMBOL(wcsnlen_s, , <wchar.h>)
+SYMBOL(wcspbrk, , <wchar.h>)
+SYMBOL(wcsrchr, , <wchar.h>)
+SYMBOL(wcsrtombs, , <wchar.h>)
+SYMBOL(wcsrtombs_s, , <wchar.h>)
+SYMBOL(wcsspn, , <wchar.h>)
+SYMBOL(wcsstr, , <wchar.h>)
+SYMBOL(wcstod, , <wchar.h>)
+SYMBOL(wcstof, , <wchar.h>)
+SYMBOL(wcstoimax, , <inttypes.h>)
+SYMBOL(wcstok, , <wchar.h>)
+SYMBOL(wcstok_s, , <wchar.h>)
+SYMBOL(wcstol, , <wchar.h>)
+SYMBOL(wcstold, , <wchar.h>)
+SYMBOL(wcstoll, , <wchar.h>)
+SYMBOL(wcstombs, , <stdlib.h>)
+SYMBOL(wcstombs_s, , <stdlib.h>)
+SYMBOL(wcstoul, , <wchar.h>)
+SYMBOL(wcstoull, , <wchar.h>)
+SYMBOL(wcstoumax, , <inttypes.h>)
+SYMBOL(wcsxfrm, , <wchar.h>)
+SYMBOL(wctob, , <wchar.h>)
+SYMBOL(wctomb, , <stdlib.h>)
+SYMBOL(wctomb_s, , <stdlib.h>)
+SYMBOL(wctrans, , <wctype.h>)
+SYMBOL(wctrans_t, , <wctype.h>)
+SYMBOL(wctype, , <wctype.h>)
+SYMBOL(wctype_t, , <wctype.h>)
+SYMBOL(wint_t, , <wctype.h>)
+SYMBOL(wmemchr, , <wchar.h>)
+SYMBOL(wmemcmp, , <wchar.h>)
+SYMBOL(wmemcpy, , <wchar.h>)
+SYMBOL(wmemcpy_s, , <wchar.h>)
+SYMBOL(wmemmove, , <wchar.h>)
+SYMBOL(wmemmove_s, , <wchar.h>)
+SYMBOL(wmemset, , <wchar.h>)
+SYMBOL(wprintf, , <wchar.h>)
+SYMBOL(wprintf_s, , <wchar.h>)
+SYMBOL(wscanf, , <wchar.h>)
+SYMBOL(wscanf_s, , <wchar.h>)
+SYMBOL(xor, , <iso646.h>)
+SYMBOL(xor_eq, , <iso646.h>)
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
