diff options
Diffstat (limited to 'contrib/libstdc++/acinclude.m4')
| -rw-r--r-- | contrib/libstdc++/acinclude.m4 | 2186 |
1 files changed, 2186 insertions, 0 deletions
diff --git a/contrib/libstdc++/acinclude.m4 b/contrib/libstdc++/acinclude.m4 new file mode 100644 index 000000000000..9950f93cf8be --- /dev/null +++ b/contrib/libstdc++/acinclude.m4 @@ -0,0 +1,2186 @@ +dnl +dnl Initialize configure bits. +dnl +dnl GLIBCPP_CONFIGURE +AC_DEFUN(GLIBCPP_CONFIGURE, [ + dnl Default to --enable-multilib + AC_ARG_ENABLE(multilib, + [ --enable-multilib build hella library versions (default)], + [case "${enableval}" in + yes) multilib=yes ;; + no) multilib=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;; + esac], [multilib=yes])dnl + + # When building with srcdir == objdir, links to the source files will + # be created in directories within the target_subdir. We have to + # adjust toplevel_srcdir accordingly, so that configure finds + # install-sh and other auxiliary files that live in the top-level + # source directory. + if test "${srcdir}" = "."; then + if test -z "${with_target_subdir}"; then + toprel=".." + else + if test "${with_target_subdir}" != "."; then + toprel="${with_multisrctop}../.." + else + toprel="${with_multisrctop}.." + fi + fi + else + toprel=".." + fi + AC_CONFIG_AUX_DIR(${srcdir}/$toprel) + toplevel_srcdir=\${top_srcdir}/$toprel + AC_SUBST(toplevel_srcdir) + + # Export build and source directories. + # These need to be absolute paths, yet at the same time need to + # canonicalize only relative paths, because then amd will not unmount + # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd. + glibcpp_builddir=`pwd` + case $srcdir in + [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;; + *) glibcpp_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;; + esac + AC_SUBST(glibcpp_builddir) + AC_SUBST(glibcpp_srcdir) + + dnl This is here just to satisfy automake. + ifelse(not,equal,[AC_CONFIG_AUX_DIR(..)]) + + AC_PROG_AWK + # Will set LN_S to either 'ln -s' or 'ln'. With autoconf 2.5x, can also + # be 'cp -p' if linking isn't available. + #ac_cv_prog_LN_S='cp -p' + AC_PROG_LN_S + + # We use these options to decide which functions to include. + AC_ARG_WITH(target-subdir, + [ --with-target-subdir=SUBDIR + configuring in a subdirectory]) + AC_ARG_WITH(cross-host, + [ --with-cross-host=HOST configuring with a cross compiler]) + + glibcpp_basedir=$srcdir/$toprel/$1/libstdc++-v3 + AC_SUBST(glibcpp_basedir) + + # Never versions of autoconf add an underscore to these functions. + # Prevent future problems ... + ifdef([AC_PROG_CC_G],[],[define([AC_PROG_CC_G],defn([_AC_PROG_CC_G]))]) + ifdef([AC_PROG_CC_GNU],[],[define([AC_PROG_CC_GNU],defn([_AC_PROG_CC_GNU]))]) + ifdef([AC_PROG_CXX_G],[],[define([AC_PROG_CXX_G],defn([_AC_PROG_CXX_G]))]) + ifdef([AC_PROG_CXX_GNU],[],[define([AC_PROG_CXX_GNU],defn([_AC_PROG_CXX_GNU]))]) + + # AC_PROG_CC + # FIXME: We temporarily define our own version of AC_PROG_CC. This is + # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We + # are probably using a cross compiler, which will not be able to fully + # link an executable. This is addressed in later versions of autoconf. + + AC_DEFUN(LIB_AC_PROG_CC, + [AC_BEFORE([$0], [AC_PROG_CPP])dnl + dnl Fool anybody using AC_PROG_CC. + AC_PROVIDE([AC_PROG_CC]) + AC_CHECK_PROG(CC, gcc, gcc) + if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) + test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) + fi + + AC_PROG_CC_GNU + + if test $ac_cv_prog_gcc = yes; then + GCC=yes + dnl Check whether -g works, even if CFLAGS is set, in case the package + dnl plays around with CFLAGS (such as to build both debugging and + dnl normal versions of a library), tasteless as that idea is. + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + AC_PROG_CC_G + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-O2" + fi + else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" + fi + ]) + + LIB_AC_PROG_CC + + # Likewise for AC_PROG_CXX. We can't just call it directly because g++ + # will try to link in libstdc++. + AC_DEFUN(LIB_AC_PROG_CXX, + [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl + dnl Fool anybody using AC_PROG_CXX. + AC_PROVIDE([AC_PROG_CXX]) + # Use glibcpp_CXX so that we do not cause CXX to be cached with the + # flags that come in CXX while configuring libstdc++. They're different + # from those used for all other target libraries. If CXX is set in + # the environment, respect that here. + glibcpp_CXX=$CXX + AC_CHECK_PROGS(glibcpp_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc) + AC_SUBST(glibcpp_CXX) + CXX=$glibcpp_CXX + test -z "$glibcpp_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH]) + + AC_PROG_CXX_GNU + + if test $ac_cv_prog_gxx = yes; then + GXX=yes + dnl Check whether -g works, even if CXXFLAGS is set, in case the package + dnl plays around with CXXFLAGS (such as to build both debugging and + dnl normal versions of a library), tasteless as that idea is. + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + AC_PROG_CXX_G + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-O2" + fi + else + GXX= + test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" + fi + ]) + + LIB_AC_PROG_CXX + + # For some reason, gettext needs this. + AC_ISC_POSIX + + AC_CHECK_TOOL(AS, as) + AC_CHECK_TOOL(AR, ar) + AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error) + AC_PROG_INSTALL + + AM_MAINTAINER_MODE + + # We need AC_EXEEXT to keep automake happy in cygnus mode. However, + # at least currently, we never actually build a program, so we never + # need to use $(EXEEXT). Moreover, the test for EXEEXT normally + # fails, because we are probably configuring with a cross compiler + # which can't create executables. So we include AC_EXEEXT to keep + # automake happy, but we don't execute it, since we don't care about + # the result. + if false; then + # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands + # to nothing, so nothing would remain between `then' and `fi' if it + # were not for the `:' below. + : + AC_EXEEXT + fi + + . [$]{glibcpp_basedir}/configure.host + + case [$]{glibcpp_basedir} in + /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;; + *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;; + esac + + # This does for the target what configure.host does for the host. In + # addition to possibly modifying the same flags, it also sets up symlinks. + GLIBCPP_CHECK_TARGET + +]) + + +dnl +dnl Check to see if g++ can compile this library, and if so, if any version- +dnl specific precautions need to be taken. +dnl +dnl GLIBCPP_CHECK_COMPILER_VERSION +AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [ +if test ! -f stamp-sanity-compiler; then + AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE(, [ + #if __GNUC__ < 3 + not_ok + #endif + ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to GCC 3.0 or above])) + AC_LANG_RESTORE + AC_MSG_RESULT($gpp_satisfactory) + touch stamp-sanity-compiler +fi +]) + + +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 be placed here. +dnl +dnl Define WERROR='-Werror' if requested and possible; g++'s that lack the +dnl new inlining code or the new system_header pragma will die on -Werror. +dnl Leave it out by default and use maint-mode to use it. +dnl +dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if +dnl compiler supports it and the user has not requested debug mode. +dnl +dnl GLIBCPP_CHECK_COMPILER_FEATURES +AC_DEFUN(GLIBCPP_CHECK_COMPILER_FEATURES, [ + # All these tests are for C++; save the language and the compiler flags. + # The CXXFLAGS thing is suspicious, but based on similar bits previously + # found in GLIBCPP_CONFIGURE. + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + + # Check for maintainer-mode bits. + if test x"$USE_MAINTAINER_MODE" = xno; then + WERROR='' + else + WERROR='-Werror' + fi + + # Check for -ffunction-sections -fdata-sections + AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections]) + CXXFLAGS='-Werror -ffunction-sections -fdata-sections' + AC_TRY_COMPILE(, [int foo; + ], [ac_fdsections=yes], [ac_fdsections=no]) + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + else + # this is the suspicious part + CXXFLAGS='' + fi + if test x"$ac_fdsections" = x"yes" && + test x"$enable_debug" = x"no"; then + SECTION_FLAGS='-ffunction-sections -fdata-sections' + fi + AC_MSG_RESULT($ac_fdsections) + + AC_LANG_RESTORE + AC_SUBST(WERROR) + AC_SUBST(SECTION_FLAGS) +]) + + +dnl +dnl If GNU ld is in use, check to see if tricky linker opts can be used. If +dnl the native linker is in use, all variables will be defined to something +dnl safe (like an empty string). +dnl +dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible. +dnl Define OPT_LDFLAGS='-Wl,-O1' if possible. +dnl Define LD, with_gnu_ld, and (possibly) glibcpp_gnu_ld_version as +dnl side-effects of testing. +dnl +dnl GLIBCPP_CHECK_LINKER_FEATURES +AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [ + # If we're not using GNU ld, then there's no point in even trying these + # tests. Check for that first. We should have already tested for gld + # by now (in libtool), but require it now just to be safe... + test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' + test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' + AC_REQUIRE([AC_PROG_LD]) + + # The name set by libtool depends on the version of libtool. Shame on us + # for depending on an impl detail, but c'est la vie. Older versions used + # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on + # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually + # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't + # set (hence we're using an older libtool), then set it. + if test x${with_gnu_ld+set} != xset; then + if test x${ac_cv_prog_gnu_ld+set} != xset; then + # We got through "ac_require(ac_prog_ld)" and still not set? Huh? + with_gnu_ld=no + else + with_gnu_ld=$ac_cv_prog_gnu_ld + fi + fi + + # Start by getting the version number. I think the libtool test already + # does some of this, but throws away the result. + changequote(,) + ldver=`$LD --version 2>/dev/null | head -1 | \ + sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'` + changequote([,]) + glibcpp_gnu_ld_version=`echo $ldver | \ + $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'` + + # Set --gc-sections. + if test "$with_gnu_ld" = "notbroken"; then + # GNU ld it is! Joy and bunny rabbits! + + # 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++ + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + 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]) + 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 + AC_MSG_RESULT($ac_sectionLDflags) + fi + + # Set linker optimization flags. + if test x"$with_gnu_ld" = x"yes" && test x"$enable_debug" = x"no"; then + OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" + fi + + AC_SUBST(SECTION_LDFLAGS) + AC_SUBST(OPT_LDFLAGS) +]) + + +dnl +dnl Check to see if the (math function) argument passed is +dnl declared when using the c++ compiler +dnl ASSUMES argument is a math function with ONE parameter +dnl +dnl GLIBCPP_CHECK_MATH_DECL_1 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <math.h> + #ifdef HAVE_IEEEFP_H + #include <ieeefp.h> + #endif + ], + [ $1(0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) +]) + +dnl +dnl Check to see if the (math function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl 3) if not, see if 1) and 2) for argument prepended with '_' +dnl +dnl Define HAVE_CARGF etc if "cargf" is declared and links +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a math function with ONE parameter +dnl +dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [ + GLIBCPP_CHECK_MATH_DECL_1($1) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_CHECK_FUNCS($1) + else + GLIBCPP_CHECK_MATH_DECL_1(_$1) + if test x$glibcpp_cv_func__$1_use = x"yes"; then + AC_CHECK_FUNCS(_$1) + fi + fi +]) + + +dnl +dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of +dnl of functions at once. It's an all-or-nothing check -- either +dnl HAVE_XYZ is defined for each of the functions, or for none of them. +dnl Doing it this way saves significant configure time. +AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [ + AC_MSG_CHECKING([for $1 functions]) + AC_CACHE_VAL(glibcpp_cv_func_$2_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <math.h>], + [ `for x in $3; do echo "$x (0);"; done` ], + [glibcpp_cv_func_$2_use=yes], + [glibcpp_cv_func_$2_use=no]) + AC_LANG_RESTORE]) + AC_MSG_RESULT($glibcpp_cv_func_$2_use) + if test x$glibcpp_cv_func_$2_use = x"yes"; then + AC_CHECK_FUNCS($3) + fi +]) + +dnl +dnl Check to see if the (math function) argument passed is +dnl declared when using the c++ compiler +dnl ASSUMES argument is a math function with TWO parameters +dnl +dnl GLIBCPP_CHECK_MATH_DECL_2 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_2, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <math.h>], + [ $1(0, 0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) +]) + +dnl +dnl Check to see if the (math function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl +dnl Define HAVE_CARGF etc if "cargf" is declared and links +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a math function with TWO parameters +dnl +dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [ + GLIBCPP_CHECK_MATH_DECL_2($1) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_CHECK_FUNCS($1) + else + GLIBCPP_CHECK_MATH_DECL_2(_$1) + if test x$glibcpp_cv_func__$1_use = x"yes"; then + AC_CHECK_FUNCS(_$1) + fi + fi +]) + + +dnl +dnl Check to see if the (math function) argument passed is +dnl declared when using the c++ compiler +dnl ASSUMES argument is a math function with THREE parameters +dnl +dnl GLIBCPP_CHECK_MATH_DECL_3 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_3, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <math.h>], + [ $1(0, 0, 0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) +]) + +dnl +dnl Check to see if the (math function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl +dnl Define HAVE_CARGF etc if "cargf" is declared and links +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a math function with THREE parameters +dnl +dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3 +AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [ + GLIBCPP_CHECK_MATH_DECL_3($1) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_CHECK_FUNCS($1) + else + GLIBCPP_CHECK_MATH_DECL_3(_$1) + if test x$glibcpp_cv_func__$1_use = x"yes"; then + AC_CHECK_FUNCS(_$1) + fi + fi +]) + + +dnl +dnl Check to see if the (stdlib function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a math function with TWO parameters +dnl +dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2 +AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <stdlib.h>], + [ $1(0, 0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_CHECK_FUNCS($1) + fi +]) + + +dnl +dnl Check to see if the (stdlib function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a function with THREE parameters +dnl +dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3 +AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <stdlib.h>], + [ $1(0, 0, 0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_CHECK_FUNCS($1) + fi +]) + + +dnl +dnl Because the builtins are picky picky picky about the arguments they take, +dnl do an explict linkage tests here. +dnl Check to see if the (math function) argument passed is +dnl 1) declared when using the c++ compiler +dnl 2) has "C" linkage +dnl +dnl Define HAVE_CARGF etc if "cargf" is declared and links +dnl +dnl argument 1 is name of function to check +dnl +dnl ASSUMES argument is a math function with ONE parameter +dnl +dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1 +AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [ + AC_MSG_CHECKING([for $1 declaration]) + if test x${glibcpp_cv_func_$1_use+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_use, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <math.h>], + [ $1(0);], + [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no]) + AC_LANG_RESTORE + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_use) + if test x$glibcpp_cv_func_$1_use = x"yes"; then + AC_MSG_CHECKING([for $1 linkage]) + if test x${glibcpp_cv_func_$1_link+set} != xset; then + AC_CACHE_VAL(glibcpp_cv_func_$1_link, [ + AC_TRY_LINK([#include <math.h>], + [ $1(0);], + [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no]) + ]) + fi + AC_MSG_RESULT($glibcpp_cv_func_$1_link) + if test x$glibcpp_cv_func_$1_link = x"yes"; then + ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + AC_DEFINE_UNQUOTED(${ac_tr_func}) + fi + fi +]) + + +dnl +dnl Check to see what builtin math functions are supported +dnl +dnl check for __builtin_abs +dnl check for __builtin_fabsf +dnl check for __builtin_fabs +dnl check for __builtin_fabl +dnl check for __builtin_labs +dnl check for __builtin_sqrtf +dnl check for __builtin_sqrtl +dnl check for __builtin_sqrt +dnl check for __builtin_sinf +dnl check for __builtin_sin +dnl check for __builtin_sinl +dnl check for __builtin_cosf +dnl check for __builtin_cos +dnl check for __builtin_cosl +dnl +dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [ + dnl Test for builtin math functions. + dnl These are made in gcc/c-common.c + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs) + + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl) + + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl) + + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos) + GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl) + + dnl There is, without a doubt, a more elegant way to have these + dnl names exported so that they won't be stripped out of acconfig.h by + dnl autoheader. I leave this as an exercise to somebody less frustrated + dnl than I.... please email the libstdc++ list if you can figure out a + dnl more elegant approach (see autoconf/acgen.m4 and specifically + dnl AC_CHECK_FUNC for things to steal.) + dummyvar=no + if test x$dummyvar = x"yes"; then + AC_DEFINE(HAVE___BUILTIN_ABS) + AC_DEFINE(HAVE___BUILTIN_LABS) + AC_DEFINE(HAVE___BUILTIN_COS) + AC_DEFINE(HAVE___BUILTIN_COSF) + AC_DEFINE(HAVE___BUILTIN_COSL) + AC_DEFINE(HAVE___BUILTIN_FABS) + AC_DEFINE(HAVE___BUILTIN_FABSF) + AC_DEFINE(HAVE___BUILTIN_FABSL) + AC_DEFINE(HAVE___BUILTIN_SIN) + AC_DEFINE(HAVE___BUILTIN_SINF) + AC_DEFINE(HAVE___BUILTIN_SINL) + AC_DEFINE(HAVE___BUILTIN_SQRT) + AC_DEFINE(HAVE___BUILTIN_SQRTF) + AC_DEFINE(HAVE___BUILTIN_SQRTL) + fi +]) + + +dnl +dnl Check to see what the underlying c library +dnl These checks need to do two things: +dnl 1) make sure the name is declared when using the c++ compiler +dnl 2) make sure the name has "C" linkage +dnl This might seem like overkill but experience has shown that it's not... +dnl +dnl Define HAVE_STRTOLD if "strtold" is declared and links +dnl Define HAVE_STRTOF if "strtof" is declared and links +dnl Define HAVE_DRAND48 if "drand48" is declared and links +dnl +dnl GLIBCPP_CHECK_STDLIB_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [ + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS='-fno-builtins -D_GNU_SOURCE' + + GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold) + GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof) + AC_CHECK_FUNCS(drand48) + + CXXFLAGS="$ac_save_CXXFLAGS" +]) + + +dnl +dnl Check to see what the underlying c library or math library is like. +dnl These checks need to do two things: +dnl 1) make sure the name is declared when using the c++ compiler +dnl 2) make sure the name has "C" linkage +dnl This might seem like overkill but experience has shown that it's not... +dnl +dnl Define HAVE_CARGF etc if "cargf" is found. +dnl +dnl GLIBCPP_CHECK_MATH_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [ + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS='-fno-builtins -D_GNU_SOURCE' + + dnl Check libm + AC_CHECK_LIB(m, sin, libm="-lm") + ac_save_LIBS="$LIBS" + LIBS="$LIBS $libm" + + dnl Check to see if certain C math functions exist. + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypot) + + dnl Check to see if basic C math functions have float versions. + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig, + float_trig, + acosf asinf atanf \ + cosf sinf tanf \ + coshf sinhf tanhf) + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round, + float_round, + ceilf floorf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef) + + dnl Check to see if basic C math functions have long double versions. + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig, + long_double_trig, + acosl asinl atanl \ + cosl sinl tanl \ + coshl sinhl tanhl) + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round, + long_double_round, + ceill floorl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl) + GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel) + + dnl Some runtimes have these functions with a preceding underscore. Please + dnl keep this sync'd with the one above. And if you add any new symbol, + dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h. + dnl Check to see if certain C math functions exist. + + dnl Check to see if basic C math functions have float versions. + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig, + _float_trig, + _acosf _asinf _atanf \ + _cosf _sinf _tanf \ + _coshf _sinhf _tanhf) + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round, + _float_round, + _ceilf _floorf) + + dnl Check to see if basic C math functions have long double versions. + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig, + _long_double_trig, + _acosl _asinl _atanl \ + _cosl _sinl _tanl \ + _coshl _sinhl _tanhl) + GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round, + _long_double_round, + _ceill _floorl) + + LIBS="$ac_save_LIBS" + CXXFLAGS="$ac_save_CXXFLAGS" +]) + + +dnl +dnl Check to see if there is native support for complex +dnl +dnl Don't compile bits in math/* if native support exits. +dnl +dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found. +dnl +dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [ + dnl Check for complex versions of math functions of platform. + AC_CHECK_LIB(m, main) + AC_REPLACE_MATHFUNCS(nan copysignf) + + dnl For __signbit to signbit conversions. + AC_CHECK_FUNCS([__signbit], , [LIBMATHOBJS="$LIBMATHOBJS signbit.lo"]) + AC_CHECK_FUNCS([__signbitf], , [LIBMATHOBJS="$LIBMATHOBJS signbitf.lo"]) + + dnl Compile the long double complex functions only if the function + dnl provides the non-complex long double functions that are needed. + dnl Currently this includes copysignl, which should be + dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above. + if test x$ac_cv_func_copysignl = x"yes"; then + AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"]) + fi + + AC_SUBST(LIBMATHOBJS) +]) + + +dnl Check to see what architecture and operating system we are compiling +dnl for. Also, if architecture- or OS-specific flags are required for +dnl compilation, pick them up here. +dnl +dnl GLIBCPP_CHECK_TARGET +AC_DEFUN(GLIBCPP_CHECK_TARGET, [ + . [$]{glibcpp_basedir}/configure.target + AC_MSG_RESULT(CPU config directory is $cpu_include_dir) + AC_MSG_RESULT(OS config directory is $os_include_dir) +]) + + +dnl +dnl Check to see if this target can enable the wchar_t parts of libstdc++. +dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled. (This +dnl must have been previously checked.) +dnl +dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found +dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h +dnl +dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [ + + dnl Test wchar.h for mbstate_t, which is needed for char_traits and + dnl 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 + + dnl 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) + + dnl 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 + + dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before + dnl 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) + + dnl Test wchar.h for WEOF, which is what we use to determine whether + dnl 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) + + dnl 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) + + dnl Checks for names injected into std:: by the c_std headers. + AC_CHECK_FUNCS(btowc wctob fgetwc fgetwc fgetws fputwc fputws fwide \ + fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf \ + vwprintf vwscanf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \ + mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstof wcstol \ + wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \ + wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr,, \ + ac_wfuncs=no) + + 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) + + dnl Use iconv for wchar_t to char conversions. As such, check for + dnl X/Open Portability Guide, version 2 features (XPG2). + AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no) + AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no) + + dnl Check for existence of libiconv.a providing XPG2 wchar_t support. + AC_CHECK_LIB(iconv, iconv, libiconv="-liconv") + ac_save_LIBS="$LIBS" + LIBS="$LIBS $libiconv" + + AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \ + ac_XPG2funcs=yes, ac_XPG2funcs=no) + + 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) + + dnl At the moment, only enable wchar_t specializations if all the + dnl above support is present. + AC_MSG_CHECKING([for enabled wchar_t specializations]) + if test x"$ac_isoC99_wchar_t" = xyes && + test x"$ac_XPG2_wchar_t" = xyes; then + AC_DEFINE(_GLIBCPP_USE_WCHAR_T) + AC_MSG_RESULT("yes") + else + AC_MSG_RESULT("no") + fi + else + dnl Wide characters disabled by the user. + AC_MSG_WARN([wchar_t support disabled.]) + fi +]) + + +dnl +dnl Check for special debugging mode; not for production use. +dnl +dnl GLIBCPP_ENABLE_DEBUG +dnl --enable-debug sets '-ggdb3 -O0'. +dnl --disable-debug sets '-g' and whatever optimization options the +dnl compiler can handle. +dnl + --enable-maintainer-mode automatically defaults this to on. +dnl + Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...? +dnl + Usage: GLIBCPP_ENABLE_DEBUG[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl +define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(debug, +changequote(<<, >>)dnl +<< --enable-debug extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT], +changequote([, ])dnl +[case "${enableval}" in + yes) enable_debug=yes ;; + no) enable_debug=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;; + esac], +enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl + +dnl Option parsed, now set things appropriately +case "${enable_debug}" in + yes) + DEBUG_FLAGS='-O0 -ggdb3' + ;; + no) + DEBUG_FLAGS='-g' + ;; +esac +AC_SUBST(DEBUG_FLAGS) +]) + + +dnl +dnl Check for "unusual" flags to pass to the compiler while building. +dnl +dnl GLIBCPP_ENABLE_CXX_FLAGS +dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing +dnl experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc. +dnl Somehow this same set of flags must be passed when [re]building +dnl libgcc. +dnl --disable-cxx-flags passes nothing. +dnl + See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html +dnl http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html +dnl http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html +dnl + Usage: GLIBCPP_ENABLE_CXX_FLAGS(default flags) +dnl If "default flags" is an empty string (or "none"), the effect is +dnl the same as --disable or --enable=no. +AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl +define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl +AC_ARG_ENABLE(cxx-flags, +changequote(<<, >>)dnl +<< --enable-cxx-flags=FLAGS pass compiler FLAGS when building library; + [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], +changequote([, ])dnl +[case "x$enableval" in + xyes) + AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;; + xno|x) + enable_cxx_flags='' ;; + *) + enable_cxx_flags="$enableval" ;; + esac], +enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT') + +dnl Thinko on my part during design. This kludge is the workaround. +if test "$enable_cxx_flags" = "none"; then + enable_cxx_flags=''; +fi + +dnl Run through flags (either default or command-line) and set anything +dnl extra (e.g., #defines) that must accompany particular g++ options. +if test -n "$enable_cxx_flags"; then + for f in $enable_cxx_flags; do + case "$f" in + -fhonor-std) ;; + -*) ;; + *) # and we're trying to pass /what/ exactly? + AC_MSG_ERROR([compiler flags start with a -]) ;; + esac + done +fi +EXTRA_CXX_FLAGS="$enable_cxx_flags" +AC_SUBST(EXTRA_CXX_FLAGS) +]) + + +dnl +dnl Check for which locale library to use: gnu or generic. +dnl +dnl GLIBCPP_ENABLE_CLOCALE +dnl --enable-clocale=gnu sets config/locale/c_locale_gnu.cc and friends +dnl --enable-clocale=generic sets config/locale/c_locale_generic.cc and friends +dnl +dnl default is generic +dnl +AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [ + AC_MSG_CHECKING([for clocale to use]) + AC_ARG_ENABLE(clocale, + [ --enable-clocale enable model for target locale package. + --enable-clocale=MODEL use MODEL target-speific locale package. [default=generic] + ], + if test x$enable_clocale = xno; then + enable_clocale=no + fi, + enable_clocale=no) + + enable_clocale_flag=$enable_clocale + + dnl Probe for locale support if no specific model is specified. + dnl Default to "generic" + if test x$enable_clocale_flag = xno; then + case x${target_os} in + xlinux* | xgnu*) + AC_EGREP_CPP([_GLIBCPP_ok], [ + #include <features.h> + #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) + _GLIBCPP_ok + #endif + ], enable_clocale_flag=gnu, enable_clocale_flag=generic) + + # Test for bugs early in glibc-2.2.x series + if test x$enable_clocale_flag = xgnu; then + AC_TRY_RUN([ + #define _GNU_SOURCE 1 + #include <locale.h> + int main() + { + const char __one[] = "Äuglein Augmen"; + const char __two[] = "Äuglein"; + int i; + int j; + __locale_t loc; + __locale_t loc_dup; + loc = __newlocale(1 << LC_ALL, "de_DE", 0); + loc_dup = __duplocale(loc); + i = __strcoll_l(__one, __two, loc); + j = __strcoll_l(__one, __two, loc_dup); + return 0; + } + ], + [enable_clocale_flag=gnu],[enable_clocale_flag=generic], + [enable_clocale_flag=generic]) + fi + + # ... at some point put __strxfrm_l tests in as well. + ;; + *) + enable_clocale_flag=generic + ;; + esac + fi + + dnl Deal with gettext issues. + AC_ARG_ENABLE(nls, + [ --enable-nls use Native Language Support (default)], + , enable_nls=yes) + USE_NLS=no + + dnl Set configure bits for specified locale package + case x${enable_clocale_flag} in + xgeneric) + AC_MSG_RESULT(generic) + + CLOCALE_H=config/locale/generic/c_locale.h + CLOCALE_CC=config/locale/generic/c_locale.cc + CCODECVT_H=config/locale/generic/codecvt_specializations.h + CCOLLATE_CC=config/locale/generic/collate_members.cc + CCTYPE_CC=config/locale/generic/ctype_members.cc + CMESSAGES_H=config/locale/generic/messages_members.h + CMESSAGES_CC=config/locale/generic/messages_members.cc + CMONEY_CC=config/locale/generic/monetary_members.cc + CNUMERIC_CC=config/locale/generic/numeric_members.cc + CTIME_CC=config/locale/generic/time_members.cc + ;; + xgnu) + AC_MSG_RESULT(gnu) + + # Declare intention to use gettext, and add support for specific + # languages. + # For some reason, ALL_LINGUAS has to be before AM_GNU_GETTEXT + ALL_LINGUAS="de fr" + + # Don't call AM_GNU_GETTEXT here. Instead, assume glibc. + AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no) + if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then + USE_NLS=yes + fi + + # Export the build objects. + for ling in $ALL_LINGUAS; do \ + glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \ + glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \ + done + AC_SUBST(glibcpp_MOFILES) + AC_SUBST(glibcpp_POFILES) + + CLOCALE_H=config/locale/gnu/c_locale.h + CLOCALE_CC=config/locale/gnu/c_locale.cc + CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h + CCOLLATE_CC=config/locale/gnu/collate_members.cc + CCTYPE_CC=config/locale/gnu/ctype_members.cc + CMESSAGES_H=config/locale/gnu/messages_members.h + CMESSAGES_CC=config/locale/gnu/messages_members.cc + CMONEY_CC=config/locale/gnu/monetary_members.cc + CNUMERIC_CC=config/locale/gnu/numeric_members.cc + CTIME_CC=config/locale/gnu/time_members.cc + ;; + xieee_1003.1-2001) + AC_MSG_RESULT(generic) + + CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h + CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc + CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h + CCOLLATE_CC=config/locale/generic/collate_members.cc + CCTYPE_CC=config/locale/generic/ctype_members.cc + CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h + CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc + CMONEY_CC=config/locale/generic/monetary_members.cc + CNUMERIC_CC=config/locale/generic/numeric_members.cc + CTIME_CC=config/locale/generic/time_members.cc + ;; + *) + echo "$enable_clocale is an unknown locale package" 1>&2 + exit 1 + ;; + esac + + # This is where the testsuite looks for locale catalogs, using the + # -DLOCALEDIR define during testsuite compilation. + glibcpp_localedir=${glibcpp_builddir}/po/share/locale + AC_SUBST(glibcpp_localedir) + + AC_SUBST(USE_NLS) + AC_SUBST(CLOCALE_H) + AC_SUBST(CCODECVT_H) + AC_SUBST(CMESSAGES_H) + AC_LINK_FILES($CLOCALE_CC, src/c++locale.cc) + AC_LINK_FILES($CCOLLATE_CC, src/collate.cc) + AC_LINK_FILES($CCTYPE_CC, src/ctype.cc) + AC_LINK_FILES($CMESSAGES_CC, src/messages.cc) + AC_LINK_FILES($CMONEY_CC, src/monetary.cc) + AC_LINK_FILES($CNUMERIC_CC, src/numeric.cc) + AC_LINK_FILES($CTIME_CC, src/time.cc) +]) + + +dnl +dnl Check for which I/O library to use: libio, or something specific. +dnl +dnl GLIBCPP_ENABLE_CSTDIO +dnl --enable-cstdio=libio sets config/io/c_io_libio.h and friends +dnl +dnl default is stdio +dnl +AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [ + AC_MSG_CHECKING([for cstdio to use]) + AC_ARG_ENABLE(cstdio, + [ --enable-cstdio enable stdio for target io package. + --enable-cstdio=LIB use LIB target-speific io package. [default=stdio] + ], + if test x$enable_cstdio = xno; then + enable_cstdio=stdio + fi, + enable_cstdio=stdio) + + enable_cstdio_flag=$enable_cstdio + + dnl Check if a valid I/O package + case x${enable_cstdio_flag} in + xlibio) + CSTDIO_H=config/io/c_io_libio.h + BASIC_FILE_H=config/io/basic_file_libio.h + BASIC_FILE_CC=config/io/basic_file_libio.cc + AC_MSG_RESULT(libio) + + # see if we are on a system with libio native (ie, linux) + AC_CHECK_HEADER(libio.h, has_libio=yes, has_libio=no) + + # Need to check and see what version of glibc is being used. If + # it's not glibc-2.2 or higher, then we'll need to go ahead and + # compile most of libio for linux systems. + if test x$has_libio = x"yes"; then + case "$target" in + *-*-linux*) + AC_MSG_CHECKING([for glibc version >= 2.2]) + AC_EGREP_CPP([ok], [ + #include <features.h> + #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) + ok + #endif + ], glibc_satisfactory=yes, glibc_satisfactory=no) + AC_MSG_RESULT($glibc_satisfactory) + ;; + esac + + # XXX at the moment, admit defeat and force the recompilation + # XXX of glibc even on glibc-2.2 systems, because libio is not synched. + glibc_satisfactory=no + + if test x$glibc_satisfactory = x"yes"; then + need_libio=no + need_wlibio=no + else + need_libio=yes + # bkoz XXX need to add checks to enable this + # pme XXX here's a first pass at such a check + if test x$enable_c_mbchar != xno; then + need_wlibio=yes + else + need_wlibio=no + fi + fi + + else + # Using libio, but <libio.h> doesn't exist on the target system. . . + need_libio=yes + # bkoz XXX need to add checks to enable this + # pme XXX here's a first pass at such a check + if test x$enable_c_mbchar != xno; then + need_wlibio=yes + else + need_wlibio=no + fi + fi + ;; + xstdio | x | xno | xnone | xyes) + # default + CSTDIO_H=config/io/c_io_stdio.h + BASIC_FILE_H=config/io/basic_file_stdio.h + BASIC_FILE_CC=config/io/basic_file_stdio.cc + AC_MSG_RESULT(stdio) + + # We're not using stdio. + need_libio=no + need_wlibio=no + ;; + *) + echo "$enable_cstdio is an unknown io package" 1>&2 + exit 1 + ;; + esac + AC_SUBST(CSTDIO_H) + AC_SUBST(BASIC_FILE_H) + AC_LINK_FILES($BASIC_FILE_CC, src/basic_file.cc) + + # 2000-08-04 bkoz hack + CCODECVT_C=config/io/c_io_libio_codecvt.c + AC_SUBST(CCODECVT_C) + # 2000-08-04 bkoz hack + + AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO, + test "$need_libio" = yes || test "$need_wlibio" = yes) + AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes) + AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes) + if test "$need_libio" = yes || test "$need_wlibio" = yes; then + libio_la=../libio/libio.la + else + libio_la= + fi + AC_SUBST(libio_la) +]) + + +dnl +dnl Setup to use the gcc gthr.h thread-specific memory and mutex model. +dnl We must stage the required headers so that they will be installed +dnl with the library (unlike libgcc, the STL implementation is provided +dnl solely within headers). Since we must not inject random user-space +dnl macro names into user-provided C++ code, we first stage into <file>-in +dnl and process to <file> with an output command. The reason for a two- +dnl stage process here is to correctly handle $srcdir!=$objdir without +dnl having to write complex code (the sed commands to clean the macro +dnl namespace are complex and fragile enough as it is). We must also +dnl add a relative path so that -I- is supported properly. +dnl +AC_DEFUN(GLIBCPP_ENABLE_THREADS, [ + AC_MSG_CHECKING([for thread model used by GCC]) + target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` + AC_MSG_RESULT([$target_thread_file]) + + if test $target_thread_file != single; then + AC_DEFINE(HAVE_GTHR_DEFAULT) + AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__) + fi + + glibcpp_thread_h=gthr-$target_thread_file.h + AC_SUBST(glibcpp_thread_h) +]) + + +dnl +dnl Check for exception handling support. If an explicit enable/disable +dnl sjlj exceptions is given, we don't have to detect. Otherwise the +dnl target may or may not support call frame exceptions. +dnl +dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS +dnl --enable-sjlj-exceptions forces the use of builtin setjmp. +dnl --disable-sjlj-exceptions forces the use of call frame unwinding. +dnl +dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it. +dnl +AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [ + AC_MSG_CHECKING([for exception model to use]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_ARG_ENABLE(sjlj-exceptions, + [ --enable-sjlj-exceptions force use of builtin_setjmp for exceptions], + [:], + [dnl Botheration. Now we've got to detect the exception model. + dnl Link tests against libgcc.a are problematic since -- at least + dnl as of this writing -- we've not been given proper -L bits for + dnl single-tree newlib and libgloss. + dnl + dnl This is what AC_TRY_COMPILE would do if it didn't delete the + dnl conftest files before we got a change to grep them first. + cat > conftest.$ac_ext << EOF +[#]line __oline__ "configure" +struct S { ~S(); }; +void bar(); +void foo() +{ + S s; + bar(); +} +EOF + old_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="-S -fexceptions" + if AC_TRY_EVAL(ac_compile); then + if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then + enable_sjlj_exceptions=yes + elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then + enable_sjlj_exceptions=no + fi + fi + CXXFLAGS="$old_CXXFLAGS" + rm -f conftest*]) + if test x$enable_sjlj_exceptions = xyes; then + AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1, + [Define if the compiler is configured for setjmp/longjmp exceptions.]) + ac_exception_model_name=sjlj + elif test x$enable_sjlj_exceptions = xno; then + ac_exception_model_name="call frame" + else + AC_MSG_ERROR([unable to detect exception model]) + fi + AC_LANG_RESTORE + AC_MSG_RESULT($ac_exception_model_name) +]) + + +dnl +dnl Check for libunwind exception handling support. If enabled then +dnl we assume that the _Unwind_* functions that make up the Unwind ABI +dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by +dnl libunwind instead of libgcc and that libstdc++ has a dependency +dnl on libunwind as well as libgcc. +dnl +dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS +dnl --enable-libunwind-exceptions forces the use of libunwind. +dnl --disable-libunwind-exceptions assumes there is no libunwind. +dnl +dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested. +dnl +AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [ + AC_MSG_CHECKING([for use of libunwind]) + AC_ARG_ENABLE(libunwind-exceptions, + [ --enable-libunwind-exceptions force use of libunwind for exceptions], + use_libunwind_exceptions=$enableval, + use_libunwind_exceptions=no) + AC_MSG_RESULT($use_libunwind_exceptions) + dnl Option parsed, now set things appropriately + if test x"$use_libunwind_exceptions" = xyes; then + LIBUNWIND_FLAG="-lunwind" + else + LIBUNWIND_FLAG="" + fi + AC_SUBST(LIBUNWIND_FLAG) +]) + +dnl +dnl Check for ISO/IEC 9899:1999 "C99" support. +dnl +dnl GLIBCPP_ENABLE_C99 +dnl --enable-c99 defines _GLIBCPP_USE_C99 +dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined +dnl + Usage: GLIBCPP_ENABLE_C99[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If omitted, it +dnl defaults to `no'. +dnl + If 'C99' stuff is not available, ignores DEFAULT and sets `no'. +dnl +dnl GLIBCPP_ENABLE_C99 +AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl + define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl + + AC_ARG_ENABLE(c99, + changequote(<<, >>)dnl + <<--enable-c99 turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT], + changequote([, ])dnl + [case "$enableval" in + yes) enable_c99=yes ;; + no) enable_c99=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;; + esac], + enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl + + 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_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]) + AC_MSG_RESULT($ac_c99_math) + + # 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_TRY_COMPILE([#include <stdio.h> + #include <stdarg.h> + void foo(char* fmt, ...) + {va_list args; va_start(args, fmt); + vsscanf(fmt, "%i", args);}], + [],, [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_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; + 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) + + AC_MSG_CHECKING([for enabled ISO C99 support]) + if test x"$ac_c99_math" = 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) + + # Option parsed, now set things appropriately + if test x"$enable_c99" = x"yes"; then + AC_DEFINE(_GLIBCPP_USE_C99) + fi + + AC_LANG_RESTORE +]) + + +dnl +dnl Check for template specializations for the 'long long' type extension. +dnl The result determines only whether 'long long' I/O is enabled; things +dnl like numeric_limits<> specializations are always available. +dnl +dnl GLIBCPP_ENABLE_LONG_LONG +dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG +dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined +dnl + Usage: GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If omitted, it +dnl defaults to `no'. +dnl + If 'long long' stuff is not available, ignores DEFAULT and sets `no'. +dnl +dnl GLIBCPP_ENABLE_LONG_LONG +AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl + define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl + + AC_ARG_ENABLE(long-long, + changequote(<<, >>)dnl + <<--enable-long-long turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT], + changequote([, ])dnl + [case "$enableval" in + yes) enable_long_long=yes ;; + no) enable_long_long=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;; + esac], + enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl + + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + + AC_MSG_CHECKING([for enabled long long I/O support]) + # iostreams require strtoll, strtoull to compile + AC_TRY_COMPILE([#include <stdlib.h>], + [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no]) + AC_TRY_COMPILE([#include <stdlib.h>], + [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no]) + + # Option parsed, now set things appropriately + if test x"$enable_long_long" = xyes; then + AC_DEFINE(_GLIBCPP_USE_LONG_LONG) + fi + AC_MSG_RESULT($enable_long_long) + + AC_LANG_RESTORE +]) + + +dnl +dnl Check for what kind of C headers to use. +dnl +dnl GLIBCPP_ENABLE_CHEADERS +dnl --enable-cheaders= [does stuff]. +dnl --disable-cheaders [does not do anything, really]. +dnl + This will eventually need to be 'c_shadow' by default. +dnl + Usage: GLIBCPP_ENABLE_CHEADERS[(DEFAULT)] +dnl Where DEFAULT is either `c' or `c_std' or 'c_shadow'. +dnl If ommitted, it defaults to `c_std'. +AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl +define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl +AC_MSG_CHECKING([for c header strategy to use]) +AC_ARG_ENABLE(cheaders, +changequote(<<, >>)dnl +<< --enable-cheaders construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT], +changequote([, ]) + [case "$enableval" in + c) + enable_cheaders=c + ;; + c_std) + enable_cheaders=c_std + ;; + c_shadow) + enable_cheaders=c_shadow + ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable "C" headers]) + ;; + esac], + enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT) + AC_MSG_RESULT($enable_cheaders) + + dnl Option parsed, now set things appropriately + case "$enable_cheaders" in + c_shadow) + CSHADOW_FLAGS="-fno-builtin" + C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_shadow' + ;; + c_std) + CSHADOW_FLAGS="" + C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std' + ;; + c) + CSHADOW_FLAGS="" + C_INCLUDE_DIR='${glibcpp_srcdir}/include/c' + ;; + esac + + AC_SUBST(CSHADOW_FLAGS) + AC_SUBST(C_INCLUDE_DIR) + AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c) + AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std) +]) + + +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 GLIBCPP_ENABLE_C_MBCHAR +dnl --enable-c-mbchar requests all the wchar_t stuff. +dnl --disable-c-mbchar doesn't. +dnl + Usage: GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl +define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(c-mbchar, +changequote(<<, >>)dnl +<< --enable-c-mbchar enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], +changequote([, ])dnl +[case "$enableval" in + yes) enable_c_mbchar=yes ;; + no) enable_c_mbchar=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;; + esac], +enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl +dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no. +]) + + +dnl +dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's. +dnl +dnl TOPLEVEL_INCLUDES +dnl LIBMATH_INCLUDES +dnl LIBSUPCXX_INCLUDES +dnl LIBIO_INCLUDES +dnl CSHADOW_INCLUDES +dnl +dnl GLIBCPP_EXPORT_INCLUDES +AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [ + # Root level of the build directory include sources. + GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include" + + # Passed down for canadian crosses. + if test x"$CANADIAN" = xyes; then + TOPLEVEL_INCLUDES='-I$(includedir)' + fi + + LIBMATH_INCLUDES='-I$(top_srcdir)/libmath' + + LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++' + + if test x"$need_libio" = xyes; then + LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio' + AC_SUBST(LIBIO_INCLUDES) + fi + + # Now, export this to all the little Makefiles.... + AC_SUBST(GLIBCPP_INCLUDES) + AC_SUBST(TOPLEVEL_INCLUDES) + AC_SUBST(LIBMATH_INCLUDES) + AC_SUBST(LIBSUPCXX_INCLUDES) +]) + + +dnl +dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's. +dnl +AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [ + # Optimization flags that are probably a good idea for thrill-seekers. Just + # uncomment the lines below and make, everything else is ready to go... + # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc + OPTIMIZE_CXXFLAGS= + AC_SUBST(OPTIMIZE_CXXFLAGS) + + WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline' + AC_SUBST(WARN_FLAGS) +]) + +dnl +dnl GLIBCPP_EXPORT_INSTALL_INFO +dnl calculates gxx_install_dir +dnl exports glibcpp_toolexecdir +dnl exports glibcpp_toolexeclibdir +dnl exports glibcpp_prefixdir +dnl +dnl Assumes cross_compiling bits already done, and with_cross_host in +dnl particular +dnl +dnl GLIBCPP_EXPORT_INSTALL_INFO +AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [ +# Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and +# exported correctly in GLIBCPP_CONFIGURE. +glibcpp_toolexecdir=no +glibcpp_toolexeclibdir=no +glibcpp_prefixdir=${prefix} + +AC_MSG_CHECKING([for interface version number]) +libstdcxx_interface=$INTERFACE +AC_MSG_RESULT($libstdcxx_interface) + +# Process the option --with-gxx-include-dir=<path to include-files directory> +AC_MSG_CHECKING([for --with-gxx-include-dir]) +AC_ARG_WITH(gxx-include-dir, +[ --with-gxx-include-dir the installation directory for include files], +[case "${withval}" in + yes) + AC_MSG_ERROR(Missing directory for --with-gxx-include-dir) + gxx_include_dir=no + ;; + no) + gxx_include_dir=no + ;; + *) + gxx_include_dir=${withval} + ;; +esac], [gxx_include_dir=no]) +AC_MSG_RESULT($gxx_include_dir) + +# Process the option "--enable-version-specific-runtime-libs" +AC_MSG_CHECKING([for --enable-version-specific-runtime-libs]) +AC_ARG_ENABLE(version-specific-runtime-libs, +[ --enable-version-specific-runtime-libs Specify that runtime libraries should be installed in a compiler-specific directory ], +[case "$enableval" in + yes) version_specific_libs=yes ;; + no) version_specific_libs=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);; + esac], +version_specific_libs=no)dnl +# Option set, now we can test it. +AC_MSG_RESULT($version_specific_libs) + +if test $version_specific_libs = yes; then + # Need the gcc compiler version to know where to install libraries + # and header files if --enable-version-specific-runtime-libs option + # is selected. + changequote(,)dnl + gcc_version_trigger=${srcdir}/../gcc/version.c + gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'` + gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'` + if test x"$gxx_include_dir" = x"no"; then + gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/g++ + fi + glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)' + glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)' + changequote([,])dnl +fi + +# 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/g++-${libstdcxx_interface} +fi + +# Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir +# Install a library built with a cross compiler in tooldir, not libdir. +if test x"$glibcpp_toolexecdir" = x"no"; then + if test -n "$with_cross_host" && + test x"$with_cross_host" != x"no"; then + glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)' + glibcpp_toolexeclibdir='$(toolexecdir)/lib$(MULTISUBDIR)' + else + glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)' + glibcpp_toolexeclibdir='$(libdir)$(MULTISUBDIR)' + fi +fi + +AC_MSG_CHECKING([for install location]) +AC_MSG_RESULT($gxx_include_dir) + +AC_SUBST(glibcpp_prefixdir) +AC_SUBST(gxx_include_dir) +AC_SUBST(glibcpp_toolexecdir) +AC_SUBST(glibcpp_toolexeclibdir) +]) + + +# Check for functions in math library. +# Ulrich Drepper <drepper@cygnus.com>, 1998. +# +# This file can be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +# serial 1 + +dnl AC_REPLACE_MATHFUNCS(FUNCTION...) +AC_DEFUN(AC_REPLACE_MATHFUNCS, +[AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])]) + + +dnl This macro searches for a GNU version of make. If a match is found, the +dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is +dnl set to "#". This is useful for including a special features in a Makefile, +dnl which cannot be handled by other versions of make. The variable +dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists, +dnl the empty string otherwise. +dnl +dnl Here is an example of its use: +dnl +dnl Makefile.in might contain: +dnl +dnl # A failsafe way of putting a dependency rule into a makefile +dnl $(DEPEND): +dnl $(CC) -MM $(srcdir)/*.c > $(DEPEND) +dnl +dnl @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND))) +dnl @ifGNUmake@ include $(DEPEND) +dnl @ifGNUmake@ endif +dnl +dnl Then configure.in would normally contain: +dnl +dnl CHECK_GNU_MAKE() +dnl AC_OUTPUT(Makefile) +dnl +dnl Then perhaps to cause gnu make to override any other make, we could do +dnl something like this (note that GNU make always looks for GNUmakefile first): +dnl +dnl if ! test x$_cv_gnu_make_command = x ; then +dnl mv Makefile GNUmakefile +dnl echo .DEFAULT: > Makefile ; +dnl echo \ $_cv_gnu_make_command \$@ >> Makefile; +dnl fi +dnl +dnl Then, if any (well almost any) other make is called, and GNU make also +dnl exists, then the other make wraps the GNU make. +dnl +dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au> +dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme +dnl +dnl #### Changes for libstdc++-v3: reformatting and linewrapping; prepending +dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the +dnl #### conditional's subshell (" --version" is not a command), using a +dnl #### different option to grep(1). +dnl #### -pme +dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not +dnl #### ${MAKE:-make}). +dnl #### -msokolov +AC_DEFUN( + GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command, + _cv_gnu_make_command='' ; +dnl Search all the common names for GNU make + for a in "${MAKE-make}" make gmake gnumake ; do + if ( $a --version 2> /dev/null | grep -c GNU > /dev/null ) + then + _cv_gnu_make_command=$a ; + break; + fi + done ; + ) ; +dnl If there was a GNU version, then set @ifGNUmake@ to the empty +dnl string, '#' otherwise + if test "x$_cv_gnu_make_command" != "x" ; then + ifGNUmake='' ; + else + ifGNUmake='#' ; + fi + AC_SUBST(ifGNUmake) +]) + + +dnl Check for headers for, and arguments to, the setrlimit() function. +dnl Used only in testsuite_hooks.h. +AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [ + AC_TRY_COMPILE([#include <sys/resource.h> + #include <unistd.h> + ], [ int f = RLIMIT_$1 ; ], + [glibcpp_mresult=1], [glibcpp_mresult=0]) + AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult, + [Only used in build directory testsuite_hooks.h.]) +]) +AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [ + setrlimit_have_headers=yes + AC_CHECK_HEADERS(sys/resource.h unistd.h, + [], + setrlimit_have_headers=no) + # If don't have the headers, then we can't run the tests now, and we + # won't be seeing any of these during testsuite compilation. + if test $setrlimit_have_headers = yes; then + # Can't do these in a loop, else the resulting syntax is wrong. + GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA) + GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS) + GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM) + GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS) + + # Check for rlimit, setrlimit. + AC_CACHE_VAL(ac_setrlimit, [ + AC_TRY_COMPILE([#include <sys/resource.h> + #include <unistd.h> + ], + [ struct rlimit r; setrlimit(0, &r);], + [ac_setrlimit=yes], [ac_setrlimit=no]) + ]) + fi + + AC_MSG_CHECKING([for testsuite memory limit support]) + if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then + ac_mem_limits=yes + AC_DEFINE(_GLIBCPP_MEM_LIMITS) + else + ac_mem_limits=no + fi + AC_MSG_RESULT($ac_mem_limits) +]) + + +dnl +dnl Does any necessary configuration of the testsuite directory. Generates +dnl the testsuite_hooks.h header. +dnl +dnl GLIBCPP_CONFIGURE_TESTSUITE [no args] +AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [ + GLIBCPP_CHECK_SETRLIMIT + + # Look for setenv, so that extended locale tests can be performed. + GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv) +]) + + +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]) +]) + + +# Check whether LC_MESSAGES is available in <locale.h>. +# Ulrich Drepper <drepper@cygnus.com>, 1995. +# +# This file file be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +# serial 1 + +AC_DEFUN(AC_LC_MESSAGES, [ + AC_CHECK_HEADER(locale.h, [ + AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, + [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) + fi + ]) +]) + + +dnl +dnl Check for whether the Boost-derived checks should be turned on. +dnl +dnl GLIBCPP_ENABLE_CONCEPT_CHECKS +dnl --enable-concept-checks turns them on. +dnl --disable-concept-checks leaves them off. +dnl + Usage: GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl +define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(concept-checks, +changequote(<<, >>)dnl +<< --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], +changequote([, ])dnl +[case "$enableval" in + yes) enable_concept_checks=yes ;; + no) enable_concept_checks=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;; + esac], +enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl +dnl Option parsed, now set things appropriately +if test x"$enable_concept_checks" = xyes; then + AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS) +fi +]) + + +dnl +dnl Add version tags to symbols in shared library (or not), additionally +dnl marking other symbols as private/local (or not). +dnl +dnl GLIBCPP_ENABLE_SYMVERS +dnl --enable-symvers=style adds a version script to the linker call when +dnl creating the shared library. The choice of version script is +dnl controlled by 'style'. +dnl --disable-symvers does not. +dnl + Usage: GLIBCPP_ENABLE_SYMVERS[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. Passing `yes' tries to choose a default style +dnl based on linker characteristics. Passing 'no' disables versioning. +AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl +define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(symvers, +changequote(<<, >>)dnl +<< --enable-symvers=style enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT], +changequote([, ])dnl +[case "$enableval" in + yes) enable_symvers=yes ;; + no) enable_symvers=no ;; + # other names here, just as sanity checks + #gnu|sun|etcetera) enable_symvers=$enableval ;; + gnu) enable_symvers=$enableval ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;; + esac], +enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl + +# If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we +# don't know enough about $LD to do tricks... +if test x$enable_shared = xno || + test x$LD = x || + test x$glibcpp_gnu_ld_version = x; then + enable_symvers=no +fi + +# Check to see if libgcc_s exists, indicating that shared libgcc is possible. +AC_MSG_CHECKING([for shared libgcc]) +ac_save_CFLAGS="$CFLAGS" +CFLAGS=' -lgcc_s' +AC_TRY_LINK( , [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no) +CFLAGS="$ac_save_CFLAGS" +AC_MSG_RESULT($glibcpp_shared_libgcc) + +# For GNU ld, we need at least this version. It's 2.12 in the same format +# as the tested-for version. See GLIBCPP_CHECK_LINKER_FEATURES for more. +glibcpp_min_gnu_ld_version=21200 + +# Check to see if unspecified "yes" value can win, given results +# above. +if test $enable_symvers = yes ; then + if test $with_gnu_ld = yes && + test $glibcpp_shared_libgcc = yes ; + then + if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then + enable_symvers=gnu + else + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS='-shared -Wl,--version-script,conftest.map' + enable_symvers=no + changequote(,) + echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map + changequote([,]) + AC_TRY_LINK([int foo;],, enable_symvers=gnu) + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + else + # this is the suspicious part + CFLAGS='' + fi + rm -f conftest.map + fi + else + # just fail for now + enable_symvers=no + fi +fi + +dnl Everything parsed; figure out what file to use. +case $enable_symvers in + no) + LINKER_MAP=config/linker-map.dummy + ;; + gnu) + LINKER_MAP=config/linker-map.gnu + ;; +esac + +AC_LINK_FILES($LINKER_MAP, src/linker.map) +AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no) +AC_MSG_CHECKING([versioning on shared library symbols]) +AC_MSG_RESULT($enable_symvers) +]) + |