diff --git a/clang/include/clang/Tooling/Inclusions/CXXSymbolMap.inc b/clang/include/clang/Tooling/Inclusions/CXXSymbolMap.inc new file mode 100644 --- /dev/null +++ b/clang/include/clang/Tooling/Inclusions/CXXSymbolMap.inc @@ -0,0 +1,2006 @@ +//===-- CXXSymbolMap.inc ----------------------------------------*- C++ -*-===// +// +// Unlike the generated StdSymbolMap.inc, this file contains a hand-cruted list +// of symbols (which are hard to deal with by the generator script). It intends +// to overlay the StdSymbolMap.inc. +// +//===----------------------------------------------------------------------===// + +// C-compatibility symbols. +SYMBOL(FILE, std::, ) +SYMBOL(FILE, None, ) +SYMBOL(FILE, None, ) +SYMBOL(_Exit, std::, ) +SYMBOL(_Exit, None, ) +SYMBOL(_Exit, None, ) +SYMBOL(acos, std::, ) +SYMBOL(acos, None, ) +SYMBOL(acos, None, ) +SYMBOL(acosf, std::, ) +SYMBOL(acosf, None, ) +SYMBOL(acosf, None, ) +SYMBOL(acosh, std::, ) +SYMBOL(acosh, None, ) +SYMBOL(acosh, None, ) +SYMBOL(acoshf, std::, ) +SYMBOL(acoshf, None, ) +SYMBOL(acoshf, None, ) +SYMBOL(acoshl, std::, ) +SYMBOL(acoshl, None, ) +SYMBOL(acoshl, None, ) +SYMBOL(acosl, std::, ) +SYMBOL(acosl, None, ) +SYMBOL(acosl, None, ) +SYMBOL(aligned_alloc, std::, ) +SYMBOL(aligned_alloc, None, ) +SYMBOL(aligned_alloc, None, ) +SYMBOL(asctime, std::, ) +SYMBOL(asctime, None, ) +SYMBOL(asctime, None, ) +SYMBOL(asin, std::, ) +SYMBOL(asin, None, ) +SYMBOL(asin, None, ) +SYMBOL(asinf, std::, ) +SYMBOL(asinf, None, ) +SYMBOL(asinf, None, ) +SYMBOL(asinh, std::, ) +SYMBOL(asinh, None, ) +SYMBOL(asinh, None, ) +SYMBOL(asinhf, std::, ) +SYMBOL(asinhf, None, ) +SYMBOL(asinhf, None, ) +SYMBOL(asinhl, std::, ) +SYMBOL(asinhl, None, ) +SYMBOL(asinhl, None, ) +SYMBOL(asinl, std::, ) +SYMBOL(asinl, None, ) +SYMBOL(asinl, None, ) +SYMBOL(at_quick_exit, std::, ) +SYMBOL(at_quick_exit, None, ) +SYMBOL(at_quick_exit, None, ) +SYMBOL(atan, std::, ) +SYMBOL(atan, None, ) +SYMBOL(atan, None, ) +SYMBOL(atan2, std::, ) +SYMBOL(atan2, None, ) +SYMBOL(atan2, None, ) +SYMBOL(atan2f, std::, ) +SYMBOL(atan2f, None, ) +SYMBOL(atan2f, None, ) +SYMBOL(atan2l, std::, ) +SYMBOL(atan2l, None, ) +SYMBOL(atan2l, None, ) +SYMBOL(atanf, std::, ) +SYMBOL(atanf, None, ) +SYMBOL(atanf, None, ) +SYMBOL(atanh, std::, ) +SYMBOL(atanh, None, ) +SYMBOL(atanh, None, ) +SYMBOL(atanhf, std::, ) +SYMBOL(atanhf, None, ) +SYMBOL(atanhf, None, ) +SYMBOL(atanhl, std::, ) +SYMBOL(atanhl, None, ) +SYMBOL(atanhl, None, ) +SYMBOL(atanl, std::, ) +SYMBOL(atanl, None, ) +SYMBOL(atanl, None, ) +SYMBOL(atexit, std::, ) +SYMBOL(atexit, None, ) +SYMBOL(atexit, None, ) +SYMBOL(atof, std::, ) +SYMBOL(atof, None, ) +SYMBOL(atof, None, ) +SYMBOL(atoi, std::, ) +SYMBOL(atoi, None, ) +SYMBOL(atoi, None, ) +SYMBOL(atol, std::, ) +SYMBOL(atol, None, ) +SYMBOL(atol, None, ) +SYMBOL(atoll, std::, ) +SYMBOL(atoll, None, ) +SYMBOL(atoll, None, ) +SYMBOL(bsearch, std::, ) +SYMBOL(bsearch, None, ) +SYMBOL(bsearch, None, ) +SYMBOL(btowc, std::, ) +SYMBOL(btowc, None, ) +SYMBOL(btowc, None, ) +SYMBOL(c16rtomb, std::, ) +SYMBOL(c16rtomb, None, ) +SYMBOL(c16rtomb, None, ) +SYMBOL(c32rtomb, std::, ) +SYMBOL(c32rtomb, None, ) +SYMBOL(c32rtomb, None, ) +SYMBOL(c8rtomb, std::, ) +SYMBOL(c8rtomb, None, ) +SYMBOL(c8rtomb, None, ) +SYMBOL(calloc, std::, ) +SYMBOL(calloc, None, ) +SYMBOL(calloc, None, ) +SYMBOL(cbrt, std::, ) +SYMBOL(cbrt, None, ) +SYMBOL(cbrt, None, ) +SYMBOL(cbrtf, std::, ) +SYMBOL(cbrtf, None, ) +SYMBOL(cbrtf, None, ) +SYMBOL(cbrtl, std::, ) +SYMBOL(cbrtl, None, ) +SYMBOL(cbrtl, None, ) +SYMBOL(ceil, std::, ) +SYMBOL(ceil, None, ) +SYMBOL(ceil, None, ) +SYMBOL(ceilf, std::, ) +SYMBOL(ceilf, None, ) +SYMBOL(ceilf, None, ) +SYMBOL(ceill, std::, ) +SYMBOL(ceill, None, ) +SYMBOL(ceill, None, ) +SYMBOL(clearerr, std::, ) +SYMBOL(clearerr, None, ) +SYMBOL(clearerr, None, ) +SYMBOL(clock, std::, ) +SYMBOL(clock, None, ) +SYMBOL(clock, None, ) +SYMBOL(clock_t, std::, ) +SYMBOL(clock_t, None, ) +SYMBOL(clock_t, None, ) +SYMBOL(copysign, std::, ) +SYMBOL(copysign, None, ) +SYMBOL(copysign, None, ) +SYMBOL(copysignf, std::, ) +SYMBOL(copysignf, None, ) +SYMBOL(copysignf, None, ) +SYMBOL(copysignl, std::, ) +SYMBOL(copysignl, None, ) +SYMBOL(copysignl, None, ) +SYMBOL(cos, std::, ) +SYMBOL(cos, None, ) +SYMBOL(cos, None, ) +SYMBOL(cosf, std::, ) +SYMBOL(cosf, None, ) +SYMBOL(cosf, None, ) +SYMBOL(cosh, std::, ) +SYMBOL(cosh, None, ) +SYMBOL(cosh, None, ) +SYMBOL(coshf, std::, ) +SYMBOL(coshf, None, ) +SYMBOL(coshf, None, ) +SYMBOL(coshl, std::, ) +SYMBOL(coshl, None, ) +SYMBOL(coshl, None, ) +SYMBOL(cosl, std::, ) +SYMBOL(cosl, None, ) +SYMBOL(cosl, None, ) +SYMBOL(ctime, std::, ) +SYMBOL(ctime, None, ) +SYMBOL(ctime, None, ) +SYMBOL(difftime, std::, ) +SYMBOL(difftime, None, ) +SYMBOL(difftime, None, ) +SYMBOL(div_t, std::, ) +SYMBOL(div_t, None, ) +SYMBOL(div_t, None, ) +SYMBOL(double_t, std::, ) +SYMBOL(double_t, None, ) +SYMBOL(double_t, None, ) +SYMBOL(erf, std::, ) +SYMBOL(erf, None, ) +SYMBOL(erf, None, ) +SYMBOL(erfc, std::, ) +SYMBOL(erfc, None, ) +SYMBOL(erfc, None, ) +SYMBOL(erfcf, std::, ) +SYMBOL(erfcf, None, ) +SYMBOL(erfcf, None, ) +SYMBOL(erfcl, std::, ) +SYMBOL(erfcl, None, ) +SYMBOL(erfcl, None, ) +SYMBOL(erff, std::, ) +SYMBOL(erff, None, ) +SYMBOL(erff, None, ) +SYMBOL(erfl, std::, ) +SYMBOL(erfl, None, ) +SYMBOL(erfl, None, ) +SYMBOL(exit, std::, ) +SYMBOL(exit, None, ) +SYMBOL(exit, None, ) +SYMBOL(exp, std::, ) +SYMBOL(exp, None, ) +SYMBOL(exp, None, ) +SYMBOL(exp2, std::, ) +SYMBOL(exp2, None, ) +SYMBOL(exp2, None, ) +SYMBOL(exp2f, std::, ) +SYMBOL(exp2f, None, ) +SYMBOL(exp2f, None, ) +SYMBOL(exp2l, std::, ) +SYMBOL(exp2l, None, ) +SYMBOL(exp2l, None, ) +SYMBOL(expf, std::, ) +SYMBOL(expf, None, ) +SYMBOL(expf, None, ) +SYMBOL(expl, std::, ) +SYMBOL(expl, None, ) +SYMBOL(expl, None, ) +SYMBOL(expm1, std::, ) +SYMBOL(expm1, None, ) +SYMBOL(expm1, None, ) +SYMBOL(expm1f, std::, ) +SYMBOL(expm1f, None, ) +SYMBOL(expm1f, None, ) +SYMBOL(expm1l, std::, ) +SYMBOL(expm1l, None, ) +SYMBOL(expm1l, None, ) +SYMBOL(fabs, std::, ) +SYMBOL(fabs, None, ) +SYMBOL(fabs, None, ) +SYMBOL(fabsf, std::, ) +SYMBOL(fabsf, None, ) +SYMBOL(fabsf, None, ) +SYMBOL(fabsl, std::, ) +SYMBOL(fabsl, None, ) +SYMBOL(fabsl, None, ) +SYMBOL(fclose, std::, ) +SYMBOL(fclose, None, ) +SYMBOL(fclose, None, ) +SYMBOL(fdim, std::, ) +SYMBOL(fdim, None, ) +SYMBOL(fdim, None, ) +SYMBOL(fdimf, std::, ) +SYMBOL(fdimf, None, ) +SYMBOL(fdimf, None, ) +SYMBOL(fdiml, std::, ) +SYMBOL(fdiml, None, ) +SYMBOL(fdiml, None, ) +SYMBOL(feclearexcept, std::, ) +SYMBOL(feclearexcept, None, ) +SYMBOL(feclearexcept, None, ) +SYMBOL(fegetenv, std::, ) +SYMBOL(fegetenv, None, ) +SYMBOL(fegetenv, None, ) +SYMBOL(fegetexceptflag, std::, ) +SYMBOL(fegetexceptflag, None, ) +SYMBOL(fegetexceptflag, None, ) +SYMBOL(fegetround, std::, ) +SYMBOL(fegetround, None, ) +SYMBOL(fegetround, None, ) +SYMBOL(feholdexcept, std::, ) +SYMBOL(feholdexcept, None, ) +SYMBOL(feholdexcept, None, ) +SYMBOL(fenv_t, std::, ) +SYMBOL(fenv_t, None, ) +SYMBOL(fenv_t, None, ) +SYMBOL(feof, std::, ) +SYMBOL(feof, None, ) +SYMBOL(feof, None, ) +SYMBOL(feraiseexcept, std::, ) +SYMBOL(feraiseexcept, None, ) +SYMBOL(feraiseexcept, None, ) +SYMBOL(ferror, std::, ) +SYMBOL(ferror, None, ) +SYMBOL(ferror, None, ) +SYMBOL(fesetenv, std::, ) +SYMBOL(fesetenv, None, ) +SYMBOL(fesetenv, None, ) +SYMBOL(fesetexceptflag, std::, ) +SYMBOL(fesetexceptflag, None, ) +SYMBOL(fesetexceptflag, None, ) +SYMBOL(fesetround, std::, ) +SYMBOL(fesetround, None, ) +SYMBOL(fesetround, None, ) +SYMBOL(fetestexcept, std::, ) +SYMBOL(fetestexcept, None, ) +SYMBOL(fetestexcept, None, ) +SYMBOL(feupdateenv, std::, ) +SYMBOL(feupdateenv, None, ) +SYMBOL(feupdateenv, None, ) +SYMBOL(fexcept_t, std::, ) +SYMBOL(fexcept_t, None, ) +SYMBOL(fexcept_t, None, ) +SYMBOL(fflush, std::, ) +SYMBOL(fflush, None, ) +SYMBOL(fflush, None, ) +SYMBOL(fgetc, std::, ) +SYMBOL(fgetc, None, ) +SYMBOL(fgetc, None, ) +SYMBOL(fgetpos, std::, ) +SYMBOL(fgetpos, None, ) +SYMBOL(fgetpos, None, ) +SYMBOL(fgets, std::, ) +SYMBOL(fgets, None, ) +SYMBOL(fgets, None, ) +SYMBOL(fgetwc, std::, ) +SYMBOL(fgetwc, None, ) +SYMBOL(fgetwc, None, ) +SYMBOL(fgetws, std::, ) +SYMBOL(fgetws, None, ) +SYMBOL(fgetws, None, ) +SYMBOL(float_t, std::, ) +SYMBOL(float_t, None, ) +SYMBOL(float_t, None, ) +SYMBOL(floor, std::, ) +SYMBOL(floor, None, ) +SYMBOL(floor, None, ) +SYMBOL(floorf, std::, ) +SYMBOL(floorf, None, ) +SYMBOL(floorf, None, ) +SYMBOL(floorl, std::, ) +SYMBOL(floorl, None, ) +SYMBOL(floorl, None, ) +SYMBOL(fma, std::, ) +SYMBOL(fma, None, ) +SYMBOL(fma, None, ) +SYMBOL(fmaf, std::, ) +SYMBOL(fmaf, None, ) +SYMBOL(fmaf, None, ) +SYMBOL(fmal, std::, ) +SYMBOL(fmal, None, ) +SYMBOL(fmal, None, ) +SYMBOL(fmax, std::, ) +SYMBOL(fmax, None, ) +SYMBOL(fmax, None, ) +SYMBOL(fmaxf, std::, ) +SYMBOL(fmaxf, None, ) +SYMBOL(fmaxf, None, ) +SYMBOL(fmaxl, std::, ) +SYMBOL(fmaxl, None, ) +SYMBOL(fmaxl, None, ) +SYMBOL(fmin, std::, ) +SYMBOL(fmin, None, ) +SYMBOL(fmin, None, ) +SYMBOL(fminf, std::, ) +SYMBOL(fminf, None, ) +SYMBOL(fminf, None, ) +SYMBOL(fminl, std::, ) +SYMBOL(fminl, None, ) +SYMBOL(fminl, None, ) +SYMBOL(fmod, std::, ) +SYMBOL(fmod, None, ) +SYMBOL(fmod, None, ) +SYMBOL(fmodf, std::, ) +SYMBOL(fmodf, None, ) +SYMBOL(fmodf, None, ) +SYMBOL(fmodl, std::, ) +SYMBOL(fmodl, None, ) +SYMBOL(fmodl, None, ) +SYMBOL(fopen, std::, ) +SYMBOL(fopen, None, ) +SYMBOL(fopen, None, ) +SYMBOL(fpclassify, std::, ) +SYMBOL(fpclassify, None, ) +SYMBOL(fpclassify, None, ) +SYMBOL(fpos_t, std::, ) +SYMBOL(fpos_t, None, ) +SYMBOL(fpos_t, None, ) +SYMBOL(fprintf, std::, ) +SYMBOL(fprintf, None, ) +SYMBOL(fprintf, None, ) +SYMBOL(fputc, std::, ) +SYMBOL(fputc, None, ) +SYMBOL(fputc, None, ) +SYMBOL(fputs, std::, ) +SYMBOL(fputs, None, ) +SYMBOL(fputs, None, ) +SYMBOL(fputwc, std::, ) +SYMBOL(fputwc, None, ) +SYMBOL(fputwc, None, ) +SYMBOL(fputws, std::, ) +SYMBOL(fputws, None, ) +SYMBOL(fputws, None, ) +SYMBOL(fread, std::, ) +SYMBOL(fread, None, ) +SYMBOL(fread, None, ) +SYMBOL(free, std::, ) +SYMBOL(free, None, ) +SYMBOL(free, None, ) +SYMBOL(freopen, std::, ) +SYMBOL(freopen, None, ) +SYMBOL(freopen, None, ) +SYMBOL(frexp, std::, ) +SYMBOL(frexp, None, ) +SYMBOL(frexp, None, ) +SYMBOL(frexpf, std::, ) +SYMBOL(frexpf, None, ) +SYMBOL(frexpf, None, ) +SYMBOL(frexpl, std::, ) +SYMBOL(frexpl, None, ) +SYMBOL(frexpl, None, ) +SYMBOL(fscanf, std::, ) +SYMBOL(fscanf, None, ) +SYMBOL(fscanf, None, ) +SYMBOL(fseek, std::, ) +SYMBOL(fseek, None, ) +SYMBOL(fseek, None, ) +SYMBOL(fsetpos, std::, ) +SYMBOL(fsetpos, None, ) +SYMBOL(fsetpos, None, ) +SYMBOL(ftell, std::, ) +SYMBOL(ftell, None, ) +SYMBOL(ftell, None, ) +SYMBOL(fwide, std::, ) +SYMBOL(fwide, None, ) +SYMBOL(fwide, None, ) +SYMBOL(fwprintf, std::, ) +SYMBOL(fwprintf, None, ) +SYMBOL(fwprintf, None, ) +SYMBOL(fwrite, std::, ) +SYMBOL(fwrite, None, ) +SYMBOL(fwrite, None, ) +SYMBOL(fwscanf, std::, ) +SYMBOL(fwscanf, None, ) +SYMBOL(fwscanf, None, ) +SYMBOL(getc, std::, ) +SYMBOL(getc, None, ) +SYMBOL(getc, None, ) +SYMBOL(getchar, std::, ) +SYMBOL(getchar, None, ) +SYMBOL(getchar, None, ) +SYMBOL(getenv, std::, ) +SYMBOL(getenv, None, ) +SYMBOL(getenv, None, ) +SYMBOL(getwc, std::, ) +SYMBOL(getwc, None, ) +SYMBOL(getwc, None, ) +SYMBOL(getwchar, std::, ) +SYMBOL(getwchar, None, ) +SYMBOL(getwchar, None, ) +SYMBOL(gmtime, std::, ) +SYMBOL(gmtime, None, ) +SYMBOL(gmtime, None, ) +SYMBOL(hypot, std::, ) +SYMBOL(hypot, None, ) +SYMBOL(hypot, None, ) +SYMBOL(hypotf, std::, ) +SYMBOL(hypotf, None, ) +SYMBOL(hypotf, None, ) +SYMBOL(hypotl, std::, ) +SYMBOL(hypotl, None, ) +SYMBOL(hypotl, None, ) +SYMBOL(ilogb, std::, ) +SYMBOL(ilogb, None, ) +SYMBOL(ilogb, None, ) +SYMBOL(ilogbf, std::, ) +SYMBOL(ilogbf, None, ) +SYMBOL(ilogbf, None, ) +SYMBOL(ilogbl, std::, ) +SYMBOL(ilogbl, None, ) +SYMBOL(ilogbl, None, ) +SYMBOL(imaxabs, std::, ) +SYMBOL(imaxabs, None, ) +SYMBOL(imaxabs, None, ) +SYMBOL(imaxdiv, std::, ) +SYMBOL(imaxdiv, None, ) +SYMBOL(imaxdiv, None, ) +SYMBOL(imaxdiv_t, std::, ) +SYMBOL(imaxdiv_t, None, ) +SYMBOL(imaxdiv_t, None, ) +SYMBOL(int16_t, std::, ) +SYMBOL(int16_t, None, ) +SYMBOL(int16_t, None, ) +SYMBOL(int32_t, std::, ) +SYMBOL(int32_t, None, ) +SYMBOL(int32_t, None, ) +SYMBOL(int64_t, std::, ) +SYMBOL(int64_t, None, ) +SYMBOL(int64_t, None, ) +SYMBOL(int8_t, std::, ) +SYMBOL(int8_t, None, ) +SYMBOL(int8_t, None, ) +SYMBOL(int_fast16_t, std::, ) +SYMBOL(int_fast16_t, None, ) +SYMBOL(int_fast16_t, None, ) +SYMBOL(int_fast32_t, std::, ) +SYMBOL(int_fast32_t, None, ) +SYMBOL(int_fast32_t, None, ) +SYMBOL(int_fast64_t, std::, ) +SYMBOL(int_fast64_t, None, ) +SYMBOL(int_fast64_t, None, ) +SYMBOL(int_fast8_t, std::, ) +SYMBOL(int_fast8_t, None, ) +SYMBOL(int_fast8_t, None, ) +SYMBOL(int_least16_t, std::, ) +SYMBOL(int_least16_t, None, ) +SYMBOL(int_least16_t, None, ) +SYMBOL(int_least32_t, std::, ) +SYMBOL(int_least32_t, None, ) +SYMBOL(int_least32_t, None, ) +SYMBOL(int_least64_t, std::, ) +SYMBOL(int_least64_t, None, ) +SYMBOL(int_least64_t, None, ) +SYMBOL(int_least8_t, std::, ) +SYMBOL(int_least8_t, None, ) +SYMBOL(int_least8_t, None, ) +SYMBOL(intmax_t, std::, ) +SYMBOL(intmax_t, None, ) +SYMBOL(intmax_t, None, ) +SYMBOL(intptr_t, std::, ) +SYMBOL(intptr_t, None, ) +SYMBOL(intptr_t, None, ) +SYMBOL(isalnum, std::, ) +SYMBOL(isalnum, None, ) +SYMBOL(isalnum, None, ) +SYMBOL(isalpha, std::, ) +SYMBOL(isalpha, None, ) +SYMBOL(isalpha, None, ) +SYMBOL(isblank, std::, ) +SYMBOL(isblank, None, ) +SYMBOL(isblank, None, ) +SYMBOL(iscntrl, std::, ) +SYMBOL(iscntrl, None, ) +SYMBOL(iscntrl, None, ) +SYMBOL(isdigit, std::, ) +SYMBOL(isdigit, None, ) +SYMBOL(isdigit, None, ) +SYMBOL(isfinite, std::, ) +SYMBOL(isfinite, None, ) +SYMBOL(isfinite, None, ) +SYMBOL(isgraph, std::, ) +SYMBOL(isgraph, None, ) +SYMBOL(isgraph, None, ) +SYMBOL(isgreater, std::, ) +SYMBOL(isgreater, None, ) +SYMBOL(isgreater, None, ) +SYMBOL(isgreaterequal, std::, ) +SYMBOL(isgreaterequal, None, ) +SYMBOL(isgreaterequal, None, ) +SYMBOL(isinf, std::, ) +SYMBOL(isinf, None, ) +SYMBOL(isinf, None, ) +SYMBOL(isless, std::, ) +SYMBOL(isless, None, ) +SYMBOL(isless, None, ) +SYMBOL(islessequal, std::, ) +SYMBOL(islessequal, None, ) +SYMBOL(islessequal, None, ) +SYMBOL(islessgreater, std::, ) +SYMBOL(islessgreater, None, ) +SYMBOL(islessgreater, None, ) +SYMBOL(islower, std::, ) +SYMBOL(islower, None, ) +SYMBOL(islower, None, ) +SYMBOL(isnan, std::, ) +SYMBOL(isnan, None, ) +SYMBOL(isnan, None, ) +SYMBOL(isnormal, std::, ) +SYMBOL(isnormal, None, ) +SYMBOL(isnormal, None, ) +SYMBOL(isprint, std::, ) +SYMBOL(isprint, None, ) +SYMBOL(isprint, None, ) +SYMBOL(ispunct, std::, ) +SYMBOL(ispunct, None, ) +SYMBOL(ispunct, None, ) +SYMBOL(isspace, std::, ) +SYMBOL(isspace, None, ) +SYMBOL(isspace, None, ) +SYMBOL(isunordered, std::, ) +SYMBOL(isunordered, None, ) +SYMBOL(isunordered, None, ) +SYMBOL(isupper, std::, ) +SYMBOL(isupper, None, ) +SYMBOL(isupper, None, ) +SYMBOL(iswalnum, std::, ) +SYMBOL(iswalnum, None, ) +SYMBOL(iswalnum, None, ) +SYMBOL(iswalpha, std::, ) +SYMBOL(iswalpha, None, ) +SYMBOL(iswalpha, None, ) +SYMBOL(iswblank, std::, ) +SYMBOL(iswblank, None, ) +SYMBOL(iswblank, None, ) +SYMBOL(iswcntrl, std::, ) +SYMBOL(iswcntrl, None, ) +SYMBOL(iswcntrl, None, ) +SYMBOL(iswctype, std::, ) +SYMBOL(iswctype, None, ) +SYMBOL(iswctype, None, ) +SYMBOL(iswdigit, std::, ) +SYMBOL(iswdigit, None, ) +SYMBOL(iswdigit, None, ) +SYMBOL(iswgraph, std::, ) +SYMBOL(iswgraph, None, ) +SYMBOL(iswgraph, None, ) +SYMBOL(iswlower, std::, ) +SYMBOL(iswlower, None, ) +SYMBOL(iswlower, None, ) +SYMBOL(iswprint, std::, ) +SYMBOL(iswprint, None, ) +SYMBOL(iswprint, None, ) +SYMBOL(iswpunct, std::, ) +SYMBOL(iswpunct, None, ) +SYMBOL(iswpunct, None, ) +SYMBOL(iswspace, std::, ) +SYMBOL(iswspace, None, ) +SYMBOL(iswspace, None, ) +SYMBOL(iswupper, std::, ) +SYMBOL(iswupper, None, ) +SYMBOL(iswupper, None, ) +SYMBOL(iswxdigit, std::, ) +SYMBOL(iswxdigit, None, ) +SYMBOL(iswxdigit, None, ) +SYMBOL(isxdigit, std::, ) +SYMBOL(isxdigit, None, ) +SYMBOL(isxdigit, None, ) +SYMBOL(jmp_buf, std::, ) +SYMBOL(jmp_buf, None, ) +SYMBOL(jmp_buf, None, ) +SYMBOL(labs, std::, ) +SYMBOL(labs, None, ) +SYMBOL(labs, None, ) +SYMBOL(lconv, std::, ) +SYMBOL(lconv, None, ) +SYMBOL(lconv, None, ) +SYMBOL(ldexp, std::, ) +SYMBOL(ldexp, None, ) +SYMBOL(ldexp, None, ) +SYMBOL(ldexpf, std::, ) +SYMBOL(ldexpf, None, ) +SYMBOL(ldexpf, None, ) +SYMBOL(ldexpl, std::, ) +SYMBOL(ldexpl, None, ) +SYMBOL(ldexpl, None, ) +SYMBOL(ldiv, std::, ) +SYMBOL(ldiv, None, ) +SYMBOL(ldiv, None, ) +SYMBOL(ldiv_t, std::, ) +SYMBOL(ldiv_t, None, ) +SYMBOL(ldiv_t, None, ) +SYMBOL(lgamma, std::, ) +SYMBOL(lgamma, None, ) +SYMBOL(lgamma, None, ) +SYMBOL(lgammaf, std::, ) +SYMBOL(lgammaf, None, ) +SYMBOL(lgammaf, None, ) +SYMBOL(lgammal, std::, ) +SYMBOL(lgammal, None, ) +SYMBOL(lgammal, None, ) +SYMBOL(llabs, std::, ) +SYMBOL(llabs, None, ) +SYMBOL(llabs, None, ) +SYMBOL(lldiv, std::, ) +SYMBOL(lldiv, None, ) +SYMBOL(lldiv, None, ) +SYMBOL(lldiv_t, std::, ) +SYMBOL(lldiv_t, None, ) +SYMBOL(lldiv_t, None, ) +SYMBOL(llrint, std::, ) +SYMBOL(llrint, None, ) +SYMBOL(llrint, None, ) +SYMBOL(llrintf, std::, ) +SYMBOL(llrintf, None, ) +SYMBOL(llrintf, None, ) +SYMBOL(llrintl, std::, ) +SYMBOL(llrintl, None, ) +SYMBOL(llrintl, None, ) +SYMBOL(llround, std::, ) +SYMBOL(llround, None, ) +SYMBOL(llround, None, ) +SYMBOL(llroundf, std::, ) +SYMBOL(llroundf, None, ) +SYMBOL(llroundf, None, ) +SYMBOL(llroundl, std::, ) +SYMBOL(llroundl, None, ) +SYMBOL(llroundl, None, ) +SYMBOL(localeconv, std::, ) +SYMBOL(localeconv, None, ) +SYMBOL(localeconv, None, ) +SYMBOL(localtime, std::, ) +SYMBOL(localtime, None, ) +SYMBOL(localtime, None, ) +SYMBOL(log, std::, ) +SYMBOL(log, None, ) +SYMBOL(log, None, ) +SYMBOL(log10, std::, ) +SYMBOL(log10, None, ) +SYMBOL(log10, None, ) +SYMBOL(log10f, std::, ) +SYMBOL(log10f, None, ) +SYMBOL(log10f, None, ) +SYMBOL(log10l, std::, ) +SYMBOL(log10l, None, ) +SYMBOL(log10l, None, ) +SYMBOL(log1p, std::, ) +SYMBOL(log1p, None, ) +SYMBOL(log1p, None, ) +SYMBOL(log1pf, std::, ) +SYMBOL(log1pf, None, ) +SYMBOL(log1pf, None, ) +SYMBOL(log1pl, std::, ) +SYMBOL(log1pl, None, ) +SYMBOL(log1pl, None, ) +SYMBOL(log2, std::, ) +SYMBOL(log2, None, ) +SYMBOL(log2, None, ) +SYMBOL(log2f, std::, ) +SYMBOL(log2f, None, ) +SYMBOL(log2f, None, ) +SYMBOL(log2l, std::, ) +SYMBOL(log2l, None, ) +SYMBOL(log2l, None, ) +SYMBOL(logb, std::, ) +SYMBOL(logb, None, ) +SYMBOL(logb, None, ) +SYMBOL(logbf, std::, ) +SYMBOL(logbf, None, ) +SYMBOL(logbf, None, ) +SYMBOL(logbl, std::, ) +SYMBOL(logbl, None, ) +SYMBOL(logbl, None, ) +SYMBOL(logf, std::, ) +SYMBOL(logf, None, ) +SYMBOL(logf, None, ) +SYMBOL(logl, std::, ) +SYMBOL(logl, None, ) +SYMBOL(logl, None, ) +SYMBOL(longjmp, std::, ) +SYMBOL(longjmp, None, ) +SYMBOL(longjmp, None, ) +SYMBOL(lrint, std::, ) +SYMBOL(lrint, None, ) +SYMBOL(lrint, None, ) +SYMBOL(lrintf, std::, ) +SYMBOL(lrintf, None, ) +SYMBOL(lrintf, None, ) +SYMBOL(lrintl, std::, ) +SYMBOL(lrintl, None, ) +SYMBOL(lrintl, None, ) +SYMBOL(lround, std::, ) +SYMBOL(lround, None, ) +SYMBOL(lround, None, ) +SYMBOL(lroundf, std::, ) +SYMBOL(lroundf, None, ) +SYMBOL(lroundf, None, ) +SYMBOL(lroundl, std::, ) +SYMBOL(lroundl, None, ) +SYMBOL(lroundl, None, ) +SYMBOL(malloc, std::, ) +SYMBOL(malloc, None, ) +SYMBOL(malloc, None, ) +SYMBOL(max_align_t, std::, ) +SYMBOL(max_align_t, None, ) +SYMBOL(max_align_t, None, ) +SYMBOL(mblen, std::, ) +SYMBOL(mblen, None, ) +SYMBOL(mblen, None, ) +SYMBOL(mbrlen, std::, ) +SYMBOL(mbrlen, None, ) +SYMBOL(mbrlen, None, ) +SYMBOL(mbrtoc16, std::, ) +SYMBOL(mbrtoc16, None, ) +SYMBOL(mbrtoc16, None, ) +SYMBOL(mbrtoc32, std::, ) +SYMBOL(mbrtoc32, None, ) +SYMBOL(mbrtoc32, None, ) +SYMBOL(mbrtoc8, std::, ) +SYMBOL(mbrtoc8, None, ) +SYMBOL(mbrtoc8, None, ) +SYMBOL(mbrtowc, std::, ) +SYMBOL(mbrtowc, None, ) +SYMBOL(mbrtowc, None, ) +SYMBOL(mbsinit, std::, ) +SYMBOL(mbsinit, None, ) +SYMBOL(mbsinit, None, ) +SYMBOL(mbsrtowcs, std::, ) +SYMBOL(mbsrtowcs, None, ) +SYMBOL(mbsrtowcs, None, ) +SYMBOL(mbstowcs, std::, ) +SYMBOL(mbstowcs, None, ) +SYMBOL(mbstowcs, None, ) +SYMBOL(mbtowc, std::, ) +SYMBOL(mbtowc, None, ) +SYMBOL(mbtowc, None, ) +SYMBOL(memchr, std::, ) +SYMBOL(memchr, None, ) +SYMBOL(memchr, None, ) +SYMBOL(memcmp, std::, ) +SYMBOL(memcmp, None, ) +SYMBOL(memcmp, None, ) +SYMBOL(memcpy, std::, ) +SYMBOL(memcpy, None, ) +SYMBOL(memcpy, None, ) +SYMBOL(memmove, std::, ) +SYMBOL(memmove, None, ) +SYMBOL(memmove, None, ) +SYMBOL(memset, std::, ) +SYMBOL(memset, None, ) +SYMBOL(memset, None, ) +SYMBOL(mktime, std::, ) +SYMBOL(mktime, None, ) +SYMBOL(mktime, None, ) +SYMBOL(modf, std::, ) +SYMBOL(modf, None, ) +SYMBOL(modf, None, ) +SYMBOL(modff, std::, ) +SYMBOL(modff, None, ) +SYMBOL(modff, None, ) +SYMBOL(modfl, std::, ) +SYMBOL(modfl, None, ) +SYMBOL(modfl, None, ) +SYMBOL(nan, std::, ) +SYMBOL(nan, None, ) +SYMBOL(nan, None, ) +SYMBOL(nanf, std::, ) +SYMBOL(nanf, None, ) +SYMBOL(nanf, None, ) +SYMBOL(nanl, std::, ) +SYMBOL(nanl, None, ) +SYMBOL(nanl, None, ) +SYMBOL(nearbyint, std::, ) +SYMBOL(nearbyint, None, ) +SYMBOL(nearbyint, None, ) +SYMBOL(nearbyintf, std::, ) +SYMBOL(nearbyintf, None, ) +SYMBOL(nearbyintf, None, ) +SYMBOL(nearbyintl, std::, ) +SYMBOL(nearbyintl, None, ) +SYMBOL(nearbyintl, None, ) +SYMBOL(nextafter, std::, ) +SYMBOL(nextafter, None, ) +SYMBOL(nextafter, None, ) +SYMBOL(nextafterf, std::, ) +SYMBOL(nextafterf, None, ) +SYMBOL(nextafterf, None, ) +SYMBOL(nextafterl, std::, ) +SYMBOL(nextafterl, None, ) +SYMBOL(nextafterl, None, ) +SYMBOL(nexttoward, std::, ) +SYMBOL(nexttoward, None, ) +SYMBOL(nexttoward, None, ) +SYMBOL(nexttowardf, std::, ) +SYMBOL(nexttowardf, None, ) +SYMBOL(nexttowardf, None, ) +SYMBOL(nexttowardl, std::, ) +SYMBOL(nexttowardl, None, ) +SYMBOL(nexttowardl, None, ) +SYMBOL(nullptr_t, std::, ) +SYMBOL(nullptr_t, None, ) +SYMBOL(nullptr_t, None, ) +SYMBOL(perror, std::, ) +SYMBOL(perror, None, ) +SYMBOL(perror, None, ) +SYMBOL(pow, std::, ) +SYMBOL(pow, None, ) +SYMBOL(pow, None, ) +SYMBOL(powf, std::, ) +SYMBOL(powf, None, ) +SYMBOL(powf, None, ) +SYMBOL(powl, std::, ) +SYMBOL(powl, None, ) +SYMBOL(powl, None, ) +SYMBOL(printf, std::, ) +SYMBOL(printf, None, ) +SYMBOL(printf, None, ) +SYMBOL(ptrdiff_t, std::, ) +SYMBOL(ptrdiff_t, None, ) +SYMBOL(ptrdiff_t, None, ) +SYMBOL(putc, std::, ) +SYMBOL(putc, None, ) +SYMBOL(putc, None, ) +SYMBOL(putchar, std::, ) +SYMBOL(putchar, None, ) +SYMBOL(putchar, None, ) +SYMBOL(puts, std::, ) +SYMBOL(puts, None, ) +SYMBOL(puts, None, ) +SYMBOL(putwc, std::, ) +SYMBOL(putwc, None, ) +SYMBOL(putwc, None, ) +SYMBOL(putwchar, std::, ) +SYMBOL(putwchar, None, ) +SYMBOL(putwchar, None, ) +SYMBOL(qsort, std::, ) +SYMBOL(qsort, None, ) +SYMBOL(qsort, None, ) +SYMBOL(quick_exit, std::, ) +SYMBOL(quick_exit, None, ) +SYMBOL(quick_exit, None, ) +SYMBOL(raise, std::, ) +SYMBOL(raise, None, ) +SYMBOL(raise, None, ) +SYMBOL(rand, std::, ) +SYMBOL(rand, None, ) +SYMBOL(rand, None, ) +SYMBOL(realloc, std::, ) +SYMBOL(realloc, None, ) +SYMBOL(realloc, None, ) +SYMBOL(remainder, std::, ) +SYMBOL(remainder, None, ) +SYMBOL(remainder, None, ) +SYMBOL(remainderf, std::, ) +SYMBOL(remainderf, None, ) +SYMBOL(remainderf, None, ) +SYMBOL(remainderl, std::, ) +SYMBOL(remainderl, None, ) +SYMBOL(remainderl, None, ) +SYMBOL(remquo, std::, ) +SYMBOL(remquo, None, ) +SYMBOL(remquo, None, ) +SYMBOL(remquof, std::, ) +SYMBOL(remquof, None, ) +SYMBOL(remquof, None, ) +SYMBOL(remquol, std::, ) +SYMBOL(remquol, None, ) +SYMBOL(remquol, None, ) +SYMBOL(rename, std::, ) +SYMBOL(rename, None, ) +SYMBOL(rename, None, ) +SYMBOL(rewind, std::, ) +SYMBOL(rewind, None, ) +SYMBOL(rewind, None, ) +SYMBOL(rint, std::, ) +SYMBOL(rint, None, ) +SYMBOL(rint, None, ) +SYMBOL(rintf, std::, ) +SYMBOL(rintf, None, ) +SYMBOL(rintf, None, ) +SYMBOL(rintl, std::, ) +SYMBOL(rintl, None, ) +SYMBOL(rintl, None, ) +SYMBOL(round, std::, ) +SYMBOL(round, None, ) +SYMBOL(round, None, ) +SYMBOL(roundf, std::, ) +SYMBOL(roundf, None, ) +SYMBOL(roundf, None, ) +SYMBOL(roundl, std::, ) +SYMBOL(roundl, None, ) +SYMBOL(roundl, None, ) +SYMBOL(scalbln, std::, ) +SYMBOL(scalbln, None, ) +SYMBOL(scalbln, None, ) +SYMBOL(scalblnf, std::, ) +SYMBOL(scalblnf, None, ) +SYMBOL(scalblnf, None, ) +SYMBOL(scalblnl, std::, ) +SYMBOL(scalblnl, None, ) +SYMBOL(scalblnl, None, ) +SYMBOL(scalbn, std::, ) +SYMBOL(scalbn, None, ) +SYMBOL(scalbn, None, ) +SYMBOL(scalbnf, std::, ) +SYMBOL(scalbnf, None, ) +SYMBOL(scalbnf, None, ) +SYMBOL(scalbnl, std::, ) +SYMBOL(scalbnl, None, ) +SYMBOL(scalbnl, None, ) +SYMBOL(scanf, std::, ) +SYMBOL(scanf, None, ) +SYMBOL(scanf, None, ) +SYMBOL(setbuf, std::, ) +SYMBOL(setbuf, None, ) +SYMBOL(setbuf, None, ) +SYMBOL(setlocale, std::, ) +SYMBOL(setlocale, None, ) +SYMBOL(setlocale, None, ) +SYMBOL(setvbuf, std::, ) +SYMBOL(setvbuf, None, ) +SYMBOL(setvbuf, None, ) +SYMBOL(sig_atomic_t, std::, ) +SYMBOL(sig_atomic_t, None, ) +SYMBOL(sig_atomic_t, None, ) +SYMBOL(signal, std::, ) +SYMBOL(signal, None, ) +SYMBOL(signal, None, ) +SYMBOL(signbit, std::, ) +SYMBOL(signbit, None, ) +SYMBOL(signbit, None, ) +SYMBOL(sin, std::, ) +SYMBOL(sin, None, ) +SYMBOL(sin, None, ) +SYMBOL(sinf, std::, ) +SYMBOL(sinf, None, ) +SYMBOL(sinf, None, ) +SYMBOL(sinh, std::, ) +SYMBOL(sinh, None, ) +SYMBOL(sinh, None, ) +SYMBOL(sinhf, std::, ) +SYMBOL(sinhf, None, ) +SYMBOL(sinhf, None, ) +SYMBOL(sinhl, std::, ) +SYMBOL(sinhl, None, ) +SYMBOL(sinhl, None, ) +SYMBOL(sinl, std::, ) +SYMBOL(sinl, None, ) +SYMBOL(sinl, None, ) +SYMBOL(snprintf, std::, ) +SYMBOL(snprintf, None, ) +SYMBOL(snprintf, None, ) +SYMBOL(sph_bessel, std::, ) +SYMBOL(sph_bessel, None, ) +SYMBOL(sph_bessel, None, ) +SYMBOL(sph_besself, std::, ) +SYMBOL(sph_besself, None, ) +SYMBOL(sph_besself, None, ) +SYMBOL(sph_bessell, std::, ) +SYMBOL(sph_bessell, None, ) +SYMBOL(sph_bessell, None, ) +SYMBOL(sprintf, std::, ) +SYMBOL(sprintf, None, ) +SYMBOL(sprintf, None, ) +SYMBOL(sqrt, std::, ) +SYMBOL(sqrt, None, ) +SYMBOL(sqrt, None, ) +SYMBOL(sqrtf, std::, ) +SYMBOL(sqrtf, None, ) +SYMBOL(sqrtf, None, ) +SYMBOL(sqrtl, std::, ) +SYMBOL(sqrtl, None, ) +SYMBOL(sqrtl, None, ) +SYMBOL(srand, std::, ) +SYMBOL(srand, None, ) +SYMBOL(srand, None, ) +SYMBOL(sscanf, std::, ) +SYMBOL(sscanf, None, ) +SYMBOL(sscanf, None, ) +SYMBOL(strcat, std::, ) +SYMBOL(strcat, None, ) +SYMBOL(strcat, None, ) +SYMBOL(strchr, std::, ) +SYMBOL(strchr, None, ) +SYMBOL(strchr, None, ) +SYMBOL(strcmp, std::, ) +SYMBOL(strcmp, None, ) +SYMBOL(strcmp, None, ) +SYMBOL(strcoll, std::, ) +SYMBOL(strcoll, None, ) +SYMBOL(strcoll, None, ) +SYMBOL(strcpy, std::, ) +SYMBOL(strcpy, None, ) +SYMBOL(strcpy, None, ) +SYMBOL(strcspn, std::, ) +SYMBOL(strcspn, None, ) +SYMBOL(strcspn, None, ) +SYMBOL(strerror, std::, ) +SYMBOL(strerror, None, ) +SYMBOL(strerror, None, ) +SYMBOL(strftime, std::, ) +SYMBOL(strftime, None, ) +SYMBOL(strftime, None, ) +SYMBOL(strlen, std::, ) +SYMBOL(strlen, None, ) +SYMBOL(strlen, None, ) +SYMBOL(strncat, std::, ) +SYMBOL(strncat, None, ) +SYMBOL(strncat, None, ) +SYMBOL(strncmp, std::, ) +SYMBOL(strncmp, None, ) +SYMBOL(strncmp, None, ) +SYMBOL(strncpy, std::, ) +SYMBOL(strncpy, None, ) +SYMBOL(strncpy, None, ) +SYMBOL(strpbrk, std::, ) +SYMBOL(strpbrk, None, ) +SYMBOL(strpbrk, None, ) +SYMBOL(strrchr, std::, ) +SYMBOL(strrchr, None, ) +SYMBOL(strrchr, None, ) +SYMBOL(strspn, std::, ) +SYMBOL(strspn, None, ) +SYMBOL(strspn, None, ) +SYMBOL(strstr, std::, ) +SYMBOL(strstr, None, ) +SYMBOL(strstr, None, ) +SYMBOL(strtod, std::, ) +SYMBOL(strtod, None, ) +SYMBOL(strtod, None, ) +SYMBOL(strtof, std::, ) +SYMBOL(strtof, None, ) +SYMBOL(strtof, None, ) +SYMBOL(strtoimax, std::, ) +SYMBOL(strtoimax, None, ) +SYMBOL(strtoimax, None, ) +SYMBOL(strtok, std::, ) +SYMBOL(strtok, None, ) +SYMBOL(strtok, None, ) +SYMBOL(strtol, std::, ) +SYMBOL(strtol, None, ) +SYMBOL(strtol, None, ) +SYMBOL(strtold, std::, ) +SYMBOL(strtold, None, ) +SYMBOL(strtold, None, ) +SYMBOL(strtoll, std::, ) +SYMBOL(strtoll, None, ) +SYMBOL(strtoll, None, ) +SYMBOL(strtoul, std::, ) +SYMBOL(strtoul, None, ) +SYMBOL(strtoul, None, ) +SYMBOL(strtoull, std::, ) +SYMBOL(strtoull, None, ) +SYMBOL(strtoull, None, ) +SYMBOL(strtoumax, std::, ) +SYMBOL(strtoumax, None, ) +SYMBOL(strtoumax, None, ) +SYMBOL(strxfrm, std::, ) +SYMBOL(strxfrm, None, ) +SYMBOL(strxfrm, None, ) +SYMBOL(swprintf, std::, ) +SYMBOL(swprintf, None, ) +SYMBOL(swprintf, None, ) +SYMBOL(swscanf, std::, ) +SYMBOL(swscanf, None, ) +SYMBOL(swscanf, None, ) +SYMBOL(system, std::, ) +SYMBOL(system, None, ) +SYMBOL(system, None, ) +SYMBOL(tan, std::, ) +SYMBOL(tan, None, ) +SYMBOL(tan, None, ) +SYMBOL(tanf, std::, ) +SYMBOL(tanf, None, ) +SYMBOL(tanf, None, ) +SYMBOL(tanh, std::, ) +SYMBOL(tanh, None, ) +SYMBOL(tanh, None, ) +SYMBOL(tanhf, std::, ) +SYMBOL(tanhf, None, ) +SYMBOL(tanhf, None, ) +SYMBOL(tanhl, std::, ) +SYMBOL(tanhl, None, ) +SYMBOL(tanhl, None, ) +SYMBOL(tanl, std::, ) +SYMBOL(tanl, None, ) +SYMBOL(tanl, None, ) +SYMBOL(tgamma, std::, ) +SYMBOL(tgamma, None, ) +SYMBOL(tgamma, None, ) +SYMBOL(tgammaf, std::, ) +SYMBOL(tgammaf, None, ) +SYMBOL(tgammaf, None, ) +SYMBOL(tgammal, std::, ) +SYMBOL(tgammal, None, ) +SYMBOL(tgammal, None, ) +SYMBOL(time, std::, ) +SYMBOL(time, None, ) +SYMBOL(time, None, ) +SYMBOL(time_t, std::, ) +SYMBOL(time_t, None, ) +SYMBOL(time_t, None, ) +SYMBOL(timespec, std::, ) +SYMBOL(timespec, None, ) +SYMBOL(timespec, None, ) +SYMBOL(timespec_get, std::, ) +SYMBOL(timespec_get, None, ) +SYMBOL(timespec_get, None, ) +SYMBOL(tm, std::, ) +SYMBOL(tm, None, ) +SYMBOL(tm, None, ) +SYMBOL(tmpfile, std::, ) +SYMBOL(tmpfile, None, ) +SYMBOL(tmpfile, None, ) +SYMBOL(tmpnam, std::, ) +SYMBOL(tmpnam, None, ) +SYMBOL(tmpnam, None, ) +SYMBOL(to_integer, std::, ) +SYMBOL(to_integer, None, ) +SYMBOL(to_integer, None, ) +SYMBOL(tolower, std::, ) +SYMBOL(tolower, None, ) +SYMBOL(tolower, None, ) +SYMBOL(toupper, std::, ) +SYMBOL(toupper, None, ) +SYMBOL(toupper, None, ) +SYMBOL(towctrans, std::, ) +SYMBOL(towctrans, None, ) +SYMBOL(towctrans, None, ) +SYMBOL(towlower, std::, ) +SYMBOL(towlower, None, ) +SYMBOL(towlower, None, ) +SYMBOL(towupper, std::, ) +SYMBOL(towupper, None, ) +SYMBOL(towupper, None, ) +SYMBOL(trunc, std::, ) +SYMBOL(trunc, None, ) +SYMBOL(trunc, None, ) +SYMBOL(truncf, std::, ) +SYMBOL(truncf, None, ) +SYMBOL(truncf, None, ) +SYMBOL(truncl, std::, ) +SYMBOL(truncl, None, ) +SYMBOL(truncl, None, ) +SYMBOL(uint16_t, std::, ) +SYMBOL(uint16_t, None, ) +SYMBOL(uint16_t, None, ) +SYMBOL(uint32_t, std::, ) +SYMBOL(uint32_t, None, ) +SYMBOL(uint32_t, None, ) +SYMBOL(uint64_t, std::, ) +SYMBOL(uint64_t, None, ) +SYMBOL(uint64_t, None, ) +SYMBOL(uint8_t, std::, ) +SYMBOL(uint8_t, None, ) +SYMBOL(uint8_t, None, ) +SYMBOL(uint_fast16_t, std::, ) +SYMBOL(uint_fast16_t, None, ) +SYMBOL(uint_fast16_t, None, ) +SYMBOL(uint_fast32_t, std::, ) +SYMBOL(uint_fast32_t, None, ) +SYMBOL(uint_fast32_t, None, ) +SYMBOL(uint_fast64_t, std::, ) +SYMBOL(uint_fast64_t, None, ) +SYMBOL(uint_fast64_t, None, ) +SYMBOL(uint_fast8_t, std::, ) +SYMBOL(uint_fast8_t, None, ) +SYMBOL(uint_fast8_t, None, ) +SYMBOL(uint_least16_t, std::, ) +SYMBOL(uint_least16_t, None, ) +SYMBOL(uint_least16_t, None, ) +SYMBOL(uint_least32_t, std::, ) +SYMBOL(uint_least32_t, None, ) +SYMBOL(uint_least32_t, None, ) +SYMBOL(uint_least64_t, std::, ) +SYMBOL(uint_least64_t, None, ) +SYMBOL(uint_least64_t, None, ) +SYMBOL(uint_least8_t, std::, ) +SYMBOL(uint_least8_t, None, ) +SYMBOL(uint_least8_t, None, ) +SYMBOL(uintmax_t, std::, ) +SYMBOL(uintmax_t, None, ) +SYMBOL(uintmax_t, None, ) +SYMBOL(uintptr_t, std::, ) +SYMBOL(uintptr_t, None, ) +SYMBOL(uintptr_t, None, ) +SYMBOL(ungetc, std::, ) +SYMBOL(ungetc, None, ) +SYMBOL(ungetc, None, ) +SYMBOL(ungetwc, std::, ) +SYMBOL(ungetwc, None, ) +SYMBOL(ungetwc, None, ) +SYMBOL(va_list, std::, ) +SYMBOL(va_list, None, ) +SYMBOL(va_list, None, ) +SYMBOL(vfprintf, std::, ) +SYMBOL(vfprintf, None, ) +SYMBOL(vfprintf, None, ) +SYMBOL(vfscanf, std::, ) +SYMBOL(vfscanf, None, ) +SYMBOL(vfscanf, None, ) +SYMBOL(vfwprintf, std::, ) +SYMBOL(vfwprintf, None, ) +SYMBOL(vfwprintf, None, ) +SYMBOL(vfwscanf, std::, ) +SYMBOL(vfwscanf, None, ) +SYMBOL(vfwscanf, None, ) +SYMBOL(vprintf, std::, ) +SYMBOL(vprintf, None, ) +SYMBOL(vprintf, None, ) +SYMBOL(vscanf, std::, ) +SYMBOL(vscanf, None, ) +SYMBOL(vscanf, None, ) +SYMBOL(vsnprintf, std::, ) +SYMBOL(vsnprintf, None, ) +SYMBOL(vsnprintf, None, ) +SYMBOL(vsprintf, std::, ) +SYMBOL(vsprintf, None, ) +SYMBOL(vsprintf, None, ) +SYMBOL(vsscanf, std::, ) +SYMBOL(vsscanf, None, ) +SYMBOL(vsscanf, None, ) +SYMBOL(vswprintf, std::, ) +SYMBOL(vswprintf, None, ) +SYMBOL(vswprintf, None, ) +SYMBOL(vswscanf, std::, ) +SYMBOL(vswscanf, None, ) +SYMBOL(vswscanf, None, ) +SYMBOL(vwprintf, std::, ) +SYMBOL(vwprintf, None, ) +SYMBOL(vwprintf, None, ) +SYMBOL(vwscanf, std::, ) +SYMBOL(vwscanf, None, ) +SYMBOL(vwscanf, None, ) +SYMBOL(wcrtomb, std::, ) +SYMBOL(wcrtomb, None, ) +SYMBOL(wcrtomb, None, ) +SYMBOL(wcscat, std::, ) +SYMBOL(wcscat, None, ) +SYMBOL(wcscat, None, ) +SYMBOL(wcschr, std::, ) +SYMBOL(wcschr, None, ) +SYMBOL(wcschr, None, ) +SYMBOL(wcscmp, std::, ) +SYMBOL(wcscmp, None, ) +SYMBOL(wcscmp, None, ) +SYMBOL(wcscoll, std::, ) +SYMBOL(wcscoll, None, ) +SYMBOL(wcscoll, None, ) +SYMBOL(wcscpy, std::, ) +SYMBOL(wcscpy, None, ) +SYMBOL(wcscpy, None, ) +SYMBOL(wcscspn, std::, ) +SYMBOL(wcscspn, None, ) +SYMBOL(wcscspn, None, ) +SYMBOL(wcsftime, std::, ) +SYMBOL(wcsftime, None, ) +SYMBOL(wcsftime, None, ) +SYMBOL(wcslen, std::, ) +SYMBOL(wcslen, None, ) +SYMBOL(wcslen, None, ) +SYMBOL(wcsncat, std::, ) +SYMBOL(wcsncat, None, ) +SYMBOL(wcsncat, None, ) +SYMBOL(wcsncmp, std::, ) +SYMBOL(wcsncmp, None, ) +SYMBOL(wcsncmp, None, ) +SYMBOL(wcsncpy, std::, ) +SYMBOL(wcsncpy, None, ) +SYMBOL(wcsncpy, None, ) +SYMBOL(wcspbrk, std::, ) +SYMBOL(wcspbrk, None, ) +SYMBOL(wcspbrk, None, ) +SYMBOL(wcsrchr, std::, ) +SYMBOL(wcsrchr, None, ) +SYMBOL(wcsrchr, None, ) +SYMBOL(wcsrtombs, std::, ) +SYMBOL(wcsrtombs, None, ) +SYMBOL(wcsrtombs, None, ) +SYMBOL(wcsspn, std::, ) +SYMBOL(wcsspn, None, ) +SYMBOL(wcsspn, None, ) +SYMBOL(wcsstr, std::, ) +SYMBOL(wcsstr, None, ) +SYMBOL(wcsstr, None, ) +SYMBOL(wcstod, std::, ) +SYMBOL(wcstod, None, ) +SYMBOL(wcstod, None, ) +SYMBOL(wcstof, std::, ) +SYMBOL(wcstof, None, ) +SYMBOL(wcstof, None, ) +SYMBOL(wcstoimax, std::, ) +SYMBOL(wcstoimax, None, ) +SYMBOL(wcstoimax, None, ) +SYMBOL(wcstok, std::, ) +SYMBOL(wcstok, None, ) +SYMBOL(wcstok, None, ) +SYMBOL(wcstol, std::, ) +SYMBOL(wcstol, None, ) +SYMBOL(wcstol, None, ) +SYMBOL(wcstold, std::, ) +SYMBOL(wcstold, None, ) +SYMBOL(wcstold, None, ) +SYMBOL(wcstoll, std::, ) +SYMBOL(wcstoll, None, ) +SYMBOL(wcstoll, None, ) +SYMBOL(wcstombs, std::, ) +SYMBOL(wcstombs, None, ) +SYMBOL(wcstombs, None, ) +SYMBOL(wcstoul, std::, ) +SYMBOL(wcstoul, None, ) +SYMBOL(wcstoul, None, ) +SYMBOL(wcstoull, std::, ) +SYMBOL(wcstoull, None, ) +SYMBOL(wcstoull, None, ) +SYMBOL(wcstoumax, std::, ) +SYMBOL(wcstoumax, None, ) +SYMBOL(wcstoumax, None, ) +SYMBOL(wcsxfrm, std::, ) +SYMBOL(wcsxfrm, None, ) +SYMBOL(wcsxfrm, None, ) +SYMBOL(wctob, std::, ) +SYMBOL(wctob, None, ) +SYMBOL(wctob, None, ) +SYMBOL(wctomb, std::, ) +SYMBOL(wctomb, None, ) +SYMBOL(wctomb, None, ) +SYMBOL(wctrans, std::, ) +SYMBOL(wctrans, None, ) +SYMBOL(wctrans, None, ) +SYMBOL(wctrans_t, std::, ) +SYMBOL(wctrans_t, None, ) +SYMBOL(wctrans_t, None, ) +SYMBOL(wctype, std::, ) +SYMBOL(wctype, None, ) +SYMBOL(wctype, None, ) +SYMBOL(wctype_t, std::, ) +SYMBOL(wctype_t, None, ) +SYMBOL(wctype_t, None, ) +SYMBOL(wmemchr, std::, ) +SYMBOL(wmemchr, None, ) +SYMBOL(wmemchr, None, ) +SYMBOL(wmemcmp, std::, ) +SYMBOL(wmemcmp, None, ) +SYMBOL(wmemcmp, None, ) +SYMBOL(wmemcpy, std::, ) +SYMBOL(wmemcpy, None, ) +SYMBOL(wmemcpy, None, ) +SYMBOL(wmemmove, std::, ) +SYMBOL(wmemmove, None, ) +SYMBOL(wmemmove, None, ) +SYMBOL(wmemset, std::, ) +SYMBOL(wmemset, None, ) +SYMBOL(wmemset, None, ) +SYMBOL(wprintf, std::, ) +SYMBOL(wprintf, None, ) +SYMBOL(wprintf, None, ) +SYMBOL(wscanf, std::, ) +SYMBOL(wscanf, None, ) +SYMBOL(wscanf, None, ) +// C++ [support.c.headers.other] 17.14.7 +// ..., behaves as if each name placed in the standard library namespace by +// the corresponding 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]. +SYMBOL(assoc_laguerre, std::, ) +SYMBOL(assoc_laguerref, std::, ) +SYMBOL(assoc_laguerrel, std::, ) +SYMBOL(assoc_legendre, std::, ) +SYMBOL(assoc_legendref, std::, ) +SYMBOL(assoc_legendrel, std::, ) +SYMBOL(beta, std::, ) +SYMBOL(betaf, std::, ) +SYMBOL(betal, std::, ) +SYMBOL(byte, std::, ) +SYMBOL(comp_ellint_1, std::, ) +SYMBOL(comp_ellint_1f, std::, ) +SYMBOL(comp_ellint_1l, std::, ) +SYMBOL(comp_ellint_2, std::, ) +SYMBOL(comp_ellint_2f, std::, ) +SYMBOL(comp_ellint_2l, std::, ) +SYMBOL(comp_ellint_3, std::, ) +SYMBOL(comp_ellint_3f, std::, ) +SYMBOL(comp_ellint_3l, std::, ) +SYMBOL(cyl_bessel_i, std::, ) +SYMBOL(cyl_bessel_if, std::, ) +SYMBOL(cyl_bessel_il, std::, ) +SYMBOL(cyl_bessel_j, std::, ) +SYMBOL(cyl_bessel_jf, std::, ) +SYMBOL(cyl_bessel_jl, std::, ) +SYMBOL(cyl_bessel_k, std::, ) +SYMBOL(cyl_bessel_kf, std::, ) +SYMBOL(cyl_bessel_kl, std::, ) +SYMBOL(cyl_neumann, std::, ) +SYMBOL(cyl_neumannf, std::, ) +SYMBOL(cyl_neumannl, std::, ) +SYMBOL(ellint_1, std::, ) +SYMBOL(ellint_1f, std::, ) +SYMBOL(ellint_1l, std::, ) +SYMBOL(ellint_2, std::, ) +SYMBOL(ellint_2f, std::, ) +SYMBOL(ellint_2l, std::, ) +SYMBOL(ellint_3, std::, ) +SYMBOL(ellint_3f, std::, ) +SYMBOL(ellint_3l, std::, ) +SYMBOL(expint, std::, ) +SYMBOL(expintf, std::, ) +SYMBOL(expintl, std::, ) +SYMBOL(hermite, std::, ) +SYMBOL(hermitef, std::, ) +SYMBOL(hermitel, std::, ) +SYMBOL(laguerre, std::, ) +SYMBOL(laguerref, std::, ) +SYMBOL(laguerrel, std::, ) +SYMBOL(legendre, std::, ) +SYMBOL(legendref, std::, ) +SYMBOL(legendrel, std::, ) +SYMBOL(lerp, std::, ) +SYMBOL(riemann_zeta, std::, ) +SYMBOL(riemann_zetaf, std::, ) +SYMBOL(riemann_zetal, std::, ) +SYMBOL(sph_legendre, std::, ) +SYMBOL(sph_legendref, std::, ) +SYMBOL(sph_legendrel, std::, ) +SYMBOL(sph_neumann, std::, ) +SYMBOL(sph_neumannf, std::, ) +SYMBOL(sph_neumannl, std::, ) +// C standard macros. +SYMBOL(BUFSIZ, None, ) +SYMBOL(BUFSIZ, None, ) +SYMBOL(CHAR_BIT, None, ) +SYMBOL(CHAR_BIT, None, ) +SYMBOL(CHAR_MAX, None, ) +SYMBOL(CHAR_MAX, None, ) +SYMBOL(CHAR_MIN, None, ) +SYMBOL(CHAR_MIN, None, ) +SYMBOL(CLOCKS_PER_SEC, None, ) +SYMBOL(CLOCKS_PER_SEC, None, ) +SYMBOL(DBL_DECIMAL_DIG, None, ) +SYMBOL(DBL_DECIMAL_DIG, None, ) +SYMBOL(DBL_DIG, None, ) +SYMBOL(DBL_DIG, None, ) +SYMBOL(DBL_EPSILON, None, ) +SYMBOL(DBL_EPSILON, None, ) +SYMBOL(DBL_HAS_SUBNORM, None, ) +SYMBOL(DBL_HAS_SUBNORM, None, ) +SYMBOL(DBL_MANT_DIG, None, ) +SYMBOL(DBL_MANT_DIG, None, ) +SYMBOL(DBL_MAX, None, ) +SYMBOL(DBL_MAX, None, ) +SYMBOL(DBL_MAX_10_EXP, None, ) +SYMBOL(DBL_MAX_10_EXP, None, ) +SYMBOL(DBL_MAX_EXP, None, ) +SYMBOL(DBL_MAX_EXP, None, ) +SYMBOL(DBL_MIN, None, ) +SYMBOL(DBL_MIN, None, ) +SYMBOL(DBL_MIN_10_EXP, None, ) +SYMBOL(DBL_MIN_10_EXP, None, ) +SYMBOL(DBL_MIN_EXP, None, ) +SYMBOL(DBL_MIN_EXP, None, ) +SYMBOL(DBL_TRUE_MIN, None, ) +SYMBOL(DBL_TRUE_MIN, None, ) +SYMBOL(DECIMAL_DIG, None, ) +SYMBOL(DECIMAL_DIG, None, ) +SYMBOL(E2BIG, None, ) +SYMBOL(E2BIG, None, ) +SYMBOL(EACCES, None, ) +SYMBOL(EACCES, None, ) +SYMBOL(EADDRINUSE, None, ) +SYMBOL(EADDRINUSE, None, ) +SYMBOL(EADDRNOTAVAIL, None, ) +SYMBOL(EADDRNOTAVAIL, None, ) +SYMBOL(EAFNOSUPPORT, None, ) +SYMBOL(EAFNOSUPPORT, None, ) +SYMBOL(EAGAIN, None, ) +SYMBOL(EAGAIN, None, ) +SYMBOL(EALREADY, None, ) +SYMBOL(EALREADY, None, ) +SYMBOL(EBADF, None, ) +SYMBOL(EBADF, None, ) +SYMBOL(EBADMSG, None, ) +SYMBOL(EBADMSG, None, ) +SYMBOL(EBUSY, None, ) +SYMBOL(EBUSY, None, ) +SYMBOL(ECANCELED, None, ) +SYMBOL(ECANCELED, None, ) +SYMBOL(ECHILD, None, ) +SYMBOL(ECHILD, None, ) +SYMBOL(ECONNABORTED, None, ) +SYMBOL(ECONNABORTED, None, ) +SYMBOL(ECONNREFUSED, None, ) +SYMBOL(ECONNREFUSED, None, ) +SYMBOL(ECONNRESET, None, ) +SYMBOL(ECONNRESET, None, ) +SYMBOL(EDEADLK, None, ) +SYMBOL(EDEADLK, None, ) +SYMBOL(EDESTADDRREQ, None, ) +SYMBOL(EDESTADDRREQ, None, ) +SYMBOL(EDOM, None, ) +SYMBOL(EDOM, None, ) +SYMBOL(EEXIST, None, ) +SYMBOL(EEXIST, None, ) +SYMBOL(EFAULT, None, ) +SYMBOL(EFAULT, None, ) +SYMBOL(EFBIG, None, ) +SYMBOL(EFBIG, None, ) +SYMBOL(EHOSTUNREACH, None, ) +SYMBOL(EHOSTUNREACH, None, ) +SYMBOL(EIDRM, None, ) +SYMBOL(EIDRM, None, ) +SYMBOL(EILSEQ, None, ) +SYMBOL(EILSEQ, None, ) +SYMBOL(EINPROGRESS, None, ) +SYMBOL(EINPROGRESS, None, ) +SYMBOL(EINTR, None, ) +SYMBOL(EINTR, None, ) +SYMBOL(EINVAL, None, ) +SYMBOL(EINVAL, None, ) +SYMBOL(EIO, None, ) +SYMBOL(EIO, None, ) +SYMBOL(EISCONN, None, ) +SYMBOL(EISCONN, None, ) +SYMBOL(EISDIR, None, ) +SYMBOL(EISDIR, None, ) +SYMBOL(ELOOP, None, ) +SYMBOL(ELOOP, None, ) +SYMBOL(EMFILE, None, ) +SYMBOL(EMFILE, None, ) +SYMBOL(EMLINK, None, ) +SYMBOL(EMLINK, None, ) +SYMBOL(EMSGSIZE, None, ) +SYMBOL(EMSGSIZE, None, ) +SYMBOL(ENAMETOOLONG, None, ) +SYMBOL(ENAMETOOLONG, None, ) +SYMBOL(ENETDOWN, None, ) +SYMBOL(ENETDOWN, None, ) +SYMBOL(ENETRESET, None, ) +SYMBOL(ENETRESET, None, ) +SYMBOL(ENETUNREACH, None, ) +SYMBOL(ENETUNREACH, None, ) +SYMBOL(ENFILE, None, ) +SYMBOL(ENFILE, None, ) +SYMBOL(ENOBUFS, None, ) +SYMBOL(ENOBUFS, None, ) +SYMBOL(ENODATA, None, ) +SYMBOL(ENODATA, None, ) +SYMBOL(ENODEV, None, ) +SYMBOL(ENODEV, None, ) +SYMBOL(ENOENT, None, ) +SYMBOL(ENOENT, None, ) +SYMBOL(ENOEXEC, None, ) +SYMBOL(ENOEXEC, None, ) +SYMBOL(ENOLCK, None, ) +SYMBOL(ENOLCK, None, ) +SYMBOL(ENOLINK, None, ) +SYMBOL(ENOLINK, None, ) +SYMBOL(ENOMEM, None, ) +SYMBOL(ENOMEM, None, ) +SYMBOL(ENOMSG, None, ) +SYMBOL(ENOMSG, None, ) +SYMBOL(ENOPROTOOPT, None, ) +SYMBOL(ENOPROTOOPT, None, ) +SYMBOL(ENOSPC, None, ) +SYMBOL(ENOSPC, None, ) +SYMBOL(ENOSR, None, ) +SYMBOL(ENOSR, None, ) +SYMBOL(ENOSTR, None, ) +SYMBOL(ENOSTR, None, ) +SYMBOL(ENOSYS, None, ) +SYMBOL(ENOSYS, None, ) +SYMBOL(ENOTCONN, None, ) +SYMBOL(ENOTCONN, None, ) +SYMBOL(ENOTDIR, None, ) +SYMBOL(ENOTDIR, None, ) +SYMBOL(ENOTEMPTY, None, ) +SYMBOL(ENOTEMPTY, None, ) +SYMBOL(ENOTRECOVERABLE, None, ) +SYMBOL(ENOTRECOVERABLE, None, ) +SYMBOL(ENOTSOCK, None, ) +SYMBOL(ENOTSOCK, None, ) +SYMBOL(ENOTSUP, None, ) +SYMBOL(ENOTSUP, None, ) +SYMBOL(ENOTTY, None, ) +SYMBOL(ENOTTY, None, ) +SYMBOL(ENXIO, None, ) +SYMBOL(ENXIO, None, ) +SYMBOL(EOF, None, ) +SYMBOL(EOF, None, ) +SYMBOL(EOPNOTSUPP, None, ) +SYMBOL(EOPNOTSUPP, None, ) +SYMBOL(EOVERFLOW, None, ) +SYMBOL(EOVERFLOW, None, ) +SYMBOL(EOWNERDEAD, None, ) +SYMBOL(EOWNERDEAD, None, ) +SYMBOL(EPERM, None, ) +SYMBOL(EPERM, None, ) +SYMBOL(EPIPE, None, ) +SYMBOL(EPIPE, None, ) +SYMBOL(EPROTO, None, ) +SYMBOL(EPROTO, None, ) +SYMBOL(EPROTONOSUPPORT, None, ) +SYMBOL(EPROTONOSUPPORT, None, ) +SYMBOL(EPROTOTYPE, None, ) +SYMBOL(EPROTOTYPE, None, ) +SYMBOL(ERANGE, None, ) +SYMBOL(ERANGE, None, ) +SYMBOL(EROFS, None, ) +SYMBOL(EROFS, None, ) +SYMBOL(ESPIPE, None, ) +SYMBOL(ESPIPE, None, ) +SYMBOL(ESRCH, None, ) +SYMBOL(ESRCH, None, ) +SYMBOL(ETIME, None, ) +SYMBOL(ETIME, None, ) +SYMBOL(ETIMEDOUT, None, ) +SYMBOL(ETIMEDOUT, None, ) +SYMBOL(ETXTBSY, None, ) +SYMBOL(ETXTBSY, None, ) +SYMBOL(EWOULDBLOCK, None, ) +SYMBOL(EWOULDBLOCK, None, ) +SYMBOL(EXDEV, None, ) +SYMBOL(EXDEV, None, ) +SYMBOL(EXIT_FAILURE, None, ) +SYMBOL(EXIT_FAILURE, None, ) +SYMBOL(EXIT_SUCCESS, None, ) +SYMBOL(EXIT_SUCCESS, None, ) +SYMBOL(FE_ALL_EXCEPT, None, ) +SYMBOL(FE_ALL_EXCEPT, None, ) +SYMBOL(FE_DFL_ENV, None, ) +SYMBOL(FE_DFL_ENV, None, ) +SYMBOL(FE_DIVBYZERO, None, ) +SYMBOL(FE_DIVBYZERO, None, ) +SYMBOL(FE_DOWNWARD, None, ) +SYMBOL(FE_DOWNWARD, None, ) +SYMBOL(FE_INEXACT, None, ) +SYMBOL(FE_INEXACT, None, ) +SYMBOL(FE_INVALID, None, ) +SYMBOL(FE_INVALID, None, ) +SYMBOL(FE_OVERFLOW, None, ) +SYMBOL(FE_OVERFLOW, None, ) +SYMBOL(FE_TONEAREST, None, ) +SYMBOL(FE_TONEAREST, None, ) +SYMBOL(FE_TOWARDZERO, None, ) +SYMBOL(FE_TOWARDZERO, None, ) +SYMBOL(FE_UNDERFLOW, None, ) +SYMBOL(FE_UNDERFLOW, None, ) +SYMBOL(FE_UPWARD, None, ) +SYMBOL(FE_UPWARD, None, ) +SYMBOL(FILENAME_MAX, None, ) +SYMBOL(FILENAME_MAX, None, ) +SYMBOL(FLT_DECIMAL_DIG, None, ) +SYMBOL(FLT_DECIMAL_DIG, None, ) +SYMBOL(FLT_DIG, None, ) +SYMBOL(FLT_DIG, None, ) +SYMBOL(FLT_EPSILON, None, ) +SYMBOL(FLT_EPSILON, None, ) +SYMBOL(FLT_EVAL_METHOD, None, ) +SYMBOL(FLT_EVAL_METHOD, None, ) +SYMBOL(FLT_HAS_SUBNORM, None, ) +SYMBOL(FLT_HAS_SUBNORM, None, ) +SYMBOL(FLT_MANT_DIG, None, ) +SYMBOL(FLT_MANT_DIG, None, ) +SYMBOL(FLT_MAX, None, ) +SYMBOL(FLT_MAX, None, ) +SYMBOL(FLT_MAX_10_EXP, None, ) +SYMBOL(FLT_MAX_10_EXP, None, ) +SYMBOL(FLT_MAX_EXP, None, ) +SYMBOL(FLT_MAX_EXP, None, ) +SYMBOL(FLT_MIN, None, ) +SYMBOL(FLT_MIN, None, ) +SYMBOL(FLT_MIN_10_EXP, None, ) +SYMBOL(FLT_MIN_10_EXP, None, ) +SYMBOL(FLT_MIN_EXP, None, ) +SYMBOL(FLT_MIN_EXP, None, ) +SYMBOL(FLT_RADIX, None, ) +SYMBOL(FLT_RADIX, None, ) +SYMBOL(FLT_ROUNDS, None, ) +SYMBOL(FLT_ROUNDS, None, ) +SYMBOL(FLT_TRUE_MIN, None, ) +SYMBOL(FLT_TRUE_MIN, None, ) +SYMBOL(FOPEN_MAX, None, ) +SYMBOL(FOPEN_MAX, None, ) +SYMBOL(FP_FAST_FMA, None, ) +SYMBOL(FP_FAST_FMA, None, ) +SYMBOL(FP_FAST_FMAF, None, ) +SYMBOL(FP_FAST_FMAF, None, ) +SYMBOL(FP_FAST_FMAL, None, ) +SYMBOL(FP_FAST_FMAL, None, ) +SYMBOL(FP_ILOGB0, None, ) +SYMBOL(FP_ILOGB0, None, ) +SYMBOL(FP_ILOGBNAN, None, ) +SYMBOL(FP_ILOGBNAN, None, ) +SYMBOL(FP_INFINITE, None, ) +SYMBOL(FP_INFINITE, None, ) +SYMBOL(FP_NAN, None, ) +SYMBOL(FP_NAN, None, ) +SYMBOL(FP_NORMAL, None, ) +SYMBOL(FP_NORMAL, None, ) +SYMBOL(FP_SUBNORMAL, None, ) +SYMBOL(FP_SUBNORMAL, None, ) +SYMBOL(FP_ZERO, None, ) +SYMBOL(FP_ZERO, None, ) +SYMBOL(HUGE_VAL, None, ) +SYMBOL(HUGE_VAL, None, ) +SYMBOL(HUGE_VALF, None, ) +SYMBOL(HUGE_VALF, None, ) +SYMBOL(HUGE_VALL, None, ) +SYMBOL(HUGE_VALL, None, ) +SYMBOL(INFINITY, None, ) +SYMBOL(INFINITY, None, ) +SYMBOL(INT16_MAX, None, ) +SYMBOL(INT16_MAX, None, ) +SYMBOL(INT16_MIN, None, ) +SYMBOL(INT16_MIN, None, ) +SYMBOL(INT32_MAX, None, ) +SYMBOL(INT32_MAX, None, ) +SYMBOL(INT32_MIN, None, ) +SYMBOL(INT32_MIN, None, ) +SYMBOL(INT64_MAX, None, ) +SYMBOL(INT64_MAX, None, ) +SYMBOL(INT64_MIN, None, ) +SYMBOL(INT64_MIN, None, ) +SYMBOL(INT8_MAX, None, ) +SYMBOL(INT8_MAX, None, ) +SYMBOL(INT8_MIN, None, ) +SYMBOL(INT8_MIN, None, ) +SYMBOL(INTMAX_MAX, None, ) +SYMBOL(INTMAX_MAX, None, ) +SYMBOL(INTMAX_MIN, None, ) +SYMBOL(INTMAX_MIN, None, ) +SYMBOL(INTPTR_MAX, None, ) +SYMBOL(INTPTR_MAX, None, ) +SYMBOL(INTPTR_MIN, None, ) +SYMBOL(INTPTR_MIN, None, ) +SYMBOL(INT_FAST16_MAX, None, ) +SYMBOL(INT_FAST16_MAX, None, ) +SYMBOL(INT_FAST16_MIN, None, ) +SYMBOL(INT_FAST16_MIN, None, ) +SYMBOL(INT_FAST32_MAX, None, ) +SYMBOL(INT_FAST32_MAX, None, ) +SYMBOL(INT_FAST32_MIN, None, ) +SYMBOL(INT_FAST32_MIN, None, ) +SYMBOL(INT_FAST64_MAX, None, ) +SYMBOL(INT_FAST64_MAX, None, ) +SYMBOL(INT_FAST64_MIN, None, ) +SYMBOL(INT_FAST64_MIN, None, ) +SYMBOL(INT_FAST8_MAX, None, ) +SYMBOL(INT_FAST8_MAX, None, ) +SYMBOL(INT_FAST8_MIN, None, ) +SYMBOL(INT_FAST8_MIN, None, ) +SYMBOL(INT_LEAST16_MAX, None, ) +SYMBOL(INT_LEAST16_MAX, None, ) +SYMBOL(INT_LEAST16_MIN, None, ) +SYMBOL(INT_LEAST16_MIN, None, ) +SYMBOL(INT_LEAST32_MAX, None, ) +SYMBOL(INT_LEAST32_MAX, None, ) +SYMBOL(INT_LEAST32_MIN, None, ) +SYMBOL(INT_LEAST32_MIN, None, ) +SYMBOL(INT_LEAST64_MAX, None, ) +SYMBOL(INT_LEAST64_MAX, None, ) +SYMBOL(INT_LEAST64_MIN, None, ) +SYMBOL(INT_LEAST64_MIN, None, ) +SYMBOL(INT_LEAST8_MAX, None, ) +SYMBOL(INT_LEAST8_MAX, None, ) +SYMBOL(INT_LEAST8_MIN, None, ) +SYMBOL(INT_LEAST8_MIN, None, ) +SYMBOL(INT_MAX, None, ) +SYMBOL(INT_MAX, None, ) +SYMBOL(INT_MIN, None, ) +SYMBOL(INT_MIN, None, ) +SYMBOL(LC_ALL, None, ) +SYMBOL(LC_ALL, None, ) +SYMBOL(LC_COLLATE, None, ) +SYMBOL(LC_COLLATE, None, ) +SYMBOL(LC_CTYPE, None, ) +SYMBOL(LC_CTYPE, None, ) +SYMBOL(LC_MONETARY, None, ) +SYMBOL(LC_MONETARY, None, ) +SYMBOL(LC_NUMERIC, None, ) +SYMBOL(LC_NUMERIC, None, ) +SYMBOL(LC_TIME, None, ) +SYMBOL(LC_TIME, None, ) +SYMBOL(LDBL_DECIMAL_DIG, None, ) +SYMBOL(LDBL_DECIMAL_DIG, None, ) +SYMBOL(LDBL_DIG, None, ) +SYMBOL(LDBL_DIG, None, ) +SYMBOL(LDBL_EPSILON, None, ) +SYMBOL(LDBL_EPSILON, None, ) +SYMBOL(LDBL_HAS_SUBNORM, None, ) +SYMBOL(LDBL_HAS_SUBNORM, None, ) +SYMBOL(LDBL_MANT_DIG, None, ) +SYMBOL(LDBL_MANT_DIG, None, ) +SYMBOL(LDBL_MAX, None, ) +SYMBOL(LDBL_MAX, None, ) +SYMBOL(LDBL_MAX_10_EXP, None, ) +SYMBOL(LDBL_MAX_10_EXP, None, ) +SYMBOL(LDBL_MAX_EXP, None, ) +SYMBOL(LDBL_MAX_EXP, None, ) +SYMBOL(LDBL_MIN, None, ) +SYMBOL(LDBL_MIN, None, ) +SYMBOL(LDBL_MIN_10_EXP, None, ) +SYMBOL(LDBL_MIN_10_EXP, None, ) +SYMBOL(LDBL_MIN_EXP, None, ) +SYMBOL(LDBL_MIN_EXP, None, ) +SYMBOL(LDBL_TRUE_MIN, None, ) +SYMBOL(LDBL_TRUE_MIN, None, ) +SYMBOL(LLONG_MAX, None, ) +SYMBOL(LLONG_MAX, None, ) +SYMBOL(LLONG_MIN, None, ) +SYMBOL(LLONG_MIN, None, ) +SYMBOL(LONG_MAX, None, ) +SYMBOL(LONG_MAX, None, ) +SYMBOL(LONG_MIN, None, ) +SYMBOL(LONG_MIN, None, ) +SYMBOL(L_tmpnam, None, ) +SYMBOL(L_tmpnam, None, ) +SYMBOL(MATH_ERREXCEPT, None, ) +SYMBOL(MATH_ERREXCEPT, None, ) +SYMBOL(MATH_ERRNO, None, ) +SYMBOL(MATH_ERRNO, None, ) +SYMBOL(MB_CUR_MAX, None, ) +SYMBOL(MB_CUR_MAX, None, ) +SYMBOL(MB_LEN_MAX, None, ) +SYMBOL(MB_LEN_MAX, None, ) +SYMBOL(NAN, None, ) +SYMBOL(NAN, None, ) +SYMBOL(PTRDIFF_MAX, None, ) +SYMBOL(PTRDIFF_MAX, None, ) +SYMBOL(PTRDIFF_MIN, None, ) +SYMBOL(PTRDIFF_MIN, None, ) +SYMBOL(RAND_MAX, None, ) +SYMBOL(RAND_MAX, None, ) +SYMBOL(SCHAR_MAX, None, ) +SYMBOL(SCHAR_MAX, None, ) +SYMBOL(SCHAR_MIN, None, ) +SYMBOL(SCHAR_MIN, None, ) +SYMBOL(SEEK_CUR, None, ) +SYMBOL(SEEK_CUR, None, ) +SYMBOL(SEEK_END, None, ) +SYMBOL(SEEK_END, None, ) +SYMBOL(SEEK_SET, None, ) +SYMBOL(SEEK_SET, None, ) +SYMBOL(SHRT_MAX, None, ) +SYMBOL(SHRT_MAX, None, ) +SYMBOL(SHRT_MIN, None, ) +SYMBOL(SHRT_MIN, None, ) +SYMBOL(SIGABRT, None, ) +SYMBOL(SIGABRT, None, ) +SYMBOL(SIGFPE, None, ) +SYMBOL(SIGFPE, None, ) +SYMBOL(SIGILL, None, ) +SYMBOL(SIGILL, None, ) +SYMBOL(SIGINT, None, ) +SYMBOL(SIGINT, None, ) +SYMBOL(SIGSEGV, None, ) +SYMBOL(SIGSEGV, None, ) +SYMBOL(SIGTERM, None, ) +SYMBOL(SIGTERM, None, ) +SYMBOL(SIG_ATOMIC_MAX, None, ) +SYMBOL(SIG_ATOMIC_MAX, None, ) +SYMBOL(SIG_ATOMIC_MIN, None, ) +SYMBOL(SIG_ATOMIC_MIN, None, ) +SYMBOL(SIG_DFL, None, ) +SYMBOL(SIG_DFL, None, ) +SYMBOL(SIG_ERR, None, ) +SYMBOL(SIG_ERR, None, ) +SYMBOL(SIG_IGN, None, ) +SYMBOL(SIG_IGN, None, ) +SYMBOL(SIZE_MAX, None, ) +SYMBOL(SIZE_MAX, None, ) +SYMBOL(TIME_UTC, None, ) +SYMBOL(TIME_UTC, None, ) +SYMBOL(TMP_MAX, None, ) +SYMBOL(TMP_MAX, None, ) +SYMBOL(UCHAR_MAX, None, ) +SYMBOL(UCHAR_MAX, None, ) +SYMBOL(UINT16_MAX, None, ) +SYMBOL(UINT16_MAX, None, ) +SYMBOL(UINT32_MAX, None, ) +SYMBOL(UINT32_MAX, None, ) +SYMBOL(UINT64_MAX, None, ) +SYMBOL(UINT64_MAX, None, ) +SYMBOL(UINT8_MAX, None, ) +SYMBOL(UINT8_MAX, None, ) +SYMBOL(UINTMAX_MAX, None, ) +SYMBOL(UINTMAX_MAX, None, ) +SYMBOL(UINTPTR_MAX, None, ) +SYMBOL(UINTPTR_MAX, None, ) +SYMBOL(UINT_FAST16_MAX, None, ) +SYMBOL(UINT_FAST16_MAX, None, ) +SYMBOL(UINT_FAST32_MAX, None, ) +SYMBOL(UINT_FAST32_MAX, None, ) +SYMBOL(UINT_FAST64_MAX, None, ) +SYMBOL(UINT_FAST64_MAX, None, ) +SYMBOL(UINT_FAST8_MAX, None, ) +SYMBOL(UINT_FAST8_MAX, None, ) +SYMBOL(UINT_LEAST16_MAX, None, ) +SYMBOL(UINT_LEAST16_MAX, None, ) +SYMBOL(UINT_LEAST32_MAX, None, ) +SYMBOL(UINT_LEAST32_MAX, None, ) +SYMBOL(UINT_LEAST64_MAX, None, ) +SYMBOL(UINT_LEAST64_MAX, None, ) +SYMBOL(UINT_LEAST8_MAX, None, ) +SYMBOL(UINT_LEAST8_MAX, None, ) +SYMBOL(UINT_MAX, None, ) +SYMBOL(UINT_MAX, None, ) +SYMBOL(ULLONG_MAX, None, ) +SYMBOL(ULLONG_MAX, None, ) +SYMBOL(ULONG_MAX, None, ) +SYMBOL(ULONG_MAX, None, ) +SYMBOL(USHRT_MAX, None, ) +SYMBOL(USHRT_MAX, None, ) +SYMBOL(WEOF, None, ) +SYMBOL(WEOF, None, ) +SYMBOL(WINT_MAX, None, ) +SYMBOL(WINT_MAX, None, ) +SYMBOL(WINT_MIN, None, ) +SYMBOL(WINT_MIN, None, ) +SYMBOL(_IOFBF, None, ) +SYMBOL(_IOFBF, None, ) +SYMBOL(_IOLBF, None, ) +SYMBOL(_IOLBF, None, ) +SYMBOL(_IONBF, None, ) +SYMBOL(_IONBF, None, ) +SYMBOL(assert, None, ) +SYMBOL(assert, None, ) +SYMBOL(errno, None, ) +SYMBOL(errno, None, ) +SYMBOL(math_errhandling, None, ) +SYMBOL(math_errhandling, None, ) +SYMBOL(offsetof, None, ) +SYMBOL(offsetof, None, ) +SYMBOL(setjmp, None, ) +SYMBOL(setjmp, None, ) +SYMBOL(stderr, None, ) +SYMBOL(stderr, None, ) +SYMBOL(stdin, None, ) +SYMBOL(stdin, None, ) +SYMBOL(stdout, None, ) +SYMBOL(stdout, None, ) +SYMBOL(va_arg, None, ) +SYMBOL(va_arg, None, ) +SYMBOL(va_copy, None, ) +SYMBOL(va_copy, None, ) +SYMBOL(va_end, None, ) +SYMBOL(va_end, None, ) +SYMBOL(va_start, None, ) +SYMBOL(va_start, None, ) diff --git a/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc b/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc --- a/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc +++ b/clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc @@ -9,15 +9,7 @@ // Generated from cppreference offline HTML book (modified on 2022-07-30). //===----------------------------------------------------------------------===// -SYMBOL(FILE, std::, ) -SYMBOL(_Exit, std::, ) SYMBOL(accumulate, std::, ) -SYMBOL(acos, std::, ) -SYMBOL(acosf, std::, ) -SYMBOL(acosh, std::, ) -SYMBOL(acoshf, std::, ) -SYMBOL(acoshl, std::, ) -SYMBOL(acosl, std::, ) SYMBOL(add_const, std::, ) SYMBOL(add_const_t, std::, ) SYMBOL(add_cv, std::, ) @@ -38,7 +30,6 @@ SYMBOL(advance, std::, ) SYMBOL(align, std::, ) SYMBOL(align_val_t, std::, ) -SYMBOL(aligned_alloc, std::, ) SYMBOL(aligned_storage, std::, ) SYMBOL(aligned_storage_t, std::, ) SYMBOL(aligned_union, std::, ) @@ -62,37 +53,9 @@ SYMBOL(as_bytes, std::, ) SYMBOL(as_const, std::, ) SYMBOL(as_writable_bytes, std::, ) -SYMBOL(asctime, std::, ) -SYMBOL(asin, std::, ) -SYMBOL(asinf, std::, ) -SYMBOL(asinh, std::, ) -SYMBOL(asinhf, std::, ) -SYMBOL(asinhl, std::, ) -SYMBOL(asinl, std::, ) SYMBOL(assignable_from, std::, ) -SYMBOL(assoc_laguerre, std::, ) -SYMBOL(assoc_laguerref, std::, ) -SYMBOL(assoc_laguerrel, std::, ) -SYMBOL(assoc_legendre, std::, ) -SYMBOL(assoc_legendref, std::, ) -SYMBOL(assoc_legendrel, std::, ) SYMBOL(assume_aligned, std::, ) SYMBOL(async, std::, ) -SYMBOL(at_quick_exit, std::, ) -SYMBOL(atan, std::, ) -SYMBOL(atan2, std::, ) -SYMBOL(atan2f, std::, ) -SYMBOL(atan2l, std::, ) -SYMBOL(atanf, std::, ) -SYMBOL(atanh, std::, ) -SYMBOL(atanhf, std::, ) -SYMBOL(atanhl, std::, ) -SYMBOL(atanl, std::, ) -SYMBOL(atexit, std::, ) -SYMBOL(atof, std::, ) -SYMBOL(atoi, std::, ) -SYMBOL(atol, std::, ) -SYMBOL(atoll, std::, ) SYMBOL(atomic_compare_exchange_strong, std::, ) SYMBOL(atomic_compare_exchange_strong_explicit, std::, ) SYMBOL(atomic_compare_exchange_weak, std::, ) @@ -176,9 +139,6 @@ SYMBOL(basic_stringstream, std::, ) SYMBOL(basic_syncbuf, std::, ) SYMBOL(bernoulli_distribution, std::, ) -SYMBOL(beta, std::, ) -SYMBOL(betaf, std::, ) -SYMBOL(betal, std::, ) SYMBOL(bidirectional_iterator, std::, ) SYMBOL(bidirectional_iterator_tag, std::, ) SYMBOL(binary_search, std::, ) @@ -200,22 +160,9 @@ SYMBOL(boolalpha, std::, ) SYMBOL(boyer_moore_horspool_searcher, std::, ) SYMBOL(boyer_moore_searcher, std::, ) -SYMBOL(bsearch, std::, ) -SYMBOL(btowc, std::, ) -SYMBOL(byte, std::, ) SYMBOL(byteswap, std::, ) -SYMBOL(c16rtomb, std::, ) -SYMBOL(c32rtomb, std::, ) -SYMBOL(c8rtomb, std::, ) SYMBOL(call_once, std::, ) -SYMBOL(calloc, std::, ) SYMBOL(cauchy_distribution, std::, ) -SYMBOL(cbrt, std::, ) -SYMBOL(cbrtf, std::, ) -SYMBOL(cbrtl, std::, ) -SYMBOL(ceil, std::, ) -SYMBOL(ceilf, std::, ) -SYMBOL(ceill, std::, ) SYMBOL(centi, std::, ) SYMBOL(cerr, std::, ) SYMBOL(char_traits, std::, ) @@ -223,9 +170,6 @@ SYMBOL(chi_squared_distribution, std::, ) SYMBOL(cin, std::, ) SYMBOL(clamp, std::, ) -SYMBOL(clearerr, std::, ) -SYMBOL(clock, std::, ) -SYMBOL(clock_t, std::, ) SYMBOL(clog, std::, ) SYMBOL(cmatch, std::, ) SYMBOL(cmp_equal, std::, ) @@ -252,15 +196,6 @@ SYMBOL(common_type, std::, ) SYMBOL(common_type_t, std::, ) SYMBOL(common_with, std::, ) -SYMBOL(comp_ellint_1, std::, ) -SYMBOL(comp_ellint_1f, std::, ) -SYMBOL(comp_ellint_1l, std::, ) -SYMBOL(comp_ellint_2, std::, ) -SYMBOL(comp_ellint_2f, std::, ) -SYMBOL(comp_ellint_2l, std::, ) -SYMBOL(comp_ellint_3, std::, ) -SYMBOL(comp_ellint_3f, std::, ) -SYMBOL(comp_ellint_3l, std::, ) SYMBOL(compare_partial_order_fallback, std::, ) SYMBOL(compare_strong_order_fallback, std::, ) SYMBOL(compare_three_way_result, std::, ) @@ -286,17 +221,8 @@ SYMBOL(copy_if, std::, ) SYMBOL(copy_n, std::, ) SYMBOL(copyable, std::, ) -SYMBOL(copysign, std::, ) -SYMBOL(copysignf, std::, ) -SYMBOL(copysignl, std::, ) SYMBOL(coroutine_handle, std::, ) SYMBOL(coroutine_traits, std::, ) -SYMBOL(cos, std::, ) -SYMBOL(cosf, std::, ) -SYMBOL(cosh, std::, ) -SYMBOL(coshf, std::, ) -SYMBOL(coshl, std::, ) -SYMBOL(cosl, std::, ) SYMBOL(count, std::, ) SYMBOL(count_if, std::, ) SYMBOL(counted_iterator, std::, ) @@ -310,24 +236,11 @@ SYMBOL(cregex_iterator, std::, ) SYMBOL(cregex_token_iterator, std::, ) SYMBOL(csub_match, std::, ) -SYMBOL(ctime, std::, ) SYMBOL(ctype, std::, ) SYMBOL(ctype_base, std::, ) SYMBOL(ctype_byname, std::, ) SYMBOL(current_exception, std::, ) SYMBOL(cv_status, std::, ) -SYMBOL(cyl_bessel_i, std::, ) -SYMBOL(cyl_bessel_if, std::, ) -SYMBOL(cyl_bessel_il, std::, ) -SYMBOL(cyl_bessel_j, std::, ) -SYMBOL(cyl_bessel_jf, std::, ) -SYMBOL(cyl_bessel_jl, std::, ) -SYMBOL(cyl_bessel_k, std::, ) -SYMBOL(cyl_bessel_kf, std::, ) -SYMBOL(cyl_bessel_kl, std::, ) -SYMBOL(cyl_neumann, std::, ) -SYMBOL(cyl_neumannf, std::, ) -SYMBOL(cyl_neumannl, std::, ) SYMBOL(dec, std::, ) SYMBOL(deca, std::, ) SYMBOL(decay, std::, ) @@ -354,28 +267,16 @@ SYMBOL(destroying_delete, std::, ) SYMBOL(destroying_delete_t, std::, ) SYMBOL(destructible, std::, ) -SYMBOL(difftime, std::, ) SYMBOL(disable_sized_sentinel_for, std::, ) SYMBOL(discard_block_engine, std::, ) SYMBOL(discrete_distribution, std::, ) SYMBOL(disjunction, std::, ) SYMBOL(disjunction_v, std::, ) SYMBOL(distance, std::, ) -SYMBOL(div_t, std::, ) SYMBOL(divides, std::, ) SYMBOL(domain_error, std::, ) -SYMBOL(double_t, std::, ) SYMBOL(dynamic_extent, std::, ) SYMBOL(dynamic_pointer_cast, std::, ) -SYMBOL(ellint_1, std::, ) -SYMBOL(ellint_1f, std::, ) -SYMBOL(ellint_1l, std::, ) -SYMBOL(ellint_2, std::, ) -SYMBOL(ellint_2f, std::, ) -SYMBOL(ellint_2l, std::, ) -SYMBOL(ellint_3, std::, ) -SYMBOL(ellint_3f, std::, ) -SYMBOL(ellint_3l, std::, ) SYMBOL(emit_on_flush, std::, ) SYMBOL(enable_if, std::, ) SYMBOL(enable_if_t, std::, ) @@ -391,12 +292,6 @@ SYMBOL(equivalence_relation, std::, ) SYMBOL(erase, std::, ) SYMBOL(erase_if, std::, ) -SYMBOL(erf, std::, ) -SYMBOL(erfc, std::, ) -SYMBOL(erfcf, std::, ) -SYMBOL(erfcl, std::, ) -SYMBOL(erff, std::, ) -SYMBOL(erfl, std::, ) SYMBOL(errc, std::, ) SYMBOL(error_category, std::, ) SYMBOL(error_code, std::, ) @@ -406,53 +301,12 @@ SYMBOL(exception_ptr, std::, ) SYMBOL(exchange, std::, ) SYMBOL(exclusive_scan, std::, ) -SYMBOL(exit, std::, ) -SYMBOL(exp, std::, ) -SYMBOL(exp2, std::, ) -SYMBOL(exp2f, std::, ) -SYMBOL(exp2l, std::, ) -SYMBOL(expf, std::, ) -SYMBOL(expint, std::, ) -SYMBOL(expintf, std::, ) -SYMBOL(expintl, std::, ) -SYMBOL(expl, std::, ) -SYMBOL(expm1, std::, ) -SYMBOL(expm1f, std::, ) -SYMBOL(expm1l, std::, ) SYMBOL(exponential_distribution, std::, ) SYMBOL(extent, std::, ) SYMBOL(extent_v, std::, ) SYMBOL(extreme_value_distribution, std::, ) -SYMBOL(fabs, std::, ) -SYMBOL(fabsf, std::, ) -SYMBOL(fabsl, std::, ) SYMBOL(false_type, std::, ) -SYMBOL(fclose, std::, ) -SYMBOL(fdim, std::, ) -SYMBOL(fdimf, std::, ) -SYMBOL(fdiml, std::, ) -SYMBOL(feclearexcept, std::, ) -SYMBOL(fegetenv, std::, ) -SYMBOL(fegetexceptflag, std::, ) -SYMBOL(fegetround, std::, ) -SYMBOL(feholdexcept, std::, ) SYMBOL(femto, std::, ) -SYMBOL(fenv_t, std::, ) -SYMBOL(feof, std::, ) -SYMBOL(feraiseexcept, std::, ) -SYMBOL(ferror, std::, ) -SYMBOL(fesetenv, std::, ) -SYMBOL(fesetexceptflag, std::, ) -SYMBOL(fesetround, std::, ) -SYMBOL(fetestexcept, std::, ) -SYMBOL(feupdateenv, std::, ) -SYMBOL(fexcept_t, std::, ) -SYMBOL(fflush, std::, ) -SYMBOL(fgetc, std::, ) -SYMBOL(fgetpos, std::, ) -SYMBOL(fgets, std::, ) -SYMBOL(fgetwc, std::, ) -SYMBOL(fgetws, std::, ) SYMBOL(filebuf, std::, ) SYMBOL(fill, std::, ) SYMBOL(fill_n, std::, ) @@ -465,26 +319,9 @@ SYMBOL(fixed, std::, ) SYMBOL(float_denorm_style, std::, ) SYMBOL(float_round_style, std::, ) -SYMBOL(float_t, std::, ) SYMBOL(floating_point, std::, ) -SYMBOL(floor, std::, ) -SYMBOL(floorf, std::, ) -SYMBOL(floorl, std::, ) SYMBOL(flush, std::, ) SYMBOL(flush_emit, std::, ) -SYMBOL(fma, std::, ) -SYMBOL(fmaf, std::, ) -SYMBOL(fmal, std::, ) -SYMBOL(fmax, std::, ) -SYMBOL(fmaxf, std::, ) -SYMBOL(fmaxl, std::, ) -SYMBOL(fmin, std::, ) -SYMBOL(fminf, std::, ) -SYMBOL(fminl, std::, ) -SYMBOL(fmod, std::, ) -SYMBOL(fmodf, std::, ) -SYMBOL(fmodl, std::, ) -SYMBOL(fopen, std::, ) SYMBOL(for_each, std::, ) SYMBOL(for_each_n, std::, ) SYMBOL(format, std::, ) @@ -503,41 +340,20 @@ SYMBOL(forward_iterator_tag, std::, ) SYMBOL(forward_like, std::, ) SYMBOL(forward_list, std::, ) -SYMBOL(fpclassify, std::, ) SYMBOL(fpos, std::, ) -SYMBOL(fpos_t, std::, ) -SYMBOL(fprintf, std::, ) -SYMBOL(fputc, std::, ) -SYMBOL(fputs, std::, ) -SYMBOL(fputwc, std::, ) -SYMBOL(fputws, std::, ) -SYMBOL(fread, std::, ) -SYMBOL(free, std::, ) -SYMBOL(freopen, std::, ) -SYMBOL(frexp, std::, ) -SYMBOL(frexpf, std::, ) -SYMBOL(frexpl, std::, ) SYMBOL(from_chars, std::, ) SYMBOL(from_chars_result, std::, ) SYMBOL(from_range, std::, ) SYMBOL(from_range_t, std::, ) SYMBOL(front_insert_iterator, std::, ) SYMBOL(front_inserter, std::, ) -SYMBOL(fscanf, std::, ) -SYMBOL(fseek, std::, ) -SYMBOL(fsetpos, std::, ) SYMBOL(fstream, std::, ) -SYMBOL(ftell, std::, ) SYMBOL(function, std::, ) SYMBOL(future, std::, ) SYMBOL(future_category, std::, ) SYMBOL(future_errc, std::, ) SYMBOL(future_error, std::, ) SYMBOL(future_status, std::, ) -SYMBOL(fwide, std::, ) -SYMBOL(fwprintf, std::, ) -SYMBOL(fwrite, std::, ) -SYMBOL(fwscanf, std::, ) SYMBOL(gamma_distribution, std::, ) SYMBOL(gcd, std::, ) SYMBOL(generate, std::, ) @@ -551,14 +367,8 @@ SYMBOL(get_new_handler, std::, ) SYMBOL(get_terminate, std::, ) SYMBOL(get_time, std::, ) -SYMBOL(getc, std::, ) -SYMBOL(getchar, std::, ) -SYMBOL(getenv, std::, ) SYMBOL(getline, std::, ) -SYMBOL(getwc, std::, ) -SYMBOL(getwchar, std::, ) SYMBOL(giga, std::, ) -SYMBOL(gmtime, std::, ) SYMBOL(greater, std::, ) SYMBOL(greater_equal, std::, ) SYMBOL(gslice, std::, ) @@ -573,25 +383,13 @@ SYMBOL(has_virtual_destructor_v, std::, ) SYMBOL(hash, std::, ) SYMBOL(hecto, std::, ) -SYMBOL(hermite, std::, ) -SYMBOL(hermitef, std::, ) -SYMBOL(hermitel, std::, ) SYMBOL(hex, std::, ) SYMBOL(hexfloat, std::, ) SYMBOL(holds_alternative, std::, ) -SYMBOL(hypot, std::, ) -SYMBOL(hypotf, std::, ) -SYMBOL(hypotl, std::, ) SYMBOL(identity, std::, ) SYMBOL(ifstream, std::, ) SYMBOL(ignore, std::, ) -SYMBOL(ilogb, std::, ) -SYMBOL(ilogbf, std::, ) -SYMBOL(ilogbl, std::, ) SYMBOL(imag, std::, ) -SYMBOL(imaxabs, std::, ) -SYMBOL(imaxdiv, std::, ) -SYMBOL(imaxdiv_t, std::, ) SYMBOL(in_place, std::, ) SYMBOL(in_place_index, std::, ) SYMBOL(in_place_index_t, std::, ) @@ -631,24 +429,10 @@ SYMBOL(input_or_output_iterator, std::, ) SYMBOL(insert_iterator, std::, ) SYMBOL(inserter, std::, ) -SYMBOL(int16_t, std::, ) -SYMBOL(int32_t, std::, ) -SYMBOL(int64_t, std::, ) -SYMBOL(int8_t, std::, ) -SYMBOL(int_fast16_t, std::, ) -SYMBOL(int_fast32_t, std::, ) -SYMBOL(int_fast64_t, std::, ) -SYMBOL(int_fast8_t, std::, ) -SYMBOL(int_least16_t, std::, ) -SYMBOL(int_least32_t, std::, ) -SYMBOL(int_least64_t, std::, ) -SYMBOL(int_least8_t, std::, ) SYMBOL(integer_sequence, std::, ) SYMBOL(integral, std::, ) SYMBOL(integral_constant, std::, ) SYMBOL(internal, std::, ) -SYMBOL(intmax_t, std::, ) -SYMBOL(intptr_t, std::, ) SYMBOL(invalid_argument, std::, ) SYMBOL(invocable, std::, ) SYMBOL(invoke, std::, ) @@ -835,47 +619,12 @@ SYMBOL(is_void_v, std::, ) SYMBOL(is_volatile, std::, ) SYMBOL(is_volatile_v, std::, ) -SYMBOL(isalnum, std::, ) -SYMBOL(isalpha, std::, ) -SYMBOL(isblank, std::, ) -SYMBOL(iscntrl, std::, ) -SYMBOL(isdigit, std::, ) -SYMBOL(isfinite, std::, ) -SYMBOL(isgraph, std::, ) -SYMBOL(isgreater, std::, ) -SYMBOL(isgreaterequal, std::, ) -SYMBOL(isinf, std::, ) -SYMBOL(isless, std::, ) -SYMBOL(islessequal, std::, ) -SYMBOL(islessgreater, std::, ) -SYMBOL(islower, std::, ) -SYMBOL(isnan, std::, ) -SYMBOL(isnormal, std::, ) SYMBOL(ispanstream, std::, ) -SYMBOL(isprint, std::, ) -SYMBOL(ispunct, std::, ) -SYMBOL(isspace, std::, ) SYMBOL(istream, std::, ) SYMBOL(istream_iterator, std::, ) SYMBOL(istreambuf_iterator, std::, ) SYMBOL(istringstream, std::, ) SYMBOL(istrstream, std::, ) -SYMBOL(isunordered, std::, ) -SYMBOL(isupper, std::, ) -SYMBOL(iswalnum, std::, ) -SYMBOL(iswalpha, std::, ) -SYMBOL(iswblank, std::, ) -SYMBOL(iswcntrl, std::, ) -SYMBOL(iswctype, std::, ) -SYMBOL(iswdigit, std::, ) -SYMBOL(iswgraph, std::, ) -SYMBOL(iswlower, std::, ) -SYMBOL(iswprint, std::, ) -SYMBOL(iswpunct, std::, ) -SYMBOL(iswspace, std::, ) -SYMBOL(iswupper, std::, ) -SYMBOL(iswxdigit, std::, ) -SYMBOL(isxdigit, std::, ) SYMBOL(iter_common_reference_t, std::, ) SYMBOL(iter_const_reference_t, std::, ) SYMBOL(iter_difference_t, std::, ) @@ -885,82 +634,31 @@ SYMBOL(iter_value_t, std::, ) SYMBOL(iterator, std::, ) SYMBOL(iterator_traits, std::, ) -SYMBOL(jmp_buf, std::, ) SYMBOL(jthread, std::, ) SYMBOL(kill_dependency, std::, ) SYMBOL(kilo, std::, ) SYMBOL(knuth_b, std::, ) -SYMBOL(labs, std::, ) -SYMBOL(laguerre, std::, ) -SYMBOL(laguerref, std::, ) -SYMBOL(laguerrel, std::, ) SYMBOL(latch, std::, ) SYMBOL(launch, std::, ) SYMBOL(launder, std::, ) SYMBOL(lcm, std::, ) -SYMBOL(lconv, std::, ) -SYMBOL(ldexp, std::, ) -SYMBOL(ldexpf, std::, ) -SYMBOL(ldexpl, std::, ) -SYMBOL(ldiv, std::, ) -SYMBOL(ldiv_t, std::, ) SYMBOL(left, std::, ) -SYMBOL(legendre, std::, ) -SYMBOL(legendref, std::, ) -SYMBOL(legendrel, std::, ) SYMBOL(length_error, std::, ) -SYMBOL(lerp, std::, ) SYMBOL(less, std::, ) SYMBOL(less_equal, std::, ) SYMBOL(lexicographical_compare, std::, ) SYMBOL(lexicographical_compare_three_way, std::, ) -SYMBOL(lgamma, std::, ) -SYMBOL(lgammaf, std::, ) -SYMBOL(lgammal, std::, ) SYMBOL(linear_congruential_engine, std::, ) SYMBOL(list, std::, ) -SYMBOL(llabs, std::, ) -SYMBOL(lldiv, std::, ) -SYMBOL(lldiv_t, std::, ) -SYMBOL(llrint, std::, ) -SYMBOL(llrintf, std::, ) -SYMBOL(llrintl, std::, ) -SYMBOL(llround, std::, ) -SYMBOL(llroundf, std::, ) -SYMBOL(llroundl, std::, ) SYMBOL(locale, std::, ) -SYMBOL(localeconv, std::, ) -SYMBOL(localtime, std::, ) SYMBOL(lock, std::, ) SYMBOL(lock_guard, std::, ) -SYMBOL(log, std::, ) -SYMBOL(log10, std::, ) -SYMBOL(log10f, std::, ) -SYMBOL(log10l, std::, ) -SYMBOL(log1p, std::, ) -SYMBOL(log1pf, std::, ) -SYMBOL(log1pl, std::, ) -SYMBOL(log2, std::, ) -SYMBOL(log2f, std::, ) -SYMBOL(log2l, std::, ) -SYMBOL(logb, std::, ) -SYMBOL(logbf, std::, ) -SYMBOL(logbl, std::, ) -SYMBOL(logf, std::, ) SYMBOL(logic_error, std::, ) SYMBOL(logical_and, std::, ) SYMBOL(logical_not, std::, ) SYMBOL(logical_or, std::, ) -SYMBOL(logl, std::, ) SYMBOL(lognormal_distribution, std::, ) -SYMBOL(longjmp, std::, ) SYMBOL(lower_bound, std::, ) -SYMBOL(lrint, std::, ) -SYMBOL(lrintf, std::, ) -SYMBOL(lrintl, std::, ) -SYMBOL(lround, std::, ) -SYMBOL(lroundf, std::, ) -SYMBOL(lroundl, std::, ) SYMBOL(make_exception_ptr, std::, ) SYMBOL(make_format_args, std::, ) SYMBOL(make_from_tuple, std::, ) @@ -980,29 +678,13 @@ SYMBOL(make_unsigned, std::, ) SYMBOL(make_unsigned_t, std::, ) SYMBOL(make_wformat_args, std::, ) -SYMBOL(malloc, std::, ) SYMBOL(map, std::, ) SYMBOL(mask_array, std::, ) SYMBOL(match_results, std::, ) SYMBOL(max, std::, ) -SYMBOL(max_align_t, std::, ) SYMBOL(max_element, std::, ) -SYMBOL(mblen, std::, ) -SYMBOL(mbrlen, std::, ) -SYMBOL(mbrtoc16, std::, ) -SYMBOL(mbrtoc32, std::, ) -SYMBOL(mbrtoc8, std::, ) -SYMBOL(mbrtowc, std::, ) -SYMBOL(mbsinit, std::, ) -SYMBOL(mbsrtowcs, std::, ) -SYMBOL(mbstowcs, std::, ) -SYMBOL(mbtowc, std::, ) SYMBOL(mega, std::, ) SYMBOL(mem_fn, std::, ) -SYMBOL(memchr, std::, ) -SYMBOL(memcmp, std::, ) -SYMBOL(memcpy, std::, ) -SYMBOL(memmove, std::, ) SYMBOL(memory_order, std::, ) SYMBOL(memory_order_acq_rel, std::, ) SYMBOL(memory_order_acquire, std::, ) @@ -1010,7 +692,6 @@ SYMBOL(memory_order_relaxed, std::, ) SYMBOL(memory_order_release, std::, ) SYMBOL(memory_order_seq_cst, std::, ) -SYMBOL(memset, std::, ) SYMBOL(merge, std::, ) SYMBOL(mergeable, std::, ) SYMBOL(mersenne_twister_engine, std::, ) @@ -1028,10 +709,6 @@ SYMBOL(minstd_rand0, std::, ) SYMBOL(minus, std::, ) SYMBOL(mismatch, std::, ) -SYMBOL(mktime, std::, ) -SYMBOL(modf, std::, ) -SYMBOL(modff, std::, ) -SYMBOL(modfl, std::, ) SYMBOL(modulus, std::, ) SYMBOL(money_base, std::, ) SYMBOL(money_get, std::, ) @@ -1052,13 +729,7 @@ SYMBOL(multiplies, std::, ) SYMBOL(multiset, std::, ) SYMBOL(mutex, std::, ) -SYMBOL(nan, std::, ) -SYMBOL(nanf, std::, ) -SYMBOL(nanl, std::, ) SYMBOL(nano, std::, ) -SYMBOL(nearbyint, std::, ) -SYMBOL(nearbyintf, std::, ) -SYMBOL(nearbyintl, std::, ) SYMBOL(negate, std::, ) SYMBOL(negation, std::, ) SYMBOL(negation_v, std::, ) @@ -1067,12 +738,6 @@ SYMBOL(new_handler, std::, ) SYMBOL(next, std::, ) SYMBOL(next_permutation, std::, ) -SYMBOL(nextafter, std::, ) -SYMBOL(nextafterf, std::, ) -SYMBOL(nextafterl, std::, ) -SYMBOL(nexttoward, std::, ) -SYMBOL(nexttowardf, std::, ) -SYMBOL(nexttowardl, std::, ) SYMBOL(noboolalpha, std::, ) SYMBOL(noemit_on_flush, std::, ) SYMBOL(none_of, std::, ) @@ -1097,7 +762,6 @@ SYMBOL(nth_element, std::, ) SYMBOL(nullopt, std::, ) SYMBOL(nullopt_t, std::, ) -SYMBOL(nullptr_t, std::, ) SYMBOL(num_get, std::, ) SYMBOL(num_put, std::, ) SYMBOL(numeric_limits, std::, ) @@ -1132,7 +796,6 @@ SYMBOL(partition_copy, std::, ) SYMBOL(partition_point, std::, ) SYMBOL(permutable, std::, ) -SYMBOL(perror, std::, ) SYMBOL(peta, std::, ) SYMBOL(pico, std::, ) SYMBOL(piecewise_constant_distribution, std::, ) @@ -1145,32 +808,18 @@ SYMBOL(polar, std::, ) SYMBOL(pop_heap, std::, ) SYMBOL(popcount, std::, ) -SYMBOL(pow, std::, ) -SYMBOL(powf, std::, ) -SYMBOL(powl, std::, ) SYMBOL(predicate, std::, ) SYMBOL(prev, std::, ) SYMBOL(prev_permutation, std::, ) -SYMBOL(printf, std::, ) SYMBOL(priority_queue, std::, ) SYMBOL(proj, std::, ) SYMBOL(projected, std::, ) SYMBOL(promise, std::, ) -SYMBOL(ptrdiff_t, std::, ) SYMBOL(push_heap, std::, ) SYMBOL(put_money, std::, ) SYMBOL(put_time, std::, ) -SYMBOL(putc, std::, ) -SYMBOL(putchar, std::, ) -SYMBOL(puts, std::, ) -SYMBOL(putwc, std::, ) -SYMBOL(putwchar, std::, ) -SYMBOL(qsort, std::, ) SYMBOL(queue, std::, ) -SYMBOL(quick_exit, std::, ) SYMBOL(quoted, std::, ) -SYMBOL(raise, std::, ) -SYMBOL(rand, std::, ) SYMBOL(random_access_iterator, std::, ) SYMBOL(random_access_iterator_tag, std::, ) SYMBOL(random_device, std::, ) @@ -1199,7 +848,6 @@ SYMBOL(ratio_not_equal_v, std::, ) SYMBOL(ratio_subtract, std::, ) SYMBOL(real, std::, ) -SYMBOL(realloc, std::, ) SYMBOL(recursive_mutex, std::, ) SYMBOL(recursive_timed_mutex, std::, ) SYMBOL(reduce, std::, ) @@ -1217,9 +865,6 @@ SYMBOL(regular_invocable, std::, ) SYMBOL(reinterpret_pointer_cast, std::, ) SYMBOL(relation, std::, ) -SYMBOL(remainder, std::, ) -SYMBOL(remainderf, std::, ) -SYMBOL(remainderl, std::, ) SYMBOL(remove_all_extents, std::, ) SYMBOL(remove_all_extents_t, std::, ) SYMBOL(remove_const, std::, ) @@ -1239,10 +884,6 @@ SYMBOL(remove_reference_t, std::, ) SYMBOL(remove_volatile, std::, ) SYMBOL(remove_volatile_t, std::, ) -SYMBOL(remquo, std::, ) -SYMBOL(remquof, std::, ) -SYMBOL(remquol, std::, ) -SYMBOL(rename, std::, ) SYMBOL(replace, std::, ) SYMBOL(replace_copy, std::, ) SYMBOL(replace_copy_if, std::, ) @@ -1253,36 +894,19 @@ SYMBOL(reverse, std::, ) SYMBOL(reverse_copy, std::, ) SYMBOL(reverse_iterator, std::, ) -SYMBOL(rewind, std::, ) -SYMBOL(riemann_zeta, std::, ) -SYMBOL(riemann_zetaf, std::, ) -SYMBOL(riemann_zetal, std::, ) SYMBOL(right, std::, ) -SYMBOL(rint, std::, ) -SYMBOL(rintf, std::, ) -SYMBOL(rintl, std::, ) SYMBOL(rotate, std::, ) SYMBOL(rotate_copy, std::, ) SYMBOL(rotl, std::, ) SYMBOL(rotr, std::, ) -SYMBOL(round, std::, ) SYMBOL(round_indeterminate, std::, ) SYMBOL(round_to_nearest, std::, ) SYMBOL(round_toward_infinity, std::, ) SYMBOL(round_toward_neg_infinity, std::, ) SYMBOL(round_toward_zero, std::, ) -SYMBOL(roundf, std::, ) -SYMBOL(roundl, std::, ) SYMBOL(runtime_error, std::, ) SYMBOL(same_as, std::, ) SYMBOL(sample, std::, ) -SYMBOL(scalbln, std::, ) -SYMBOL(scalblnf, std::, ) -SYMBOL(scalblnl, std::, ) -SYMBOL(scalbn, std::, ) -SYMBOL(scalbnf, std::, ) -SYMBOL(scalbnl, std::, ) -SYMBOL(scanf, std::, ) SYMBOL(scientific, std::, ) SYMBOL(scoped_allocator_adaptor, std::, ) SYMBOL(scoped_lock, std::, ) @@ -1299,12 +923,9 @@ SYMBOL(set_terminate, std::, ) SYMBOL(set_union, std::, ) SYMBOL(setbase, std::, ) -SYMBOL(setbuf, std::, ) SYMBOL(setfill, std::, ) SYMBOL(setiosflags, std::, ) -SYMBOL(setlocale, std::, ) SYMBOL(setprecision, std::, ) -SYMBOL(setvbuf, std::, ) SYMBOL(setw, std::, ) SYMBOL(shared_future, std::, ) SYMBOL(shared_lock, std::, ) @@ -1318,22 +939,12 @@ SYMBOL(showpos, std::, ) SYMBOL(shuffle, std::, ) SYMBOL(shuffle_order_engine, std::, ) -SYMBOL(sig_atomic_t, std::, ) -SYMBOL(signal, std::, ) -SYMBOL(signbit, std::, ) SYMBOL(signed_integral, std::, ) -SYMBOL(sin, std::, ) -SYMBOL(sinf, std::, ) -SYMBOL(sinh, std::, ) -SYMBOL(sinhf, std::, ) -SYMBOL(sinhl, std::, ) -SYMBOL(sinl, std::, ) SYMBOL(sized_sentinel_for, std::, ) SYMBOL(skipws, std::, ) SYMBOL(slice, std::, ) SYMBOL(slice_array, std::, ) SYMBOL(smatch, std::, ) -SYMBOL(snprintf, std::, ) SYMBOL(sort, std::, ) SYMBOL(sort_heap, std::, ) SYMBOL(sortable, std::, ) @@ -1341,23 +952,8 @@ SYMBOL(span, std::, ) SYMBOL(spanbuf, std::, ) SYMBOL(spanstream, std::, ) -SYMBOL(sph_bessel, std::, ) -SYMBOL(sph_besself, std::, ) -SYMBOL(sph_bessell, std::, ) -SYMBOL(sph_legendre, std::, ) -SYMBOL(sph_legendref, std::, ) -SYMBOL(sph_legendrel, std::, ) -SYMBOL(sph_neumann, std::, ) -SYMBOL(sph_neumannf, std::, ) -SYMBOL(sph_neumannl, std::, ) -SYMBOL(sprintf, std::, ) -SYMBOL(sqrt, std::, ) -SYMBOL(sqrtf, std::, ) -SYMBOL(sqrtl, std::, ) -SYMBOL(srand, std::, ) SYMBOL(sregex_iterator, std::, ) SYMBOL(sregex_token_iterator, std::, ) -SYMBOL(sscanf, std::, ) SYMBOL(ssub_match, std::, ) SYMBOL(stable_partition, std::, ) SYMBOL(stable_sort, std::, ) @@ -1376,46 +972,19 @@ SYMBOL(stop_token, std::, ) SYMBOL(stoul, std::, ) SYMBOL(stoull, std::, ) -SYMBOL(strcat, std::, ) -SYMBOL(strchr, std::, ) -SYMBOL(strcmp, std::, ) -SYMBOL(strcoll, std::, ) -SYMBOL(strcpy, std::, ) -SYMBOL(strcspn, std::, ) SYMBOL(streambuf, std::, ) SYMBOL(streamoff, std::, ) SYMBOL(streampos, std::, ) SYMBOL(streamsize, std::, ) -SYMBOL(strerror, std::, ) -SYMBOL(strftime, std::, ) SYMBOL(strict_weak_order, std::, ) SYMBOL(string, std::, ) SYMBOL(string_view, std::, ) SYMBOL(stringbuf, std::, ) SYMBOL(stringstream, std::, ) -SYMBOL(strlen, std::, ) -SYMBOL(strncat, std::, ) -SYMBOL(strncmp, std::, ) -SYMBOL(strncpy, std::, ) SYMBOL(strong_order, std::, ) SYMBOL(strong_ordering, std::, ) -SYMBOL(strpbrk, std::, ) -SYMBOL(strrchr, std::, ) -SYMBOL(strspn, std::, ) -SYMBOL(strstr, std::, ) SYMBOL(strstream, std::, ) SYMBOL(strstreambuf, std::, ) -SYMBOL(strtod, std::, ) -SYMBOL(strtof, std::, ) -SYMBOL(strtoimax, std::, ) -SYMBOL(strtok, std::, ) -SYMBOL(strtol, std::, ) -SYMBOL(strtold, std::, ) -SYMBOL(strtoll, std::, ) -SYMBOL(strtoul, std::, ) -SYMBOL(strtoull, std::, ) -SYMBOL(strtoumax, std::, ) -SYMBOL(strxfrm, std::, ) SYMBOL(student_t_distribution, std::, ) SYMBOL(sub_match, std::, ) SYMBOL(subtract_with_carry_engine, std::, ) @@ -1424,65 +993,37 @@ SYMBOL(swap_ranges, std::, ) SYMBOL(swappable, std::, ) SYMBOL(swappable_with, std::, ) -SYMBOL(swprintf, std::, ) -SYMBOL(swscanf, std::, ) SYMBOL(syncbuf, std::, ) -SYMBOL(system, std::, ) SYMBOL(system_category, std::, ) SYMBOL(system_error, std::, ) -SYMBOL(tan, std::, ) -SYMBOL(tanf, std::, ) -SYMBOL(tanh, std::, ) -SYMBOL(tanhf, std::, ) -SYMBOL(tanhl, std::, ) -SYMBOL(tanl, std::, ) SYMBOL(tera, std::, ) SYMBOL(terminate, std::, ) SYMBOL(terminate_handler, std::, ) -SYMBOL(tgamma, std::, ) -SYMBOL(tgammaf, std::, ) -SYMBOL(tgammal, std::, ) SYMBOL(thread, std::, ) SYMBOL(three_way_comparable, std::, ) SYMBOL(three_way_comparable_with, std::, ) SYMBOL(throw_with_nested, std::, ) SYMBOL(tie, std::, ) -SYMBOL(time, std::, ) SYMBOL(time_base, std::, ) SYMBOL(time_get, std::, ) SYMBOL(time_get_byname, std::, ) SYMBOL(time_put, std::, ) SYMBOL(time_put_byname, std::, ) -SYMBOL(time_t, std::, ) SYMBOL(timed_mutex, std::, ) -SYMBOL(timespec, std::, ) -SYMBOL(timespec_get, std::, ) -SYMBOL(tm, std::, ) -SYMBOL(tmpfile, std::, ) -SYMBOL(tmpnam, std::, ) SYMBOL(to_address, std::, ) SYMBOL(to_array, std::, ) SYMBOL(to_chars, std::, ) SYMBOL(to_chars_result, std::, ) -SYMBOL(to_integer, std::, ) SYMBOL(to_string, std::, ) SYMBOL(to_underlying, std::, ) SYMBOL(to_wstring, std::, ) -SYMBOL(tolower, std::, ) SYMBOL(totally_ordered, std::, ) SYMBOL(totally_ordered_with, std::, ) -SYMBOL(toupper, std::, ) -SYMBOL(towctrans, std::, ) -SYMBOL(towlower, std::, ) -SYMBOL(towupper, std::, ) SYMBOL(transform, std::, ) SYMBOL(transform_exclusive_scan, std::, ) SYMBOL(transform_inclusive_scan, std::, ) SYMBOL(transform_reduce, std::, ) SYMBOL(true_type, std::, ) -SYMBOL(trunc, std::, ) -SYMBOL(truncf, std::, ) -SYMBOL(truncl, std::, ) SYMBOL(try_lock, std::, ) SYMBOL(try_to_lock, std::, ) SYMBOL(try_to_lock_t, std::, ) @@ -1503,26 +1044,10 @@ SYMBOL(u8streampos, std::, ) SYMBOL(u8string, std::, ) SYMBOL(u8string_view, std::, ) -SYMBOL(uint16_t, std::, ) -SYMBOL(uint32_t, std::, ) -SYMBOL(uint64_t, std::, ) -SYMBOL(uint8_t, std::, ) -SYMBOL(uint_fast16_t, std::, ) -SYMBOL(uint_fast32_t, std::, ) -SYMBOL(uint_fast64_t, std::, ) -SYMBOL(uint_fast8_t, std::, ) -SYMBOL(uint_least16_t, std::, ) -SYMBOL(uint_least32_t, std::, ) -SYMBOL(uint_least64_t, std::, ) -SYMBOL(uint_least8_t, std::, ) -SYMBOL(uintmax_t, std::, ) -SYMBOL(uintptr_t, std::, ) SYMBOL(uncaught_exceptions, std::, ) SYMBOL(underflow_error, std::, ) SYMBOL(underlying_type, std::, ) SYMBOL(underlying_type_t, std::, ) -SYMBOL(ungetc, std::, ) -SYMBOL(ungetwc, std::, ) SYMBOL(uniform_int_distribution, std::, ) SYMBOL(uniform_random_bit_generator, std::, ) SYMBOL(uniform_real_distribution, std::, ) @@ -1556,7 +1081,6 @@ SYMBOL(uses_allocator, std::, ) SYMBOL(uses_allocator_construction_args, std::, ) SYMBOL(uses_allocator_v, std::, ) -SYMBOL(va_list, std::, ) SYMBOL(valarray, std::, ) SYMBOL(variant, std::, ) SYMBOL(variant_alternative, std::, ) @@ -1567,22 +1091,9 @@ SYMBOL(vector, std::, ) SYMBOL(vformat, std::, ) SYMBOL(vformat_to, std::, ) -SYMBOL(vfprintf, std::, ) -SYMBOL(vfscanf, std::, ) -SYMBOL(vfwprintf, std::, ) -SYMBOL(vfwscanf, std::, ) SYMBOL(visit, std::, ) SYMBOL(visit_format_arg, std::, ) SYMBOL(void_t, std::, ) -SYMBOL(vprintf, std::, ) -SYMBOL(vscanf, std::, ) -SYMBOL(vsnprintf, std::, ) -SYMBOL(vsprintf, std::, ) -SYMBOL(vsscanf, std::, ) -SYMBOL(vswprintf, std::, ) -SYMBOL(vswscanf, std::, ) -SYMBOL(vwprintf, std::, ) -SYMBOL(vwscanf, std::, ) SYMBOL(wbuffer_convert, std::, ) SYMBOL(wcerr, std::, ) SYMBOL(wcin, std::, ) @@ -1591,42 +1102,7 @@ SYMBOL(wcout, std::, ) SYMBOL(wcregex_iterator, std::, ) SYMBOL(wcregex_token_iterator, std::, ) -SYMBOL(wcrtomb, std::, ) -SYMBOL(wcscat, std::, ) -SYMBOL(wcschr, std::, ) -SYMBOL(wcscmp, std::, ) -SYMBOL(wcscoll, std::, ) -SYMBOL(wcscpy, std::, ) -SYMBOL(wcscspn, std::, ) -SYMBOL(wcsftime, std::, ) -SYMBOL(wcslen, std::, ) -SYMBOL(wcsncat, std::, ) -SYMBOL(wcsncmp, std::, ) -SYMBOL(wcsncpy, std::, ) -SYMBOL(wcspbrk, std::, ) -SYMBOL(wcsrchr, std::, ) -SYMBOL(wcsrtombs, std::, ) -SYMBOL(wcsspn, std::, ) -SYMBOL(wcsstr, std::, ) -SYMBOL(wcstod, std::, ) -SYMBOL(wcstof, std::, ) -SYMBOL(wcstoimax, std::, ) -SYMBOL(wcstok, std::, ) -SYMBOL(wcstol, std::, ) -SYMBOL(wcstold, std::, ) -SYMBOL(wcstoll, std::, ) -SYMBOL(wcstombs, std::, ) -SYMBOL(wcstoul, std::, ) -SYMBOL(wcstoull, std::, ) -SYMBOL(wcstoumax, std::, ) SYMBOL(wcsub_match, std::, ) -SYMBOL(wcsxfrm, std::, ) -SYMBOL(wctob, std::, ) -SYMBOL(wctomb, std::, ) -SYMBOL(wctrans, std::, ) -SYMBOL(wctrans_t, std::, ) -SYMBOL(wctype, std::, ) -SYMBOL(wctype_t, std::, ) SYMBOL(weak_order, std::, ) SYMBOL(weak_ordering, std::, ) SYMBOL(weak_ptr, std::, ) @@ -1643,20 +1119,13 @@ SYMBOL(wispanstream, std::, ) SYMBOL(wistream, std::, ) SYMBOL(wistringstream, std::, ) -SYMBOL(wmemchr, std::, ) -SYMBOL(wmemcmp, std::, ) -SYMBOL(wmemcpy, std::, ) -SYMBOL(wmemmove, std::, ) -SYMBOL(wmemset, std::, ) SYMBOL(wofstream, std::, ) SYMBOL(wospanstream, std::, ) SYMBOL(wostream, std::, ) SYMBOL(wostringstream, std::, ) SYMBOL(wosyncstream, std::, ) -SYMBOL(wprintf, std::, ) SYMBOL(wregex, std::, ) SYMBOL(ws, std::, ) -SYMBOL(wscanf, std::, ) SYMBOL(wsmatch, std::, ) SYMBOL(wspanbuf, std::, ) SYMBOL(wspanstream, std::, ) diff --git a/clang/tools/include-mapping/gen_std.py b/clang/tools/include-mapping/gen_std.py --- a/clang/tools/include-mapping/gen_std.py +++ b/clang/tools/include-mapping/gen_std.py @@ -102,7 +102,30 @@ exit("Path %s doesn't exist!" % symbol_index_root) symbols = cppreference_parser.GetSymbols(parse_pages) - + # C++ form of the C standard headers. + c_style_headers = { + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + } # We don't have version information from the unzipped offline HTML files. # so we use the modified time of the symbol_index.html as the version. index_page_path = os.path.join(page_root, "index.html") @@ -111,6 +134,10 @@ print(CODE_PREFIX % (args.symbols.upper(), cppreference_modified_date)) for symbol in symbols: if len(symbol.headers) == 1: + # Excluding the c-compatibility symbols, they are covered by the + # human-edit CXXSymbolMap.inc file. + if symbol.headers[0] in c_style_headers: + continue # SYMBOL(unqualified_name, namespace, header) print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace, symbol.headers[0]))