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); } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
