+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(ac_c99_ctype_tr1, [
+ AC_TRY_COMPILE([#include <ctype.h>],
+ [int ch;
+ int ret;
+ ret = isblank(ch);
+ ],[ac_c99_ctype_tr1=yes], [ac_c99_ctype_tr1=no])
+ ])
+ AC_MSG_RESULT($ac_c99_ctype_tr1)
+ if test x"$ac_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(ac_c99_stdint_tr1, [
+ AC_TRY_COMPILE([#include <stdint.h>],
+ [typedef int8_t my_int8_t;
+ typedef int16_t my_int16_t;
+ typedef int32_t my_int32_t;
+ typedef int64_t my_int64_t;
+ typedef int_fast8_t my_int_fast8_t;
+ typedef int_fast16_t my_int_fast16_t;
+ typedef int_fast32_t my_int_fast32_t;
+ typedef int_fast64_t my_int_fast64_t;
+ typedef int_least8_t my_int_least8_t;
+ typedef int_least16_t my_int_least16_t;
+ typedef int_least32_t my_int_least32_t;
+ typedef int_least64_t my_int_least64_t;
+ typedef intmax_t my_intmax_t;
+ typedef intptr_t my_intptr_t;
+ typedef uint8_t my_uint8_t;
+ typedef uint16_t my_uint16_t;
+ typedef uint32_t my_uint32_t;
+ typedef uint64_t my_uint64_t;
+ typedef uint_fast8_t my_uint_fast8_t;
+ typedef uint_fast16_t my_uint_fast16_t;
+ typedef uint_fast32_t my_uint_fast32_t;
+ typedef uint_fast64_t my_uint_fast64_t;
+ typedef uint_least8_t my_uint_least8_t;
+ typedef uint_least16_t my_uint_least16_t;
+ typedef uint_least32_t my_uint_least32_t;
+ typedef uint_least64_t my_uint_least64_t;
+ typedef uintmax_t my_uintmax_t;
+ typedef uintptr_t my_uintptr_t;
+ ],[ac_c99_stdint_tr1=yes], [ac_c99_stdint_tr1=no])
+ ])
+ AC_MSG_RESULT($ac_c99_stdint_tr1)
+ if test x"$ac_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(ac_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);
+ remquo(0.0f, 0.0f, 0);
+ remquo(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);
+ ],[ac_c99_math_tr1=yes], [ac_c99_math_tr1=no])
+ ])
+ AC_MSG_RESULT($ac_c99_math_tr1)
+ if test x"$ac_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 previous check fails, per C99, 7.8/1).
+ ac_c99_inttypes_tr1=no;
+ if test x"$ac_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 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(ac_random_tr1, [
+ AC_TRY_RUN([#include <stdio.h>
+ int main()
+ {
+ return !(fopen("/dev/random", "r")
+ && fopen("/dev/urandom", "r"));
+ }
+ ],
+ [ac_random_tr1=yes], [ac_random_tr1=no],
+ [ac_random_tr1=no])
+ ])
+ AC_MSG_RESULT($ac_random_tr1)
+ if test x"$ac_random_tr1" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
+ [Define if dev/random and dev/urandom are available for
+ the random_device of TR1 (Chapter 5.1).])
+ fi
+
+])
+
+dnl
+dnl Check whether macros, etc are present for <system_error>
+dnl
+AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
+
+ AC_MSG_CHECKING([for EOWNERDEAD])
+ AC_CACHE_VAL(ac_system_error1, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = EOWNERDEAD; ],
+ [ac_system_error1=yes], [ac_system_error1=no])
+ ])
+ AC_MSG_RESULT($ac_system_error1)
+ if test x"$ac_system_error1" = x"yes"; then
+ AC_DEFINE(HAVE_EOWNERDEAD, 1, [Define if EOWNERDEAD exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENOTRECOVERABLE])
+ AC_CACHE_VAL(ac_system_error2, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOTRECOVERABLE; ],
+ [ac_system_error2=yes], [ac_system_error2=no])
+ ])
+ AC_MSG_RESULT($ac_system_error2)
+ if test x"$ac_system_error2" = x"yes"; then
+ AC_DEFINE(HAVE_ENOTRECOVERABLE, 1, [Define if ENOTRECOVERABLE exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENOLINK])
+ AC_CACHE_VAL(ac_system_error3, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOLINK; ],
+ [ac_system_error3=yes], [ac_system_error3=no])
+ ])
+ AC_MSG_RESULT($ac_system_error3)
+ if test x"$ac_system_error3" = x"yes"; then
+ AC_DEFINE(HAVE_ENOLINK, 1, [Define if ENOLINK exists.])
+ fi
+
+ AC_MSG_CHECKING([for EPROTO])
+ AC_CACHE_VAL(ac_system_error_4, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = EPROTO; ],
+ [ac_system_error_4=yes], [ac_system_error_4=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_4)
+ if test x"$ac_system_error_4" = x"yes"; then
+ AC_DEFINE(HAVE_EPROTO, 1, [Define if EPROTO exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENODATA])
+ AC_CACHE_VAL(ac_system_error_5, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENODATA; ],
+ [ac_system_error_5=yes], [ac_system_error_5=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_5)
+ if test x"$ac_system_error_5" = x"yes"; then
+ AC_DEFINE(HAVE_ENODATA, 1, [Define if ENODATA exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENOSR])
+ AC_CACHE_VAL(ac_system_error_6, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSR; ],
+ [ac_system_error_6=yes], [ac_system_error_6=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_6)
+ if test x"$ac_system_error_6" = x"yes"; then
+ AC_DEFINE(HAVE_ENOSR, 1, [Define if ENOSR exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENOSTR])
+ AC_CACHE_VAL(ac_system_error_7, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOSTR; ],
+ [ac_system_error_7=yes], [ac_system_error_7=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_7)
+ if test x"$ac_system_error_7" = x"yes"; then
+ AC_DEFINE(HAVE_ENOSTR, 1, [Define if ENOSTR exists.])
+ fi
+
+ AC_MSG_CHECKING([for ETIME])
+ AC_CACHE_VAL(ac_system_error_8, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ETIME; ],
+ [ac_system_error_8=yes], [ac_system_error_8=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_8)
+ if test x"$ac_system_error_8" = x"yes"; then
+ AC_DEFINE(HAVE_ETIME, 1, [Define if ETIME exists.])
+ fi
+
+ AC_MSG_CHECKING([for sys_nerr])
+ AC_CACHE_VAL(ac_system_error9, [
+ AC_TRY_COMPILE([#include <errno.h> ], [ int i = sys_nerr; ],
+ [ac_system_error9=yes], [ac_system_error9=no])
+ ])
+ AC_MSG_RESULT($ac_system_error9)
+ if test x"$ac_system_error9" = x"yes"; then
+ AC_DEFINE(HAVE_SYS_NERR, 1, [Define if sys_nerr exists.])
+ fi
+
+ AC_MSG_CHECKING([for EBADMSG])
+ AC_CACHE_VAL(ac_system_error_10, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = EBADMSG; ],
+ [ac_system_error_10=yes], [ac_system_error_10=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_10)
+ if test x"$ac_system_error_10" = x"yes"; then
+ AC_DEFINE(HAVE_EBADMSG, 1, [Define if EBADMSG exists.])
+ fi
+
+ AC_MSG_CHECKING([for ECANCELED])
+ AC_CACHE_VAL(ac_system_error_11, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ECANCELED; ],
+ [ac_system_error_11=yes], [ac_system_error_11=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_11)
+ if test x"$ac_system_error_11" = x"yes"; then
+ AC_DEFINE(HAVE_ECANCELED, 1, [Define if ECANCELED exists.])
+ fi
+
+ AC_MSG_CHECKING([for EOVERFLOW])
+ AC_CACHE_VAL(ac_system_error_12, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = EOVERFLOW; ],
+ [ac_system_error_12=yes], [ac_system_error_12=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_12)
+ if test x"$ac_system_error_12" = x"yes"; then
+ AC_DEFINE(HAVE_EOVERFLOW, 1, [Define if EOVERFLOW exists.])
+ fi
+
+ AC_MSG_CHECKING([for ENOTSUP])
+ AC_CACHE_VAL(ac_system_error_13, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ENOTSUP; ],
+ [ac_system_error_13=yes], [ac_system_error_13=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_13)
+ if test x"$ac_system_error_13" = x"yes"; then
+ AC_DEFINE(HAVE_ENOTSUP, 1, [Define if ENOTSUP exists.])
+ fi
+
+ AC_MSG_CHECKING([for EIDRM])
+ AC_CACHE_VAL(ac_system_error_14, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = EIDRM; ],
+ [ac_system_error_14=yes], [ac_system_error_14=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_14)
+ if test x"$ac_system_error_14" = x"yes"; then
+ AC_DEFINE(HAVE_EIDRM, 1, [Define if EIDRM exists.])
+ fi
+
+ AC_MSG_CHECKING([for ETXTBSY])
+ AC_CACHE_VAL(ac_system_error_15, [
+ AC_TRY_COMPILE([#include <errno.h>], [ int i = ETXTBSY; ],
+ [ac_system_error_15=yes], [ac_system_error_15=no])
+ ])
+ AC_MSG_RESULT($ac_system_error_15)
+ if test x"$ac_system_error_15" = x"yes"; then
+ AC_DEFINE(HAVE_ETXTBSY, 1, [Define if ETXTBSY exists.])
+ fi
+])
+
+dnl
OSDN Git Service
