+dnl
+dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
+dnl facilities in Chapter 8, "C compatibility".
+dnl
+AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
+
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+
+ # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
+ # undefined and fake C99 facilities may be spuriously enabled.
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++98"
+
+ # Check for the existence of <complex.h> complex math functions used
+ # by tr1/complex.
+ AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+ ac_c99_complex_tr1=no;
+ if test x"$ac_has_complex_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
+ AC_TRY_COMPILE([#include <complex.h>],
+ [typedef __complex__ float float_type; float_type tmpf;
+ cacosf(tmpf);
+ casinf(tmpf);
+ catanf(tmpf);
+ cacoshf(tmpf);
+ casinhf(tmpf);
+ catanhf(tmpf);
+ typedef __complex__ double double_type; double_type tmpd;
+ cacos(tmpd);
+ casin(tmpd);
+ catan(tmpd);
+ cacosh(tmpd);
+ casinh(tmpd);
+ catanh(tmpd);
+ typedef __complex__ long double ld_type; ld_type tmpld;
+ cacosl(tmpld);
+ casinl(tmpld);
+ catanl(tmpld);
+ cacoshl(tmpld);
+ casinhl(tmpld);
+ catanhl(tmpld);
+ ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
+ fi
+ AC_MSG_RESULT($ac_c99_complex_tr1)
+ if test x"$ac_c99_complex_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
+ [Define if C99 functions in <complex.h> should be used in
+ <tr1/complex>. Using compiler builtins for these functions
+ requires corresponding C99 library functions to be present.])
+ fi
+
+ # Check for the existence of <ctype.h> functions.
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
+ AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
+ AC_TRY_COMPILE([#include <ctype.h>],
+ [int ch;
+ int ret;
+ ret = isblank(ch);
+ ],[glibcxx_cv_c99_ctype_tr1=yes],
+ [glibcxx_cv_c99_ctype_tr1=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
+ if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
+ [Define if C99 functions in <ctype.h> should be imported in
+ <tr1/cctype> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of <fenv.h> functions.
+ AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
+ ac_c99_fenv_tr1=no;
+ if test x"$ac_has_fenv_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
+ AC_TRY_COMPILE([#include <fenv.h>],
+ [int except, mode;
+ fexcept_t* pflag;
+ fenv_t* penv;
+ int ret;
+ ret = feclearexcept(except);
+ ret = fegetexceptflag(pflag, except);
+ ret = feraiseexcept(except);
+ ret = fesetexceptflag(pflag, except);
+ ret = fetestexcept(except);
+ ret = fegetround();
+ ret = fesetround(mode);
+ ret = fegetenv(penv);
+ ret = feholdexcept(penv);
+ ret = fesetenv(penv);
+ ret = feupdateenv(penv);
+ ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
+ fi
+ AC_MSG_RESULT($ac_c99_fenv_tr1)
+ if test x"$ac_c99_fenv_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
+ [Define if C99 functions in <fenv.h> should be imported in
+ <tr1/cfenv> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of <stdint.h> types.
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
+ AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
+ AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
+ #define __STDC_CONSTANT_MACROS
+ #include <stdint.h>],
+ [typedef int8_t my_int8_t;
+ my_int8_t i8 = INT8_MIN;
+ i8 = INT8_MAX;
+ typedef int16_t my_int16_t;
+ my_int16_t i16 = INT16_MIN;
+ i16 = INT16_MAX;
+ typedef int32_t my_int32_t;
+ my_int32_t i32 = INT32_MIN;
+ i32 = INT32_MAX;
+ typedef int64_t my_int64_t;
+ my_int64_t i64 = INT64_MIN;
+ i64 = INT64_MAX;
+ typedef int_fast8_t my_int_fast8_t;
+ my_int_fast8_t if8 = INT_FAST8_MIN;
+ if8 = INT_FAST8_MAX;
+ typedef int_fast16_t my_int_fast16_t;
+ my_int_fast16_t if16 = INT_FAST16_MIN;
+ if16 = INT_FAST16_MAX;
+ typedef int_fast32_t my_int_fast32_t;
+ my_int_fast32_t if32 = INT_FAST32_MIN;
+ if32 = INT_FAST32_MAX;
+ typedef int_fast64_t my_int_fast64_t;
+ my_int_fast64_t if64 = INT_FAST64_MIN;
+ if64 = INT_FAST64_MAX;
+ typedef int_least8_t my_int_least8_t;
+ my_int_least8_t il8 = INT_LEAST8_MIN;
+ il8 = INT_LEAST8_MAX;
+ typedef int_least16_t my_int_least16_t;
+ my_int_least16_t il16 = INT_LEAST16_MIN;
+ il16 = INT_LEAST16_MAX;
+ typedef int_least32_t my_int_least32_t;
+ my_int_least32_t il32 = INT_LEAST32_MIN;
+ il32 = INT_LEAST32_MAX;
+ typedef int_least64_t my_int_least64_t;
+ my_int_least64_t il64 = INT_LEAST64_MIN;
+ il64 = INT_LEAST64_MAX;
+ typedef intmax_t my_intmax_t;
+ my_intmax_t im = INTMAX_MAX;
+ im = INTMAX_MIN;
+ typedef intptr_t my_intptr_t;
+ my_intptr_t ip = INTPTR_MAX;
+ ip = INTPTR_MIN;
+ typedef uint8_t my_uint8_t;
+ my_uint8_t ui8 = UINT8_MAX;
+ ui8 = UINT8_MAX;
+ typedef uint16_t my_uint16_t;
+ my_uint16_t ui16 = UINT16_MAX;
+ ui16 = UINT16_MAX;
+ typedef uint32_t my_uint32_t;
+ my_uint32_t ui32 = UINT32_MAX;
+ ui32 = UINT32_MAX;
+ typedef uint64_t my_uint64_t;
+ my_uint64_t ui64 = UINT64_MAX;
+ ui64 = UINT64_MAX;
+ typedef uint_fast8_t my_uint_fast8_t;
+ my_uint_fast8_t uif8 = UINT_FAST8_MAX;
+ uif8 = UINT_FAST8_MAX;
+ typedef uint_fast16_t my_uint_fast16_t;
+ my_uint_fast16_t uif16 = UINT_FAST16_MAX;
+ uif16 = UINT_FAST16_MAX;
+ typedef uint_fast32_t my_uint_fast32_t;
+ my_uint_fast32_t uif32 = UINT_FAST32_MAX;
+ uif32 = UINT_FAST32_MAX;
+ typedef uint_fast64_t my_uint_fast64_t;
+ my_uint_fast64_t uif64 = UINT_FAST64_MAX;
+ uif64 = UINT_FAST64_MAX;
+ typedef uint_least8_t my_uint_least8_t;
+ my_uint_least8_t uil8 = UINT_LEAST8_MAX;
+ uil8 = UINT_LEAST8_MAX;
+ typedef uint_least16_t my_uint_least16_t;
+ my_uint_least16_t uil16 = UINT_LEAST16_MAX;
+ uil16 = UINT_LEAST16_MAX;
+ typedef uint_least32_t my_uint_least32_t;
+ my_uint_least32_t uil32 = UINT_LEAST32_MAX;
+ uil32 = UINT_LEAST32_MAX;
+ typedef uint_least64_t my_uint_least64_t;
+ my_uint_least64_t uil64 = UINT_LEAST64_MAX;
+ uil64 = UINT_LEAST64_MAX;
+ typedef uintmax_t my_uintmax_t;
+ my_uintmax_t uim = UINTMAX_MAX;
+ uim = UINTMAX_MAX;
+ typedef uintptr_t my_uintptr_t;
+ my_uintptr_t uip = UINTPTR_MAX;
+ uip = UINTPTR_MAX;
+ ],[glibcxx_cv_c99_stdint_tr1=yes],
+ [glibcxx_cv_c99_stdint_tr1=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
+ if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
+ [Define if C99 types in <stdint.h> should be imported in
+ <tr1/cstdint> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of <math.h> functions.
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
+ AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
+ AC_TRY_COMPILE([#include <math.h>],
+ [typedef double_t my_double_t;
+ typedef float_t my_float_t;
+ acosh(0.0);
+ acoshf(0.0f);
+ acoshl(0.0l);
+ asinh(0.0);
+ asinhf(0.0f);
+ asinhl(0.0l);
+ atanh(0.0);
+ atanhf(0.0f);
+ atanhl(0.0l);
+ cbrt(0.0);
+ cbrtf(0.0f);
+ cbrtl(0.0l);
+ copysign(0.0, 0.0);
+ copysignf(0.0f, 0.0f);
+ copysignl(0.0l, 0.0l);
+ erf(0.0);
+ erff(0.0f);
+ erfl(0.0l);
+ erfc(0.0);
+ erfcf(0.0f);
+ erfcl(0.0l);
+ exp2(0.0);
+ exp2f(0.0f);
+ exp2l(0.0l);
+ expm1(0.0);
+ expm1f(0.0f);
+ expm1l(0.0l);
+ fdim(0.0, 0.0);
+ fdimf(0.0f, 0.0f);
+ fdiml(0.0l, 0.0l);
+ fma(0.0, 0.0, 0.0);
+ fmaf(0.0f, 0.0f, 0.0f);
+ fmal(0.0l, 0.0l, 0.0l);
+ fmax(0.0, 0.0);
+ fmaxf(0.0f, 0.0f);
+ fmaxl(0.0l, 0.0l);
+ fmin(0.0, 0.0);
+ fminf(0.0f, 0.0f);
+ fminl(0.0l, 0.0l);
+ hypot(0.0, 0.0);
+ hypotf(0.0f, 0.0f);
+ hypotl(0.0l, 0.0l);
+ ilogb(0.0);
+ ilogbf(0.0f);
+ ilogbl(0.0l);
+ lgamma(0.0);
+ lgammaf(0.0f);
+ lgammal(0.0l);
+ llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+ log1p(0.0);
+ log1pf(0.0f);
+ log1pl(0.0l);
+ log2(0.0);
+ log2f(0.0f);
+ log2l(0.0l);
+ logb(0.0);
+ logbf(0.0f);
+ logbl(0.0l);
+ lrint(0.0);
+ lrintf(0.0f);
+ lrintl(0.0l);
+ lround(0.0);
+ lroundf(0.0f);
+ lroundl(0.0l);
+ nan(0);
+ nanf(0);
+ nanl(0);
+ nearbyint(0.0);
+ nearbyintf(0.0f);
+ nearbyintl(0.0l);
+ nextafter(0.0, 0.0);
+ nextafterf(0.0f, 0.0f);
+ nextafterl(0.0l, 0.0l);
+ nexttoward(0.0, 0.0);
+ nexttowardf(0.0f, 0.0f);
+ nexttowardl(0.0l, 0.0l);
+ remainder(0.0, 0.0);
+ remainderf(0.0f, 0.0f);
+ remainderl(0.0l, 0.0l);
+ remquo(0.0, 0.0, 0);
+ remquof(0.0f, 0.0f, 0);
+ remquol(0.0l, 0.0l, 0);
+ rint(0.0);
+ rintf(0.0f);
+ rintl(0.0l);
+ round(0.0);
+ roundf(0.0f);
+ roundl(0.0l);
+ scalbln(0.0, 0l);
+ scalblnf(0.0f, 0l);
+ scalblnl(0.0l, 0l);
+ scalbn(0.0, 0);
+ scalbnf(0.0f, 0);
+ scalbnl(0.0l, 0);
+ tgamma(0.0);
+ tgammaf(0.0f);
+ tgammal(0.0l);
+ trunc(0.0);
+ truncf(0.0f);
+ truncl(0.0l);
+ ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
+ ])
+ AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
+ if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
+ [Define if C99 functions or macros in <math.h> should be imported
+ in <tr1/cmath> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of <inttypes.h> functions (NB: doesn't make
+ # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
+ ac_c99_inttypes_tr1=no;
+ if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
+ AC_TRY_COMPILE([#include <inttypes.h>],
+ [intmax_t i, numer, denom, base;
+ const char* s;
+ char** endptr;
+ intmax_t ret = imaxabs(i);
+ imaxdiv_t dret = imaxdiv(numer, denom);
+ ret = strtoimax(s, endptr, base);
+ uintmax_t uret = strtoumax(s, endptr, base);
+ ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
+ fi
+ AC_MSG_RESULT($ac_c99_inttypes_tr1)
+ if test x"$ac_c99_inttypes_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
+ [Define if C99 functions in <inttypes.h> should be imported in
+ <tr1/cinttypes> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
+ # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
+ ac_c99_inttypes_wchar_t_tr1=no;
+ if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
+ AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
+ AC_TRY_COMPILE([#include <inttypes.h>],
+ [intmax_t base;
+ const wchar_t* s;
+ wchar_t** endptr;
+ intmax_t ret = wcstoimax(s, endptr, base);
+ uintmax_t uret = wcstoumax(s, endptr, base);
+ ],[ac_c99_inttypes_wchar_t_tr1=yes],
+ [ac_c99_inttypes_wchar_t_tr1=no])
+ fi
+ AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
+ if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
+ [Define if wchar_t C99 functions in <inttypes.h> should be
+ imported in <tr1/cinttypes> in namespace std::tr1.])
+ fi
+
+ # Check for the existence of the <stdbool.h> header.
+ AC_CHECK_HEADERS(stdbool.h)
+
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+])
+
+dnl
+dnl Check whether "/dev/random" and "/dev/urandom" are available for the
+dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
+dnl
+AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
+
+ AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
+ AC_CACHE_VAL(glibcxx_cv_random_tr1, [
+ if test -r /dev/random && test -r /dev/urandom; then
+ glibcxx_cv_random_tr1=yes;