## other macros from doing the same. This should be automated.) -pme
need_libmath=no
+ # Check for uClibc since Linux platforms use different configuration
+ # directories depending on the C library in use.
+ AC_EGREP_CPP([_using_uclibc], [
+ #include <stdio.h>
+ #if __UCLIBC__
+ _using_uclibc
+ #endif
+ ], uclibc=yes, uclibc=no)
+
# Find platform-specific directories containing configuration info.
# Also possibly modify flags used elsewhere, as needed by the platform.
GLIBCXX_CHECK_HOST
dnl
dnl Defines:
dnl SECTION_LDFLAGS='-Wl,--gc-sections' if possible
-dnl OPT_LDFLAGS='-Wl,-O1' if possible
+dnl OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
dnl LD (as a side effect of testing)
dnl Sets:
dnl with_gnu_ld
# Start by getting the version number. I think the libtool test already
# does some of this, but throws away the result.
+ AC_MSG_CHECKING([for ld version])
changequote(,)
ldver=`$LD --version 2>/dev/null | head -1 | \
sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
changequote([,])
glibcxx_gnu_ld_version=`echo $ldver | \
$AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
+ AC_MSG_RESULT($glibcxx_gnu_ld_version)
# Set --gc-sections.
- if test "$with_gnu_ld" = "notbroken"; then
- # GNU ld it is! Joy and bunny rabbits!
+ glibcxx_gcsections_min_ld=21602
+ if test x"$with_gnu_ld" = x"yes" &&
+ test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
+
+ # Sufficiently young GNU ld it is! Joy and bunny rabbits!
+ # NB: This flag only works reliably after 2.16.1. Configure tests
+ # for this are difficult, so hard wire a value that should work.
- # All these tests are for C++; save the language and the compiler flags.
- # Need to do this so that g++ won't try to link in libstdc++
+ # All these tests are for C++, but run with the "C" compiler driver.
+ # Need to do this so that g++ won't try to link in libstdc++/libsupc++.
ac_test_CFLAGS="${CFLAGS+set}"
ac_save_CFLAGS="$CFLAGS"
- CFLAGS='-x c++ -Wl,--gc-sections'
+ CFLAGS='-x c++ -Wl,--gc-sections'
# Check for -Wl,--gc-sections
- # XXX This test is broken at the moment, as symbols required for linking
- # are now in libsupc++ (not built yet). In addition, this test has
- # cored on solaris in the past. In addition, --gc-sections doesn't
- # really work at the moment (keeps on discarding used sections, first
- # .eh_frame and now some of the glibc sections for iconv).
- # Bzzzzt. Thanks for playing, maybe next time.
AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
- AC_TRY_RUN([
- int main(void)
- {
- try { throw 1; }
- catch (...) { };
- return 0;
- }
- ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
+ AC_TRY_LINK([ int one(void) { return 1; }
+ int two(void) { return 2; }
+ ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
+ if test "$ac_gcsections" = "yes"; then
+ rm -f conftest.c
+ touch conftest.c
+ if $CC -c conftest.c; then
+ if $LD --gc-sections -o conftest conftest.o 2>&1 | \
+ grep "Warning: gc-sections option ignored" > /dev/null; then
+ ac_gcsections=no
+ fi
+ fi
+ rm -f conftest.c conftest.o conftest
+ fi
+ if test "$ac_gcsections" = "yes"; then
+ SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
+ fi
+ AC_MSG_RESULT($ac_gcsections)
+
if test "$ac_test_CFLAGS" = set; then
CFLAGS="$ac_save_CFLAGS"
else
# this is the suspicious part
CFLAGS=''
fi
- if test "$ac_sectionLDflags" = "yes"; then
- SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
+ fi
+
+ # Set -z,relro.
+ # Note this is only for shared objects.
+ ac_ld_relro=no
+ if test x"$with_gnu_ld" = x"yes"; then
+ AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
+ cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
+ if test -n "$cxx_z_relo"; then
+ OPT_LDFLAGS="-Wl,-z,relro"
+ ac_ld_relro=yes
fi
- AC_MSG_RESULT($ac_sectionLDflags)
+ AC_MSG_RESULT($ac_ld_relro)
fi
# Set linker optimization flags.
dnl Assumes cross_compiling bits already done, and with_cross_host in
dnl particular.
dnl
+dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
glibcxx_toolexecdir=no
glibcxx_toolexeclibdir=no
# Default case for install directory for include files.
if test $version_specific_libs = no && test $gxx_include_dir = no; then
- gxx_include_dir='${prefix}/include/c++/${gcc_version}'
+ gxx_include_dir='include/c++/${gcc_version}'
+ if test -n "$with_cross_host" &&
+ test x"$with_cross_host" != x"no"; then
+ gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
+ else
+ gxx_include_dir='${prefix}/'"$gxx_include_dir"
+ fi
fi
# Version-specific runtime libs processing.
AC_DEFUN([GLIBCXX_ENABLE_C99], [
GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
- # Test wchar.h for mbstate_t, which is needed for char_traits and fpos
- # even if C99 support is turned off.
- AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
- AC_MSG_CHECKING([for mbstate_t])
- AC_TRY_COMPILE([#include <wchar.h>],
- [mbstate_t teststate;],
- have_mbstate_t=yes, have_mbstate_t=no)
- AC_MSG_RESULT($have_mbstate_t)
- if test x"$have_mbstate_t" = xyes; then
- AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
- fi
-
if test x"$enable_c99" = x"yes"; then
AC_LANG_SAVE
])
AC_MSG_RESULT($ac_c99_stdlib)
- # Check for the existence in <wchar.h> of wcstoull, WEOF, etc.
- AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+ # Check for the existence in <wchar.h> of wcstold, etc.
ac_c99_wchar=no;
if test x"$ac_has_wchar_h" = xyes &&
test x"$ac_has_wctype_h" = xyes; then
+ AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
AC_TRY_COMPILE([#include <wchar.h>
- #include <stddef.h>
- wint_t i;
- long l = WEOF;
- long j = WCHAR_MIN;
- long k = WCHAR_MAX;
namespace test
{
- using ::btowc;
- using ::fgetwc;
- using ::fgetws;
- using ::fputwc;
- using ::fputws;
- using ::fwide;
- using ::fwprintf;
- using ::fwscanf;
- using ::getwc;
- using ::getwchar;
- using ::mbrlen;
- using ::mbrtowc;
- using ::mbsinit;
- using ::mbsrtowcs;
- using ::putwc;
- using ::putwchar;
- using ::swprintf;
- using ::swscanf;
- using ::ungetwc;
- using ::vfwprintf;
- using ::vswprintf;
- using ::vwprintf;
- using ::wcrtomb;
- using ::wcscat;
- using ::wcschr;
- using ::wcscmp;
- using ::wcscoll;
- using ::wcscpy;
- using ::wcscspn;
- using ::wcsftime;
- using ::wcslen;
- using ::wcsncat;
- using ::wcsncmp;
- using ::wcsncpy;
- using ::wcspbrk;
- using ::wcsrchr;
- using ::wcsrtombs;
- using ::wcsspn;
- using ::wcsstr;
- using ::wcstod;
- using ::wcstok;
- using ::wcstol;
using ::wcstold;
using ::wcstoll;
- using ::wcstoul;
using ::wcstoull;
- using ::wcsxfrm;
- using ::wctob;
- using ::wmemchr;
- using ::wmemcmp;
- using ::wmemcpy;
- using ::wmemmove;
- using ::wmemset;
- using ::wprintf;
- using ::wscanf;
}
],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
[AC_DEFINE(HAVE_ISWBLANK,1,
[Defined if iswblank exists.])],[])
- AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
AC_MSG_RESULT($ac_c99_wchar)
fi
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
+
+ # 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)
+
+ 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 for what type of C headers to use.
dnl
dnl --enable-cheaders= [does stuff].
dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
dnl Where DEFAULT is either `yes' or `no'.
dnl
-dnl Necessary support (probed along with C99 support) must also be present.
+dnl Necessary support must also be present.
dnl
AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
- if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
+
+ # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
+ AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
+ AC_MSG_CHECKING([for mbstate_t])
+ AC_TRY_COMPILE([#include <wchar.h>],
+ [mbstate_t teststate;],
+ have_mbstate_t=yes, have_mbstate_t=no)
+ AC_MSG_RESULT($have_mbstate_t)
+ if test x"$have_mbstate_t" = xyes; then
+ AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
+ fi
+
+ # Test it always, for use in GLIBCXX_ENABLE_C99, together with
+ # ac_has_wchar_h.
+ AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+
+ if test x"$enable_wchar_t" = x"yes"; then
+
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+
+ if test x"$ac_has_wchar_h" = xyes &&
+ test x"$ac_has_wctype_h" = xyes; then
+ AC_TRY_COMPILE([#include <wchar.h>
+ #include <stddef.h>
+ wint_t i;
+ long l = WEOF;
+ long j = WCHAR_MIN;
+ long k = WCHAR_MAX;
+ namespace test
+ {
+ using ::btowc;
+ using ::fgetwc;
+ using ::fgetws;
+ using ::fputwc;
+ using ::fputws;
+ using ::fwide;
+ using ::fwprintf;
+ using ::fwscanf;
+ using ::getwc;
+ using ::getwchar;
+ using ::mbrlen;
+ using ::mbrtowc;
+ using ::mbsinit;
+ using ::mbsrtowcs;
+ using ::putwc;
+ using ::putwchar;
+ using ::swprintf;
+ using ::swscanf;
+ using ::ungetwc;
+ using ::vfwprintf;
+ using ::vswprintf;
+ using ::vwprintf;
+ using ::wcrtomb;
+ using ::wcscat;
+ using ::wcschr;
+ using ::wcscmp;
+ using ::wcscoll;
+ using ::wcscpy;
+ using ::wcscspn;
+ using ::wcsftime;
+ using ::wcslen;
+ using ::wcsncat;
+ using ::wcsncmp;
+ using ::wcsncpy;
+ using ::wcspbrk;
+ using ::wcsrchr;
+ using ::wcsrtombs;
+ using ::wcsspn;
+ using ::wcsstr;
+ using ::wcstod;
+ using ::wcstok;
+ using ::wcstol;
+ using ::wcstoul;
+ using ::wcsxfrm;
+ using ::wctob;
+ using ::wmemchr;
+ using ::wmemcmp;
+ using ::wmemcpy;
+ using ::wmemmove;
+ using ::wmemset;
+ using ::wprintf;
+ using ::wscanf;
+ }
+ ],[],[], [enable_wchar_t=no])
+ else
+ enable_wchar_t=no
+ fi
+
+ AC_LANG_RESTORE
+ fi
+
+ if test x"$enable_wchar_t" = x"yes"; then
AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
[Define if code specialized for wchar_t should be used.])
fi
+
AC_MSG_CHECKING([for enabled wchar_t specializations])
AC_MSG_RESULT([$enable_wchar_t])
])
OSDN Git Service
