dnl variables like $host.
dnl
dnl Sets:
-dnl gcc_version (x.y.z format)
dnl SUBDIRS
dnl Substs:
dnl glibcxx_builddir (absolute path)
AC_SUBST(CFLAGS)
AC_SUBST(CXXFLAGS)
- # For directory versioning (e.g., headers) and other variables.
- AC_MSG_CHECKING([for GCC version number])
- gcc_version=`$CXX -dumpversion`
- AC_MSG_RESULT($gcc_version)
-
# Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
# available). Uncomment the next line to force a particular method.
AC_PROG_LN_S
## (Right now, this only matters for enable_wchar_t, but nothing prevents
## other macros from doing the same. This should be automated.) -pme
need_libmath=no
- enable_wchar_t=no
- #enable_libstdcxx_debug=no
- #enable_libstdcxx_pch=no
- #enable_cheaders=c
- #c_compatibility=no
- #enable_abi_check=no
- #enable_symvers=no
- #enable_hosted_libstdcxx=yes
# Find platform-specific directories containing configuration info.
# Also possibly modify flags used elsewhere, as needed by the platform.
])
-m4_include([linkage.m4])
-m4_include([../config/no-executables.m4])
-
-
dnl
dnl Tests for newer compiler features, or features that are present in newer
dnl compiler versions but not older compiler versions still in use, should
dnl
-dnl Check to see if this target can enable the wchar_t parts.
-dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled. (This
-dnl must have been previously checked.) By default, wide characters are
-dnl disabled.
+dnl Check to see if this target can enable the iconv specializations.
+dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.
+dnl (This must have been previously checked, along with the rest of C99
+dnl support.) By default, iconv support is disabled.
dnl
dnl Defines:
-dnl HAVE_MBSTATE_T if mbstate_t is not in wchar.h
-dnl _GLIBCXX_USE_WCHAR_T if all the bits are found.
+dnl _GLIBCXX_USE_ICONV if all the bits are found.
dnl Substs:
dnl LIBICONV to a -l string containing the iconv library, if needed.
dnl
-AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [
- # Test wchar.h for mbstate_t, which is needed for char_traits and
- # others even if wchar_t support is not on.
- 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)
- fi
-
- # Sanity check for existence of ISO C99 headers for extended encoding.
- AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
- AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [
+ enable_iconv=no
# Only continue checking if the ISO C99 headers exist and support is on.
- if test x"$ac_has_wchar_h" = xyes &&
- test x"$ac_has_wctype_h" = xyes &&
- test x"$enable_c_mbchar" != xno; then
-
- # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
- # numeric_limits can instantiate type_traits<wchar_t>
- AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
- AC_TRY_COMPILE([#include <wchar.h>],
- [int i = WCHAR_MIN; int j = WCHAR_MAX;],
- has_wchar_minmax=yes, has_wchar_minmax=no)
- AC_MSG_RESULT($has_wchar_minmax)
-
- # Test wchar.h for WEOF, which is what we use to determine whether
- # to specialize for char_traits<wchar_t> or not.
- AC_MSG_CHECKING([for WEOF])
- AC_TRY_COMPILE([
- #include <wchar.h>
- #include <stddef.h>],
- [wint_t i = WEOF;],
- has_weof=yes, has_weof=no)
- AC_MSG_RESULT($has_weof)
-
- # Tests for wide character functions used in char_traits<wchar_t>.
- ac_wfuncs=yes
- AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset],
- [],[ac_wfuncs=no])
-
- # Checks for names injected into std:: by the c_std headers.
- AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \
- fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \
- vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
- mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \
- wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
- wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr],
- [],[ac_wfuncs=no])
-
- # Checks for wide character functions that are not required
- # for basic wchar_t support. Don't disable support if they are missing.
- # Injection of these is wrapped with guard macros.
- AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[])
-
- AC_MSG_CHECKING([for ISO C99 wchar_t support])
- if test x"$has_weof" = xyes &&
- test x"$has_wchar_minmax" = xyes &&
- test x"$ac_wfuncs" = xyes;
- then
- ac_isoC99_wchar_t=yes
- else
- ac_isoC99_wchar_t=no
- fi
- AC_MSG_RESULT($ac_isoC99_wchar_t)
+ if test x"$enable_wchar_t" = xyes; then
# Use iconv for wchar_t to char conversions. As such, check for
# X/Open Portability Guide, version 2 features (XPG2).
LIBS="$ac_save_LIBS"
- AC_MSG_CHECKING([for XPG2 wchar_t support])
if test x"$ac_has_iconv_h" = xyes &&
test x"$ac_has_langinfo_h" = xyes &&
test x"$ac_XPG2funcs" = xyes;
then
- ac_XPG2_wchar_t=yes
- else
- ac_XPG2_wchar_t=no
- fi
- AC_MSG_RESULT($ac_XPG2_wchar_t)
-
- # At the moment, only enable wchar_t specializations if all the
- # above support is present.
- if test x"$ac_isoC99_wchar_t" = xyes &&
- test x"$ac_XPG2_wchar_t" = xyes;
- then
- AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
- enable_wchar_t=yes
+ AC_DEFINE([_GLIBCXX_USE_ICONV],1,
+ [Define if iconv and related functions exist and are usable.])
+ enable_iconv=yes
fi
fi
- AC_MSG_CHECKING([for enabled wchar_t specializations])
- AC_MSG_RESULT($enable_wchar_t)
+ AC_MSG_CHECKING([for enabled iconv specializations])
+ AC_MSG_RESULT($enable_iconv)
])
dnl various HAVE_LIMIT_* for individual limit names
dnl
AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
+ AC_MSG_CHECKING([for RLIMIT_$1])
AC_TRY_COMPILE(
[#include <unistd.h>
#include <sys/time.h>
[glibcxx_mresult=1], [glibcxx_mresult=0])
AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
[Only used in build directory testsuite_hooks.h.])
+ if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
+ AC_MSG_RESULT($res)
])
AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
AC_MSG_CHECKING([for testsuite resource limits support])
if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
ac_res_limits=yes
- AC_DEFINE(_GLIBCXX_RES_LIMITS)
+ AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
+ [Define if using setrlimit to set resource limits during
+ "make check"])
else
ac_res_limits=no
fi
dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
dnl
AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
+ AC_MSG_CHECKING([for S_ISREG or S_IFREG])
AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
AC_TRY_LINK(
[#include <sys/stat.h>],
[glibcxx_cv_S_IFREG=yes],
[glibcxx_cv_S_IFREG=no])
])
+ res=no
if test $glibcxx_cv_S_ISREG = yes; then
- AC_DEFINE(HAVE_S_ISREG)
+ AC_DEFINE(HAVE_S_ISREG, 1,
+ [Define if S_IFREG is available in <sys/stat.h>.])
+ res=S_ISREG
elif test $glibcxx_cv_S_IFREG = yes; then
- AC_DEFINE(HAVE_S_IFREG)
+ AC_DEFINE(HAVE_S_IFREG, 1,
+ [Define if S_IFREG is available in <sys/stat.h>.])
+ res=S_IFREG
fi
+ AC_MSG_RESULT($res)
])
dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
dnl
AC_DEFUN([GLIBCXX_CHECK_POLL], [
+ AC_MSG_CHECKING([for poll])
AC_CACHE_VAL(glibcxx_cv_POLL, [
AC_TRY_LINK(
[#include <poll.h>],
[glibcxx_cv_POLL=no])
])
if test $glibcxx_cv_POLL = yes; then
- AC_DEFINE(HAVE_POLL)
+ AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
fi
+ AC_MSG_RESULT($glibcxx_cv_POLL)
])
dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
dnl
AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
+ AC_MSG_CHECKING([for writev])
AC_CACHE_VAL(glibcxx_cv_WRITEV, [
AC_TRY_LINK(
[#include <sys/uio.h>],
[glibcxx_cv_WRITEV=no])
])
if test $glibcxx_cv_WRITEV = yes; then
- AC_DEFINE(HAVE_WRITEV)
+ AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
fi
+ AC_MSG_RESULT($glibcxx_cv_WRITEV)
])
dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
dnl
AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
+ AC_MSG_CHECKING([for int64_t])
AC_CACHE_VAL(glibcxx_cv_INT64_T, [
AC_TRY_COMPILE(
[#include <stdint.h>],
[glibcxx_cv_INT64_T=no])
])
if test $glibcxx_cv_INT64_T = yes; then
- AC_DEFINE(HAVE_INT64_T)
+ AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
fi
+ AC_MSG_RESULT($glibcxx_cv_INT64_T)
])
AC_LANG_CPLUSPLUS
ac_save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS -fno-exceptions"
+ AC_MSG_CHECKING([for LFS support])
AC_CACHE_VAL(glibcxx_cv_LFS, [
AC_TRY_LINK(
[#include <unistd.h>
[glibcxx_cv_LFS=no])
])
if test $glibcxx_cv_LFS = yes; then
- AC_DEFINE(_GLIBCXX_USE_LFS)
+ AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
fi
+ AC_MSG_RESULT($glibcxx_cv_LFS)
CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
])
AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
if test $enable_fully_dynamic_string = yes; then
- AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING)
+ AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
+ [Define if a fully dynamic basic_string is wanted.])
fi
])
dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
dnl
dnl Sets:
-dnl enable_abi_check / GLIBCXX_TEST_ABI
+dnl enable_abi_check
dnl GLIBCXX_TEST_WCHAR_T
dnl GLIBCXX_TEST_THREAD
dnl Substs:
dnl baseline_dir
dnl
AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
- if $GLIBCXX_IS_NATIVE && test $is_hosted = yes; then
+ if $GLIBCXX_IS_NATIVE ; then
# Do checks for resource limit functions.
GLIBCXX_CHECK_SETRLIMIT
# Look for setenv, so that extended locale tests can be performed.
GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
+ fi
- if test $enable_symvers = no; then
- enable_abi_check=no
- else
- case "$host" in
- *-*-cygwin*)
- enable_abi_check=no ;;
- *)
- enable_abi_check=yes ;;
- esac
- fi
+ if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
+ test $enable_symvers != no; then
+ case "$host" in
+ *-*-cygwin*)
+ enable_abi_check=no ;;
+ *)
+ enable_abi_check=yes ;;
+ esac
else
# Only build this as native, since automake does not understand
# CXX_FOR_BUILD.
enable_abi_check=no
fi
-
+
# Export file names for ABI checking.
baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
AC_SUBST(baseline_dir)
-
- GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes)
- GLIBCXX_CONDITIONAL(GLIBCXX_TEST_THREAD, test $enable_thread = yes)
- GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes)
])
# 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='${prefix}/include/c++/${gcc_version}'
fi
# Version-specific runtime libs processing.
# is selected. FIXME: these variables are misnamed, there are
# no executables installed in _toolexecdir or _toolexeclibdir.
if test x"$gxx_include_dir" = x"no"; then
- gxx_include_dir='${libdir}/gcc/${host_alias}/'$gcc_version/include/c++
+ gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
fi
glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
- glibcxx_toolexeclibdir='${toolexecdir}/'$gcc_version'$(MULTISUBDIR)'
+ glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
fi
# Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
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_LANG_CPLUSPLUS
# Check for the existence of <math.h> functions used if C99 is enabled.
- ac_c99_math=yes;
AC_MSG_CHECKING([for ISO C99 support in <math.h>])
- AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
+ AC_CACHE_VAL(ac_c99_math, [
AC_TRY_COMPILE([#include <math.h>],
- [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],
- [islessgreater(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],
- [isunordered(0.0,0.0);],, [ac_c99_math=no])
+ [fpclassify(0.0);
+ isfinite(0.0);
+ isinf(0.0);
+ isnan(0.0);
+ isnormal(0.0);
+ signbit(0.0);
+ isgreater(0.0,0.0);
+ isgreaterequal(0.0,0.0);
+ isless(0.0,0.0);
+ islessequal(0.0,0.0);
+ islessgreater(0.0,0.0);
+ islessgreater(0.0,0.0);
+ isunordered(0.0,0.0);
+ ],[ac_c99_math=yes], [ac_c99_math=no])
+ ])
AC_MSG_RESULT($ac_c99_math)
-
if test x"$ac_c99_math" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_MATH)
+ AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
+ [Define if C99 functions or macros in <math.h> should be imported
+ in <cmath> in namespace std.])
+ fi
+
+ # Check for the existence of <complex.h> complex math functions.
+ # This is necessary even though libstdc++ uses the builtin versions
+ # of these functions, because if the builtin cannot be used, a reference
+ # to the library function is emitted.
+ AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+ ac_c99_complex=no;
+ if test x"$ac_has_complex_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
+ AC_TRY_COMPILE([#include <complex.h>],
+ [typedef __complex__ float float_type; float_type tmpf;
+ cabsf(tmpf);
+ cargf(tmpf);
+ ccosf(tmpf);
+ ccoshf(tmpf);
+ cexpf(tmpf);
+ clogf(tmpf);
+ csinf(tmpf);
+ csinhf(tmpf);
+ csqrtf(tmpf);
+ ctanf(tmpf);
+ ctanhf(tmpf);
+ cpowf(tmpf, tmpf);
+ typedef __complex__ double double_type; double_type tmpd;
+ cabs(tmpd);
+ carg(tmpd);
+ ccos(tmpd);
+ ccosh(tmpd);
+ cexp(tmpd);
+ clog(tmpd);
+ csin(tmpd);
+ csinh(tmpd);
+ csqrt(tmpd);
+ ctan(tmpd);
+ ctanh(tmpd);
+ cpow(tmpd, tmpd);
+ typedef __complex__ long double ld_type; ld_type tmpld;
+ cabsl(tmpld);
+ cargl(tmpld);
+ ccosl(tmpld);
+ ccoshl(tmpld);
+ cexpl(tmpld);
+ clogl(tmpld);
+ csinl(tmpld);
+ csinhl(tmpld);
+ csqrtl(tmpld);
+ ctanl(tmpld);
+ ctanhl(tmpld);
+ cpowl(tmpld, tmpld);
+ ],[ac_c99_complex=yes], [ac_c99_complex=no])
+ fi
+ AC_MSG_RESULT($ac_c99_complex)
+ if test x"$ac_c99_complex" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
+ [Define if C99 functions in <complex.h> should be used in
+ <complex>. Using compiler builtins for these functions requires
+ corresponding C99 library functions to be present.])
fi
# Check for the existence in <stdio.h> of vscanf, et. al.
- ac_c99_stdio=yes;
AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
- AC_TRY_COMPILE([#include <stdio.h>],
- [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vfscanf(stderr, "%i", args);}],
- [],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vscanf("%i", args);}],
- [],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vsnprintf(fmt, 0, "%i", args);}],
- [],, [ac_c99_stdio=no])
+ AC_CACHE_VAL(ac_c99_stdio, [
AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
+ #include <stdarg.h>
void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vsscanf(fmt, "%i", args);}],
- [],, [ac_c99_stdio=no])
+ {
+ va_list args; va_start(args, fmt);
+ vfscanf(stderr, "%i", args);
+ vscanf("%i", args);
+ vsnprintf(fmt, 0, "%i", args);
+ vsscanf(fmt, "%i", args);
+ }],
+ [snprintf("12", 0, "%i");],
+ [ac_c99_stdio=yes], [ac_c99_stdio=no])
+ ])
AC_MSG_RESULT($ac_c99_stdio)
# Check for the existence in <stdlib.h> of lldiv_t, et. al.
- ac_c99_stdlib=yes;
- AC_MSG_CHECKING([for lldiv_t declaration])
- AC_CACHE_VAL(ac_c99_lldiv_t, [
- AC_TRY_COMPILE([#include <stdlib.h>],
- [ lldiv_t mydivt;],
- [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
- ])
- AC_MSG_RESULT($ac_c99_lldiv_t)
-
AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
+ AC_CACHE_VAL(ac_c99_stdlib, [
AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
- if test x"$ac_c99_lldiv_t" = x"no"; then
- ac_c99_stdlib=no;
- fi;
+ [char* tmp;
+ strtof("gnu", &tmp);
+ strtold("gnu", &tmp);
+ strtoll("gnu", &tmp, 10);
+ strtoull("gnu", &tmp, 10);
+ llabs(10);
+ lldiv(10,1);
+ atoll("10");
+ _Exit(0);
+ lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
+ ])
AC_MSG_RESULT($ac_c99_stdlib)
- # Check for the existence of <wchar.h> functions used if C99 is enabled.
- # XXX the wchar.h checks should be rolled into the general C99 bits.
- ac_c99_wchar=yes;
- AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
- AC_MSG_RESULT($ac_c99_wchar)
+ # 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)
+ ac_c99_wchar=no;
+ 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 ::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])
+
+ # Checks for wide character functions that may not be present.
+ # Injection of these is wrapped with guard macros.
+ # NB: only put functions here, instead of immediately above, if
+ # absolutely necessary.
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vfwscanf; } ], [],
+ [AC_DEFINE(HAVE_VFWSCANF,1,
+ [Defined if vfwscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vswscanf; } ], [],
+ [AC_DEFINE(HAVE_VSWSCANF,1,
+ [Defined if vswscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vwscanf; } ], [],
+ [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::wcstof; } ], [],
+ [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
+
+ AC_TRY_COMPILE([#include <wctype.h>],
+ [ wint_t t; int i = iswblank(t);],
+ [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
- AC_MSG_CHECKING([for enabled ISO C99 support])
+ # Option parsed, now set things appropriately.
if test x"$ac_c99_math" = x"no" ||
+ test x"$ac_c99_complex" = x"no" ||
test x"$ac_c99_stdio" = x"no" ||
test x"$ac_c99_stdlib" = x"no" ||
test x"$ac_c99_wchar" = x"no"; then
enable_c99=no;
- fi;
- AC_MSG_RESULT($enable_c99)
-
- if test x"$ac_99_math" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_MATH)
- fi
-
- # Option parsed, now set things appropriately
- if test x"$enable_c99" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99)
+ else
+ AC_DEFINE(_GLIBCXX_USE_C99, 1,
+ [Define if C99 functions or macros from <wchar.h>, <math.h>,
+ <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
fi
AC_LANG_RESTORE
+ fi
+
+ AC_MSG_CHECKING([for fully enabled ISO C99 support])
+ AC_MSG_RESULT($enable_c99)
])
# ... at some point put __strxfrm_l tests in as well.
;;
- darwin*)
+ darwin* | freebsd*)
enable_clocale_flag=darwin
;;
*)
CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
;;
darwin)
- AC_MSG_RESULT(darwin)
+ AC_MSG_RESULT(darwin or freebsd)
CLOCALE_H=config/locale/generic/c_locale.h
CLOCALE_CC=config/locale/generic/c_locale.cc
AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
fi
if test $USE_NLS = yes; then
- AC_DEFINE(_GLIBCXX_USE_NLS)
+ AC_DEFINE(_GLIBCXX_USE_NLS, 1,
+ [Define if NLS translations are to be used.])
fi
AC_SUBST(USE_NLS)
dnl Default is new.
dnl
AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
- AC_MSG_CHECKING([for std::allocator base class to use])
+ AC_MSG_CHECKING([for std::allocator base class])
GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
[use KIND for target std::allocator base],
[permit new|malloc|mt|bitmap|pool|yes|no|auto])
AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
if test $enable_concept_checks = yes; then
- AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
+ AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
+ [Define to use concept checking code from the boost libraries.])
fi
])
dnl
-dnl Check for wide character support. Has the same effect as the option
-dnl in gcc's configure, but in a form that autoconf can mess with.
-dnl
-dnl --enable-c-mbchar requests all the wchar_t stuff.
-dnl --disable-c-mbchar doesn't.
-dnl + Usage: GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
-dnl Where DEFAULT is either `yes' or `no'.
-dnl
-AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [
- GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters])
- # Option parsed, now other scripts can test enable_c_mbchar for yes/no.
-])
-
-
-dnl
dnl Check to see if debugging libraries are to be built.
dnl
dnl --enable-libstdcxx-debug
dnl
-dnl Check for template specializations for the 'long long' type extension.
+dnl Check for template specializations for the 'long long' type.
dnl The result determines only whether 'long long' I/O is enabled; things
dnl like numeric_limits<> specializations are always available.
dnl
dnl Where DEFAULT is either `yes' or `no'.
dnl
AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
- GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long'])
+ GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
if test $enable_long_long = yes; then
- AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
+ AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
+ [Define if code specialized for long long should be used.])
+ fi
+ AC_MSG_CHECKING([for enabled long long specializations])
+ AC_MSG_RESULT([$enable_long_long])
+])
+
+
+dnl
+dnl Check for template specializations for the 'wchar_t' type.
+dnl
+dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
+dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
+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
+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
+ 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])
])
enable_sjlj_exceptions=yes
elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
enable_sjlj_exceptions=no
+ elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
+ enable_sjlj_exceptions=no
fi
fi
CXXFLAGS="$old_CXXFLAGS"
GLIBCXX_ENABLE(symvers,$1,[=STYLE],
[enables symbol versioning of the shared library],
- [permit yes|no|gnu])
+ [permit yes|no|gnu|darwin-export])
# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
# don't know enough about $LD to do tricks...
AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
-# FIXME The following test is too strict, in theory.
-if test $enable_shared = no ||
- test "x$LD" = x ||
- test x$glibcxx_gnu_ld_version = x; then
- enable_symvers=no
+
+# Turn a 'yes' into a suitable default.
+if test x$enable_symvers = xyes ; then
+ if test $enable_shared = no ||
+ test "x$LD" = x ; then
+ enable_symvers=no
+ elif test $with_gnu_ld = yes ; then
+ enable_symvers=gnu
+ else
+ case ${target_os} in
+ darwin*)
+ enable_symvers=darwin-export ;;
+ *)
+ AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
+ AC_MSG_WARN([=== you are not using a supported linker.])
+ AC_MSG_WARN([=== Symbol versioning will be disabled.])
+ enable_symvers=no ;;
+ esac
+ fi
fi
# Check to see if libgcc_s exists, indicating that shared libgcc is possible.
AC_MSG_RESULT($glibcxx_shared_libgcc)
fi
-# For GNU ld, we need at least this version. The format is described in
-# GLIBCXX_CHECK_LINKER_FEATURES above.
-glibcxx_min_gnu_ld_version=21400
-# XXXXXXXXXXX glibcxx_gnu_ld_version=21390
+# If no shared libgcc, can't win.
+if test $glibcxx_shared_libgcc != yes &&
+ test $enable_symvers != no ; then
+ AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
+ AC_MSG_WARN([=== you are not building a shared libgcc_s.])
+ AC_MSG_WARN([=== Symbol versioning will be disabled.])
+ enable_symvers=no
+ enable_symvers=no
+fi
+
+# Check to see if 'gnu' can win.
+if test $enable_symvers = gnu; then
+ # For GNU ld, we need at least this version. The format is described in
+ # GLIBCXX_CHECK_LINKER_FEATURES above.
+ glibcxx_min_gnu_ld_version=21400
-# Check to see if unspecified "yes" value can win, given results above.
-# Change "yes" into either "no" or a style name.
-if test $enable_symvers = yes; then
- if test $with_gnu_ld = yes &&
- test $glibcxx_shared_libgcc = yes;
- then
- if test $glibcxx_gnu_ld_version -ge $glibcxx_min_gnu_ld_version ; then
- enable_symvers=gnu
- else
- # The right tools, the right setup, but too old. Fallbacks?
- AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
- AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
- AC_MSG_WARN(=== You would need to upgrade your binutils to version)
- AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
- if test $glibcxx_gnu_ld_version -ge 21200 ; then
- # Globbing fix is present, proper block support is not.
- dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.])
- dnl enable_symvers=???
- AC_MSG_WARN([=== Symbol versioning will be disabled.])
- enable_symvers=no
- else
- # 2.11 or older.
- AC_MSG_WARN([=== Symbol versioning will be disabled.])
- enable_symvers=no
- fi
- fi
- else
+ if test $with_gnu_ld != yes ; then
# just fail for now
- AC_MSG_WARN([=== You have requested some kind of symbol versioning, but])
- AC_MSG_WARN([=== either you are not using a supported linker, or you are])
- AC_MSG_WARN([=== not building a shared libgcc_s (which is required).])
+ AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
+ AC_MSG_WARN([=== you are not using the GNU linker.])
+ AC_MSG_WARN([=== Symbol versioning will be disabled.])
+ enable_symvers=no
+ elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
+ # The right tools, the right setup, but too old. Fallbacks?
+ AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
+ AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
+ AC_MSG_WARN(=== You would need to upgrade your binutils to version)
+ AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
AC_MSG_WARN([=== Symbol versioning will be disabled.])
enable_symvers=no
fi
;;
gnu)
SYMVER_MAP=config/linker-map.gnu
- AC_DEFINE(_GLIBCXX_SYMVER)
+ AC_DEFINE(_GLIBCXX_SYMVER, 1,
+ [Define to use GNU symbol versioning in the shared library.])
+ ;;
+ darwin-export)
+ SYMVER_MAP=config/linker-map.gnu
;;
esac
+# In addition, need this to deal with std::size_t mangling in
+# src/compatibility.cc. In a perfect world, could use
+# typeid(std::size_t).name()[0] to do direct substitution.
+AC_MSG_CHECKING([for size_t as unsigned int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
+ [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_size_t_is_i" = yes; then
+ AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
+fi
+AC_MSG_RESULT([$glibcxx_size_t_is_i])
+
+AC_MSG_CHECKING([for ptrdiff_t as int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
+ [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_ptrdiff_t_is_i" = yes; then
+ AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
+fi
+AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
+
AC_SUBST(SYMVER_MAP)
AC_SUBST(port_specific_symbol_files)
-GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
+GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN_EXPORT, dnl
+ test $enable_symvers = darwin-export)
AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
])
AC_MSG_RESULT([$target_thread_file])
if test $target_thread_file != single; then
- AC_DEFINE(HAVE_GTHR_DEFAULT)
+ AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
+ [Define if gthr-default.h exists
+ (meaning that threading support is enabled).])
fi
glibcxx_thread_h=gthr-$target_thread_file.h
[AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
if test $ac_cv_val_LC_MESSAGES = yes; then
- AC_DEFINE(HAVE_LC_MESSAGES)
+ AC_DEFINE(HAVE_LC_MESSAGES, 1,
+ [Define if LC_MESSAGES is available in <locale.h>.])
fi
])
])
-sinclude([../libtool.m4])
-dnl The lines below arrange for aclocal not to bring an installed
-dnl libtool.m4 into aclocal.m4, while still arranging for automake to
-dnl add a definition of LIBTOOL to Makefile.in.
-ifelse(,,,[AC_SUBST(LIBTOOL)
-AC_DEFUN([AM_PROG_LIBTOOL])
-AC_DEFUN([AC_LIBTOOL_DLOPEN])
-AC_DEFUN([AC_PROG_LD])
-])
-
dnl vim:et:ts=2:sw=2