[clang] c812ab7 - [include-mapping] Add C-compatibility symbol entries.
Haojian Wu via cfe-commits
cfe-commits at lists.llvm.org
Thu Feb 9 06:52:12 PST 2023
Author: Haojian Wu
Date: 2023-02-09T15:34:41+01:00
New Revision: c812ab731243f9d5fe1764eb995809a22409ca71
URL: https://github.com/llvm/llvm-project/commit/c812ab731243f9d5fe1764eb995809a22409ca71
DIFF: https://github.com/llvm/llvm-project/commit/c812ab731243f9d5fe1764eb995809a22409ca71.diff
LOG: [include-mapping] Add C-compatibility symbol entries.
Extending the python generator:
- to generate C-compatibility symbols
- to generate macros
Differential Revision: https://reviews.llvm.org/D143214
Added:
Modified:
clang-tools-extra/clangd/unittests/StdLibTests.cpp
clang/include/clang/Tooling/Inclusions/StandardLibrary.h
clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
clang/tools/include-mapping/cppreference_parser.py
clang/tools/include-mapping/gen_std.py
clang/unittests/Tooling/StandardLibraryTest.cpp
Removed:
################################################################################
diff --git a/clang-tools-extra/clangd/unittests/StdLibTests.cpp b/clang-tools-extra/clangd/unittests/StdLibTests.cpp
index f70de71edfc3d..ef47141bade15 100644
--- a/clang-tools-extra/clangd/unittests/StdLibTests.cpp
+++ b/clang-tools-extra/clangd/unittests/StdLibTests.cpp
@@ -34,7 +34,7 @@ TEST(StdLibTests, getStdlibUmbrellaHeader) {
auto CXX = getStdlibUmbrellaHeader(LO).str();
EXPECT_THAT(CXX, HasSubstr("#include <string>"));
EXPECT_THAT(CXX, HasSubstr("#include <cstdio>"));
- EXPECT_THAT(CXX, Not(HasSubstr("#include <stdio.h>")));
+ EXPECT_THAT(CXX, Not(HasSubstr("#include <ios646.h>")));
LO.CPlusPlus = false;
auto C = getStdlibUmbrellaHeader(LO).str();
diff --git a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
index 830cbd5873bc6..9d45d84a429be 100644
--- a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
+++ b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
@@ -108,7 +108,7 @@ class Recognizer {
private:
using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
- NSSymbolMap *namespaceSymbols(const NamespaceDecl *D);
+ NSSymbolMap *namespaceSymbols(const DeclContext *DC, Lang L);
llvm::DenseMap<const DeclContext *, NSSymbolMap *> NamespaceCache;
};
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
index 55d87b98eb653..0340a9151424d 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -213,21 +213,14 @@ llvm::SmallVector<Header> Symbol::headers() const {
Recognizer::Recognizer() { ensureInitialized(); }
-NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
- if (!D)
- return nullptr;
- Lang Language;
- if (D->getLangOpts().CPlusPlus)
- Language = Lang::CXX;
- else if (D->getLangOpts().C11)
- Language = Lang::C;
- else
- return nullptr;
+NSSymbolMap *Recognizer::namespaceSymbols(const DeclContext *DC, Lang L) {
+ if (DC->isTranslationUnit()) // global scope.
+ return getMappingPerLang(L)->NamespaceSymbols->lookup("");
- auto It = NamespaceCache.find(D);
+ auto It = NamespaceCache.find(DC);
if (It != NamespaceCache.end())
return It->second;
-
+ const NamespaceDecl *D = llvm::cast<NamespaceDecl>(DC);
NSSymbolMap *Result = [&]() -> NSSymbolMap * {
if (D->isAnonymousNamespace())
return nullptr;
@@ -237,24 +230,35 @@ NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
ND = llvm::dyn_cast_or_null<NamespaceDecl>(ND->getParent()))
if (!ND->isInlineNamespace() && !ND->isAnonymousNamespace())
Scope = ND->getName().str() + "::" + Scope;
- return getMappingPerLang(Language)->NamespaceSymbols->lookup(Scope);
+ return getMappingPerLang(L)->NamespaceSymbols->lookup(Scope);
}();
NamespaceCache.try_emplace(D, Result);
return Result;
}
std::optional<Symbol> Recognizer::operator()(const Decl *D) {
+ Lang L;
+ if (D->getLangOpts().CPlusPlus) {
+ L = Lang::CXX;
+ } else if (D->getLangOpts().C11) {
+ L = Lang::C;
+ } else {
+ return std::nullopt; // not a supported language.
+ }
+
// If D is std::vector::iterator, `vector` is the outer symbol to look up.
// We keep all the candidate DCs as some may turn out to be anon enums.
// Do this resolution lazily as we may turn out not to have a std namespace.
llvm::SmallVector<const DeclContext *> IntermediateDecl;
const DeclContext *DC = D->getDeclContext();
- while (DC && !DC->isNamespace()) {
+ if (!DC) // The passed D is a TranslationUnitDecl!
+ return std::nullopt;
+ while (!DC->isNamespace() && !DC->isTranslationUnit()) {
if (NamedDecl::classofKind(DC->getDeclKind()))
IntermediateDecl.push_back(DC);
DC = DC->getParent();
}
- NSSymbolMap *Symbols = namespaceSymbols(cast_or_null<NamespaceDecl>(DC));
+ NSSymbolMap *Symbols = namespaceSymbols(DC, L);
if (!Symbols)
return std::nullopt;
@@ -277,7 +281,7 @@ std::optional<Symbol> Recognizer::operator()(const Decl *D) {
auto It = Symbols->find(Name);
if (It == Symbols->end())
return std::nullopt;
- return Symbol(It->second, D->getLangOpts().CPlusPlus? Lang::CXX : Lang::C);
+ return Symbol(It->second, L);
}
} // namespace stdlib
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
index 8e0162a648508..1712c06c78704 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
@@ -9,15 +9,565 @@
// Generated from cppreference offline HTML book (modified on 2022-07-30).
//===----------------------------------------------------------------------===//
+SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR8_T_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_FLAG_INIT, None, <atomic>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_LONG_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <atomic>)
+SYMBOL(ATOMIC_VAR_INIT, None, <atomic>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <atomic>)
+SYMBOL(BUFSIZ, None, <cstdio>)
+SYMBOL(BUFSIZ, None, <stdio.h>)
+SYMBOL(CHAR_BIT, None, <climits>)
+SYMBOL(CHAR_BIT, None, <limits.h>)
+SYMBOL(CHAR_MAX, None, <climits>)
+SYMBOL(CHAR_MAX, None, <limits.h>)
+SYMBOL(CHAR_MIN, None, <climits>)
+SYMBOL(CHAR_MIN, None, <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, None, <ctime>)
+SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
+SYMBOL(DBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(DBL_DIG, None, <cfloat>)
+SYMBOL(DBL_DIG, None, <float.h>)
+SYMBOL(DBL_EPSILON, None, <cfloat>)
+SYMBOL(DBL_EPSILON, None, <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(DBL_MANT_DIG, None, <cfloat>)
+SYMBOL(DBL_MANT_DIG, None, <float.h>)
+SYMBOL(DBL_MAX, None, <cfloat>)
+SYMBOL(DBL_MAX, None, <float.h>)
+SYMBOL(DBL_MAX_10_EXP, None, <cfloat>)
+SYMBOL(DBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(DBL_MAX_EXP, None, <cfloat>)
+SYMBOL(DBL_MAX_EXP, None, <float.h>)
+SYMBOL(DBL_MIN, None, <cfloat>)
+SYMBOL(DBL_MIN, None, <float.h>)
+SYMBOL(DBL_MIN_10_EXP, None, <cfloat>)
+SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(DBL_MIN_EXP, None, <cfloat>)
+SYMBOL(DBL_MIN_EXP, None, <float.h>)
+SYMBOL(DBL_TRUE_MIN, None, <cfloat>)
+SYMBOL(DBL_TRUE_MIN, None, <float.h>)
+SYMBOL(DECIMAL_DIG, None, <cfloat>)
+SYMBOL(DECIMAL_DIG, None, <float.h>)
+SYMBOL(E2BIG, None, <cerrno>)
+SYMBOL(E2BIG, None, <errno.h>)
+SYMBOL(EACCES, None, <cerrno>)
+SYMBOL(EACCES, None, <errno.h>)
+SYMBOL(EADDRINUSE, None, <cerrno>)
+SYMBOL(EADDRINUSE, None, <errno.h>)
+SYMBOL(EADDRNOTAVAIL, None, <cerrno>)
+SYMBOL(EADDRNOTAVAIL, None, <errno.h>)
+SYMBOL(EAFNOSUPPORT, None, <cerrno>)
+SYMBOL(EAFNOSUPPORT, None, <errno.h>)
+SYMBOL(EAGAIN, None, <cerrno>)
+SYMBOL(EAGAIN, None, <errno.h>)
+SYMBOL(EALREADY, None, <cerrno>)
+SYMBOL(EALREADY, None, <errno.h>)
+SYMBOL(EBADF, None, <cerrno>)
+SYMBOL(EBADF, None, <errno.h>)
+SYMBOL(EBADMSG, None, <cerrno>)
+SYMBOL(EBADMSG, None, <errno.h>)
+SYMBOL(EBUSY, None, <cerrno>)
+SYMBOL(EBUSY, None, <errno.h>)
+SYMBOL(ECANCELED, None, <cerrno>)
+SYMBOL(ECANCELED, None, <errno.h>)
+SYMBOL(ECHILD, None, <cerrno>)
+SYMBOL(ECHILD, None, <errno.h>)
+SYMBOL(ECONNABORTED, None, <cerrno>)
+SYMBOL(ECONNABORTED, None, <errno.h>)
+SYMBOL(ECONNREFUSED, None, <cerrno>)
+SYMBOL(ECONNREFUSED, None, <errno.h>)
+SYMBOL(ECONNRESET, None, <cerrno>)
+SYMBOL(ECONNRESET, None, <errno.h>)
+SYMBOL(EDEADLK, None, <cerrno>)
+SYMBOL(EDEADLK, None, <errno.h>)
+SYMBOL(EDESTADDRREQ, None, <cerrno>)
+SYMBOL(EDESTADDRREQ, None, <errno.h>)
+SYMBOL(EDOM, None, <cerrno>)
+SYMBOL(EDOM, None, <errno.h>)
+SYMBOL(EEXIST, None, <cerrno>)
+SYMBOL(EEXIST, None, <errno.h>)
+SYMBOL(EFAULT, None, <cerrno>)
+SYMBOL(EFAULT, None, <errno.h>)
+SYMBOL(EFBIG, None, <cerrno>)
+SYMBOL(EFBIG, None, <errno.h>)
+SYMBOL(EHOSTUNREACH, None, <cerrno>)
+SYMBOL(EHOSTUNREACH, None, <errno.h>)
+SYMBOL(EIDRM, None, <cerrno>)
+SYMBOL(EIDRM, None, <errno.h>)
+SYMBOL(EILSEQ, None, <cerrno>)
+SYMBOL(EILSEQ, None, <errno.h>)
+SYMBOL(EINPROGRESS, None, <cerrno>)
+SYMBOL(EINPROGRESS, None, <errno.h>)
+SYMBOL(EINTR, None, <cerrno>)
+SYMBOL(EINTR, None, <errno.h>)
+SYMBOL(EINVAL, None, <cerrno>)
+SYMBOL(EINVAL, None, <errno.h>)
+SYMBOL(EIO, None, <cerrno>)
+SYMBOL(EIO, None, <errno.h>)
+SYMBOL(EISCONN, None, <cerrno>)
+SYMBOL(EISCONN, None, <errno.h>)
+SYMBOL(EISDIR, None, <cerrno>)
+SYMBOL(EISDIR, None, <errno.h>)
+SYMBOL(ELOOP, None, <cerrno>)
+SYMBOL(ELOOP, None, <errno.h>)
+SYMBOL(EMFILE, None, <cerrno>)
+SYMBOL(EMFILE, None, <errno.h>)
+SYMBOL(EMLINK, None, <cerrno>)
+SYMBOL(EMLINK, None, <errno.h>)
+SYMBOL(EMSGSIZE, None, <cerrno>)
+SYMBOL(EMSGSIZE, None, <errno.h>)
+SYMBOL(ENAMETOOLONG, None, <cerrno>)
+SYMBOL(ENAMETOOLONG, None, <errno.h>)
+SYMBOL(ENETDOWN, None, <cerrno>)
+SYMBOL(ENETDOWN, None, <errno.h>)
+SYMBOL(ENETRESET, None, <cerrno>)
+SYMBOL(ENETRESET, None, <errno.h>)
+SYMBOL(ENETUNREACH, None, <cerrno>)
+SYMBOL(ENETUNREACH, None, <errno.h>)
+SYMBOL(ENFILE, None, <cerrno>)
+SYMBOL(ENFILE, None, <errno.h>)
+SYMBOL(ENOBUFS, None, <cerrno>)
+SYMBOL(ENOBUFS, None, <errno.h>)
+SYMBOL(ENODATA, None, <cerrno>)
+SYMBOL(ENODATA, None, <errno.h>)
+SYMBOL(ENODEV, None, <cerrno>)
+SYMBOL(ENODEV, None, <errno.h>)
+SYMBOL(ENOENT, None, <cerrno>)
+SYMBOL(ENOENT, None, <errno.h>)
+SYMBOL(ENOEXEC, None, <cerrno>)
+SYMBOL(ENOEXEC, None, <errno.h>)
+SYMBOL(ENOLCK, None, <cerrno>)
+SYMBOL(ENOLCK, None, <errno.h>)
+SYMBOL(ENOLINK, None, <cerrno>)
+SYMBOL(ENOLINK, None, <errno.h>)
+SYMBOL(ENOMEM, None, <cerrno>)
+SYMBOL(ENOMEM, None, <errno.h>)
+SYMBOL(ENOMSG, None, <cerrno>)
+SYMBOL(ENOMSG, None, <errno.h>)
+SYMBOL(ENOPROTOOPT, None, <cerrno>)
+SYMBOL(ENOPROTOOPT, None, <errno.h>)
+SYMBOL(ENOSPC, None, <cerrno>)
+SYMBOL(ENOSPC, None, <errno.h>)
+SYMBOL(ENOSR, None, <cerrno>)
+SYMBOL(ENOSR, None, <errno.h>)
+SYMBOL(ENOSTR, None, <cerrno>)
+SYMBOL(ENOSTR, None, <errno.h>)
+SYMBOL(ENOSYS, None, <cerrno>)
+SYMBOL(ENOSYS, None, <errno.h>)
+SYMBOL(ENOTCONN, None, <cerrno>)
+SYMBOL(ENOTCONN, None, <errno.h>)
+SYMBOL(ENOTDIR, None, <cerrno>)
+SYMBOL(ENOTDIR, None, <errno.h>)
+SYMBOL(ENOTEMPTY, None, <cerrno>)
+SYMBOL(ENOTEMPTY, None, <errno.h>)
+SYMBOL(ENOTRECOVERABLE, None, <cerrno>)
+SYMBOL(ENOTRECOVERABLE, None, <errno.h>)
+SYMBOL(ENOTSOCK, None, <cerrno>)
+SYMBOL(ENOTSOCK, None, <errno.h>)
+SYMBOL(ENOTSUP, None, <cerrno>)
+SYMBOL(ENOTSUP, None, <errno.h>)
+SYMBOL(ENOTTY, None, <cerrno>)
+SYMBOL(ENOTTY, None, <errno.h>)
+SYMBOL(ENXIO, None, <cerrno>)
+SYMBOL(ENXIO, None, <errno.h>)
+SYMBOL(EOF, None, <cstdio>)
+SYMBOL(EOF, None, <stdio.h>)
+SYMBOL(EOPNOTSUPP, None, <cerrno>)
+SYMBOL(EOPNOTSUPP, None, <errno.h>)
+SYMBOL(EOVERFLOW, None, <cerrno>)
+SYMBOL(EOVERFLOW, None, <errno.h>)
+SYMBOL(EOWNERDEAD, None, <cerrno>)
+SYMBOL(EOWNERDEAD, None, <errno.h>)
+SYMBOL(EPERM, None, <cerrno>)
+SYMBOL(EPERM, None, <errno.h>)
+SYMBOL(EPIPE, None, <cerrno>)
+SYMBOL(EPIPE, None, <errno.h>)
+SYMBOL(EPROTO, None, <cerrno>)
+SYMBOL(EPROTO, None, <errno.h>)
+SYMBOL(EPROTONOSUPPORT, None, <cerrno>)
+SYMBOL(EPROTONOSUPPORT, None, <errno.h>)
+SYMBOL(EPROTOTYPE, None, <cerrno>)
+SYMBOL(EPROTOTYPE, None, <errno.h>)
+SYMBOL(ERANGE, None, <cerrno>)
+SYMBOL(ERANGE, None, <errno.h>)
+SYMBOL(EROFS, None, <cerrno>)
+SYMBOL(EROFS, None, <errno.h>)
+SYMBOL(ESPIPE, None, <cerrno>)
+SYMBOL(ESPIPE, None, <errno.h>)
+SYMBOL(ESRCH, None, <cerrno>)
+SYMBOL(ESRCH, None, <errno.h>)
+SYMBOL(ETIME, None, <cerrno>)
+SYMBOL(ETIME, None, <errno.h>)
+SYMBOL(ETIMEDOUT, None, <cerrno>)
+SYMBOL(ETIMEDOUT, None, <errno.h>)
+SYMBOL(ETXTBSY, None, <cerrno>)
+SYMBOL(ETXTBSY, None, <errno.h>)
+SYMBOL(EWOULDBLOCK, None, <cerrno>)
+SYMBOL(EWOULDBLOCK, None, <errno.h>)
+SYMBOL(EXDEV, None, <cerrno>)
+SYMBOL(EXDEV, None, <errno.h>)
+SYMBOL(EXIT_FAILURE, None, <cstdlib>)
+SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, None, <cstdlib>)
+SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, None, <cfenv>)
+SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
+SYMBOL(FE_DFL_ENV, None, <cfenv>)
+SYMBOL(FE_DFL_ENV, None, <fenv.h>)
+SYMBOL(FE_DIVBYZERO, None, <cfenv>)
+SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
+SYMBOL(FE_DOWNWARD, None, <cfenv>)
+SYMBOL(FE_DOWNWARD, None, <fenv.h>)
+SYMBOL(FE_INEXACT, None, <cfenv>)
+SYMBOL(FE_INEXACT, None, <fenv.h>)
+SYMBOL(FE_INVALID, None, <cfenv>)
+SYMBOL(FE_INVALID, None, <fenv.h>)
+SYMBOL(FE_OVERFLOW, None, <cfenv>)
+SYMBOL(FE_OVERFLOW, None, <fenv.h>)
+SYMBOL(FE_TONEAREST, None, <cfenv>)
+SYMBOL(FE_TONEAREST, None, <fenv.h>)
+SYMBOL(FE_TOWARDZERO, None, <cfenv>)
+SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
+SYMBOL(FE_UNDERFLOW, None, <cfenv>)
+SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
+SYMBOL(FE_UPWARD, None, <cfenv>)
+SYMBOL(FE_UPWARD, None, <fenv.h>)
+SYMBOL(FILENAME_MAX, None, <cstdio>)
+SYMBOL(FILENAME_MAX, None, <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
+SYMBOL(FLT_DIG, None, <cfloat>)
+SYMBOL(FLT_DIG, None, <float.h>)
+SYMBOL(FLT_EPSILON, None, <cfloat>)
+SYMBOL(FLT_EPSILON, None, <float.h>)
+SYMBOL(FLT_EVAL_METHOD, None, <cfloat>)
+SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
+SYMBOL(FLT_MANT_DIG, None, <cfloat>)
+SYMBOL(FLT_MANT_DIG, None, <float.h>)
+SYMBOL(FLT_MAX, None, <cfloat>)
+SYMBOL(FLT_MAX, None, <float.h>)
+SYMBOL(FLT_MAX_10_EXP, None, <cfloat>)
+SYMBOL(FLT_MAX_10_EXP, None, <float.h>)
+SYMBOL(FLT_MAX_EXP, None, <cfloat>)
+SYMBOL(FLT_MAX_EXP, None, <float.h>)
+SYMBOL(FLT_MIN, None, <cfloat>)
+SYMBOL(FLT_MIN, None, <float.h>)
+SYMBOL(FLT_MIN_10_EXP, None, <cfloat>)
+SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
+SYMBOL(FLT_MIN_EXP, None, <cfloat>)
+SYMBOL(FLT_MIN_EXP, None, <float.h>)
+SYMBOL(FLT_RADIX, None, <cfloat>)
+SYMBOL(FLT_RADIX, None, <float.h>)
+SYMBOL(FLT_ROUNDS, None, <cfloat>)
+SYMBOL(FLT_ROUNDS, None, <float.h>)
+SYMBOL(FLT_TRUE_MIN, None, <cfloat>)
+SYMBOL(FLT_TRUE_MIN, None, <float.h>)
+SYMBOL(FOPEN_MAX, None, <cstdio>)
+SYMBOL(FOPEN_MAX, None, <stdio.h>)
+SYMBOL(FP_FAST_FMA, None, <cmath>)
+SYMBOL(FP_FAST_FMA, None, <math.h>)
+SYMBOL(FP_FAST_FMAF, None, <cmath>)
+SYMBOL(FP_FAST_FMAF, None, <math.h>)
+SYMBOL(FP_FAST_FMAL, None, <cmath>)
+SYMBOL(FP_FAST_FMAL, None, <math.h>)
+SYMBOL(FP_ILOGB0, None, <cmath>)
+SYMBOL(FP_ILOGB0, None, <math.h>)
+SYMBOL(FP_ILOGBNAN, None, <cmath>)
+SYMBOL(FP_ILOGBNAN, None, <math.h>)
+SYMBOL(FP_INFINITE, None, <cmath>)
+SYMBOL(FP_INFINITE, None, <math.h>)
+SYMBOL(FP_NAN, None, <cmath>)
+SYMBOL(FP_NAN, None, <math.h>)
+SYMBOL(FP_NORMAL, None, <cmath>)
+SYMBOL(FP_NORMAL, None, <math.h>)
+SYMBOL(FP_SUBNORMAL, None, <cmath>)
+SYMBOL(FP_SUBNORMAL, None, <math.h>)
+SYMBOL(FP_ZERO, None, <cmath>)
+SYMBOL(FP_ZERO, None, <math.h>)
+SYMBOL(HUGE_VAL, None, <cmath>)
+SYMBOL(HUGE_VAL, None, <math.h>)
+SYMBOL(HUGE_VALF, None, <cmath>)
+SYMBOL(HUGE_VALF, None, <math.h>)
+SYMBOL(HUGE_VALL, None, <cmath>)
+SYMBOL(HUGE_VALL, None, <math.h>)
+SYMBOL(INFINITY, None, <cmath>)
+SYMBOL(INFINITY, None, <math.h>)
+SYMBOL(INT16_MAX, None, <cstdint>)
+SYMBOL(INT16_MAX, None, <stdint.h>)
+SYMBOL(INT16_MIN, None, <cstdint>)
+SYMBOL(INT16_MIN, None, <stdint.h>)
+SYMBOL(INT32_MAX, None, <cstdint>)
+SYMBOL(INT32_MAX, None, <stdint.h>)
+SYMBOL(INT32_MIN, None, <cstdint>)
+SYMBOL(INT32_MIN, None, <stdint.h>)
+SYMBOL(INT64_MAX, None, <cstdint>)
+SYMBOL(INT64_MAX, None, <stdint.h>)
+SYMBOL(INT64_MIN, None, <cstdint>)
+SYMBOL(INT64_MIN, None, <stdint.h>)
+SYMBOL(INT8_MAX, None, <cstdint>)
+SYMBOL(INT8_MAX, None, <stdint.h>)
+SYMBOL(INT8_MIN, None, <cstdint>)
+SYMBOL(INT8_MIN, None, <stdint.h>)
+SYMBOL(INTMAX_MAX, None, <cstdint>)
+SYMBOL(INTMAX_MAX, None, <stdint.h>)
+SYMBOL(INTMAX_MIN, None, <cstdint>)
+SYMBOL(INTMAX_MIN, None, <stdint.h>)
+SYMBOL(INTPTR_MAX, None, <cstdint>)
+SYMBOL(INTPTR_MAX, None, <stdint.h>)
+SYMBOL(INTPTR_MIN, None, <cstdint>)
+SYMBOL(INTPTR_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST16_MAX, None, <cstdint>)
+SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST16_MIN, None, <cstdint>)
+SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST32_MAX, None, <cstdint>)
+SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST32_MIN, None, <cstdint>)
+SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST64_MAX, None, <cstdint>)
+SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST64_MIN, None, <cstdint>)
+SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_FAST8_MAX, None, <cstdint>)
+SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_FAST8_MIN, None, <cstdint>)
+SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, None, <cstdint>)
+SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, None, <cstdint>)
+SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
+SYMBOL(INT_MAX, None, <climits>)
+SYMBOL(INT_MAX, None, <limits.h>)
+SYMBOL(INT_MIN, None, <climits>)
+SYMBOL(INT_MIN, None, <limits.h>)
+SYMBOL(LC_ALL, None, <clocale>)
+SYMBOL(LC_ALL, None, <locale.h>)
+SYMBOL(LC_COLLATE, None, <clocale>)
+SYMBOL(LC_COLLATE, None, <locale.h>)
+SYMBOL(LC_CTYPE, None, <clocale>)
+SYMBOL(LC_CTYPE, None, <locale.h>)
+SYMBOL(LC_MONETARY, None, <clocale>)
+SYMBOL(LC_MONETARY, None, <locale.h>)
+SYMBOL(LC_NUMERIC, None, <clocale>)
+SYMBOL(LC_NUMERIC, None, <locale.h>)
+SYMBOL(LC_TIME, None, <clocale>)
+SYMBOL(LC_TIME, None, <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
+SYMBOL(LDBL_DIG, None, <cfloat>)
+SYMBOL(LDBL_DIG, None, <float.h>)
+SYMBOL(LDBL_EPSILON, None, <cfloat>)
+SYMBOL(LDBL_EPSILON, None, <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
+SYMBOL(LDBL_MANT_DIG, None, <cfloat>)
+SYMBOL(LDBL_MANT_DIG, None, <float.h>)
+SYMBOL(LDBL_MAX, None, <cfloat>)
+SYMBOL(LDBL_MAX, None, <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, None, <cfloat>)
+SYMBOL(LDBL_MAX_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MAX_EXP, None, <cfloat>)
+SYMBOL(LDBL_MAX_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN, None, <cfloat>)
+SYMBOL(LDBL_MIN, None, <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, None, <cfloat>)
+SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
+SYMBOL(LDBL_MIN_EXP, None, <cfloat>)
+SYMBOL(LDBL_MIN_EXP, None, <float.h>)
+SYMBOL(LDBL_TRUE_MIN, None, <cfloat>)
+SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
+SYMBOL(LLONG_MAX, None, <climits>)
+SYMBOL(LLONG_MAX, None, <limits.h>)
+SYMBOL(LLONG_MIN, None, <climits>)
+SYMBOL(LLONG_MIN, None, <limits.h>)
+SYMBOL(LONG_MAX, None, <climits>)
+SYMBOL(LONG_MAX, None, <limits.h>)
+SYMBOL(LONG_MIN, None, <climits>)
+SYMBOL(LONG_MIN, None, <limits.h>)
+SYMBOL(L_tmpnam, None, <cstdio>)
+SYMBOL(L_tmpnam, None, <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, None, <cmath>)
+SYMBOL(MATH_ERREXCEPT, None, <math.h>)
+SYMBOL(MATH_ERRNO, None, <cmath>)
+SYMBOL(MATH_ERRNO, None, <math.h>)
+SYMBOL(MB_CUR_MAX, None, <cstdlib>)
+SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
+SYMBOL(MB_LEN_MAX, None, <climits>)
+SYMBOL(MB_LEN_MAX, None, <limits.h>)
+SYMBOL(NAN, None, <cmath>)
+SYMBOL(NAN, None, <math.h>)
+SYMBOL(ONCE_FLAG_INIT, None, <mutex>)
+SYMBOL(PTRDIFF_MAX, None, <cstdint>)
+SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
+SYMBOL(PTRDIFF_MIN, None, <cstdint>)
+SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
+SYMBOL(RAND_MAX, None, <cstdlib>)
+SYMBOL(RAND_MAX, None, <stdlib.h>)
+SYMBOL(SCHAR_MAX, None, <climits>)
+SYMBOL(SCHAR_MAX, None, <limits.h>)
+SYMBOL(SCHAR_MIN, None, <climits>)
+SYMBOL(SCHAR_MIN, None, <limits.h>)
+SYMBOL(SEEK_CUR, None, <cstdio>)
+SYMBOL(SEEK_CUR, None, <stdio.h>)
+SYMBOL(SEEK_END, None, <cstdio>)
+SYMBOL(SEEK_END, None, <stdio.h>)
+SYMBOL(SEEK_SET, None, <cstdio>)
+SYMBOL(SEEK_SET, None, <stdio.h>)
+SYMBOL(SHRT_MAX, None, <climits>)
+SYMBOL(SHRT_MAX, None, <limits.h>)
+SYMBOL(SHRT_MIN, None, <climits>)
+SYMBOL(SHRT_MIN, None, <limits.h>)
+SYMBOL(SIGABRT, None, <csignal>)
+SYMBOL(SIGABRT, None, <signal.h>)
+SYMBOL(SIGFPE, None, <csignal>)
+SYMBOL(SIGFPE, None, <signal.h>)
+SYMBOL(SIGILL, None, <csignal>)
+SYMBOL(SIGILL, None, <signal.h>)
+SYMBOL(SIGINT, None, <csignal>)
+SYMBOL(SIGINT, None, <signal.h>)
+SYMBOL(SIGSEGV, None, <csignal>)
+SYMBOL(SIGSEGV, None, <signal.h>)
+SYMBOL(SIGTERM, None, <csignal>)
+SYMBOL(SIGTERM, None, <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, None, <cstdint>)
+SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, None, <cstdint>)
+SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
+SYMBOL(SIG_DFL, None, <csignal>)
+SYMBOL(SIG_DFL, None, <signal.h>)
+SYMBOL(SIG_ERR, None, <csignal>)
+SYMBOL(SIG_ERR, None, <signal.h>)
+SYMBOL(SIG_IGN, None, <csignal>)
+SYMBOL(SIG_IGN, None, <signal.h>)
+SYMBOL(SIZE_MAX, None, <cstdint>)
+SYMBOL(SIZE_MAX, None, <stdint.h>)
+SYMBOL(TIME_UTC, None, <ctime>)
+SYMBOL(TIME_UTC, None, <time.h>)
+SYMBOL(TMP_MAX, None, <cstdio>)
+SYMBOL(TMP_MAX, None, <stdio.h>)
+SYMBOL(UCHAR_MAX, None, <climits>)
+SYMBOL(UCHAR_MAX, None, <limits.h>)
+SYMBOL(UINT16_MAX, None, <cstdint>)
+SYMBOL(UINT16_MAX, None, <stdint.h>)
+SYMBOL(UINT32_MAX, None, <cstdint>)
+SYMBOL(UINT32_MAX, None, <stdint.h>)
+SYMBOL(UINT64_MAX, None, <cstdint>)
+SYMBOL(UINT64_MAX, None, <stdint.h>)
+SYMBOL(UINT8_MAX, None, <cstdint>)
+SYMBOL(UINT8_MAX, None, <stdint.h>)
+SYMBOL(UINTMAX_MAX, None, <cstdint>)
+SYMBOL(UINTMAX_MAX, None, <stdint.h>)
+SYMBOL(UINTPTR_MAX, None, <cstdint>)
+SYMBOL(UINTPTR_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, None, <cstdint>)
+SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, None, <cstdint>)
+SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
+SYMBOL(UINT_MAX, None, <climits>)
+SYMBOL(UINT_MAX, None, <limits.h>)
+SYMBOL(ULLONG_MAX, None, <climits>)
+SYMBOL(ULLONG_MAX, None, <limits.h>)
+SYMBOL(ULONG_MAX, None, <climits>)
+SYMBOL(ULONG_MAX, None, <limits.h>)
+SYMBOL(USHRT_MAX, None, <climits>)
+SYMBOL(USHRT_MAX, None, <limits.h>)
+SYMBOL(WEOF, None, <cwchar>)
+SYMBOL(WEOF, None, <wchar.h>)
+SYMBOL(WINT_MAX, None, <cstdint>)
+SYMBOL(WINT_MAX, None, <stdint.h>)
+SYMBOL(WINT_MIN, None, <cstdint>)
+SYMBOL(WINT_MIN, None, <stdint.h>)
+SYMBOL(_IOFBF, None, <cstdio>)
+SYMBOL(_IOFBF, None, <stdio.h>)
+SYMBOL(_IOLBF, None, <cstdio>)
+SYMBOL(_IOLBF, None, <stdio.h>)
+SYMBOL(_IONBF, None, <cstdio>)
+SYMBOL(_IONBF, None, <stdio.h>)
+SYMBOL(assert, None, <cassert>)
+SYMBOL(assert, None, <assert.h>)
+SYMBOL(errno, None, <cerrno>)
+SYMBOL(errno, None, <errno.h>)
+SYMBOL(math_errhandling, None, <cmath>)
+SYMBOL(math_errhandling, None, <math.h>)
+SYMBOL(offsetof, None, <cstddef>)
+SYMBOL(offsetof, None, <stddef.h>)
+SYMBOL(setjmp, None, <csetjmp>)
+SYMBOL(setjmp, None, <setjmp.h>)
+SYMBOL(stderr, None, <cstdio>)
+SYMBOL(stderr, None, <stdio.h>)
+SYMBOL(stdin, None, <cstdio>)
+SYMBOL(stdin, None, <stdio.h>)
+SYMBOL(stdout, None, <cstdio>)
+SYMBOL(stdout, None, <stdio.h>)
+SYMBOL(va_arg, None, <cstdarg>)
+SYMBOL(va_arg, None, <stdarg.h>)
+SYMBOL(va_copy, None, <cstdarg>)
+SYMBOL(va_copy, None, <stdarg.h>)
+SYMBOL(va_end, None, <cstdarg>)
+SYMBOL(va_end, None, <stdarg.h>)
+SYMBOL(va_start, None, <cstdarg>)
+SYMBOL(va_start, None, <stdarg.h>)
SYMBOL(FILE, std::, <cstdio>)
+SYMBOL(FILE, None, <cstdio>)
+SYMBOL(FILE, None, <stdio.h>)
SYMBOL(_Exit, std::, <cstdlib>)
+SYMBOL(_Exit, None, <cstdlib>)
+SYMBOL(_Exit, None, <stdlib.h>)
SYMBOL(accumulate, std::, <numeric>)
SYMBOL(acos, std::, <cmath>)
+SYMBOL(acos, None, <cmath>)
+SYMBOL(acos, None, <math.h>)
SYMBOL(acosf, std::, <cmath>)
+SYMBOL(acosf, None, <cmath>)
+SYMBOL(acosf, None, <math.h>)
SYMBOL(acosh, std::, <cmath>)
+SYMBOL(acosh, None, <cmath>)
+SYMBOL(acosh, None, <math.h>)
SYMBOL(acoshf, std::, <cmath>)
+SYMBOL(acoshf, None, <cmath>)
+SYMBOL(acoshf, None, <math.h>)
SYMBOL(acoshl, std::, <cmath>)
+SYMBOL(acoshl, None, <cmath>)
+SYMBOL(acoshl, None, <math.h>)
SYMBOL(acosl, std::, <cmath>)
+SYMBOL(acosl, None, <cmath>)
+SYMBOL(acosl, None, <math.h>)
SYMBOL(add_const, std::, <type_traits>)
SYMBOL(add_const_t, std::, <type_traits>)
SYMBOL(add_cv, std::, <type_traits>)
@@ -39,6 +589,8 @@ SYMBOL(advance, std::, <iterator>)
SYMBOL(align, std::, <memory>)
SYMBOL(align_val_t, std::, <new>)
SYMBOL(aligned_alloc, std::, <cstdlib>)
+SYMBOL(aligned_alloc, None, <cstdlib>)
+SYMBOL(aligned_alloc, None, <stdlib.h>)
SYMBOL(aligned_storage, std::, <type_traits>)
SYMBOL(aligned_storage_t, std::, <type_traits>)
SYMBOL(aligned_union, std::, <type_traits>)
@@ -63,12 +615,26 @@ SYMBOL(as_bytes, std::, <span>)
SYMBOL(as_const, std::, <utility>)
SYMBOL(as_writable_bytes, std::, <span>)
SYMBOL(asctime, std::, <ctime>)
+SYMBOL(asctime, None, <ctime>)
+SYMBOL(asctime, None, <time.h>)
SYMBOL(asin, std::, <cmath>)
+SYMBOL(asin, None, <cmath>)
+SYMBOL(asin, None, <math.h>)
SYMBOL(asinf, std::, <cmath>)
+SYMBOL(asinf, None, <cmath>)
+SYMBOL(asinf, None, <math.h>)
SYMBOL(asinh, std::, <cmath>)
+SYMBOL(asinh, None, <cmath>)
+SYMBOL(asinh, None, <math.h>)
SYMBOL(asinhf, std::, <cmath>)
+SYMBOL(asinhf, None, <cmath>)
+SYMBOL(asinhf, None, <math.h>)
SYMBOL(asinhl, std::, <cmath>)
+SYMBOL(asinhl, None, <cmath>)
+SYMBOL(asinhl, None, <math.h>)
SYMBOL(asinl, std::, <cmath>)
+SYMBOL(asinl, None, <cmath>)
+SYMBOL(asinl, None, <math.h>)
SYMBOL(assignable_from, std::, <concepts>)
SYMBOL(assoc_laguerre, std::, <cmath>)
SYMBOL(assoc_laguerref, std::, <cmath>)
@@ -79,20 +645,50 @@ SYMBOL(assoc_legendrel, std::, <cmath>)
SYMBOL(assume_aligned, std::, <memory>)
SYMBOL(async, std::, <future>)
SYMBOL(at_quick_exit, std::, <cstdlib>)
+SYMBOL(at_quick_exit, None, <cstdlib>)
+SYMBOL(at_quick_exit, None, <stdlib.h>)
SYMBOL(atan, std::, <cmath>)
+SYMBOL(atan, None, <cmath>)
+SYMBOL(atan, None, <math.h>)
SYMBOL(atan2, std::, <cmath>)
+SYMBOL(atan2, None, <cmath>)
+SYMBOL(atan2, None, <math.h>)
SYMBOL(atan2f, std::, <cmath>)
+SYMBOL(atan2f, None, <cmath>)
+SYMBOL(atan2f, None, <math.h>)
SYMBOL(atan2l, std::, <cmath>)
+SYMBOL(atan2l, None, <cmath>)
+SYMBOL(atan2l, None, <math.h>)
SYMBOL(atanf, std::, <cmath>)
+SYMBOL(atanf, None, <cmath>)
+SYMBOL(atanf, None, <math.h>)
SYMBOL(atanh, std::, <cmath>)
+SYMBOL(atanh, None, <cmath>)
+SYMBOL(atanh, None, <math.h>)
SYMBOL(atanhf, std::, <cmath>)
+SYMBOL(atanhf, None, <cmath>)
+SYMBOL(atanhf, None, <math.h>)
SYMBOL(atanhl, std::, <cmath>)
+SYMBOL(atanhl, None, <cmath>)
+SYMBOL(atanhl, None, <math.h>)
SYMBOL(atanl, std::, <cmath>)
+SYMBOL(atanl, None, <cmath>)
+SYMBOL(atanl, None, <math.h>)
SYMBOL(atexit, std::, <cstdlib>)
+SYMBOL(atexit, None, <cstdlib>)
+SYMBOL(atexit, None, <stdlib.h>)
SYMBOL(atof, std::, <cstdlib>)
+SYMBOL(atof, None, <cstdlib>)
+SYMBOL(atof, None, <stdlib.h>)
SYMBOL(atoi, std::, <cstdlib>)
+SYMBOL(atoi, None, <cstdlib>)
+SYMBOL(atoi, None, <stdlib.h>)
SYMBOL(atol, std::, <cstdlib>)
+SYMBOL(atol, None, <cstdlib>)
+SYMBOL(atol, None, <stdlib.h>)
SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL(atoll, None, <cstdlib>)
+SYMBOL(atoll, None, <stdlib.h>)
SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
@@ -233,21 +829,45 @@ SYMBOL(boolalpha, std::, <iostream>)
SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
SYMBOL(boyer_moore_searcher, std::, <functional>)
SYMBOL(bsearch, std::, <cstdlib>)
+SYMBOL(bsearch, None, <cstdlib>)
+SYMBOL(bsearch, None, <stdlib.h>)
SYMBOL(btowc, std::, <cwchar>)
+SYMBOL(btowc, None, <cwchar>)
+SYMBOL(btowc, None, <wchar.h>)
SYMBOL(byte, std::, <cstddef>)
SYMBOL(byteswap, std::, <bit>)
SYMBOL(c16rtomb, std::, <cuchar>)
+SYMBOL(c16rtomb, None, <cuchar>)
+SYMBOL(c16rtomb, None, <uchar.h>)
SYMBOL(c32rtomb, std::, <cuchar>)
+SYMBOL(c32rtomb, None, <cuchar>)
+SYMBOL(c32rtomb, None, <uchar.h>)
SYMBOL(c8rtomb, std::, <cuchar>)
+SYMBOL(c8rtomb, None, <cuchar>)
+SYMBOL(c8rtomb, None, <uchar.h>)
SYMBOL(call_once, std::, <mutex>)
SYMBOL(calloc, std::, <cstdlib>)
+SYMBOL(calloc, None, <cstdlib>)
+SYMBOL(calloc, None, <stdlib.h>)
SYMBOL(cauchy_distribution, std::, <random>)
SYMBOL(cbrt, std::, <cmath>)
+SYMBOL(cbrt, None, <cmath>)
+SYMBOL(cbrt, None, <math.h>)
SYMBOL(cbrtf, std::, <cmath>)
+SYMBOL(cbrtf, None, <cmath>)
+SYMBOL(cbrtf, None, <math.h>)
SYMBOL(cbrtl, std::, <cmath>)
+SYMBOL(cbrtl, None, <cmath>)
+SYMBOL(cbrtl, None, <math.h>)
SYMBOL(ceil, std::, <cmath>)
+SYMBOL(ceil, None, <cmath>)
+SYMBOL(ceil, None, <math.h>)
SYMBOL(ceilf, std::, <cmath>)
+SYMBOL(ceilf, None, <cmath>)
+SYMBOL(ceilf, None, <math.h>)
SYMBOL(ceill, std::, <cmath>)
+SYMBOL(ceill, None, <cmath>)
+SYMBOL(ceill, None, <math.h>)
SYMBOL(centi, std::, <ratio>)
SYMBOL(cerr, std::, <iostream>)
SYMBOL(char_traits, std::, <string>)
@@ -256,8 +876,14 @@ SYMBOL(chi_squared_distribution, std::, <random>)
SYMBOL(cin, std::, <iostream>)
SYMBOL(clamp, std::, <algorithm>)
SYMBOL(clearerr, std::, <cstdio>)
+SYMBOL(clearerr, None, <cstdio>)
+SYMBOL(clearerr, None, <stdio.h>)
SYMBOL(clock, std::, <ctime>)
+SYMBOL(clock, None, <ctime>)
+SYMBOL(clock, None, <time.h>)
SYMBOL(clock_t, std::, <ctime>)
+SYMBOL(clock_t, None, <ctime>)
+SYMBOL(clock_t, None, <time.h>)
SYMBOL(clog, std::, <iostream>)
SYMBOL(cmatch, std::, <regex>)
SYMBOL(cmp_equal, std::, <utility>)
@@ -323,16 +949,34 @@ SYMBOL(copy_if, std::, <algorithm>)
SYMBOL(copy_n, std::, <algorithm>)
SYMBOL(copyable, std::, <concepts>)
SYMBOL(copysign, std::, <cmath>)
+SYMBOL(copysign, None, <cmath>)
+SYMBOL(copysign, None, <math.h>)
SYMBOL(copysignf, std::, <cmath>)
+SYMBOL(copysignf, None, <cmath>)
+SYMBOL(copysignf, None, <math.h>)
SYMBOL(copysignl, std::, <cmath>)
+SYMBOL(copysignl, None, <cmath>)
+SYMBOL(copysignl, None, <math.h>)
SYMBOL(coroutine_handle, std::, <coroutine>)
SYMBOL(coroutine_traits, std::, <coroutine>)
SYMBOL(cos, std::, <cmath>)
+SYMBOL(cos, None, <cmath>)
+SYMBOL(cos, None, <math.h>)
SYMBOL(cosf, std::, <cmath>)
+SYMBOL(cosf, None, <cmath>)
+SYMBOL(cosf, None, <math.h>)
SYMBOL(cosh, std::, <cmath>)
+SYMBOL(cosh, None, <cmath>)
+SYMBOL(cosh, None, <math.h>)
SYMBOL(coshf, std::, <cmath>)
+SYMBOL(coshf, None, <cmath>)
+SYMBOL(coshf, None, <math.h>)
SYMBOL(coshl, std::, <cmath>)
+SYMBOL(coshl, None, <cmath>)
+SYMBOL(coshl, None, <math.h>)
SYMBOL(cosl, std::, <cmath>)
+SYMBOL(cosl, None, <cmath>)
+SYMBOL(cosl, None, <math.h>)
SYMBOL(count, std::, <algorithm>)
SYMBOL(count_if, std::, <algorithm>)
SYMBOL(counted_iterator, std::, <iterator>)
@@ -347,6 +991,8 @@ SYMBOL(cregex_iterator, std::, <regex>)
SYMBOL(cregex_token_iterator, std::, <regex>)
SYMBOL(csub_match, std::, <regex>)
SYMBOL(ctime, std::, <ctime>)
+SYMBOL(ctime, None, <ctime>)
+SYMBOL(ctime, None, <time.h>)
SYMBOL(ctype, std::, <locale>)
SYMBOL(ctype_base, std::, <locale>)
SYMBOL(ctype_byname, std::, <locale>)
@@ -395,6 +1041,8 @@ SYMBOL(destroying_delete, std::, <new>)
SYMBOL(destroying_delete_t, std::, <new>)
SYMBOL(destructible, std::, <concepts>)
SYMBOL(
diff time, std::, <ctime>)
+SYMBOL(
diff time, None, <ctime>)
+SYMBOL(
diff time, None, <time.h>)
SYMBOL(disable_sized_sentinel_for, std::, <iterator>)
SYMBOL(discard_block_engine, std::, <random>)
SYMBOL(discrete_distribution, std::, <random>)
@@ -402,9 +1050,13 @@ SYMBOL(disjunction, std::, <type_traits>)
SYMBOL(disjunction_v, std::, <type_traits>)
SYMBOL(distance, std::, <iterator>)
SYMBOL(div_t, std::, <cstdlib>)
+SYMBOL(div_t, None, <cstdlib>)
+SYMBOL(div_t, None, <stdlib.h>)
SYMBOL(divides, std::, <functional>)
SYMBOL(domain_error, std::, <stdexcept>)
SYMBOL(double_t, std::, <cmath>)
+SYMBOL(double_t, None, <cmath>)
+SYMBOL(double_t, None, <math.h>)
SYMBOL(dynamic_extent, std::, <span>)
SYMBOL(dynamic_pointer_cast, std::, <memory>)
SYMBOL(ellint_1, std::, <cmath>)
@@ -435,11 +1087,23 @@ SYMBOL(equivalence_relation, std::, <concepts>)
SYMBOL(erase, std::, <vector>)
SYMBOL(erase_if, std::, <vector>)
SYMBOL(erf, std::, <cmath>)
+SYMBOL(erf, None, <cmath>)
+SYMBOL(erf, None, <math.h>)
SYMBOL(erfc, std::, <cmath>)
+SYMBOL(erfc, None, <cmath>)
+SYMBOL(erfc, None, <math.h>)
SYMBOL(erfcf, std::, <cmath>)
+SYMBOL(erfcf, None, <cmath>)
+SYMBOL(erfcf, None, <math.h>)
SYMBOL(erfcl, std::, <cmath>)
+SYMBOL(erfcl, None, <cmath>)
+SYMBOL(erfcl, None, <math.h>)
SYMBOL(erff, std::, <cmath>)
+SYMBOL(erff, None, <cmath>)
+SYMBOL(erff, None, <math.h>)
SYMBOL(erfl, std::, <cmath>)
+SYMBOL(erfl, None, <cmath>)
+SYMBOL(erfl, None, <math.h>)
SYMBOL(errc, std::, <system_error>)
SYMBOL(error_category, std::, <system_error>)
SYMBOL(error_code, std::, <system_error>)
@@ -450,52 +1114,128 @@ SYMBOL(exception_ptr, std::, <exception>)
SYMBOL(exchange, std::, <utility>)
SYMBOL(exclusive_scan, std::, <numeric>)
SYMBOL(exit, std::, <cstdlib>)
+SYMBOL(exit, None, <cstdlib>)
+SYMBOL(exit, None, <stdlib.h>)
SYMBOL(exp, std::, <cmath>)
+SYMBOL(exp, None, <cmath>)
+SYMBOL(exp, None, <math.h>)
SYMBOL(exp2, std::, <cmath>)
+SYMBOL(exp2, None, <cmath>)
+SYMBOL(exp2, None, <math.h>)
SYMBOL(exp2f, std::, <cmath>)
+SYMBOL(exp2f, None, <cmath>)
+SYMBOL(exp2f, None, <math.h>)
SYMBOL(exp2l, std::, <cmath>)
+SYMBOL(exp2l, None, <cmath>)
+SYMBOL(exp2l, None, <math.h>)
SYMBOL(expf, std::, <cmath>)
+SYMBOL(expf, None, <cmath>)
+SYMBOL(expf, None, <math.h>)
SYMBOL(expint, std::, <cmath>)
SYMBOL(expintf, std::, <cmath>)
SYMBOL(expintl, std::, <cmath>)
SYMBOL(expl, std::, <cmath>)
+SYMBOL(expl, None, <cmath>)
+SYMBOL(expl, None, <math.h>)
SYMBOL(expm1, std::, <cmath>)
+SYMBOL(expm1, None, <cmath>)
+SYMBOL(expm1, None, <math.h>)
SYMBOL(expm1f, std::, <cmath>)
+SYMBOL(expm1f, None, <cmath>)
+SYMBOL(expm1f, None, <math.h>)
SYMBOL(expm1l, std::, <cmath>)
+SYMBOL(expm1l, None, <cmath>)
+SYMBOL(expm1l, None, <math.h>)
SYMBOL(exponential_distribution, std::, <random>)
SYMBOL(extent, std::, <type_traits>)
SYMBOL(extent_v, std::, <type_traits>)
SYMBOL(extreme_value_distribution, std::, <random>)
SYMBOL(fabs, std::, <cmath>)
+SYMBOL(fabs, None, <cmath>)
+SYMBOL(fabs, None, <math.h>)
SYMBOL(fabsf, std::, <cmath>)
+SYMBOL(fabsf, None, <cmath>)
+SYMBOL(fabsf, None, <math.h>)
SYMBOL(fabsl, std::, <cmath>)
+SYMBOL(fabsl, None, <cmath>)
+SYMBOL(fabsl, None, <math.h>)
SYMBOL(false_type, std::, <type_traits>)
SYMBOL(fclose, std::, <cstdio>)
+SYMBOL(fclose, None, <cstdio>)
+SYMBOL(fclose, None, <stdio.h>)
SYMBOL(fdim, std::, <cmath>)
+SYMBOL(fdim, None, <cmath>)
+SYMBOL(fdim, None, <math.h>)
SYMBOL(fdimf, std::, <cmath>)
+SYMBOL(fdimf, None, <cmath>)
+SYMBOL(fdimf, None, <math.h>)
SYMBOL(fdiml, std::, <cmath>)
+SYMBOL(fdiml, None, <cmath>)
+SYMBOL(fdiml, None, <math.h>)
SYMBOL(feclearexcept, std::, <cfenv>)
+SYMBOL(feclearexcept, None, <cfenv>)
+SYMBOL(feclearexcept, None, <fenv.h>)
SYMBOL(fegetenv, std::, <cfenv>)
+SYMBOL(fegetenv, None, <cfenv>)
+SYMBOL(fegetenv, None, <fenv.h>)
SYMBOL(fegetexceptflag, std::, <cfenv>)
+SYMBOL(fegetexceptflag, None, <cfenv>)
+SYMBOL(fegetexceptflag, None, <fenv.h>)
SYMBOL(fegetround, std::, <cfenv>)
+SYMBOL(fegetround, None, <cfenv>)
+SYMBOL(fegetround, None, <fenv.h>)
SYMBOL(feholdexcept, std::, <cfenv>)
+SYMBOL(feholdexcept, None, <cfenv>)
+SYMBOL(feholdexcept, None, <fenv.h>)
SYMBOL(femto, std::, <ratio>)
SYMBOL(fenv_t, std::, <cfenv>)
+SYMBOL(fenv_t, None, <cfenv>)
+SYMBOL(fenv_t, None, <fenv.h>)
SYMBOL(feof, std::, <cstdio>)
+SYMBOL(feof, None, <cstdio>)
+SYMBOL(feof, None, <stdio.h>)
SYMBOL(feraiseexcept, std::, <cfenv>)
+SYMBOL(feraiseexcept, None, <cfenv>)
+SYMBOL(feraiseexcept, None, <fenv.h>)
SYMBOL(ferror, std::, <cstdio>)
+SYMBOL(ferror, None, <cstdio>)
+SYMBOL(ferror, None, <stdio.h>)
SYMBOL(fesetenv, std::, <cfenv>)
+SYMBOL(fesetenv, None, <cfenv>)
+SYMBOL(fesetenv, None, <fenv.h>)
SYMBOL(fesetexceptflag, std::, <cfenv>)
+SYMBOL(fesetexceptflag, None, <cfenv>)
+SYMBOL(fesetexceptflag, None, <fenv.h>)
SYMBOL(fesetround, std::, <cfenv>)
+SYMBOL(fesetround, None, <cfenv>)
+SYMBOL(fesetround, None, <fenv.h>)
SYMBOL(fetestexcept, std::, <cfenv>)
+SYMBOL(fetestexcept, None, <cfenv>)
+SYMBOL(fetestexcept, None, <fenv.h>)
SYMBOL(feupdateenv, std::, <cfenv>)
+SYMBOL(feupdateenv, None, <cfenv>)
+SYMBOL(feupdateenv, None, <fenv.h>)
SYMBOL(fexcept_t, std::, <cfenv>)
+SYMBOL(fexcept_t, None, <cfenv>)
+SYMBOL(fexcept_t, None, <fenv.h>)
SYMBOL(fflush, std::, <cstdio>)
+SYMBOL(fflush, None, <cstdio>)
+SYMBOL(fflush, None, <stdio.h>)
SYMBOL(fgetc, std::, <cstdio>)
+SYMBOL(fgetc, None, <cstdio>)
+SYMBOL(fgetc, None, <stdio.h>)
SYMBOL(fgetpos, std::, <cstdio>)
+SYMBOL(fgetpos, None, <cstdio>)
+SYMBOL(fgetpos, None, <stdio.h>)
SYMBOL(fgets, std::, <cstdio>)
+SYMBOL(fgets, None, <cstdio>)
+SYMBOL(fgets, None, <stdio.h>)
SYMBOL(fgetwc, std::, <cwchar>)
+SYMBOL(fgetwc, None, <cwchar>)
+SYMBOL(fgetwc, None, <wchar.h>)
SYMBOL(fgetws, std::, <cwchar>)
+SYMBOL(fgetws, None, <cwchar>)
+SYMBOL(fgetws, None, <wchar.h>)
SYMBOL(filebuf, std::, <streambuf>)
SYMBOL(filebuf, std::, <iostream>)
SYMBOL(filebuf, std::, <iosfwd>)
@@ -512,27 +1252,61 @@ SYMBOL(fixed, std::, <iostream>)
SYMBOL(float_denorm_style, std::, <limits>)
SYMBOL(float_round_style, std::, <limits>)
SYMBOL(float_t, std::, <cmath>)
+SYMBOL(float_t, None, <cmath>)
+SYMBOL(float_t, None, <math.h>)
SYMBOL(floating_point, std::, <concepts>)
SYMBOL(floor, std::, <cmath>)
+SYMBOL(floor, None, <cmath>)
+SYMBOL(floor, None, <math.h>)
SYMBOL(floorf, std::, <cmath>)
+SYMBOL(floorf, None, <cmath>)
+SYMBOL(floorf, None, <math.h>)
SYMBOL(floorl, std::, <cmath>)
+SYMBOL(floorl, None, <cmath>)
+SYMBOL(floorl, None, <math.h>)
SYMBOL(flush, std::, <ostream>)
SYMBOL(flush, std::, <iostream>)
SYMBOL(flush_emit, std::, <ostream>)
SYMBOL(flush_emit, std::, <iostream>)
SYMBOL(fma, std::, <cmath>)
+SYMBOL(fma, None, <cmath>)
+SYMBOL(fma, None, <math.h>)
SYMBOL(fmaf, std::, <cmath>)
+SYMBOL(fmaf, None, <cmath>)
+SYMBOL(fmaf, None, <math.h>)
SYMBOL(fmal, std::, <cmath>)
+SYMBOL(fmal, None, <cmath>)
+SYMBOL(fmal, None, <math.h>)
SYMBOL(fmax, std::, <cmath>)
+SYMBOL(fmax, None, <cmath>)
+SYMBOL(fmax, None, <math.h>)
SYMBOL(fmaxf, std::, <cmath>)
+SYMBOL(fmaxf, None, <cmath>)
+SYMBOL(fmaxf, None, <math.h>)
SYMBOL(fmaxl, std::, <cmath>)
+SYMBOL(fmaxl, None, <cmath>)
+SYMBOL(fmaxl, None, <math.h>)
SYMBOL(fmin, std::, <cmath>)
+SYMBOL(fmin, None, <cmath>)
+SYMBOL(fmin, None, <math.h>)
SYMBOL(fminf, std::, <cmath>)
+SYMBOL(fminf, None, <cmath>)
+SYMBOL(fminf, None, <math.h>)
SYMBOL(fminl, std::, <cmath>)
+SYMBOL(fminl, None, <cmath>)
+SYMBOL(fminl, None, <math.h>)
SYMBOL(fmod, std::, <cmath>)
+SYMBOL(fmod, None, <cmath>)
+SYMBOL(fmod, None, <math.h>)
SYMBOL(fmodf, std::, <cmath>)
+SYMBOL(fmodf, None, <cmath>)
+SYMBOL(fmodf, None, <math.h>)
SYMBOL(fmodl, std::, <cmath>)
+SYMBOL(fmodl, None, <cmath>)
+SYMBOL(fmodl, None, <math.h>)
SYMBOL(fopen, std::, <cstdio>)
+SYMBOL(fopen, None, <cstdio>)
+SYMBOL(fopen, None, <stdio.h>)
SYMBOL(for_each, std::, <algorithm>)
SYMBOL(for_each_n, std::, <algorithm>)
SYMBOL(format, std::, <format>)
@@ -552,21 +1326,47 @@ SYMBOL(forward_iterator_tag, std::, <iterator>)
SYMBOL(forward_like, std::, <utility>)
SYMBOL(forward_list, std::, <forward_list>)
SYMBOL(fpclassify, std::, <cmath>)
+SYMBOL(fpclassify, None, <cmath>)
+SYMBOL(fpclassify, None, <math.h>)
SYMBOL(fpos, std::, <ios>)
SYMBOL(fpos, std::, <iostream>)
SYMBOL(fpos, std::, <iosfwd>)
SYMBOL(fpos_t, std::, <cstdio>)
+SYMBOL(fpos_t, None, <cstdio>)
+SYMBOL(fpos_t, None, <stdio.h>)
SYMBOL(fprintf, std::, <cstdio>)
+SYMBOL(fprintf, None, <cstdio>)
+SYMBOL(fprintf, None, <stdio.h>)
SYMBOL(fputc, std::, <cstdio>)
+SYMBOL(fputc, None, <cstdio>)
+SYMBOL(fputc, None, <stdio.h>)
SYMBOL(fputs, std::, <cstdio>)
+SYMBOL(fputs, None, <cstdio>)
+SYMBOL(fputs, None, <stdio.h>)
SYMBOL(fputwc, std::, <cwchar>)
+SYMBOL(fputwc, None, <cwchar>)
+SYMBOL(fputwc, None, <wchar.h>)
SYMBOL(fputws, std::, <cwchar>)
+SYMBOL(fputws, None, <cwchar>)
+SYMBOL(fputws, None, <wchar.h>)
SYMBOL(fread, std::, <cstdio>)
+SYMBOL(fread, None, <cstdio>)
+SYMBOL(fread, None, <stdio.h>)
SYMBOL(free, std::, <cstdlib>)
+SYMBOL(free, None, <cstdlib>)
+SYMBOL(free, None, <stdlib.h>)
SYMBOL(freopen, std::, <cstdio>)
+SYMBOL(freopen, None, <cstdio>)
+SYMBOL(freopen, None, <stdio.h>)
SYMBOL(frexp, std::, <cmath>)
+SYMBOL(frexp, None, <cmath>)
+SYMBOL(frexp, None, <math.h>)
SYMBOL(frexpf, std::, <cmath>)
+SYMBOL(frexpf, None, <cmath>)
+SYMBOL(frexpf, None, <math.h>)
SYMBOL(frexpl, std::, <cmath>)
+SYMBOL(frexpl, None, <cmath>)
+SYMBOL(frexpl, None, <math.h>)
SYMBOL(from_chars, std::, <charconv>)
SYMBOL(from_chars_result, std::, <charconv>)
SYMBOL(from_range, std::, <ranges>)
@@ -574,11 +1374,19 @@ SYMBOL(from_range_t, std::, <ranges>)
SYMBOL(front_insert_iterator, std::, <iterator>)
SYMBOL(front_inserter, std::, <iterator>)
SYMBOL(fscanf, std::, <cstdio>)
+SYMBOL(fscanf, None, <cstdio>)
+SYMBOL(fscanf, None, <stdio.h>)
SYMBOL(fseek, std::, <cstdio>)
+SYMBOL(fseek, None, <cstdio>)
+SYMBOL(fseek, None, <stdio.h>)
SYMBOL(fsetpos, std::, <cstdio>)
+SYMBOL(fsetpos, None, <cstdio>)
+SYMBOL(fsetpos, None, <stdio.h>)
SYMBOL(fstream, std::, <fstream>)
SYMBOL(fstream, std::, <iosfwd>)
SYMBOL(ftell, std::, <cstdio>)
+SYMBOL(ftell, None, <cstdio>)
+SYMBOL(ftell, None, <stdio.h>)
SYMBOL(function, std::, <functional>)
SYMBOL(future, std::, <future>)
SYMBOL(future_category, std::, <future>)
@@ -586,9 +1394,17 @@ SYMBOL(future_errc, std::, <future>)
SYMBOL(future_error, std::, <future>)
SYMBOL(future_status, std::, <future>)
SYMBOL(fwide, std::, <cwchar>)
+SYMBOL(fwide, None, <cwchar>)
+SYMBOL(fwide, None, <wchar.h>)
SYMBOL(fwprintf, std::, <cwchar>)
+SYMBOL(fwprintf, None, <cwchar>)
+SYMBOL(fwprintf, None, <wchar.h>)
SYMBOL(fwrite, std::, <cstdio>)
+SYMBOL(fwrite, None, <cstdio>)
+SYMBOL(fwrite, None, <stdio.h>)
SYMBOL(fwscanf, std::, <cwchar>)
+SYMBOL(fwscanf, None, <cwchar>)
+SYMBOL(fwscanf, None, <wchar.h>)
SYMBOL(gamma_distribution, std::, <random>)
SYMBOL(gcd, std::, <numeric>)
SYMBOL(generate, std::, <algorithm>)
@@ -606,14 +1422,28 @@ SYMBOL(get_terminate, std::, <exception>)
SYMBOL(get_time, std::, <iomanip>)
SYMBOL(get_unexpected, std::, <exception>)
SYMBOL(getc, std::, <cstdio>)
+SYMBOL(getc, None, <cstdio>)
+SYMBOL(getc, None, <stdio.h>)
SYMBOL(getchar, std::, <cstdio>)
+SYMBOL(getchar, None, <cstdio>)
+SYMBOL(getchar, None, <stdio.h>)
SYMBOL(getenv, std::, <cstdlib>)
+SYMBOL(getenv, None, <cstdlib>)
+SYMBOL(getenv, None, <stdlib.h>)
SYMBOL(getline, std::, <string>)
SYMBOL(gets, std::, <cstdio>)
+SYMBOL(gets, None, <cstdio>)
+SYMBOL(gets, None, <stdio.h>)
SYMBOL(getwc, std::, <cwchar>)
+SYMBOL(getwc, None, <cwchar>)
+SYMBOL(getwc, None, <wchar.h>)
SYMBOL(getwchar, std::, <cwchar>)
+SYMBOL(getwchar, None, <cwchar>)
+SYMBOL(getwchar, None, <wchar.h>)
SYMBOL(giga, std::, <ratio>)
SYMBOL(gmtime, std::, <ctime>)
+SYMBOL(gmtime, None, <ctime>)
+SYMBOL(gmtime, None, <time.h>)
SYMBOL(greater, std::, <functional>)
SYMBOL(greater_equal, std::, <functional>)
SYMBOL(gslice, std::, <valarray>)
@@ -637,19 +1467,37 @@ SYMBOL(hexfloat, std::, <ios>)
SYMBOL(hexfloat, std::, <iostream>)
SYMBOL(holds_alternative, std::, <variant>)
SYMBOL(hypot, std::, <cmath>)
+SYMBOL(hypot, None, <cmath>)
+SYMBOL(hypot, None, <math.h>)
SYMBOL(hypotf, std::, <cmath>)
+SYMBOL(hypotf, None, <cmath>)
+SYMBOL(hypotf, None, <math.h>)
SYMBOL(hypotl, std::, <cmath>)
+SYMBOL(hypotl, None, <cmath>)
+SYMBOL(hypotl, None, <math.h>)
SYMBOL(identity, std::, <functional>)
SYMBOL(ifstream, std::, <fstream>)
SYMBOL(ifstream, std::, <iosfwd>)
SYMBOL(ignore, std::, <tuple>)
SYMBOL(ilogb, std::, <cmath>)
+SYMBOL(ilogb, None, <cmath>)
+SYMBOL(ilogb, None, <math.h>)
SYMBOL(ilogbf, std::, <cmath>)
+SYMBOL(ilogbf, None, <cmath>)
+SYMBOL(ilogbf, None, <math.h>)
SYMBOL(ilogbl, std::, <cmath>)
+SYMBOL(ilogbl, None, <cmath>)
+SYMBOL(ilogbl, None, <math.h>)
SYMBOL(imag, std::, <complex>)
SYMBOL(imaxabs, std::, <cinttypes>)
+SYMBOL(imaxabs, None, <cinttypes>)
+SYMBOL(imaxabs, None, <inttypes.h>)
SYMBOL(imaxdiv, std::, <cinttypes>)
+SYMBOL(imaxdiv, None, <cinttypes>)
+SYMBOL(imaxdiv, None, <inttypes.h>)
SYMBOL(imaxdiv_t, std::, <cinttypes>)
+SYMBOL(imaxdiv_t, None, <cinttypes>)
+SYMBOL(imaxdiv_t, None, <inttypes.h>)
SYMBOL(in_place, std::, <utility>)
SYMBOL(in_place_index, std::, <utility>)
SYMBOL(in_place_index_t, std::, <utility>)
@@ -690,24 +1538,52 @@ SYMBOL(input_or_output_iterator, std::, <iterator>)
SYMBOL(insert_iterator, std::, <iterator>)
SYMBOL(inserter, std::, <iterator>)
SYMBOL(int16_t, std::, <cstdint>)
+SYMBOL(int16_t, None, <cstdint>)
+SYMBOL(int16_t, None, <stdint.h>)
SYMBOL(int32_t, std::, <cstdint>)
+SYMBOL(int32_t, None, <cstdint>)
+SYMBOL(int32_t, None, <stdint.h>)
SYMBOL(int64_t, std::, <cstdint>)
+SYMBOL(int64_t, None, <cstdint>)
+SYMBOL(int64_t, None, <stdint.h>)
SYMBOL(int8_t, std::, <cstdint>)
+SYMBOL(int8_t, None, <cstdint>)
+SYMBOL(int8_t, None, <stdint.h>)
SYMBOL(int_fast16_t, std::, <cstdint>)
+SYMBOL(int_fast16_t, None, <cstdint>)
+SYMBOL(int_fast16_t, None, <stdint.h>)
SYMBOL(int_fast32_t, std::, <cstdint>)
+SYMBOL(int_fast32_t, None, <cstdint>)
+SYMBOL(int_fast32_t, None, <stdint.h>)
SYMBOL(int_fast64_t, std::, <cstdint>)
+SYMBOL(int_fast64_t, None, <cstdint>)
+SYMBOL(int_fast64_t, None, <stdint.h>)
SYMBOL(int_fast8_t, std::, <cstdint>)
+SYMBOL(int_fast8_t, None, <cstdint>)
+SYMBOL(int_fast8_t, None, <stdint.h>)
SYMBOL(int_least16_t, std::, <cstdint>)
+SYMBOL(int_least16_t, None, <cstdint>)
+SYMBOL(int_least16_t, None, <stdint.h>)
SYMBOL(int_least32_t, std::, <cstdint>)
+SYMBOL(int_least32_t, None, <cstdint>)
+SYMBOL(int_least32_t, None, <stdint.h>)
SYMBOL(int_least64_t, std::, <cstdint>)
+SYMBOL(int_least64_t, None, <cstdint>)
+SYMBOL(int_least64_t, None, <stdint.h>)
SYMBOL(int_least8_t, std::, <cstdint>)
+SYMBOL(int_least8_t, None, <cstdint>)
+SYMBOL(int_least8_t, None, <stdint.h>)
SYMBOL(integer_sequence, std::, <utility>)
SYMBOL(integral, std::, <concepts>)
SYMBOL(integral_constant, std::, <type_traits>)
SYMBOL(internal, std::, <ios>)
SYMBOL(internal, std::, <iostream>)
SYMBOL(intmax_t, std::, <cstdint>)
+SYMBOL(intmax_t, None, <cstdint>)
+SYMBOL(intmax_t, None, <stdint.h>)
SYMBOL(intptr_t, std::, <cstdint>)
+SYMBOL(intptr_t, None, <cstdint>)
+SYMBOL(intptr_t, None, <stdint.h>)
SYMBOL(invalid_argument, std::, <stdexcept>)
SYMBOL(invocable, std::, <concepts>)
SYMBOL(invoke, std::, <functional>)
@@ -906,26 +1782,64 @@ SYMBOL(is_void_v, std::, <type_traits>)
SYMBOL(is_volatile, std::, <type_traits>)
SYMBOL(is_volatile_v, std::, <type_traits>)
SYMBOL(isalnum, std::, <cctype>)
+SYMBOL(isalnum, None, <cctype>)
+SYMBOL(isalnum, None, <ctype.h>)
SYMBOL(isalpha, std::, <cctype>)
+SYMBOL(isalpha, None, <cctype>)
+SYMBOL(isalpha, None, <ctype.h>)
SYMBOL(isblank, std::, <cctype>)
+SYMBOL(isblank, None, <cctype>)
+SYMBOL(isblank, None, <ctype.h>)
SYMBOL(iscntrl, std::, <cctype>)
+SYMBOL(iscntrl, None, <cctype>)
+SYMBOL(iscntrl, None, <ctype.h>)
SYMBOL(isdigit, std::, <cctype>)
+SYMBOL(isdigit, None, <cctype>)
+SYMBOL(isdigit, None, <ctype.h>)
SYMBOL(isfinite, std::, <cmath>)
+SYMBOL(isfinite, None, <cmath>)
+SYMBOL(isfinite, None, <math.h>)
SYMBOL(isgraph, std::, <cctype>)
+SYMBOL(isgraph, None, <cctype>)
+SYMBOL(isgraph, None, <ctype.h>)
SYMBOL(isgreater, std::, <cmath>)
+SYMBOL(isgreater, None, <cmath>)
+SYMBOL(isgreater, None, <math.h>)
SYMBOL(isgreaterequal, std::, <cmath>)
+SYMBOL(isgreaterequal, None, <cmath>)
+SYMBOL(isgreaterequal, None, <math.h>)
SYMBOL(isinf, std::, <cmath>)
+SYMBOL(isinf, None, <cmath>)
+SYMBOL(isinf, None, <math.h>)
SYMBOL(isless, std::, <cmath>)
+SYMBOL(isless, None, <cmath>)
+SYMBOL(isless, None, <math.h>)
SYMBOL(islessequal, std::, <cmath>)
+SYMBOL(islessequal, None, <cmath>)
+SYMBOL(islessequal, None, <math.h>)
SYMBOL(islessgreater, std::, <cmath>)
+SYMBOL(islessgreater, None, <cmath>)
+SYMBOL(islessgreater, None, <math.h>)
SYMBOL(islower, std::, <cctype>)
+SYMBOL(islower, None, <cctype>)
+SYMBOL(islower, None, <ctype.h>)
SYMBOL(isnan, std::, <cmath>)
+SYMBOL(isnan, None, <cmath>)
+SYMBOL(isnan, None, <math.h>)
SYMBOL(isnormal, std::, <cmath>)
+SYMBOL(isnormal, None, <cmath>)
+SYMBOL(isnormal, None, <math.h>)
SYMBOL(ispanstream, std::, <spanstream>)
SYMBOL(ispanstream, std::, <iosfwd>)
SYMBOL(isprint, std::, <cctype>)
+SYMBOL(isprint, None, <cctype>)
+SYMBOL(isprint, None, <ctype.h>)
SYMBOL(ispunct, std::, <cctype>)
+SYMBOL(ispunct, None, <cctype>)
+SYMBOL(ispunct, None, <ctype.h>)
SYMBOL(isspace, std::, <cctype>)
+SYMBOL(isspace, None, <cctype>)
+SYMBOL(isspace, None, <ctype.h>)
SYMBOL(istream, std::, <istream>)
SYMBOL(istream, std::, <iostream>)
SYMBOL(istream, std::, <iosfwd>)
@@ -936,21 +1850,53 @@ SYMBOL(istringstream, std::, <sstream>)
SYMBOL(istringstream, std::, <iosfwd>)
SYMBOL(istrstream, std::, <strstream>)
SYMBOL(isunordered, std::, <cmath>)
+SYMBOL(isunordered, None, <cmath>)
+SYMBOL(isunordered, None, <math.h>)
SYMBOL(isupper, std::, <cctype>)
+SYMBOL(isupper, None, <cctype>)
+SYMBOL(isupper, None, <ctype.h>)
SYMBOL(iswalnum, std::, <cwctype>)
+SYMBOL(iswalnum, None, <cwctype>)
+SYMBOL(iswalnum, None, <wctype.h>)
SYMBOL(iswalpha, std::, <cwctype>)
+SYMBOL(iswalpha, None, <cwctype>)
+SYMBOL(iswalpha, None, <wctype.h>)
SYMBOL(iswblank, std::, <cwctype>)
+SYMBOL(iswblank, None, <cwctype>)
+SYMBOL(iswblank, None, <wctype.h>)
SYMBOL(iswcntrl, std::, <cwctype>)
+SYMBOL(iswcntrl, None, <cwctype>)
+SYMBOL(iswcntrl, None, <wctype.h>)
SYMBOL(iswctype, std::, <cwctype>)
+SYMBOL(iswctype, None, <cwctype>)
+SYMBOL(iswctype, None, <wctype.h>)
SYMBOL(iswdigit, std::, <cwctype>)
+SYMBOL(iswdigit, None, <cwctype>)
+SYMBOL(iswdigit, None, <wctype.h>)
SYMBOL(iswgraph, std::, <cwctype>)
+SYMBOL(iswgraph, None, <cwctype>)
+SYMBOL(iswgraph, None, <wctype.h>)
SYMBOL(iswlower, std::, <cwctype>)
+SYMBOL(iswlower, None, <cwctype>)
+SYMBOL(iswlower, None, <wctype.h>)
SYMBOL(iswprint, std::, <cwctype>)
+SYMBOL(iswprint, None, <cwctype>)
+SYMBOL(iswprint, None, <wctype.h>)
SYMBOL(iswpunct, std::, <cwctype>)
+SYMBOL(iswpunct, None, <cwctype>)
+SYMBOL(iswpunct, None, <wctype.h>)
SYMBOL(iswspace, std::, <cwctype>)
+SYMBOL(iswspace, None, <cwctype>)
+SYMBOL(iswspace, None, <wctype.h>)
SYMBOL(iswupper, std::, <cwctype>)
+SYMBOL(iswupper, None, <cwctype>)
+SYMBOL(iswupper, None, <wctype.h>)
SYMBOL(iswxdigit, std::, <cwctype>)
+SYMBOL(iswxdigit, None, <cwctype>)
+SYMBOL(iswxdigit, None, <wctype.h>)
SYMBOL(isxdigit, std::, <cctype>)
+SYMBOL(isxdigit, None, <cctype>)
+SYMBOL(isxdigit, None, <ctype.h>)
SYMBOL(iter_common_reference_t, std::, <iterator>)
SYMBOL(iter_const_reference_t, std::, <iterator>)
SYMBOL(iter_
diff erence_t, std::, <iterator>)
@@ -961,11 +1907,15 @@ SYMBOL(iter_value_t, std::, <iterator>)
SYMBOL(iterator, std::, <iterator>)
SYMBOL(iterator_traits, std::, <iterator>)
SYMBOL(jmp_buf, std::, <csetjmp>)
+SYMBOL(jmp_buf, None, <csetjmp>)
+SYMBOL(jmp_buf, None, <setjmp.h>)
SYMBOL(jthread, std::, <thread>)
SYMBOL(kill_dependency, std::, <atomic>)
SYMBOL(kilo, std::, <ratio>)
SYMBOL(knuth_b, std::, <random>)
SYMBOL(labs, std::, <cstdlib>)
+SYMBOL(labs, None, <cstdlib>)
+SYMBOL(labs, None, <stdlib.h>)
SYMBOL(laguerre, std::, <cmath>)
SYMBOL(laguerref, std::, <cmath>)
SYMBOL(laguerrel, std::, <cmath>)
@@ -974,11 +1924,23 @@ SYMBOL(launch, std::, <future>)
SYMBOL(launder, std::, <new>)
SYMBOL(lcm, std::, <numeric>)
SYMBOL(lconv, std::, <clocale>)
+SYMBOL(lconv, None, <clocale>)
+SYMBOL(lconv, None, <locale.h>)
SYMBOL(ldexp, std::, <cmath>)
+SYMBOL(ldexp, None, <cmath>)
+SYMBOL(ldexp, None, <math.h>)
SYMBOL(ldexpf, std::, <cmath>)
+SYMBOL(ldexpf, None, <cmath>)
+SYMBOL(ldexpf, None, <math.h>)
SYMBOL(ldexpl, std::, <cmath>)
+SYMBOL(ldexpl, None, <cmath>)
+SYMBOL(ldexpl, None, <math.h>)
SYMBOL(ldiv, std::, <cstdlib>)
+SYMBOL(ldiv, None, <cstdlib>)
+SYMBOL(ldiv, None, <stdlib.h>)
SYMBOL(ldiv_t, std::, <cstdlib>)
+SYMBOL(ldiv_t, None, <cstdlib>)
+SYMBOL(ldiv_t, None, <stdlib.h>)
SYMBOL(left, std::, <ios>)
SYMBOL(left, std::, <iostream>)
SYMBOL(legendre, std::, <cmath>)
@@ -991,52 +1953,124 @@ SYMBOL(less_equal, std::, <functional>)
SYMBOL(lexicographical_compare, std::, <algorithm>)
SYMBOL(lexicographical_compare_three_way, std::, <algorithm>)
SYMBOL(lgamma, std::, <cmath>)
+SYMBOL(lgamma, None, <cmath>)
+SYMBOL(lgamma, None, <math.h>)
SYMBOL(lgammaf, std::, <cmath>)
+SYMBOL(lgammaf, None, <cmath>)
+SYMBOL(lgammaf, None, <math.h>)
SYMBOL(lgammal, std::, <cmath>)
+SYMBOL(lgammal, None, <cmath>)
+SYMBOL(lgammal, None, <math.h>)
SYMBOL(linear_congruential_engine, std::, <random>)
SYMBOL(list, std::, <list>)
SYMBOL(llabs, std::, <cstdlib>)
+SYMBOL(llabs, None, <cstdlib>)
+SYMBOL(llabs, None, <stdlib.h>)
SYMBOL(lldiv, std::, <cstdlib>)
+SYMBOL(lldiv, None, <cstdlib>)
+SYMBOL(lldiv, None, <stdlib.h>)
SYMBOL(lldiv_t, std::, <cstdlib>)
+SYMBOL(lldiv_t, None, <cstdlib>)
+SYMBOL(lldiv_t, None, <stdlib.h>)
SYMBOL(llrint, std::, <cmath>)
+SYMBOL(llrint, None, <cmath>)
+SYMBOL(llrint, None, <math.h>)
SYMBOL(llrintf, std::, <cmath>)
+SYMBOL(llrintf, None, <cmath>)
+SYMBOL(llrintf, None, <math.h>)
SYMBOL(llrintl, std::, <cmath>)
+SYMBOL(llrintl, None, <cmath>)
+SYMBOL(llrintl, None, <math.h>)
SYMBOL(llround, std::, <cmath>)
+SYMBOL(llround, None, <cmath>)
+SYMBOL(llround, None, <math.h>)
SYMBOL(llroundf, std::, <cmath>)
+SYMBOL(llroundf, None, <cmath>)
+SYMBOL(llroundf, None, <math.h>)
SYMBOL(llroundl, std::, <cmath>)
+SYMBOL(llroundl, None, <cmath>)
+SYMBOL(llroundl, None, <math.h>)
SYMBOL(locale, std::, <locale>)
SYMBOL(localeconv, std::, <clocale>)
+SYMBOL(localeconv, None, <clocale>)
+SYMBOL(localeconv, None, <locale.h>)
SYMBOL(localtime, std::, <ctime>)
+SYMBOL(localtime, None, <ctime>)
+SYMBOL(localtime, None, <time.h>)
SYMBOL(lock, std::, <mutex>)
SYMBOL(lock_guard, std::, <mutex>)
SYMBOL(log, std::, <cmath>)
+SYMBOL(log, None, <cmath>)
+SYMBOL(log, None, <math.h>)
SYMBOL(log10, std::, <cmath>)
+SYMBOL(log10, None, <cmath>)
+SYMBOL(log10, None, <math.h>)
SYMBOL(log10f, std::, <cmath>)
+SYMBOL(log10f, None, <cmath>)
+SYMBOL(log10f, None, <math.h>)
SYMBOL(log10l, std::, <cmath>)
+SYMBOL(log10l, None, <cmath>)
+SYMBOL(log10l, None, <math.h>)
SYMBOL(log1p, std::, <cmath>)
+SYMBOL(log1p, None, <cmath>)
+SYMBOL(log1p, None, <math.h>)
SYMBOL(log1pf, std::, <cmath>)
+SYMBOL(log1pf, None, <cmath>)
+SYMBOL(log1pf, None, <math.h>)
SYMBOL(log1pl, std::, <cmath>)
+SYMBOL(log1pl, None, <cmath>)
+SYMBOL(log1pl, None, <math.h>)
SYMBOL(log2, std::, <cmath>)
+SYMBOL(log2, None, <cmath>)
+SYMBOL(log2, None, <math.h>)
SYMBOL(log2f, std::, <cmath>)
+SYMBOL(log2f, None, <cmath>)
+SYMBOL(log2f, None, <math.h>)
SYMBOL(log2l, std::, <cmath>)
+SYMBOL(log2l, None, <cmath>)
+SYMBOL(log2l, None, <math.h>)
SYMBOL(logb, std::, <cmath>)
+SYMBOL(logb, None, <cmath>)
+SYMBOL(logb, None, <math.h>)
SYMBOL(logbf, std::, <cmath>)
+SYMBOL(logbf, None, <cmath>)
+SYMBOL(logbf, None, <math.h>)
SYMBOL(logbl, std::, <cmath>)
+SYMBOL(logbl, None, <cmath>)
+SYMBOL(logbl, None, <math.h>)
SYMBOL(logf, std::, <cmath>)
+SYMBOL(logf, None, <cmath>)
+SYMBOL(logf, None, <math.h>)
SYMBOL(logic_error, std::, <stdexcept>)
SYMBOL(logical_and, std::, <functional>)
SYMBOL(logical_not, std::, <functional>)
SYMBOL(logical_or, std::, <functional>)
SYMBOL(logl, std::, <cmath>)
+SYMBOL(logl, None, <cmath>)
+SYMBOL(logl, None, <math.h>)
SYMBOL(lognormal_distribution, std::, <random>)
SYMBOL(longjmp, std::, <csetjmp>)
+SYMBOL(longjmp, None, <csetjmp>)
+SYMBOL(longjmp, None, <setjmp.h>)
SYMBOL(lower_bound, std::, <algorithm>)
SYMBOL(lrint, std::, <cmath>)
+SYMBOL(lrint, None, <cmath>)
+SYMBOL(lrint, None, <math.h>)
SYMBOL(lrintf, std::, <cmath>)
+SYMBOL(lrintf, None, <cmath>)
+SYMBOL(lrintf, None, <math.h>)
SYMBOL(lrintl, std::, <cmath>)
+SYMBOL(lrintl, None, <cmath>)
+SYMBOL(lrintl, None, <math.h>)
SYMBOL(lround, std::, <cmath>)
+SYMBOL(lround, None, <cmath>)
+SYMBOL(lround, None, <math.h>)
SYMBOL(lroundf, std::, <cmath>)
+SYMBOL(lroundf, None, <cmath>)
+SYMBOL(lroundf, None, <math.h>)
SYMBOL(lroundl, std::, <cmath>)
+SYMBOL(lroundl, None, <cmath>)
+SYMBOL(lroundl, None, <math.h>)
SYMBOL(make_exception_ptr, std::, <exception>)
SYMBOL(make_format_args, std::, <format>)
SYMBOL(make_from_tuple, std::, <tuple>)
@@ -1057,22 +2091,46 @@ SYMBOL(make_unsigned, std::, <type_traits>)
SYMBOL(make_unsigned_t, std::, <type_traits>)
SYMBOL(make_wformat_args, std::, <format>)
SYMBOL(malloc, std::, <cstdlib>)
+SYMBOL(malloc, None, <cstdlib>)
+SYMBOL(malloc, None, <stdlib.h>)
SYMBOL(map, std::, <map>)
SYMBOL(mask_array, std::, <valarray>)
SYMBOL(match_results, std::, <regex>)
SYMBOL(max, std::, <algorithm>)
SYMBOL(max_align_t, std::, <cstddef>)
+SYMBOL(max_align_t, None, <cstddef>)
+SYMBOL(max_align_t, None, <stddef.h>)
SYMBOL(max_element, std::, <algorithm>)
SYMBOL(mblen, std::, <cstdlib>)
+SYMBOL(mblen, None, <cstdlib>)
+SYMBOL(mblen, None, <stdlib.h>)
SYMBOL(mbrlen, std::, <cwchar>)
+SYMBOL(mbrlen, None, <cwchar>)
+SYMBOL(mbrlen, None, <wchar.h>)
SYMBOL(mbrtoc16, std::, <cuchar>)
+SYMBOL(mbrtoc16, None, <cuchar>)
+SYMBOL(mbrtoc16, None, <uchar.h>)
SYMBOL(mbrtoc32, std::, <cuchar>)
+SYMBOL(mbrtoc32, None, <cuchar>)
+SYMBOL(mbrtoc32, None, <uchar.h>)
SYMBOL(mbrtoc8, std::, <cuchar>)
+SYMBOL(mbrtoc8, None, <cuchar>)
+SYMBOL(mbrtoc8, None, <uchar.h>)
SYMBOL(mbrtowc, std::, <cwchar>)
+SYMBOL(mbrtowc, None, <cwchar>)
+SYMBOL(mbrtowc, None, <wchar.h>)
SYMBOL(mbsinit, std::, <cwchar>)
+SYMBOL(mbsinit, None, <cwchar>)
+SYMBOL(mbsinit, None, <wchar.h>)
SYMBOL(mbsrtowcs, std::, <cwchar>)
+SYMBOL(mbsrtowcs, None, <cwchar>)
+SYMBOL(mbsrtowcs, None, <wchar.h>)
SYMBOL(mbstowcs, std::, <cstdlib>)
+SYMBOL(mbstowcs, None, <cstdlib>)
+SYMBOL(mbstowcs, None, <stdlib.h>)
SYMBOL(mbtowc, std::, <cstdlib>)
+SYMBOL(mbtowc, None, <cstdlib>)
+SYMBOL(mbtowc, None, <stdlib.h>)
SYMBOL(mega, std::, <ratio>)
SYMBOL(mem_fn, std::, <functional>)
SYMBOL(mem_fun, std::, <functional>)
@@ -1082,9 +2140,17 @@ SYMBOL(mem_fun_ref, std::, <functional>)
SYMBOL(mem_fun_ref_t, std::, <functional>)
SYMBOL(mem_fun_t, std::, <functional>)
SYMBOL(memchr, std::, <cstring>)
+SYMBOL(memchr, None, <cstring>)
+SYMBOL(memchr, None, <string.h>)
SYMBOL(memcmp, std::, <cstring>)
+SYMBOL(memcmp, None, <cstring>)
+SYMBOL(memcmp, None, <string.h>)
SYMBOL(memcpy, std::, <cstring>)
+SYMBOL(memcpy, None, <cstring>)
+SYMBOL(memcpy, None, <string.h>)
SYMBOL(memmove, std::, <cstring>)
+SYMBOL(memmove, None, <cstring>)
+SYMBOL(memmove, None, <string.h>)
SYMBOL(memory_order, std::, <atomic>)
SYMBOL(memory_order_acq_rel, std::, <atomic>)
SYMBOL(memory_order_acquire, std::, <atomic>)
@@ -1093,6 +2159,8 @@ SYMBOL(memory_order_relaxed, std::, <atomic>)
SYMBOL(memory_order_release, std::, <atomic>)
SYMBOL(memory_order_seq_cst, std::, <atomic>)
SYMBOL(memset, std::, <cstring>)
+SYMBOL(memset, None, <cstring>)
+SYMBOL(memset, None, <string.h>)
SYMBOL(merge, std::, <algorithm>)
SYMBOL(mergeable, std::, <iterator>)
SYMBOL(mersenne_twister_engine, std::, <random>)
@@ -1111,9 +2179,17 @@ SYMBOL(minstd_rand0, std::, <random>)
SYMBOL(minus, std::, <functional>)
SYMBOL(mismatch, std::, <algorithm>)
SYMBOL(mktime, std::, <ctime>)
+SYMBOL(mktime, None, <ctime>)
+SYMBOL(mktime, None, <time.h>)
SYMBOL(modf, std::, <cmath>)
+SYMBOL(modf, None, <cmath>)
+SYMBOL(modf, None, <math.h>)
SYMBOL(modff, std::, <cmath>)
+SYMBOL(modff, None, <cmath>)
+SYMBOL(modff, None, <math.h>)
SYMBOL(modfl, std::, <cmath>)
+SYMBOL(modfl, None, <cmath>)
+SYMBOL(modfl, None, <math.h>)
SYMBOL(modulus, std::, <functional>)
SYMBOL(money_base, std::, <locale>)
SYMBOL(money_get, std::, <locale>)
@@ -1135,12 +2211,24 @@ SYMBOL(multiplies, std::, <functional>)
SYMBOL(multiset, std::, <set>)
SYMBOL(mutex, std::, <mutex>)
SYMBOL(nan, std::, <cmath>)
+SYMBOL(nan, None, <cmath>)
+SYMBOL(nan, None, <math.h>)
SYMBOL(nanf, std::, <cmath>)
+SYMBOL(nanf, None, <cmath>)
+SYMBOL(nanf, None, <math.h>)
SYMBOL(nanl, std::, <cmath>)
+SYMBOL(nanl, None, <cmath>)
+SYMBOL(nanl, None, <math.h>)
SYMBOL(nano, std::, <ratio>)
SYMBOL(nearbyint, std::, <cmath>)
+SYMBOL(nearbyint, None, <cmath>)
+SYMBOL(nearbyint, None, <math.h>)
SYMBOL(nearbyintf, std::, <cmath>)
+SYMBOL(nearbyintf, None, <cmath>)
+SYMBOL(nearbyintf, None, <math.h>)
SYMBOL(nearbyintl, std::, <cmath>)
+SYMBOL(nearbyintl, None, <cmath>)
+SYMBOL(nearbyintl, None, <math.h>)
SYMBOL(negate, std::, <functional>)
SYMBOL(negation, std::, <type_traits>)
SYMBOL(negation_v, std::, <type_traits>)
@@ -1150,11 +2238,23 @@ SYMBOL(new_handler, std::, <new>)
SYMBOL(next, std::, <iterator>)
SYMBOL(next_permutation, std::, <algorithm>)
SYMBOL(nextafter, std::, <cmath>)
+SYMBOL(nextafter, None, <cmath>)
+SYMBOL(nextafter, None, <math.h>)
SYMBOL(nextafterf, std::, <cmath>)
+SYMBOL(nextafterf, None, <cmath>)
+SYMBOL(nextafterf, None, <math.h>)
SYMBOL(nextafterl, std::, <cmath>)
+SYMBOL(nextafterl, None, <cmath>)
+SYMBOL(nextafterl, None, <math.h>)
SYMBOL(nexttoward, std::, <cmath>)
+SYMBOL(nexttoward, None, <cmath>)
+SYMBOL(nexttoward, None, <math.h>)
SYMBOL(nexttowardf, std::, <cmath>)
+SYMBOL(nexttowardf, None, <cmath>)
+SYMBOL(nexttowardf, None, <math.h>)
SYMBOL(nexttowardl, std::, <cmath>)
+SYMBOL(nexttowardl, None, <cmath>)
+SYMBOL(nexttowardl, None, <math.h>)
SYMBOL(noboolalpha, std::, <ios>)
SYMBOL(noboolalpha, std::, <iostream>)
SYMBOL(noemit_on_flush, std::, <ostream>)
@@ -1190,6 +2290,8 @@ SYMBOL(nth_element, std::, <algorithm>)
SYMBOL(nullopt, std::, <optional>)
SYMBOL(nullopt_t, std::, <optional>)
SYMBOL(nullptr_t, std::, <cstddef>)
+SYMBOL(nullptr_t, None, <cstddef>)
+SYMBOL(nullptr_t, None, <stddef.h>)
SYMBOL(num_get, std::, <locale>)
SYMBOL(num_put, std::, <locale>)
SYMBOL(numeric_limits, std::, <limits>)
@@ -1235,6 +2337,8 @@ SYMBOL(partition_copy, std::, <algorithm>)
SYMBOL(partition_point, std::, <algorithm>)
SYMBOL(permutable, std::, <iterator>)
SYMBOL(perror, std::, <cstdio>)
+SYMBOL(perror, None, <cstdio>)
+SYMBOL(perror, None, <stdio.h>)
SYMBOL(peta, std::, <ratio>)
SYMBOL(pico, std::, <ratio>)
SYMBOL(piecewise_constant_distribution, std::, <random>)
@@ -1249,33 +2353,61 @@ SYMBOL(polar, std::, <complex>)
SYMBOL(pop_heap, std::, <algorithm>)
SYMBOL(popcount, std::, <bit>)
SYMBOL(pow, std::, <cmath>)
+SYMBOL(pow, None, <cmath>)
+SYMBOL(pow, None, <math.h>)
SYMBOL(powf, std::, <cmath>)
+SYMBOL(powf, None, <cmath>)
+SYMBOL(powf, None, <math.h>)
SYMBOL(powl, std::, <cmath>)
+SYMBOL(powl, None, <cmath>)
+SYMBOL(powl, None, <math.h>)
SYMBOL(predicate, std::, <concepts>)
SYMBOL(preferred, std::, <memory>)
SYMBOL(prev, std::, <iterator>)
SYMBOL(prev_permutation, std::, <algorithm>)
SYMBOL(printf, std::, <cstdio>)
+SYMBOL(printf, None, <cstdio>)
+SYMBOL(printf, None, <stdio.h>)
SYMBOL(priority_queue, std::, <queue>)
SYMBOL(proj, std::, <complex>)
SYMBOL(projected, std::, <iterator>)
SYMBOL(promise, std::, <future>)
SYMBOL(ptr_fun, std::, <functional>)
SYMBOL(ptr
diff _t, std::, <cstddef>)
+SYMBOL(ptr
diff _t, None, <cstddef>)
+SYMBOL(ptr
diff _t, None, <stddef.h>)
SYMBOL(push_heap, std::, <algorithm>)
SYMBOL(put_money, std::, <iomanip>)
SYMBOL(put_time, std::, <iomanip>)
SYMBOL(putc, std::, <cstdio>)
+SYMBOL(putc, None, <cstdio>)
+SYMBOL(putc, None, <stdio.h>)
SYMBOL(putchar, std::, <cstdio>)
+SYMBOL(putchar, None, <cstdio>)
+SYMBOL(putchar, None, <stdio.h>)
SYMBOL(puts, std::, <cstdio>)
+SYMBOL(puts, None, <cstdio>)
+SYMBOL(puts, None, <stdio.h>)
SYMBOL(putwc, std::, <cwchar>)
+SYMBOL(putwc, None, <cwchar>)
+SYMBOL(putwc, None, <wchar.h>)
SYMBOL(putwchar, std::, <cwchar>)
+SYMBOL(putwchar, None, <cwchar>)
+SYMBOL(putwchar, None, <wchar.h>)
SYMBOL(qsort, std::, <cstdlib>)
+SYMBOL(qsort, None, <cstdlib>)
+SYMBOL(qsort, None, <stdlib.h>)
SYMBOL(queue, std::, <queue>)
SYMBOL(quick_exit, std::, <cstdlib>)
+SYMBOL(quick_exit, None, <cstdlib>)
+SYMBOL(quick_exit, None, <stdlib.h>)
SYMBOL(quoted, std::, <iomanip>)
SYMBOL(raise, std::, <csignal>)
+SYMBOL(raise, None, <csignal>)
+SYMBOL(raise, None, <signal.h>)
SYMBOL(rand, std::, <cstdlib>)
+SYMBOL(rand, None, <cstdlib>)
+SYMBOL(rand, None, <stdlib.h>)
SYMBOL(random_access_iterator, std::, <iterator>)
SYMBOL(random_access_iterator_tag, std::, <iterator>)
SYMBOL(random_device, std::, <random>)
@@ -1307,6 +2439,8 @@ SYMBOL(ratio_subtract, std::, <ratio>)
SYMBOL(raw_storage_iterator, std::, <memory>)
SYMBOL(real, std::, <complex>)
SYMBOL(realloc, std::, <cstdlib>)
+SYMBOL(realloc, None, <cstdlib>)
+SYMBOL(realloc, None, <stdlib.h>)
SYMBOL(recursive_mutex, std::, <mutex>)
SYMBOL(recursive_timed_mutex, std::, <mutex>)
SYMBOL(reduce, std::, <numeric>)
@@ -1325,8 +2459,14 @@ SYMBOL(regular_invocable, std::, <concepts>)
SYMBOL(reinterpret_pointer_cast, std::, <memory>)
SYMBOL(relation, std::, <concepts>)
SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remainder, None, <cmath>)
+SYMBOL(remainder, None, <math.h>)
SYMBOL(remainderf, std::, <cmath>)
+SYMBOL(remainderf, None, <cmath>)
+SYMBOL(remainderf, None, <math.h>)
SYMBOL(remainderl, std::, <cmath>)
+SYMBOL(remainderl, None, <cmath>)
+SYMBOL(remainderl, None, <math.h>)
SYMBOL(remove_all_extents, std::, <type_traits>)
SYMBOL(remove_all_extents_t, std::, <type_traits>)
SYMBOL(remove_const, std::, <type_traits>)
@@ -1347,9 +2487,17 @@ SYMBOL(remove_reference_t, std::, <type_traits>)
SYMBOL(remove_volatile, std::, <type_traits>)
SYMBOL(remove_volatile_t, std::, <type_traits>)
SYMBOL(remquo, std::, <cmath>)
+SYMBOL(remquo, None, <cmath>)
+SYMBOL(remquo, None, <math.h>)
SYMBOL(remquof, std::, <cmath>)
+SYMBOL(remquof, None, <cmath>)
+SYMBOL(remquof, None, <math.h>)
SYMBOL(remquol, std::, <cmath>)
+SYMBOL(remquol, None, <cmath>)
+SYMBOL(remquol, None, <math.h>)
SYMBOL(rename, std::, <cstdio>)
+SYMBOL(rename, None, <cstdio>)
+SYMBOL(rename, None, <stdio.h>)
SYMBOL(replace, std::, <algorithm>)
SYMBOL(replace_copy, std::, <algorithm>)
SYMBOL(replace_copy_if, std::, <algorithm>)
@@ -1364,36 +2512,64 @@ SYMBOL(reverse, std::, <algorithm>)
SYMBOL(reverse_copy, std::, <algorithm>)
SYMBOL(reverse_iterator, std::, <iterator>)
SYMBOL(rewind, std::, <cstdio>)
+SYMBOL(rewind, None, <cstdio>)
+SYMBOL(rewind, None, <stdio.h>)
SYMBOL(riemann_zeta, std::, <cmath>)
SYMBOL(riemann_zetaf, std::, <cmath>)
SYMBOL(riemann_zetal, std::, <cmath>)
SYMBOL(right, std::, <ios>)
SYMBOL(right, std::, <iostream>)
SYMBOL(rint, std::, <cmath>)
+SYMBOL(rint, None, <cmath>)
+SYMBOL(rint, None, <math.h>)
SYMBOL(rintf, std::, <cmath>)
+SYMBOL(rintf, None, <cmath>)
+SYMBOL(rintf, None, <math.h>)
SYMBOL(rintl, std::, <cmath>)
+SYMBOL(rintl, None, <cmath>)
+SYMBOL(rintl, None, <math.h>)
SYMBOL(rotate, std::, <algorithm>)
SYMBOL(rotate_copy, std::, <algorithm>)
SYMBOL(rotl, std::, <bit>)
SYMBOL(rotr, std::, <bit>)
SYMBOL(round, std::, <cmath>)
+SYMBOL(round, None, <cmath>)
+SYMBOL(round, None, <math.h>)
SYMBOL(round_indeterminate, std::, <limits>)
SYMBOL(round_to_nearest, std::, <limits>)
SYMBOL(round_toward_infinity, std::, <limits>)
SYMBOL(round_toward_neg_infinity, std::, <limits>)
SYMBOL(round_toward_zero, std::, <limits>)
SYMBOL(roundf, std::, <cmath>)
+SYMBOL(roundf, None, <cmath>)
+SYMBOL(roundf, None, <math.h>)
SYMBOL(roundl, std::, <cmath>)
+SYMBOL(roundl, None, <cmath>)
+SYMBOL(roundl, None, <math.h>)
SYMBOL(runtime_error, std::, <stdexcept>)
SYMBOL(same_as, std::, <concepts>)
SYMBOL(sample, std::, <algorithm>)
SYMBOL(scalbln, std::, <cmath>)
+SYMBOL(scalbln, None, <cmath>)
+SYMBOL(scalbln, None, <math.h>)
SYMBOL(scalblnf, std::, <cmath>)
+SYMBOL(scalblnf, None, <cmath>)
+SYMBOL(scalblnf, None, <math.h>)
SYMBOL(scalblnl, std::, <cmath>)
+SYMBOL(scalblnl, None, <cmath>)
+SYMBOL(scalblnl, None, <math.h>)
SYMBOL(scalbn, std::, <cmath>)
+SYMBOL(scalbn, None, <cmath>)
+SYMBOL(scalbn, None, <math.h>)
SYMBOL(scalbnf, std::, <cmath>)
+SYMBOL(scalbnf, None, <cmath>)
+SYMBOL(scalbnf, None, <math.h>)
SYMBOL(scalbnl, std::, <cmath>)
+SYMBOL(scalbnl, None, <cmath>)
+SYMBOL(scalbnl, None, <math.h>)
SYMBOL(scanf, std::, <cstdio>)
+SYMBOL(scanf, None, <cstdio>)
+SYMBOL(scanf, None, <stdio.h>)
SYMBOL(scientific, std::, <ios>)
SYMBOL(scientific, std::, <iostream>)
SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
@@ -1415,11 +2591,17 @@ SYMBOL(set_unexpected, std::, <exception>)
SYMBOL(set_union, std::, <algorithm>)
SYMBOL(setbase, std::, <iomanip>)
SYMBOL(setbuf, std::, <cstdio>)
+SYMBOL(setbuf, None, <cstdio>)
+SYMBOL(setbuf, None, <stdio.h>)
SYMBOL(setfill, std::, <iomanip>)
SYMBOL(setiosflags, std::, <iomanip>)
SYMBOL(setlocale, std::, <clocale>)
+SYMBOL(setlocale, None, <clocale>)
+SYMBOL(setlocale, None, <locale.h>)
SYMBOL(setprecision, std::, <iomanip>)
SYMBOL(setvbuf, std::, <cstdio>)
+SYMBOL(setvbuf, None, <cstdio>)
+SYMBOL(setvbuf, None, <stdio.h>)
SYMBOL(setw, std::, <iomanip>)
SYMBOL(shared_future, std::, <future>)
SYMBOL(shared_lock, std::, <shared_mutex>)
@@ -1437,15 +2619,33 @@ SYMBOL(showpos, std::, <iostream>)
SYMBOL(shuffle, std::, <algorithm>)
SYMBOL(shuffle_order_engine, std::, <random>)
SYMBOL(sig_atomic_t, std::, <csignal>)
+SYMBOL(sig_atomic_t, None, <csignal>)
+SYMBOL(sig_atomic_t, None, <signal.h>)
SYMBOL(signal, std::, <csignal>)
+SYMBOL(signal, None, <csignal>)
+SYMBOL(signal, None, <signal.h>)
SYMBOL(signbit, std::, <cmath>)
+SYMBOL(signbit, None, <cmath>)
+SYMBOL(signbit, None, <math.h>)
SYMBOL(signed_integral, std::, <concepts>)
SYMBOL(sin, std::, <cmath>)
+SYMBOL(sin, None, <cmath>)
+SYMBOL(sin, None, <math.h>)
SYMBOL(sinf, std::, <cmath>)
+SYMBOL(sinf, None, <cmath>)
+SYMBOL(sinf, None, <math.h>)
SYMBOL(sinh, std::, <cmath>)
+SYMBOL(sinh, None, <cmath>)
+SYMBOL(sinh, None, <math.h>)
SYMBOL(sinhf, std::, <cmath>)
+SYMBOL(sinhf, None, <cmath>)
+SYMBOL(sinhf, None, <math.h>)
SYMBOL(sinhl, std::, <cmath>)
+SYMBOL(sinhl, None, <cmath>)
+SYMBOL(sinhl, None, <math.h>)
SYMBOL(sinl, std::, <cmath>)
+SYMBOL(sinl, None, <cmath>)
+SYMBOL(sinl, None, <math.h>)
SYMBOL(sized_sentinel_for, std::, <iterator>)
SYMBOL(skipws, std::, <ios>)
SYMBOL(skipws, std::, <iostream>)
@@ -1453,6 +2653,8 @@ SYMBOL(slice, std::, <valarray>)
SYMBOL(slice_array, std::, <valarray>)
SYMBOL(smatch, std::, <regex>)
SYMBOL(snprintf, std::, <cstdio>)
+SYMBOL(snprintf, None, <cstdio>)
+SYMBOL(snprintf, None, <stdio.h>)
SYMBOL(sort, std::, <algorithm>)
SYMBOL(sort_heap, std::, <algorithm>)
SYMBOL(sortable, std::, <iterator>)
@@ -1463,8 +2665,14 @@ SYMBOL(spanbuf, std::, <iosfwd>)
SYMBOL(spanstream, std::, <spanstream>)
SYMBOL(spanstream, std::, <iosfwd>)
SYMBOL(sph_bessel, std::, <cmath>)
+SYMBOL(sph_bessel, None, <cmath>)
+SYMBOL(sph_bessel, None, <math.h>)
SYMBOL(sph_besself, std::, <cmath>)
+SYMBOL(sph_besself, None, <cmath>)
+SYMBOL(sph_besself, None, <math.h>)
SYMBOL(sph_bessell, std::, <cmath>)
+SYMBOL(sph_bessell, None, <cmath>)
+SYMBOL(sph_bessell, None, <math.h>)
SYMBOL(sph_legendre, std::, <cmath>)
SYMBOL(sph_legendref, std::, <cmath>)
SYMBOL(sph_legendrel, std::, <cmath>)
@@ -1472,13 +2680,25 @@ SYMBOL(sph_neumann, std::, <cmath>)
SYMBOL(sph_neumannf, std::, <cmath>)
SYMBOL(sph_neumannl, std::, <cmath>)
SYMBOL(sprintf, std::, <cstdio>)
+SYMBOL(sprintf, None, <cstdio>)
+SYMBOL(sprintf, None, <stdio.h>)
SYMBOL(sqrt, std::, <cmath>)
+SYMBOL(sqrt, None, <cmath>)
+SYMBOL(sqrt, None, <math.h>)
SYMBOL(sqrtf, std::, <cmath>)
+SYMBOL(sqrtf, None, <cmath>)
+SYMBOL(sqrtf, None, <math.h>)
SYMBOL(sqrtl, std::, <cmath>)
+SYMBOL(sqrtl, None, <cmath>)
+SYMBOL(sqrtl, None, <math.h>)
SYMBOL(srand, std::, <cstdlib>)
+SYMBOL(srand, None, <cstdlib>)
+SYMBOL(srand, None, <stdlib.h>)
SYMBOL(sregex_iterator, std::, <regex>)
SYMBOL(sregex_token_iterator, std::, <regex>)
SYMBOL(sscanf, std::, <cstdio>)
+SYMBOL(sscanf, None, <cstdio>)
+SYMBOL(sscanf, None, <stdio.h>)
SYMBOL(ssub_match, std::, <regex>)
SYMBOL(stable_partition, std::, <algorithm>)
SYMBOL(stable_sort, std::, <algorithm>)
@@ -1498,11 +2718,23 @@ SYMBOL(stop_token, std::, <stop_token>)
SYMBOL(stoul, std::, <string>)
SYMBOL(stoull, std::, <string>)
SYMBOL(strcat, std::, <cstring>)
+SYMBOL(strcat, None, <cstring>)
+SYMBOL(strcat, None, <string.h>)
SYMBOL(strchr, std::, <cstring>)
+SYMBOL(strchr, None, <cstring>)
+SYMBOL(strchr, None, <string.h>)
SYMBOL(strcmp, std::, <cstring>)
+SYMBOL(strcmp, None, <cstring>)
+SYMBOL(strcmp, None, <string.h>)
SYMBOL(strcoll, std::, <cstring>)
+SYMBOL(strcoll, None, <cstring>)
+SYMBOL(strcoll, None, <string.h>)
SYMBOL(strcpy, std::, <cstring>)
+SYMBOL(strcpy, None, <cstring>)
+SYMBOL(strcpy, None, <string.h>)
SYMBOL(strcspn, std::, <cstring>)
+SYMBOL(strcspn, None, <cstring>)
+SYMBOL(strcspn, None, <string.h>)
SYMBOL(streambuf, std::, <streambuf>)
SYMBOL(streambuf, std::, <iostream>)
SYMBOL(streambuf, std::, <iosfwd>)
@@ -1513,7 +2745,11 @@ SYMBOL(streampos, std::, <iosfwd>)
SYMBOL(streamsize, std::, <ios>)
SYMBOL(streamsize, std::, <iostream>)
SYMBOL(strerror, std::, <cstring>)
+SYMBOL(strerror, None, <cstring>)
+SYMBOL(strerror, None, <string.h>)
SYMBOL(strftime, std::, <ctime>)
+SYMBOL(strftime, None, <ctime>)
+SYMBOL(strftime, None, <time.h>)
SYMBOL(strict, std::, <memory>)
SYMBOL(strict_weak_order, std::, <concepts>)
SYMBOL(string, std::, <string>)
@@ -1523,28 +2759,66 @@ SYMBOL(stringbuf, std::, <iosfwd>)
SYMBOL(stringstream, std::, <sstream>)
SYMBOL(stringstream, std::, <iosfwd>)
SYMBOL(strlen, std::, <cstring>)
+SYMBOL(strlen, None, <cstring>)
+SYMBOL(strlen, None, <string.h>)
SYMBOL(strncat, std::, <cstring>)
+SYMBOL(strncat, None, <cstring>)
+SYMBOL(strncat, None, <string.h>)
SYMBOL(strncmp, std::, <cstring>)
+SYMBOL(strncmp, None, <cstring>)
+SYMBOL(strncmp, None, <string.h>)
SYMBOL(strncpy, std::, <cstring>)
+SYMBOL(strncpy, None, <cstring>)
+SYMBOL(strncpy, None, <string.h>)
SYMBOL(strong_order, std::, <compare>)
SYMBOL(strong_ordering, std::, <compare>)
SYMBOL(strpbrk, std::, <cstring>)
+SYMBOL(strpbrk, None, <cstring>)
+SYMBOL(strpbrk, None, <string.h>)
SYMBOL(strrchr, std::, <cstring>)
+SYMBOL(strrchr, None, <cstring>)
+SYMBOL(strrchr, None, <string.h>)
SYMBOL(strspn, std::, <cstring>)
+SYMBOL(strspn, None, <cstring>)
+SYMBOL(strspn, None, <string.h>)
SYMBOL(strstr, std::, <cstring>)
+SYMBOL(strstr, None, <cstring>)
+SYMBOL(strstr, None, <string.h>)
SYMBOL(strstream, std::, <strstream>)
SYMBOL(strstreambuf, std::, <strstream>)
SYMBOL(strtod, std::, <cstdlib>)
+SYMBOL(strtod, None, <cstdlib>)
+SYMBOL(strtod, None, <stdlib.h>)
SYMBOL(strtof, std::, <cstdlib>)
+SYMBOL(strtof, None, <cstdlib>)
+SYMBOL(strtof, None, <stdlib.h>)
SYMBOL(strtoimax, std::, <cinttypes>)
+SYMBOL(strtoimax, None, <cinttypes>)
+SYMBOL(strtoimax, None, <inttypes.h>)
SYMBOL(strtok, std::, <cstring>)
+SYMBOL(strtok, None, <cstring>)
+SYMBOL(strtok, None, <string.h>)
SYMBOL(strtol, std::, <cstdlib>)
+SYMBOL(strtol, None, <cstdlib>)
+SYMBOL(strtol, None, <stdlib.h>)
SYMBOL(strtold, std::, <cstdlib>)
+SYMBOL(strtold, None, <cstdlib>)
+SYMBOL(strtold, None, <stdlib.h>)
SYMBOL(strtoll, std::, <cstdlib>)
+SYMBOL(strtoll, None, <cstdlib>)
+SYMBOL(strtoll, None, <stdlib.h>)
SYMBOL(strtoul, std::, <cstdlib>)
+SYMBOL(strtoul, None, <cstdlib>)
+SYMBOL(strtoul, None, <stdlib.h>)
SYMBOL(strtoull, std::, <cstdlib>)
+SYMBOL(strtoull, None, <cstdlib>)
+SYMBOL(strtoull, None, <stdlib.h>)
SYMBOL(strtoumax, std::, <cinttypes>)
+SYMBOL(strtoumax, None, <cinttypes>)
+SYMBOL(strtoumax, None, <inttypes.h>)
SYMBOL(strxfrm, std::, <cstring>)
+SYMBOL(strxfrm, None, <cstring>)
+SYMBOL(strxfrm, None, <string.h>)
SYMBOL(student_t_distribution, std::, <random>)
SYMBOL(sub_match, std::, <regex>)
SYMBOL(subtract_with_carry_engine, std::, <random>)
@@ -1554,65 +2828,121 @@ SYMBOL(swap_ranges, std::, <algorithm>)
SYMBOL(swappable, std::, <concepts>)
SYMBOL(swappable_with, std::, <concepts>)
SYMBOL(swprintf, std::, <cwchar>)
+SYMBOL(swprintf, None, <cwchar>)
+SYMBOL(swprintf, None, <wchar.h>)
SYMBOL(swscanf, std::, <cwchar>)
+SYMBOL(swscanf, None, <cwchar>)
+SYMBOL(swscanf, None, <wchar.h>)
SYMBOL(syncbuf, std::, <syncstream>)
SYMBOL(syncbuf, std::, <iosfwd>)
SYMBOL(system, std::, <cstdlib>)
+SYMBOL(system, None, <cstdlib>)
+SYMBOL(system, None, <stdlib.h>)
SYMBOL(system_category, std::, <system_error>)
SYMBOL(system_error, std::, <system_error>)
SYMBOL(tan, std::, <cmath>)
+SYMBOL(tan, None, <cmath>)
+SYMBOL(tan, None, <math.h>)
SYMBOL(tanf, std::, <cmath>)
+SYMBOL(tanf, None, <cmath>)
+SYMBOL(tanf, None, <math.h>)
SYMBOL(tanh, std::, <cmath>)
+SYMBOL(tanh, None, <cmath>)
+SYMBOL(tanh, None, <math.h>)
SYMBOL(tanhf, std::, <cmath>)
+SYMBOL(tanhf, None, <cmath>)
+SYMBOL(tanhf, None, <math.h>)
SYMBOL(tanhl, std::, <cmath>)
+SYMBOL(tanhl, None, <cmath>)
+SYMBOL(tanhl, None, <math.h>)
SYMBOL(tanl, std::, <cmath>)
+SYMBOL(tanl, None, <cmath>)
+SYMBOL(tanl, None, <math.h>)
SYMBOL(tera, std::, <ratio>)
SYMBOL(terminate, std::, <exception>)
SYMBOL(terminate_handler, std::, <exception>)
SYMBOL(tgamma, std::, <cmath>)
+SYMBOL(tgamma, None, <cmath>)
+SYMBOL(tgamma, None, <math.h>)
SYMBOL(tgammaf, std::, <cmath>)
+SYMBOL(tgammaf, None, <cmath>)
+SYMBOL(tgammaf, None, <math.h>)
SYMBOL(tgammal, std::, <cmath>)
+SYMBOL(tgammal, None, <cmath>)
+SYMBOL(tgammal, None, <math.h>)
SYMBOL(thread, std::, <thread>)
SYMBOL(three_way_comparable, std::, <compare>)
SYMBOL(three_way_comparable_with, std::, <compare>)
SYMBOL(throw_with_nested, std::, <exception>)
SYMBOL(tie, std::, <tuple>)
SYMBOL(time, std::, <ctime>)
+SYMBOL(time, None, <ctime>)
+SYMBOL(time, None, <time.h>)
SYMBOL(time_base, std::, <locale>)
SYMBOL(time_get, std::, <locale>)
SYMBOL(time_get_byname, std::, <locale>)
SYMBOL(time_put, std::, <locale>)
SYMBOL(time_put_byname, std::, <locale>)
SYMBOL(time_t, std::, <ctime>)
+SYMBOL(time_t, None, <ctime>)
+SYMBOL(time_t, None, <time.h>)
SYMBOL(timed_mutex, std::, <mutex>)
SYMBOL(timespec, std::, <ctime>)
+SYMBOL(timespec, None, <ctime>)
+SYMBOL(timespec, None, <time.h>)
SYMBOL(timespec_get, std::, <ctime>)
+SYMBOL(timespec_get, None, <ctime>)
+SYMBOL(timespec_get, None, <time.h>)
SYMBOL(tm, std::, <ctime>)
+SYMBOL(tm, None, <ctime>)
+SYMBOL(tm, None, <time.h>)
SYMBOL(tmpfile, std::, <cstdio>)
+SYMBOL(tmpfile, None, <cstdio>)
+SYMBOL(tmpfile, None, <stdio.h>)
SYMBOL(tmpnam, std::, <cstdio>)
+SYMBOL(tmpnam, None, <cstdio>)
+SYMBOL(tmpnam, None, <stdio.h>)
SYMBOL(to_address, std::, <memory>)
SYMBOL(to_array, std::, <array>)
SYMBOL(to_chars, std::, <charconv>)
SYMBOL(to_chars_result, std::, <charconv>)
SYMBOL(to_integer, std::, <cstddef>)
+SYMBOL(to_integer, None, <cstddef>)
+SYMBOL(to_integer, None, <stddef.h>)
SYMBOL(to_string, std::, <string>)
SYMBOL(to_underlying, std::, <utility>)
SYMBOL(to_wstring, std::, <string>)
SYMBOL(tolower, std::, <cctype>)
+SYMBOL(tolower, None, <cctype>)
+SYMBOL(tolower, None, <ctype.h>)
SYMBOL(totally_ordered, std::, <concepts>)
SYMBOL(totally_ordered_with, std::, <concepts>)
SYMBOL(toupper, std::, <cctype>)
+SYMBOL(toupper, None, <cctype>)
+SYMBOL(toupper, None, <ctype.h>)
SYMBOL(towctrans, std::, <cwctype>)
+SYMBOL(towctrans, None, <cwctype>)
+SYMBOL(towctrans, None, <wctype.h>)
SYMBOL(towlower, std::, <cwctype>)
+SYMBOL(towlower, None, <cwctype>)
+SYMBOL(towlower, None, <wctype.h>)
SYMBOL(towupper, std::, <cwctype>)
+SYMBOL(towupper, None, <cwctype>)
+SYMBOL(towupper, None, <wctype.h>)
SYMBOL(transform, std::, <algorithm>)
SYMBOL(transform_exclusive_scan, std::, <numeric>)
SYMBOL(transform_inclusive_scan, std::, <numeric>)
SYMBOL(transform_reduce, std::, <numeric>)
SYMBOL(true_type, std::, <type_traits>)
SYMBOL(trunc, std::, <cmath>)
+SYMBOL(trunc, None, <cmath>)
+SYMBOL(trunc, None, <math.h>)
SYMBOL(truncf, std::, <cmath>)
+SYMBOL(truncf, None, <cmath>)
+SYMBOL(truncf, None, <math.h>)
SYMBOL(truncl, std::, <cmath>)
+SYMBOL(truncl, None, <cmath>)
+SYMBOL(truncl, None, <math.h>)
SYMBOL(try_lock, std::, <mutex>)
SYMBOL(try_to_lock, std::, <mutex>)
SYMBOL(try_to_lock_t, std::, <mutex>)
@@ -1637,19 +2967,47 @@ SYMBOL(u8streampos, std::, <iosfwd>)
SYMBOL(u8string, std::, <string>)
SYMBOL(u8string_view, std::, <string_view>)
SYMBOL(uint16_t, std::, <cstdint>)
+SYMBOL(uint16_t, None, <cstdint>)
+SYMBOL(uint16_t, None, <stdint.h>)
SYMBOL(uint32_t, std::, <cstdint>)
+SYMBOL(uint32_t, None, <cstdint>)
+SYMBOL(uint32_t, None, <stdint.h>)
SYMBOL(uint64_t, std::, <cstdint>)
+SYMBOL(uint64_t, None, <cstdint>)
+SYMBOL(uint64_t, None, <stdint.h>)
SYMBOL(uint8_t, std::, <cstdint>)
+SYMBOL(uint8_t, None, <cstdint>)
+SYMBOL(uint8_t, None, <stdint.h>)
SYMBOL(uint_fast16_t, std::, <cstdint>)
+SYMBOL(uint_fast16_t, None, <cstdint>)
+SYMBOL(uint_fast16_t, None, <stdint.h>)
SYMBOL(uint_fast32_t, std::, <cstdint>)
+SYMBOL(uint_fast32_t, None, <cstdint>)
+SYMBOL(uint_fast32_t, None, <stdint.h>)
SYMBOL(uint_fast64_t, std::, <cstdint>)
+SYMBOL(uint_fast64_t, None, <cstdint>)
+SYMBOL(uint_fast64_t, None, <stdint.h>)
SYMBOL(uint_fast8_t, std::, <cstdint>)
+SYMBOL(uint_fast8_t, None, <cstdint>)
+SYMBOL(uint_fast8_t, None, <stdint.h>)
SYMBOL(uint_least16_t, std::, <cstdint>)
+SYMBOL(uint_least16_t, None, <cstdint>)
+SYMBOL(uint_least16_t, None, <stdint.h>)
SYMBOL(uint_least32_t, std::, <cstdint>)
+SYMBOL(uint_least32_t, None, <cstdint>)
+SYMBOL(uint_least32_t, None, <stdint.h>)
SYMBOL(uint_least64_t, std::, <cstdint>)
+SYMBOL(uint_least64_t, None, <cstdint>)
+SYMBOL(uint_least64_t, None, <stdint.h>)
SYMBOL(uint_least8_t, std::, <cstdint>)
+SYMBOL(uint_least8_t, None, <cstdint>)
+SYMBOL(uint_least8_t, None, <stdint.h>)
SYMBOL(uintmax_t, std::, <cstdint>)
+SYMBOL(uintmax_t, None, <cstdint>)
+SYMBOL(uintmax_t, None, <stdint.h>)
SYMBOL(uintptr_t, std::, <cstdint>)
+SYMBOL(uintptr_t, None, <cstdint>)
+SYMBOL(uintptr_t, None, <stdint.h>)
SYMBOL(unary_function, std::, <functional>)
SYMBOL(unary_negate, std::, <functional>)
SYMBOL(uncaught_exception, std::, <exception>)
@@ -1661,7 +3019,11 @@ SYMBOL(underlying_type, std::, <type_traits>)
SYMBOL(underlying_type_t, std::, <type_traits>)
SYMBOL(unexpected_handler, std::, <exception>)
SYMBOL(ungetc, std::, <cstdio>)
+SYMBOL(ungetc, None, <cstdio>)
+SYMBOL(ungetc, None, <stdio.h>)
SYMBOL(ungetwc, std::, <cwchar>)
+SYMBOL(ungetwc, None, <cwchar>)
+SYMBOL(ungetwc, None, <wchar.h>)
SYMBOL(uniform_int_distribution, std::, <random>)
SYMBOL(uniform_random_bit_generator, std::, <random>)
SYMBOL(uniform_real_distribution, std::, <random>)
@@ -1698,6 +3060,8 @@ SYMBOL(uses_allocator, std::, <memory>)
SYMBOL(uses_allocator_construction_args, std::, <memory>)
SYMBOL(uses_allocator_v, std::, <memory>)
SYMBOL(va_list, std::, <cstdarg>)
+SYMBOL(va_list, None, <cstdarg>)
+SYMBOL(va_list, None, <stdarg.h>)
SYMBOL(valarray, std::, <valarray>)
SYMBOL(variant, std::, <variant>)
SYMBOL(variant_alternative, std::, <variant>)
@@ -1709,21 +3073,47 @@ SYMBOL(vector, std::, <vector>)
SYMBOL(vformat, std::, <format>)
SYMBOL(vformat_to, std::, <format>)
SYMBOL(vfprintf, std::, <cstdio>)
+SYMBOL(vfprintf, None, <cstdio>)
+SYMBOL(vfprintf, None, <stdio.h>)
SYMBOL(vfscanf, std::, <cstdio>)
+SYMBOL(vfscanf, None, <cstdio>)
+SYMBOL(vfscanf, None, <stdio.h>)
SYMBOL(vfwprintf, std::, <cwchar>)
+SYMBOL(vfwprintf, None, <cwchar>)
+SYMBOL(vfwprintf, None, <wchar.h>)
SYMBOL(vfwscanf, std::, <cwchar>)
+SYMBOL(vfwscanf, None, <cwchar>)
+SYMBOL(vfwscanf, None, <wchar.h>)
SYMBOL(visit, std::, <variant>)
SYMBOL(visit_format_arg, std::, <format>)
SYMBOL(void_t, std::, <type_traits>)
SYMBOL(vprintf, std::, <cstdio>)
+SYMBOL(vprintf, None, <cstdio>)
+SYMBOL(vprintf, None, <stdio.h>)
SYMBOL(vscanf, std::, <cstdio>)
+SYMBOL(vscanf, None, <cstdio>)
+SYMBOL(vscanf, None, <stdio.h>)
SYMBOL(vsnprintf, std::, <cstdio>)
+SYMBOL(vsnprintf, None, <cstdio>)
+SYMBOL(vsnprintf, None, <stdio.h>)
SYMBOL(vsprintf, std::, <cstdio>)
+SYMBOL(vsprintf, None, <cstdio>)
+SYMBOL(vsprintf, None, <stdio.h>)
SYMBOL(vsscanf, std::, <cstdio>)
+SYMBOL(vsscanf, None, <cstdio>)
+SYMBOL(vsscanf, None, <stdio.h>)
SYMBOL(vswprintf, std::, <cwchar>)
+SYMBOL(vswprintf, None, <cwchar>)
+SYMBOL(vswprintf, None, <wchar.h>)
SYMBOL(vswscanf, std::, <cwchar>)
+SYMBOL(vswscanf, None, <cwchar>)
+SYMBOL(vswscanf, None, <wchar.h>)
SYMBOL(vwprintf, std::, <cwchar>)
+SYMBOL(vwprintf, None, <cwchar>)
+SYMBOL(vwprintf, None, <wchar.h>)
SYMBOL(vwscanf, std::, <cwchar>)
+SYMBOL(vwscanf, None, <cwchar>)
+SYMBOL(vwscanf, None, <wchar.h>)
SYMBOL(wbuffer_convert, std::, <locale>)
SYMBOL(wcerr, std::, <iostream>)
SYMBOL(wcin, std::, <iostream>)
@@ -1733,41 +3123,111 @@ SYMBOL(wcout, std::, <iostream>)
SYMBOL(wcregex_iterator, std::, <regex>)
SYMBOL(wcregex_token_iterator, std::, <regex>)
SYMBOL(wcrtomb, std::, <cwchar>)
+SYMBOL(wcrtomb, None, <cwchar>)
+SYMBOL(wcrtomb, None, <wchar.h>)
SYMBOL(wcscat, std::, <cwchar>)
+SYMBOL(wcscat, None, <cwchar>)
+SYMBOL(wcscat, None, <wchar.h>)
SYMBOL(wcschr, std::, <cwchar>)
+SYMBOL(wcschr, None, <cwchar>)
+SYMBOL(wcschr, None, <wchar.h>)
SYMBOL(wcscmp, std::, <cwchar>)
+SYMBOL(wcscmp, None, <cwchar>)
+SYMBOL(wcscmp, None, <wchar.h>)
SYMBOL(wcscoll, std::, <cwchar>)
+SYMBOL(wcscoll, None, <cwchar>)
+SYMBOL(wcscoll, None, <wchar.h>)
SYMBOL(wcscpy, std::, <cwchar>)
+SYMBOL(wcscpy, None, <cwchar>)
+SYMBOL(wcscpy, None, <wchar.h>)
SYMBOL(wcscspn, std::, <cwchar>)
+SYMBOL(wcscspn, None, <cwchar>)
+SYMBOL(wcscspn, None, <wchar.h>)
SYMBOL(wcsftime, std::, <cwchar>)
+SYMBOL(wcsftime, None, <cwchar>)
+SYMBOL(wcsftime, None, <wchar.h>)
SYMBOL(wcslen, std::, <cwchar>)
+SYMBOL(wcslen, None, <cwchar>)
+SYMBOL(wcslen, None, <wchar.h>)
SYMBOL(wcsncat, std::, <cwchar>)
+SYMBOL(wcsncat, None, <cwchar>)
+SYMBOL(wcsncat, None, <wchar.h>)
SYMBOL(wcsncmp, std::, <cwchar>)
+SYMBOL(wcsncmp, None, <cwchar>)
+SYMBOL(wcsncmp, None, <wchar.h>)
SYMBOL(wcsncpy, std::, <cwchar>)
+SYMBOL(wcsncpy, None, <cwchar>)
+SYMBOL(wcsncpy, None, <wchar.h>)
SYMBOL(wcspbrk, std::, <cwchar>)
+SYMBOL(wcspbrk, None, <cwchar>)
+SYMBOL(wcspbrk, None, <wchar.h>)
SYMBOL(wcsrchr, std::, <cwchar>)
+SYMBOL(wcsrchr, None, <cwchar>)
+SYMBOL(wcsrchr, None, <wchar.h>)
SYMBOL(wcsrtombs, std::, <cwchar>)
+SYMBOL(wcsrtombs, None, <cwchar>)
+SYMBOL(wcsrtombs, None, <wchar.h>)
SYMBOL(wcsspn, std::, <cwchar>)
+SYMBOL(wcsspn, None, <cwchar>)
+SYMBOL(wcsspn, None, <wchar.h>)
SYMBOL(wcsstr, std::, <cwchar>)
+SYMBOL(wcsstr, None, <cwchar>)
+SYMBOL(wcsstr, None, <wchar.h>)
SYMBOL(wcstod, std::, <cwchar>)
+SYMBOL(wcstod, None, <cwchar>)
+SYMBOL(wcstod, None, <wchar.h>)
SYMBOL(wcstof, std::, <cwchar>)
+SYMBOL(wcstof, None, <cwchar>)
+SYMBOL(wcstof, None, <wchar.h>)
SYMBOL(wcstoimax, std::, <cinttypes>)
+SYMBOL(wcstoimax, None, <cinttypes>)
+SYMBOL(wcstoimax, None, <inttypes.h>)
SYMBOL(wcstok, std::, <cwchar>)
+SYMBOL(wcstok, None, <cwchar>)
+SYMBOL(wcstok, None, <wchar.h>)
SYMBOL(wcstol, std::, <cwchar>)
+SYMBOL(wcstol, None, <cwchar>)
+SYMBOL(wcstol, None, <wchar.h>)
SYMBOL(wcstold, std::, <cwchar>)
+SYMBOL(wcstold, None, <cwchar>)
+SYMBOL(wcstold, None, <wchar.h>)
SYMBOL(wcstoll, std::, <cwchar>)
+SYMBOL(wcstoll, None, <cwchar>)
+SYMBOL(wcstoll, None, <wchar.h>)
SYMBOL(wcstombs, std::, <cstdlib>)
+SYMBOL(wcstombs, None, <cstdlib>)
+SYMBOL(wcstombs, None, <stdlib.h>)
SYMBOL(wcstoul, std::, <cwchar>)
+SYMBOL(wcstoul, None, <cwchar>)
+SYMBOL(wcstoul, None, <wchar.h>)
SYMBOL(wcstoull, std::, <cwchar>)
+SYMBOL(wcstoull, None, <cwchar>)
+SYMBOL(wcstoull, None, <wchar.h>)
SYMBOL(wcstoumax, std::, <cinttypes>)
+SYMBOL(wcstoumax, None, <cinttypes>)
+SYMBOL(wcstoumax, None, <inttypes.h>)
SYMBOL(wcsub_match, std::, <regex>)
SYMBOL(wcsxfrm, std::, <cwchar>)
+SYMBOL(wcsxfrm, None, <cwchar>)
+SYMBOL(wcsxfrm, None, <wchar.h>)
SYMBOL(wctob, std::, <cwchar>)
+SYMBOL(wctob, None, <cwchar>)
+SYMBOL(wctob, None, <wchar.h>)
SYMBOL(wctomb, std::, <cstdlib>)
+SYMBOL(wctomb, None, <cstdlib>)
+SYMBOL(wctomb, None, <stdlib.h>)
SYMBOL(wctrans, std::, <cwctype>)
+SYMBOL(wctrans, None, <cwctype>)
+SYMBOL(wctrans, None, <wctype.h>)
SYMBOL(wctrans_t, std::, <cwctype>)
+SYMBOL(wctrans_t, None, <cwctype>)
+SYMBOL(wctrans_t, None, <wctype.h>)
SYMBOL(wctype, std::, <cwctype>)
+SYMBOL(wctype, None, <cwctype>)
+SYMBOL(wctype, None, <wctype.h>)
SYMBOL(wctype_t, std::, <cwctype>)
+SYMBOL(wctype_t, None, <cwctype>)
+SYMBOL(wctype_t, None, <wctype.h>)
SYMBOL(weak_order, std::, <compare>)
SYMBOL(weak_ordering, std::, <compare>)
SYMBOL(weak_ptr, std::, <memory>)
@@ -1797,10 +3257,20 @@ SYMBOL(wistream, std::, <iosfwd>)
SYMBOL(wistringstream, std::, <sstream>)
SYMBOL(wistringstream, std::, <iosfwd>)
SYMBOL(wmemchr, std::, <cwchar>)
+SYMBOL(wmemchr, None, <cwchar>)
+SYMBOL(wmemchr, None, <wchar.h>)
SYMBOL(wmemcmp, std::, <cwchar>)
+SYMBOL(wmemcmp, None, <cwchar>)
+SYMBOL(wmemcmp, None, <wchar.h>)
SYMBOL(wmemcpy, std::, <cwchar>)
+SYMBOL(wmemcpy, None, <cwchar>)
+SYMBOL(wmemcpy, None, <wchar.h>)
SYMBOL(wmemmove, std::, <cwchar>)
+SYMBOL(wmemmove, None, <cwchar>)
+SYMBOL(wmemmove, None, <wchar.h>)
SYMBOL(wmemset, std::, <cwchar>)
+SYMBOL(wmemset, None, <cwchar>)
+SYMBOL(wmemset, None, <wchar.h>)
SYMBOL(wofstream, std::, <fstream>)
SYMBOL(wofstream, std::, <iosfwd>)
SYMBOL(wospanstream, std::, <spanstream>)
@@ -1813,10 +3283,14 @@ SYMBOL(wostringstream, std::, <iosfwd>)
SYMBOL(wosyncstream, std::, <syncstream>)
SYMBOL(wosyncstream, std::, <iosfwd>)
SYMBOL(wprintf, std::, <cwchar>)
+SYMBOL(wprintf, None, <cwchar>)
+SYMBOL(wprintf, None, <wchar.h>)
SYMBOL(wregex, std::, <regex>)
SYMBOL(ws, std::, <istream>)
SYMBOL(ws, std::, <iostream>)
SYMBOL(wscanf, std::, <cwchar>)
+SYMBOL(wscanf, None, <cwchar>)
+SYMBOL(wscanf, None, <wchar.h>)
SYMBOL(wsmatch, std::, <regex>)
SYMBOL(wspanbuf, std::, <spanstream>)
SYMBOL(wspanbuf, std::, <iosfwd>)
diff --git a/clang/tools/include-mapping/cppreference_parser.py b/clang/tools/include-mapping/cppreference_parser.py
index b6f8c71127d86..19bdde7eb94d9 100644
--- a/clang/tools/include-mapping/cppreference_parser.py
+++ b/clang/tools/include-mapping/cppreference_parser.py
@@ -30,7 +30,7 @@ def __init__(self, name, namespace, headers):
def __lt__(self, other):
if self.namespace != other.namespace:
- return self.namespace < other.namespace
+ return str(self.namespace) < str(other.namespace)
return self.name < other.name
diff --git a/clang/tools/include-mapping/gen_std.py b/clang/tools/include-mapping/gen_std.py
index 23a201bed1a3f..291946ef5378b 100755
--- a/clang/tools/include-mapping/gen_std.py
+++ b/clang/tools/include-mapping/gen_std.py
@@ -39,6 +39,7 @@
import datetime
import os
import sys
+import re
CODE_PREFIX = """\
@@ -170,6 +171,69 @@ def AdditionalHeadersForIOSymbols(symbol):
return headers
+def GetCCompatibilitySymbols(symbol):
+ # C++ form of the C standard headers.
+ c_compat_headers = {
+ "<cassert>",
+ "<cctype>",
+ "<cerrno>",
+ "<cfenv>",
+ "<cfloat>",
+ "<cinttypes>",
+ "<climits>",
+ "<clocale>",
+ "<cmath>",
+ "<csetjmp>",
+ "<csignal>",
+ "<cstdarg>",
+ "<cstddef>",
+ "<cstdint>",
+ "<cstdio>",
+ "<cstdlib>",
+ "<cstring>",
+ "<ctime>",
+ "<cuchar>",
+ "<cwchar>",
+ "<cwctype>",
+ }
+ # C++ [support.c.headers.other] 17.14.7
+ # ..., behaves as if each name placed in the standard library namespace by
+ # the corresponding <cname> header is placed within the global namespace
+ # scope, except for the functions described in [sf.cmath], the
+ # std::lerp function overloads ([c.math.lerp]), the declaration of
+ # std::byte ([cstddef.syn]), and the functions and function templates
+ # described in [support.types.byteops].
+ exception_symbols = {
+ "(assoc_)?laguerre[f|l]?",
+ "(assoc_|sph_)?legendre[f|l]?",
+ "beta[f|l]?",
+ "(comp_)?ellint_[1-3][f|l]?",
+ "(cyl_|sph_)?bessel_[i-k][f|l]?",
+ "(cyl_|sph_)?neumann[f|l]?",
+ "expint[f|l]?",
+ "hermite[f|l]?",
+ "riemann_zeta[f|l]?",
+ "lerp",
+ "byte",
+ }
+ assert(len(symbol.headers) == 1)
+ header = symbol.headers[0]
+ if header not in c_compat_headers:
+ return []
+ if any(re.fullmatch(x, symbol.name) for x in exception_symbols):
+ return []
+
+ # Introduce two more entries, both in the global namespace, one using the
+ # C++-compat header and another using the C header.
+ results = []
+ if symbol.namespace != None:
+ # avoid printing duplicated entries, for C macros!
+ results.append(cppreference_parser.Symbol(symbol.name, None, [header]))
+ c_header = "<" + header[2:-1] + ".h>" # <cstdio> => <stdio.h>
+ results.append(cppreference_parser.Symbol(symbol.name, None, [c_header]))
+ return results
+
+
def main():
args = ParseArg()
if args.symbols == 'cpp':
@@ -192,6 +256,7 @@ def main():
# Zombie symbols that were available from the Standard Library, but are
# removed in the following standards.
(symbol_index_root, "zombie_names.html", "std::"),
+ (symbol_index_root, "macro.html", None),
]
elif args.symbols == 'c':
page_root = os.path.join(args.cppreference, "en", "c")
@@ -211,11 +276,14 @@ def main():
print(CODE_PREFIX % (args.symbols.upper(), cppreference_modified_date))
for symbol in symbols:
if len(symbol.headers) == 1:
- # SYMBOL(unqualified_name, namespace, header)
- symbol.headers.extend(AdditionalHeadersForIOSymbols(symbol))
- for header in symbol.headers:
- print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
- header))
+ augmented_symbols = [symbol]
+ augmented_symbols.extend(GetCCompatibilitySymbols(symbol))
+ for s in augmented_symbols:
+ s.headers.extend(AdditionalHeadersForIOSymbols(s))
+ for header in s.headers:
+ # SYMBOL(unqualified_name, namespace, header)
+ print("SYMBOL(%s, %s, %s)" % (s.name, s.namespace,
+ header))
elif len(symbol.headers) == 0:
sys.stderr.write("No header found for symbol %s\n" % symbol.name)
else:
diff --git a/clang/unittests/Tooling/StandardLibraryTest.cpp b/clang/unittests/Tooling/StandardLibraryTest.cpp
index ed671fe4481c8..aac13579a5f17 100644
--- a/clang/unittests/Tooling/StandardLibraryTest.cpp
+++ b/clang/unittests/Tooling/StandardLibraryTest.cpp
@@ -65,13 +65,24 @@ TEST(StdlibTest, All) {
EXPECT_THAT(stdlib::Header::all(), Contains(*VectorH));
EXPECT_THAT(stdlib::Symbol::all(), Contains(*Vector));
- EXPECT_FALSE(stdlib::Header::named("<stdint.h>"));
- EXPECT_FALSE(stdlib::Header::named("<stdint.h>", stdlib::Lang::CXX));
- EXPECT_TRUE(stdlib::Header::named("<stdint.h>", stdlib::Lang::C));
+ EXPECT_TRUE(stdlib::Header::named("<stdint.h>", stdlib::Lang::CXX));
+ EXPECT_FALSE(stdlib::Header::named("<ios646.h>", stdlib::Lang::CXX));
+}
- EXPECT_FALSE(stdlib::Symbol::named("", "int16_t"));
- EXPECT_FALSE(stdlib::Symbol::named("", "int16_t", stdlib::Lang::CXX));
- EXPECT_TRUE(stdlib::Symbol::named("", "int16_t", stdlib::Lang::C));
+TEST(StdlibTest, CCompat) {
+ EXPECT_THAT(
+ stdlib::Symbol::named("", "int16_t", stdlib::Lang::CXX)->headers(),
+ ElementsAre(stdlib::Header::named("<cstdint>"),
+ stdlib::Header::named("<stdint.h>")));
+ EXPECT_THAT(
+ stdlib::Symbol::named("std::", "int16_t", stdlib::Lang::CXX)->headers(),
+ ElementsAre(stdlib::Header::named("<cstdint>")));
+
+ EXPECT_TRUE(stdlib::Header::named("<stdint.h>", stdlib::Lang::C));
+ EXPECT_THAT(
+ stdlib::Symbol::named("", "int16_t", stdlib::Lang::C)->headers(),
+ ElementsAre(stdlib::Header::named("<stdint.h>", stdlib::Lang::C)));
+ EXPECT_FALSE(stdlib::Symbol::named("std::", "int16_t", stdlib::Lang::C));
}
TEST(StdlibTest, Recognizer) {
@@ -127,9 +138,9 @@ TEST(StdlibTest, Recognizer) {
EXPECT_EQ(Recognizer(Nest), stdlib::Symbol::named("std::", "vector"));
EXPECT_EQ(Recognizer(Clock),
stdlib::Symbol::named("std::chrono::", "system_clock"));
- EXPECT_EQ(Recognizer(CDivT), stdlib::Symbol::named("", "div_t"));
- EXPECT_EQ(Recognizer(CDivT),
- stdlib::Symbol::named("", "div_t", stdlib::Lang::C));
+ auto DivT = stdlib::Symbol::named("", "div_t", stdlib::Lang::CXX);
+ EXPECT_TRUE(DivT);
+ EXPECT_EQ(Recognizer(CDivT), DivT);
EXPECT_EQ(Recognizer(Sec), std::nullopt);
}
More information about the cfe-commits
mailing list