libstdc++-v3/acinclude.m4

   1 dnl
   2 dnl Initialize basic configure bits, set toplevel_srcdir for Makefiles.
   3 dnl
   4 dnl GLIBCPP_TOPREL_CONFIGURE
   5 AC_DEFUN(GLIBCPP_TOPREL_CONFIGURE, [
   6   dnl Default to --enable-multilib (this is also passed by default
   7   dnl from the ubercommon-top-level configure)
   8   AC_ARG_ENABLE(multilib,
   9   [  --enable-multilib       build hella library versions (default)],
  10   [case "${enableval}" in
  11     yes) multilib=yes ;;
  12     no)  multilib=no ;;
  13     *)   AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
  14    esac], [multilib=yes])dnl
  15
  16   # When building with srcdir == objdir, links to the source files will
  17   # be created in directories within the target_subdir.  We have to
  18   # adjust toplevel_srcdir accordingly, so that configure finds
  19   # install-sh and other auxiliary files that live in the top-level
  20   # source directory.
  21   if test "${srcdir}" = "."; then
  22     if test -z "${with_target_subdir}"; then
  23       toprel=".."
  24     else
  25       if test "${with_target_subdir}" != "."; then
  26         toprel="${with_multisrctop}../.."
  27       else
  28         toprel="${with_multisrctop}.."
  29       fi
  30     fi
  31   else
  32     toprel=".."
  33   fi
  34   AC_CONFIG_AUX_DIR(${srcdir}/$toprel)
  35   toplevel_srcdir=\${top_srcdir}/$toprel
  36   AC_SUBST(toplevel_srcdir)
  37 ])
  38
  39 dnl
  40 dnl Initialize the rest of the library configury.
  41 dnl
  42 dnl GLIBCPP_CONFIGURE
  43 AC_DEFUN(GLIBCPP_CONFIGURE, [
  44   # Export build and source directories.
  45   # These need to be absolute paths, yet at the same time need to
  46   # canonicalize only relative paths, because then amd will not unmount
  47   # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
  48   glibcpp_builddir=`${PWDCMD-pwd}`
  49   case $srcdir in
  50   [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;;
  51   *) glibcpp_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
  52   esac
  53   AC_SUBST(glibcpp_builddir)
  54   AC_SUBST(glibcpp_srcdir)
  55
  56   dnl This is here just to satisfy automake.
  57   ifelse(not,equal,[AC_CONFIG_AUX_DIR(..)])
  58
  59   AC_PROG_AWK
  60   # Will set LN_S to either 'ln -s' or 'ln'.  With autoconf 2.5x, can also
  61   # be 'cp -p' if linking isn't available.  Uncomment the next line to
  62   # force a particular method.
  63   #ac_cv_prog_LN_S='cp -p'
  64   AC_PROG_LN_S
  65
  66   # We use these options to decide which functions to include.
  67   AC_ARG_WITH(target-subdir,
  68   [  --with-target-subdir=SUBDIR
  69                           configuring in a subdirectory])
  70   AC_ARG_WITH(cross-host,
  71   [  --with-cross-host=HOST  configuring with a cross compiler])
  72
  73   AC_ARG_WITH(newlib,
  74   [  --with-newlib                    Configuring with newlib])
  75
  76   glibcpp_basedir=$srcdir/$toprel/$1/libstdc++-v3
  77   AC_SUBST(glibcpp_basedir)
  78
  79   # Never versions of autoconf add an underscore to these functions.
  80   # Prevent future problems ...
  81   ifdef([AC_PROG_CC_G],[],[define([AC_PROG_CC_G],defn([_AC_PROG_CC_G]))])
  82   ifdef([AC_PROG_CC_GNU],[],[define([AC_PROG_CC_GNU],defn([_AC_PROG_CC_GNU]))])
  83   ifdef([AC_PROG_CXX_G],[],[define([AC_PROG_CXX_G],defn([_AC_PROG_CXX_G]))])
  84   ifdef([AC_PROG_CXX_GNU],[],[define([AC_PROG_CXX_GNU],defn([_AC_PROG_CXX_GNU]))])
  85
  86   # AC_PROG_CC
  87   # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
  88   # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
  89   # are probably using a cross compiler, which will not be able to fully
  90   # link an executable.  This is addressed in later versions of autoconf.
  91
  92   AC_DEFUN(LIB_AC_PROG_CC,
  93   [AC_BEFORE([$0], [AC_PROG_CPP])dnl
  94   dnl Fool anybody using AC_PROG_CC.
  95   AC_PROVIDE([AC_PROG_CC])
  96   AC_CHECK_PROG(CC, gcc, gcc)
  97   if test -z "$CC"; then
  98     AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
  99     test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
 100   fi
 101
 102   AC_PROG_CC_GNU
 103
 104   if test $ac_cv_prog_gcc = yes; then
 105     GCC=yes
 106   dnl Check whether -g works, even if CFLAGS is set, in case the package
 107   dnl plays around with CFLAGS (such as to build both debugging and
 108   dnl normal versions of a library), tasteless as that idea is.
 109     ac_test_CFLAGS="${CFLAGS+set}"
 110     ac_save_CFLAGS="$CFLAGS"
 111     CFLAGS=
 112     AC_PROG_CC_G
 113     if test "$ac_test_CFLAGS" = set; then
 114       CFLAGS="$ac_save_CFLAGS"
 115     elif test $ac_cv_prog_cc_g = yes; then
 116       CFLAGS="-g -O2"
 117     else
 118       CFLAGS="-O2"
 119     fi
 120   else
 121     GCC=
 122     test "${CFLAGS+set}" = set || CFLAGS="-g"
 123   fi
 124   ])
 125
 126   LIB_AC_PROG_CC
 127
 128   # Likewise for AC_PROG_CXX.  We can't just call it directly because g++
 129   # will try to link in libstdc++.
 130   AC_DEFUN(LIB_AC_PROG_CXX,
 131   [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
 132   dnl Fool anybody using AC_PROG_CXX.
 133   AC_PROVIDE([AC_PROG_CXX])
 134   # Use glibcpp_CXX so that we do not cause CXX to be cached with the
 135   # flags that come in CXX while configuring libstdc++.  They're different
 136   # from those used for all other target libraries.  If CXX is set in
 137   # the environment, respect that here.
 138   glibcpp_CXX=$CXX
 139   AC_CHECK_PROGS(glibcpp_CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
 140   AC_SUBST(glibcpp_CXX)
 141   CXX=$glibcpp_CXX
 142   test -z "$glibcpp_CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
 143
 144   AC_PROG_CXX_GNU
 145
 146   if test $ac_cv_prog_gxx = yes; then
 147     GXX=yes
 148     dnl Check whether -g works, even if CXXFLAGS is set, in case the package
 149     dnl plays around with CXXFLAGS (such as to build both debugging and
 150     dnl normal versions of a library), tasteless as that idea is.
 151     ac_test_CXXFLAGS="${CXXFLAGS+set}"
 152     ac_save_CXXFLAGS="$CXXFLAGS"
 153     CXXFLAGS=
 154     AC_PROG_CXX_G
 155     if test "$ac_test_CXXFLAGS" = set; then
 156       CXXFLAGS="$ac_save_CXXFLAGS"
 157     elif test $ac_cv_prog_cxx_g = yes; then
 158       CXXFLAGS="-g -O2"
 159     else
 160       CXXFLAGS="-O2"
 161     fi
 162   else
 163     GXX=
 164     test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
 165   fi
 166   ])
 167
 168   LIB_AC_PROG_CXX
 169
 170   # For directory versioning (e.g., headers) and other variables.
 171   AC_MSG_CHECKING([for GCC version number])
 172   gcc_version=`$glibcpp_CXX -dumpversion`
 173   AC_MSG_RESULT($gcc_version)
 174
 175   # For some reason, gettext needs this.
 176   AC_ISC_POSIX
 177
 178   AC_CHECK_TOOL(AS, as)
 179   AC_CHECK_TOOL(AR, ar)
 180   AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
 181   AC_PROG_INSTALL
 182
 183   AM_MAINTAINER_MODE
 184
 185   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
 186   # at least currently, we never actually build a program, so we never
 187   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
 188   # fails, because we are probably configuring with a cross compiler
 189   # which can't create executables.  So we include AC_EXEEXT to keep
 190   # automake happy, but we don't execute it, since we don't care about
 191   # the result.
 192   if false; then
 193     # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
 194     # to nothing, so nothing would remain between `then' and `fi' if it
 195     # were not for the `:' below.
 196     :
 197     AC_EXEEXT
 198   fi
 199
 200   case [$]{glibcpp_basedir} in
 201     /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
 202     *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
 203   esac
 204
 205   # Set up safe default values for all subsequent AM_CONDITIONAL tests.
 206   need_libmath=no
 207   enable_wchar_t=no
 208   #enable_debug=no
 209   #glibcpp_pch_comp=no
 210   #enable_cheaders=c
 211   #c_compatibility=no
 212   #enable_abi_check=no
 213   #enable_symvers=no
 214
 215   # Find platform-specific directories containing configuration info.  In
 216   # addition to possibly modifying the same flags, it also sets up symlinks.
 217   GLIBCPP_CHECK_HOST
 218 ])
 219
 220
 221 dnl
 222 dnl Check to see if g++ can compile this library, and if so, if any version-
 223 dnl specific precautions need to be taken.
 224 dnl
 225 dnl GLIBCPP_CHECK_COMPILER_VERSION
 226 AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
 227 if test ! -f stamp-sanity-compiler; then
 228   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
 229   AC_LANG_SAVE
 230   AC_LANG_CPLUSPLUS
 231   AC_TRY_COMPILE(, [
 232   #if __GNUC__ < 3
 233     not_ok
 234   #endif
 235   ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to GCC 3.0 or above]))
 236   AC_LANG_RESTORE
 237   AC_MSG_RESULT($gpp_satisfactory)
 238   touch stamp-sanity-compiler
 239 fi
 240 ])
 241
 242
 243 dnl
 244 dnl Tests for newer compiler features, or features that are present in newer
 245 dnl compiler versions but not older compiler versions still in use, should
 246 dnl be placed here.
 247 dnl
 248 dnl Define WERROR='-Werror' if requested and possible; g++'s that lack the
 249 dnl new inlining code or the new system_header pragma will die on -Werror.
 250 dnl Leave it out by default and use maint-mode to use it.
 251 dnl
 252 dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 253 dnl compiler supports it and the user has not requested debug mode.
 254 dnl
 255 dnl GLIBCPP_CHECK_COMPILER_FEATURES
 256 AC_DEFUN(GLIBCPP_CHECK_COMPILER_FEATURES, [
 257   # All these tests are for C++; save the language and the compiler flags.
 258   # The CXXFLAGS thing is suspicious, but based on similar bits previously
 259   # found in GLIBCPP_CONFIGURE.
 260   AC_LANG_SAVE
 261   AC_LANG_CPLUSPLUS
 262   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 263   ac_save_CXXFLAGS="$CXXFLAGS"
 264
 265   # Check for maintainer-mode bits.
 266   if test x"$USE_MAINTAINER_MODE" = xno; then
 267     WERROR=''
 268   else
 269     WERROR='-Werror'
 270   fi
 271
 272   # Check for -ffunction-sections -fdata-sections
 273   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 274   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 275   AC_TRY_COMPILE(, [int foo;
 276   ], [ac_fdsections=yes], [ac_fdsections=no])
 277   if test "$ac_test_CXXFLAGS" = set; then
 278     CXXFLAGS="$ac_save_CXXFLAGS"
 279   else
 280     # this is the suspicious part
 281     CXXFLAGS=''
 282   fi
 283   if test x"$ac_fdsections" = x"yes"; then
 284     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 285   fi
 286   AC_MSG_RESULT($ac_fdsections)
 287
 288   AC_LANG_RESTORE
 289   AC_SUBST(WERROR)
 290   AC_SUBST(SECTION_FLAGS)
 291 ])
 292
 293
 294 dnl
 295 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 296 dnl the native linker is in use, all variables will be defined to something
 297 dnl safe (like an empty string).
 298 dnl
 299 dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible.
 300 dnl Define OPT_LDFLAGS='-Wl,-O1' if possible.
 301 dnl Define LD, with_gnu_ld, and (possibly) glibcpp_gnu_ld_version as
 302 dnl side-effects of testing.
 303 dnl
 304 dnl GLIBCPP_CHECK_LINKER_FEATURES
 305 AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
 306   # If we're not using GNU ld, then there's no point in even trying these
 307   # tests.  Check for that first.  We should have already tested for gld
 308   # by now (in libtool), but require it now just to be safe...
 309   test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
 310   test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
 311   AC_REQUIRE([AC_PROG_LD])
 312
 313   # The name set by libtool depends on the version of libtool.  Shame on us
 314   # for depending on an impl detail, but c'est la vie.  Older versions used
 315   # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
 316   # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
 317   # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
 318   # set (hence we're using an older libtool), then set it.
 319   if test x${with_gnu_ld+set} != xset; then
 320     if test x${ac_cv_prog_gnu_ld+set} != xset; then
 321       # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
 322       with_gnu_ld=no
 323     else
 324       with_gnu_ld=$ac_cv_prog_gnu_ld
 325     fi
 326   fi
 327
 328   # Start by getting the version number.  I think the libtool test already
 329   # does some of this, but throws away the result.
 330   changequote(,)
 331   ldver=`$LD --version 2>/dev/null | head -1 | \
 332          sed -e 's/GNU ld version \([0-9.][0-9.]*\).*/\1/'`
 333   changequote([,])
 334   glibcpp_gnu_ld_version=`echo $ldver | \
 335          $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
 336
 337   # Set --gc-sections.
 338   if test "$with_gnu_ld" = "notbroken"; then
 339     # GNU ld it is!  Joy and bunny rabbits!
 340
 341     # All these tests are for C++; save the language and the compiler flags.
 342     # Need to do this so that g++ won't try to link in libstdc++
 343     ac_test_CFLAGS="${CFLAGS+set}"
 344     ac_save_CFLAGS="$CFLAGS"
 345     CFLAGS='-x c++  -Wl,--gc-sections'
 346
 347     # Check for -Wl,--gc-sections
 348     # XXX This test is broken at the moment, as symbols required for
 349     # linking are now in libsupc++ (not built yet.....). In addition,
 350     # this test has cored on solaris in the past. In addition,
 351     # --gc-sections doesn't really work at the moment (keeps on discarding
 352     # used sections, first .eh_frame and now some of the glibc sections for
 353     # iconv). Bzzzzt. Thanks for playing, maybe next time.
 354     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 355     AC_TRY_RUN([
 356      int main(void)
 357      {
 358        try { throw 1; }
 359        catch (...) { };
 360        return 0;
 361      }
 362     ], [ac_sectionLDflags=yes],[ac_sectionLDflags=no], [ac_sectionLDflags=yes])
 363     if test "$ac_test_CFLAGS" = set; then
 364       CFLAGS="$ac_save_CFLAGS"
 365     else
 366       # this is the suspicious part
 367       CFLAGS=''
 368     fi
 369     if test "$ac_sectionLDflags" = "yes"; then
 370       SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
 371     fi
 372     AC_MSG_RESULT($ac_sectionLDflags)
 373   fi
 374
 375   # Set linker optimization flags.
 376   if test x"$with_gnu_ld" = x"yes"; then
 377     OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
 378   fi
 379
 380   AC_SUBST(SECTION_LDFLAGS)
 381   AC_SUBST(OPT_LDFLAGS)
 382 ])
 383
 384
 385 dnl
 386 dnl Check to see if the (math function) argument passed is
 387 dnl declared when using the c++ compiler
 388 dnl ASSUMES argument is a math function with ONE parameter
 389 dnl
 390 dnl GLIBCPP_CHECK_MATH_DECL_1
 391 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_1, [
 392   AC_MSG_CHECKING([for $1 declaration])
 393   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 394     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 395       AC_LANG_SAVE
 396       AC_LANG_CPLUSPLUS
 397       AC_TRY_COMPILE([#include <math.h>
 398                       #ifdef HAVE_IEEEFP_H
 399                       #include <ieeefp.h>
 400                       #endif
 401                      ],
 402                      [ $1(0);],
 403                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 404       AC_LANG_RESTORE
 405     ])
 406   fi
 407   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 408 ])
 409
 410 dnl
 411 dnl Check to see if the (math function) argument passed is
 412 dnl 1) declared when using the c++ compiler
 413 dnl 2) has "C" linkage
 414 dnl 3) if not, see if 1) and 2) for argument prepended with '_'
 415 dnl
 416 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 417 dnl
 418 dnl argument 1 is name of function to check
 419 dnl
 420 dnl ASSUMES argument is a math function with ONE parameter
 421 dnl
 422 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1
 423 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
 424   GLIBCPP_CHECK_MATH_DECL_1($1)
 425   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 426     AC_CHECK_FUNCS($1)
 427   else
 428     GLIBCPP_CHECK_MATH_DECL_1(_$1)
 429     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 430       AC_CHECK_FUNCS(_$1)
 431     fi
 432   fi
 433 ])
 434
 435
 436 dnl
 437 dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
 438 dnl of functions at once.  It's an all-or-nothing check -- either
 439 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
 440 dnl Doing it this way saves significant configure time.
 441 AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [
 442   AC_MSG_CHECKING([for $1 functions])
 443   AC_CACHE_VAL(glibcpp_cv_func_$2_use, [
 444     AC_LANG_SAVE
 445     AC_LANG_CPLUSPLUS
 446     AC_TRY_COMPILE([#include <math.h>],
 447                    [ `for x in $3; do echo "$x (0);"; done` ],
 448                    [glibcpp_cv_func_$2_use=yes],
 449                    [glibcpp_cv_func_$2_use=no])
 450     AC_LANG_RESTORE])
 451   AC_MSG_RESULT($glibcpp_cv_func_$2_use)
 452   if test x$glibcpp_cv_func_$2_use = x"yes"; then
 453     AC_CHECK_FUNCS($3)
 454   fi
 455 ])
 456
 457 dnl
 458 dnl Check to see if the (math function) argument passed is
 459 dnl declared when using the c++ compiler
 460 dnl ASSUMES argument is a math function with TWO parameters
 461 dnl
 462 dnl GLIBCPP_CHECK_MATH_DECL_2
 463 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_2, [
 464   AC_MSG_CHECKING([for $1 declaration])
 465   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 466     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 467       AC_LANG_SAVE
 468       AC_LANG_CPLUSPLUS
 469       AC_TRY_COMPILE([#include <math.h>],
 470                      [ $1(0, 0);],
 471                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 472       AC_LANG_RESTORE
 473     ])
 474   fi
 475   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 476 ])
 477
 478 dnl
 479 dnl Check to see if the (math function) argument passed is
 480 dnl 1) declared when using the c++ compiler
 481 dnl 2) has "C" linkage
 482 dnl
 483 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 484 dnl
 485 dnl argument 1 is name of function to check
 486 dnl
 487 dnl ASSUMES argument is a math function with TWO parameters
 488 dnl
 489 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
 490 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
 491   GLIBCPP_CHECK_MATH_DECL_2($1)
 492   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 493     AC_CHECK_FUNCS($1)
 494   else
 495     GLIBCPP_CHECK_MATH_DECL_2(_$1)
 496     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 497       AC_CHECK_FUNCS(_$1)
 498     fi
 499   fi
 500 ])
 501
 502
 503 dnl
 504 dnl Check to see if the (math function) argument passed is
 505 dnl declared when using the c++ compiler
 506 dnl ASSUMES argument is a math function with THREE parameters
 507 dnl
 508 dnl GLIBCPP_CHECK_MATH_DECL_3
 509 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_3, [
 510   AC_MSG_CHECKING([for $1 declaration])
 511   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 512     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 513       AC_LANG_SAVE
 514       AC_LANG_CPLUSPLUS
 515       AC_TRY_COMPILE([#include <math.h>],
 516                      [ $1(0, 0, 0);],
 517                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 518       AC_LANG_RESTORE
 519     ])
 520   fi
 521   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 522 ])
 523
 524 dnl
 525 dnl Check to see if the (math function) argument passed is
 526 dnl 1) declared when using the c++ compiler
 527 dnl 2) has "C" linkage
 528 dnl
 529 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 530 dnl
 531 dnl argument 1 is name of function to check
 532 dnl
 533 dnl ASSUMES argument is a math function with THREE parameters
 534 dnl
 535 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
 536 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
 537   GLIBCPP_CHECK_MATH_DECL_3($1)
 538   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 539     AC_CHECK_FUNCS($1)
 540   else
 541     GLIBCPP_CHECK_MATH_DECL_3(_$1)
 542     if test x$glibcpp_cv_func__$1_use = x"yes"; then
 543       AC_CHECK_FUNCS(_$1)
 544     fi
 545   fi
 546 ])
 547
 548
 549 dnl
 550 dnl Check to see if the (stdlib function) argument passed is
 551 dnl 1) declared when using the c++ compiler
 552 dnl 2) has "C" linkage
 553 dnl
 554 dnl argument 1 is name of function to check
 555 dnl
 556 dnl ASSUMES argument is a math function with TWO parameters
 557 dnl
 558 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
 559 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
 560   AC_MSG_CHECKING([for $1 declaration])
 561   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 562     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 563       AC_LANG_SAVE
 564       AC_LANG_CPLUSPLUS
 565       AC_TRY_COMPILE([#include <stdlib.h>],
 566                      [ $1(0, 0);],
 567                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 568       AC_LANG_RESTORE
 569     ])
 570   fi
 571   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 572   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 573     AC_CHECK_FUNCS($1)
 574   fi
 575 ])
 576
 577
 578 dnl
 579 dnl Check to see if the (stdlib function) argument passed is
 580 dnl 1) declared when using the c++ compiler
 581 dnl 2) has "C" linkage
 582 dnl
 583 dnl argument 1 is name of function to check
 584 dnl
 585 dnl ASSUMES argument is a function with THREE parameters
 586 dnl
 587 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3
 588 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3, [
 589   AC_MSG_CHECKING([for $1 declaration])
 590   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 591     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 592       AC_LANG_SAVE
 593       AC_LANG_CPLUSPLUS
 594       AC_TRY_COMPILE([#include <stdlib.h>],
 595                      [ $1(0, 0, 0);],
 596                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 597       AC_LANG_RESTORE
 598     ])
 599   fi
 600   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 601   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 602     AC_CHECK_FUNCS($1)
 603   fi
 604 ])
 605
 606 dnl
 607 dnl Because the builtins are picky picky picky about the arguments they take,
 608 dnl do an explict linkage tests here.
 609 dnl Check to see if the (math function) argument passed is
 610 dnl 1) declared when using the c++ compiler
 611 dnl 2) has "C" linkage
 612 dnl
 613 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 614 dnl
 615 dnl argument 1 is name of function to check
 616 dnl
 617 dnl ASSUMES argument is a math function with ONE parameter
 618 dnl
 619 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 620 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 621   AC_MSG_CHECKING([for $1 declaration])
 622   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 623     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 624       AC_LANG_SAVE
 625       AC_LANG_CPLUSPLUS
 626       AC_TRY_COMPILE([#include <math.h>],
 627                      [ $1(0);],
 628                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 629       AC_LANG_RESTORE
 630     ])
 631   fi
 632   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 633   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 634     AC_MSG_CHECKING([for $1 linkage])
 635     if test x${glibcpp_cv_func_$1_link+set} != xset; then
 636       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 637         AC_TRY_LINK([#include <math.h>],
 638                     [ $1(0);],
 639                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 640       ])
 641     fi
 642     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 643     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 644       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 645       AC_DEFINE_UNQUOTED(${ac_tr_func})
 646     fi
 647   fi
 648 ])
 649
 650
 651 dnl
 652 dnl Check to see what builtin math functions are supported
 653 dnl
 654 dnl check for __builtin_abs
 655 dnl check for __builtin_fabsf
 656 dnl check for __builtin_fabs
 657 dnl check for __builtin_fabl
 658 dnl check for __builtin_labs
 659 dnl check for __builtin_sqrtf
 660 dnl check for __builtin_sqrtl
 661 dnl check for __builtin_sqrt
 662 dnl check for __builtin_sinf
 663 dnl check for __builtin_sin
 664 dnl check for __builtin_sinl
 665 dnl check for __builtin_cosf
 666 dnl check for __builtin_cos
 667 dnl check for __builtin_cosl
 668 dnl
 669 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 670 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 671   dnl Test for builtin math functions.
 672   dnl These are made in gcc/c-common.c
 673   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 674   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 675   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 676   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 677   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 678
 679   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 680   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
 681   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 682
 683   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 684   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 685   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 686
 687   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 688   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 689   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 690
 691   dnl There is, without a doubt, a more elegant way to have these
 692   dnl names exported so that they won't be stripped out of acconfig.h by
 693   dnl autoheader. I leave this as an exercise to somebody less frustrated
 694   dnl than I.... please email the libstdc++ list if you can figure out a
 695   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 696   dnl AC_CHECK_FUNC for things to steal.)
 697   dummyvar=no
 698   if test x$dummyvar = x"yes"; then
 699     AC_DEFINE(HAVE___BUILTIN_ABS)
 700     AC_DEFINE(HAVE___BUILTIN_LABS)
 701     AC_DEFINE(HAVE___BUILTIN_COS)
 702     AC_DEFINE(HAVE___BUILTIN_COSF)
 703     AC_DEFINE(HAVE___BUILTIN_COSL)
 704     AC_DEFINE(HAVE___BUILTIN_FABS)
 705     AC_DEFINE(HAVE___BUILTIN_FABSF)
 706     AC_DEFINE(HAVE___BUILTIN_FABSL)
 707     AC_DEFINE(HAVE___BUILTIN_SIN)
 708     AC_DEFINE(HAVE___BUILTIN_SINF)
 709     AC_DEFINE(HAVE___BUILTIN_SINL)
 710     AC_DEFINE(HAVE___BUILTIN_SQRT)
 711     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 712     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 713   fi
 714 ])
 715
 716 dnl
 717 dnl Check to see what the underlying c library is like
 718 dnl These checks need to do two things:
 719 dnl 1) make sure the name is declared when using the c++ compiler
 720 dnl 2) make sure the name has "C" linkage
 721 dnl This might seem like overkill but experience has shown that it's not...
 722 dnl
 723 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 724 dnl Define HAVE_STRTOF if "strtof" is declared and links
 725 dnl Define HAVE_DRAND48 if "drand48" is declared and links
 726 dnl
 727 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
 728 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
 729   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 730   ac_save_CXXFLAGS="$CXXFLAGS"
 731   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 732
 733   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 734   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
 735   AC_CHECK_FUNCS(drand48)
 736
 737   CXXFLAGS="$ac_save_CXXFLAGS"
 738 ])
 739
 740 dnl
 741 dnl Check to see what the underlying c library or math library is like.
 742 dnl These checks need to do two things:
 743 dnl 1) make sure the name is declared when using the c++ compiler
 744 dnl 2) make sure the name has "C" linkage
 745 dnl This might seem like overkill but experience has shown that it's not...
 746 dnl
 747 dnl Define HAVE_CARGF etc if "cargf" is found.
 748 dnl
 749 dnl GLIBCPP_CHECK_MATH_SUPPORT
 750 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
 751   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 752   ac_save_CXXFLAGS="$CXXFLAGS"
 753   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 754
 755   dnl Check libm
 756   AC_CHECK_LIB(m, sin, libm="-lm")
 757   ac_save_LIBS="$LIBS"
 758   LIBS="$LIBS $libm"
 759
 760   dnl Check to see if certain C math functions exist.
 761   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 762   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 763   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 764   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 765   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 766   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 767   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 768   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
 769
 770   dnl Check to see if basic C math functions have float versions.
 771   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
 772                                           float_trig,
 773                                           acosf asinf atanf \
 774                                           cosf sinf tanf \
 775                                           coshf sinhf tanhf)
 776   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
 777                                           float_round,
 778                                           ceilf floorf)
 779   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
 780   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 781   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 782   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
 783   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 784   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 785   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 786   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
 787   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 788   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 789   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 790   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 791   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 792   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 793   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 794   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 795
 796   dnl Check to see if basic C math functions have long double versions.
 797   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
 798                                           long_double_trig,
 799                                           acosl asinl atanl \
 800                                           cosl sinl tanl \
 801                                           coshl sinhl tanhl)
 802   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
 803                                           long_double_round,
 804                                           ceill floorl)
 805   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 806   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 807   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 808   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 809   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 810   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 811   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 812   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 813   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
 814   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 815   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 816   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 817   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 818   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 819   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 820   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 821   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 822
 823   dnl Some runtimes have these functions with a preceding underscore. Please
 824   dnl keep this sync'd with the one above. And if you add any new symbol,
 825   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
 826   dnl Check to see if certain C math functions exist.
 827
 828   dnl Check to see if basic C math functions have float versions.
 829   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
 830                                           _float_trig,
 831                                           _acosf _asinf _atanf \
 832                                           _cosf _sinf _tanf \
 833                                           _coshf _sinhf _tanhf)
 834   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
 835                                           _float_round,
 836                                           _ceilf _floorf)
 837
 838   dnl Check to see if basic C math functions have long double versions.
 839   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
 840                                           _long_double_trig,
 841                                           _acosl _asinl _atanl \
 842                                           _cosl _sinl _tanl \
 843                                           _coshl _sinhl _tanhl)
 844   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
 845                                           _long_double_round,
 846                                           _ceill _floorl)
 847
 848   LIBS="$ac_save_LIBS"
 849   CXXFLAGS="$ac_save_CXXFLAGS"
 850 ])
 851
 852
 853 dnl
 854 dnl Check to see if there is native support for complex
 855 dnl
 856 dnl Don't compile bits in math/* if native support exits.
 857 dnl
 858 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found.
 859 dnl
 860 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
 861 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
 862   dnl Check for complex versions of math functions of platform.  This will
 863   dnl always pass if libm is available, and fail if it isn't.  If it is
 864   dnl available, we assume we'll need it later, so add it to LIBS.
 865   AC_CHECK_LIB(m, main)
 866   AC_REPLACE_MATHFUNCS(nan copysignf)
 867
 868   dnl For __signbit to signbit conversions.
 869   AC_CHECK_FUNCS([__signbit], , [LIBMATHOBJS="$LIBMATHOBJS signbit.lo"])
 870   AC_CHECK_FUNCS([__signbitf], , [LIBMATHOBJS="$LIBMATHOBJS signbitf.lo"])
 871
 872   dnl Compile the long double complex functions only if the function
 873   dnl provides the non-complex long double functions that are needed.
 874   dnl Currently this includes copysignl, which should be
 875   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
 876   if test x$ac_cv_func_copysignl = x"yes"; then
 877     AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"])
 878   fi
 879
 880   if test -n "$LIBMATHOBJS"; then
 881     need_libmath=yes
 882   fi
 883   AC_SUBST(LIBMATHOBJS)
 884 ])
 885
 886
 887 dnl Check to see what architecture and operating system we are compiling
 888 dnl for.  Also, if architecture- or OS-specific flags are required for
 889 dnl compilation, pick them up here.
 890 dnl
 891 dnl GLIBCPP_CHECK_HOST
 892 AC_DEFUN(GLIBCPP_CHECK_HOST, [
 893   . [$]{glibcpp_basedir}/configure.host
 894   AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
 895   AC_MSG_RESULT(OS config directory is $os_include_dir)
 896 ])
 897
 898
 899 dnl
 900 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 901 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 902 dnl must have been previously checked.)
 903 dnl
 904 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
 905 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
 906 dnl
 907 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
 908 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 909   dnl Wide characters disabled by default.
 910
 911   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
 912   dnl others even if wchar_t support is not on.
 913   AC_MSG_CHECKING([for mbstate_t])
 914   AC_TRY_COMPILE([#include <wchar.h>],
 915   [mbstate_t teststate;],
 916   have_mbstate_t=yes, have_mbstate_t=no)
 917   AC_MSG_RESULT($have_mbstate_t)
 918   if test x"$have_mbstate_t" = xyes; then
 919     AC_DEFINE(HAVE_MBSTATE_T)
 920   fi
 921
 922   dnl Sanity check for existence of ISO C99 headers for extended encoding.
 923   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 924   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 925
 926   dnl Only continue checking if the ISO C99 headers exist and support is on.
 927   if test x"$ac_has_wchar_h" = xyes &&
 928      test x"$ac_has_wctype_h" = xyes &&
 929      test x"$enable_c_mbchar" != xno; then
 930
 931     dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
 932     dnl numeric_limits can instantiate type_traits<wchar_t>
 933     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
 934     AC_TRY_COMPILE([#include <wchar.h>],
 935     [int i = WCHAR_MIN; int j = WCHAR_MAX;],
 936     has_wchar_minmax=yes, has_wchar_minmax=no)
 937     AC_MSG_RESULT($has_wchar_minmax)
 938
 939     dnl Test wchar.h for WEOF, which is what we use to determine whether
 940     dnl to specialize for char_traits<wchar_t> or not.
 941     AC_MSG_CHECKING([for WEOF])
 942     AC_TRY_COMPILE([
 943       #include <wchar.h>
 944       #include <stddef.h>],
 945     [wint_t i = WEOF;],
 946     has_weof=yes, has_weof=no)
 947     AC_MSG_RESULT($has_weof)
 948
 949     dnl Tests for wide character functions used in char_traits<wchar_t>.
 950     ac_wfuncs=yes
 951     AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset,, \
 952     ac_wfuncs=no)
 953
 954     dnl Checks for names injected into std:: by the c_std headers.
 955     AC_CHECK_FUNCS(btowc wctob fgetwc fgetws fputwc fputws fwide \
 956     fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf \
 957     vwprintf vwscanf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
 958     mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstof wcstol \
 959     wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
 960     wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr,, \
 961     ac_wfuncs=no)
 962
 963     AC_MSG_CHECKING([for ISO C99 wchar_t support])
 964     if test x"$has_weof" = xyes &&
 965        test x"$has_wchar_minmax" = xyes &&
 966        test x"$ac_wfuncs" = xyes; then
 967       ac_isoC99_wchar_t=yes
 968     else
 969       ac_isoC99_wchar_t=no
 970     fi
 971     AC_MSG_RESULT($ac_isoC99_wchar_t)
 972
 973     dnl Use iconv for wchar_t to char conversions. As such, check for
 974     dnl X/Open Portability Guide, version 2 features (XPG2).
 975     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 976     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 977
 978     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
 979     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
 980     ac_save_LIBS="$LIBS"
 981     LIBS="$LIBS $libiconv"
 982
 983     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
 984     ac_XPG2funcs=yes, ac_XPG2funcs=no)
 985
 986     LIBS="$ac_save_LIBS"
 987
 988     AC_MSG_CHECKING([for XPG2 wchar_t support])
 989     if test x"$ac_has_iconv_h" = xyes &&
 990        test x"$ac_has_langinfo_h" = xyes &&
 991        test x"$ac_XPG2funcs" = xyes; then
 992       ac_XPG2_wchar_t=yes
 993     else
 994       ac_XPG2_wchar_t=no
 995     fi
 996     AC_MSG_RESULT($ac_XPG2_wchar_t)
 997
 998     dnl At the moment, only enable wchar_t specializations if all the
 999     dnl above support is present.
1000     if test x"$ac_isoC99_wchar_t" = xyes &&
1001         test x"$ac_XPG2_wchar_t" = xyes; then
1002       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
1003       enable_wchar_t=yes
1004     fi
1005   fi
1006   AC_MSG_CHECKING([for enabled wchar_t specializations])
1007   AC_MSG_RESULT($enable_wchar_t)
1008 ])
1009
1010
1011 dnl
1012 dnl Check to see if debugging libraries are to be built.
1013 dnl
1014 dnl GLIBCPP_ENABLE_DEBUG
1015 dnl
1016 dnl --enable-debug
1017 dnl builds a separate set of debugging libraries in addition to the
1018 dnl normal (shared, static) libstdc++ binaries.
1019 dnl
1020 dnl --disable-debug
1021 dnl builds only one (non-debug) version of libstdc++.
1022 dnl
1023 dnl --enable-debug-flags=FLAGS
1024 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1025 dnl
1026 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
1027 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1028 dnl       defaults to `no'.
1029 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
1030 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
1031 AC_ARG_ENABLE(debug,
1032 changequote(<<, >>)dnl
1033 <<  --enable-debug          build extra debug library [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
1034 changequote([, ])dnl
1035 [case "${enableval}" in
1036  yes) enable_debug=yes ;;
1037  no)  enable_debug=no ;;
1038  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
1039  esac],
1040 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
1041 AC_MSG_CHECKING([for additional debug build])
1042 AC_MSG_RESULT($enable_debug)
1043 AM_CONDITIONAL(GLIBCPP_BUILD_DEBUG, test "$enable_debug" = yes)
1044 ])
1045
1046
1047 dnl Check for explicit debug flags.
1048 dnl
1049 dnl GLIBCPP_ENABLE_DEBUG_FLAGS
1050 dnl
1051 dnl --enable-debug-flags='-O1'
1052 dnl is a general method for passing flags to be used when
1053 dnl building debug libraries with --enable-debug.
1054 dnl
1055 dnl --disable-debug-flags does nothing.
1056 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG_FLAGS(default flags)
1057 dnl       If "default flags" is an empty string (or "none"), the effect is
1058 dnl       the same as --disable or --enable=no.
1059 AC_DEFUN(GLIBCPP_ENABLE_DEBUG_FLAGS, [dnl
1060 define([GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1061 AC_ARG_ENABLE(debug_flags,
1062 changequote(<<, >>)dnl
1063 <<  --enable-debug-flags=FLAGS    pass compiler FLAGS when building debug
1064                         library;[default=>>GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT],
1065 changequote([, ])dnl
1066 [case "${enableval}" in
1067  none)  ;;
1068  -*) enable_debug_flags="${enableval}" ;;
1069  *)   AC_MSG_ERROR([Unknown argument to extra debugging flags]) ;;
1070  esac],
1071 enable_debug_flags=GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT)dnl
1072
1073 dnl Option parsed, now set things appropriately
1074 case x"$enable_debug" in
1075     xyes)
1076         case "$enable_debug_flags" in
1077           none)
1078             DEBUG_FLAGS="-g3 -O0";;
1079           -*) #valid input
1080             DEBUG_FLAGS="${enableval}"
1081         esac
1082         ;;
1083     xno)
1084         DEBUG_FLAGS=""
1085         ;;
1086 esac
1087 AC_SUBST(DEBUG_FLAGS)
1088
1089 AC_MSG_CHECKING([for debug build flags])
1090 AC_MSG_RESULT($DEBUG_FLAGS)
1091 ])
1092
1093
1094 dnl
1095 dnl Check for "unusual" flags to pass to the compiler while building.
1096 dnl
1097 dnl GLIBCPP_ENABLE_CXX_FLAGS
1098 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1099 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
1100 dnl     Somehow this same set of flags must be passed when [re]building
1101 dnl     libgcc.
1102 dnl --disable-cxx-flags passes nothing.
1103 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1104 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1105 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1106 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1107 dnl       If "default flags" is an empty string (or "none"), the effect is
1108 dnl       the same as --disable or --enable=no.
1109 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1110 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1111 AC_MSG_CHECKING([for extra compiler flags for building])
1112 AC_ARG_ENABLE(cxx_flags,
1113 changequote(<<, >>)dnl
1114 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1115                                   [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1116 changequote([, ])dnl
1117 [case "x$enable_cxx_flags" in
1118   xyes)
1119     AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1120   xno | xnone | x)
1121     enable_cxx_flags='' ;;
1122   *)
1123     enable_cxx_flags="$enableval" ;;
1124 esac],
1125 enable_cxx_flags=GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT)
1126
1127 dnl Run through flags (either default or command-line) and set anything
1128 dnl extra (e.g., #defines) that must accompany particular g++ options.
1129 if test -n "$enable_cxx_flags"; then
1130   for f in $enable_cxx_flags; do
1131     case "$f" in
1132       -fhonor-std)  ;;
1133       -*)  ;;
1134       *)   # and we're trying to pass /what/ exactly?
1135            AC_MSG_ERROR([compiler flags start with a -]) ;;
1136     esac
1137   done
1138 fi
1139 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1140 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1141 AC_SUBST(EXTRA_CXX_FLAGS)
1142 ])
1143
1144
1145 dnl
1146 dnl Check for which locale library to use:  gnu or generic.
1147 dnl
1148 dnl GLIBCPP_ENABLE_CLOCALE
1149 dnl --enable-clocale=gnu sets config/locale/c_locale_gnu.cc and friends
1150 dnl --enable-clocale=generic sets config/locale/c_locale_generic.cc and friends
1151 dnl
1152 dnl default is generic
1153 dnl
1154 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
1155   AC_MSG_CHECKING([for clocale to use])
1156   AC_ARG_ENABLE(clocale,
1157   [  --enable-clocale        enable model for target locale package.
1158   --enable-clocale=MODEL  use MODEL target-speific locale package. [default=generic]
1159   ],
1160   if test x$enable_clocale = xno; then
1161      enable_clocale=no
1162   fi,
1163      enable_clocale=no)
1164
1165   enable_clocale_flag=$enable_clocale
1166
1167   dnl Probe for locale support if no specific model is specified.
1168   dnl Default to "generic"
1169   if test x$enable_clocale_flag = xno; then
1170     case x${target_os} in
1171       xlinux* | xgnu*)
1172         AC_EGREP_CPP([_GLIBCPP_ok], [
1173         #include <features.h>
1174         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1175           _GLIBCPP_ok
1176         #endif
1177         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1178
1179         # Test for bugs early in glibc-2.2.x series
1180         if test x$enable_clocale_flag = xgnu; then
1181           AC_TRY_RUN([
1182           #define _GNU_SOURCE 1
1183           #include <locale.h>
1184           #include <string.h>
1185           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1186           extern __typeof(newlocale) __newlocale;
1187           extern __typeof(duplocale) __duplocale;
1188           extern __typeof(strcoll_l) __strcoll_l;
1189           #endif
1190           int main()
1191           {
1192             const char __one[] = "Äuglein Augmen";
1193             const char __two[] = "Äuglein";
1194             int i;
1195             int j;
1196             __locale_t  loc;
1197             __locale_t  loc_dup;
1198             loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1199             loc_dup = __duplocale(loc);
1200             i = __strcoll_l(__one, __two, loc);
1201             j = __strcoll_l(__one, __two, loc_dup);
1202             return 0;
1203           }
1204           ],
1205           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1206           [enable_clocale_flag=generic])
1207         fi
1208
1209         # ... at some point put __strxfrm_l tests in as well.
1210         ;;
1211       *)
1212         enable_clocale_flag=generic
1213         ;;
1214     esac
1215   fi
1216
1217   dnl Deal with gettext issues.
1218   AC_ARG_ENABLE(nls,
1219   [  --enable-nls            use Native Language Support (default)],
1220   , enable_nls=yes)
1221   USE_NLS=no
1222
1223   dnl Set configure bits for specified locale package
1224   case x${enable_clocale_flag} in
1225     xgeneric)
1226       AC_MSG_RESULT(generic)
1227
1228       CLOCALE_H=config/locale/generic/c_locale.h
1229       CLOCALE_CC=config/locale/generic/c_locale.cc
1230       CCODECVT_H=config/locale/generic/codecvt_specializations.h
1231       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1232       CCOLLATE_CC=config/locale/generic/collate_members.cc
1233       CCTYPE_CC=config/locale/generic/ctype_members.cc
1234       CMESSAGES_H=config/locale/generic/messages_members.h
1235       CMESSAGES_CC=config/locale/generic/messages_members.cc
1236       CMONEY_CC=config/locale/generic/monetary_members.cc
1237       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1238       CTIME_H=config/locale/generic/time_members.h
1239       CTIME_CC=config/locale/generic/time_members.cc
1240       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1241       ;;
1242     xgnu)
1243       AC_MSG_RESULT(gnu)
1244
1245       # Declare intention to use gettext, and add support for specific
1246       # languages.
1247       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1248       ALL_LINGUAS="de fr"
1249
1250       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1251       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1252       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1253         USE_NLS=yes
1254       fi
1255       # Export the build objects.
1256       for ling in $ALL_LINGUAS; do \
1257         glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \
1258         glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \
1259       done
1260       AC_SUBST(glibcpp_MOFILES)
1261       AC_SUBST(glibcpp_POFILES)
1262
1263       CLOCALE_H=config/locale/gnu/c_locale.h
1264       CLOCALE_CC=config/locale/gnu/c_locale.cc
1265       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1266       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1267       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1268       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1269       CMESSAGES_H=config/locale/gnu/messages_members.h
1270       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1271       CMONEY_CC=config/locale/gnu/monetary_members.cc
1272       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1273       CTIME_H=config/locale/gnu/time_members.h
1274       CTIME_CC=config/locale/gnu/time_members.cc
1275       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1276       ;;
1277     xieee_1003.1-2001)
1278       AC_MSG_RESULT(IEEE 1003.1)
1279
1280       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1281       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1282       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1283       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1284       CCOLLATE_CC=config/locale/generic/collate_members.cc
1285       CCTYPE_CC=config/locale/generic/ctype_members.cc
1286       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1287       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1288       CMONEY_CC=config/locale/generic/monetary_members.cc
1289       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1290       CTIME_H=config/locale/generic/time_members.h
1291       CTIME_CC=config/locale/generic/time_members.cc
1292       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1293       ;;
1294     *)
1295       echo "$enable_clocale is an unknown locale package" 1>&2
1296       exit 1
1297       ;;
1298   esac
1299
1300   # This is where the testsuite looks for locale catalogs, using the
1301   # -DLOCALEDIR define during testsuite compilation.
1302   glibcpp_localedir=${glibcpp_builddir}/po/share/locale
1303   AC_SUBST(glibcpp_localedir)
1304
1305   # A standalone libintl (e.g., GNU libintl) may be in use.
1306   if test $USE_NLS = yes; then
1307     AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
1308     AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
1309   fi
1310   if test $USE_NLS = yes; then
1311     AC_DEFINE(_GLIBCPP_USE_NLS)
1312   fi
1313
1314   AC_SUBST(USE_NLS)
1315   AC_SUBST(CLOCALE_H)
1316   AC_SUBST(CCODECVT_H)
1317   AC_SUBST(CMESSAGES_H)
1318   AC_SUBST(CCODECVT_CC)
1319   AC_SUBST(CCOLLATE_CC)
1320   AC_SUBST(CCTYPE_CC)
1321   AC_SUBST(CMESSAGES_CC)
1322   AC_SUBST(CMONEY_CC)
1323   AC_SUBST(CNUMERIC_CC)
1324   AC_SUBST(CTIME_H)
1325   AC_SUBST(CTIME_CC)
1326   AC_SUBST(CLOCALE_CC)
1327   AC_SUBST(CLOCALE_INTERNAL_H)
1328 ])
1329
1330
1331 dnl
1332 dnl Check for which I/O library to use:  stdio, or something specific.
1333 dnl
1334 dnl GLIBCPP_ENABLE_CSTDIO
1335 dnl
1336 dnl default is stdio
1337 dnl
1338 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1339   AC_MSG_CHECKING([for cstdio to use])
1340   AC_ARG_ENABLE(cstdio,
1341   [  --enable-cstdio         enable stdio for target io package.
1342   --enable-cstdio=LIB     use LIB target-speific io package. [default=stdio]
1343   ],
1344   if test x$enable_cstdio = xno; then
1345      enable_cstdio=stdio
1346   fi,
1347      enable_cstdio=stdio)
1348
1349   enable_cstdio_flag=$enable_cstdio
1350
1351   dnl Check if a valid I/O package
1352   case x${enable_cstdio_flag} in
1353     xstdio | x | xno | xnone | xyes)
1354       # default
1355       CSTDIO_H=config/io/c_io_stdio.h
1356       BASIC_FILE_H=config/io/basic_file_stdio.h
1357       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1358       AC_MSG_RESULT(stdio)
1359       ;;
1360     *)
1361       echo "$enable_cstdio is an unknown io package" 1>&2
1362       exit 1
1363       ;;
1364   esac
1365   AC_SUBST(CSTDIO_H)
1366   AC_SUBST(BASIC_FILE_H)
1367   AC_SUBST(BASIC_FILE_CC)
1368 ])
1369
1370
1371 dnl
1372 dnl Check to see if building and using a C++ precompiled header can be done.
1373 dnl
1374 dnl GLIBCPP_CHECK_PCH
1375 dnl
1376 dnl If it looks like it may work, flip bits on in include/Makefile.am
1377 dnl
1378 AC_DEFUN(GLIBCPP_CHECK_PCH, [
1379   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1380   ac_save_CXXFLAGS="$CXXFLAGS"
1381   CXXFLAGS='-Werror -Winvalid-pch -Wno-deprecated -x c++-header'
1382
1383   AC_MSG_CHECKING([for compiler that seems to compile .gch files])
1384   if test x${glibcpp_pch_comp+set} != xset; then
1385     AC_CACHE_VAL(glibcpp_pch_comp, [
1386       AC_LANG_SAVE
1387       AC_LANG_CPLUSPLUS
1388       AC_TRY_COMPILE([#include <math.h>
1389                      ],
1390                      [ $1(0);],
1391                      [glibcpp_pch_comp=yes], [glibcpp_pch_comp=no])
1392       AC_LANG_RESTORE
1393     ])
1394   fi
1395   AC_MSG_RESULT([$glibcpp_pch_comp])
1396
1397   CXXFLAGS="$ac_save_CXXFLAGS"
1398   AM_CONDITIONAL(GLIBCPP_BUILD_PCH, test "$glibcpp_pch_comp" = yes)
1399   if test "$glibcpp_pch_comp" = yes; then
1400         glibcpp_PCHFLAGS="-include bits/stdc++.h"
1401   else
1402         glibcpp_PCHFLAGS=""
1403   fi
1404   AC_SUBST(glibcpp_PCHFLAGS)
1405 ])
1406
1407 dnl
1408 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1409 dnl We must stage the required headers so that they will be installed
1410 dnl with the library (unlike libgcc, the STL implementation is provided
1411 dnl solely within headers).  Since we must not inject random user-space
1412 dnl macro names into user-provided C++ code, we first stage into <file>-in
1413 dnl and process to <file> with an output command.  The reason for a two-
1414 dnl stage process here is to correctly handle $srcdir!=$objdir without
1415 dnl having to write complex code (the sed commands to clean the macro
1416 dnl namespace are complex and fragile enough as it is).  We must also
1417 dnl add a relative path so that -I- is supported properly.
1418 dnl
1419 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1420   AC_MSG_CHECKING([for thread model used by GCC])
1421   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1422   AC_MSG_RESULT([$target_thread_file])
1423
1424   if test $target_thread_file != single; then
1425     AC_DEFINE(HAVE_GTHR_DEFAULT)
1426     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1427   fi
1428
1429   glibcpp_thread_h=gthr-$target_thread_file.h
1430   AC_SUBST(glibcpp_thread_h)
1431 ])
1432
1433
1434 dnl
1435 dnl Check for exception handling support.  If an explicit enable/disable
1436 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1437 dnl target may or may not support call frame exceptions.
1438 dnl
1439 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1440 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1441 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1442 dnl
1443 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1444 dnl
1445 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1446   AC_MSG_CHECKING([for exception model to use])
1447   AC_LANG_SAVE
1448   AC_LANG_CPLUSPLUS
1449   AC_ARG_ENABLE(sjlj-exceptions,
1450   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1451   [:],
1452   [dnl Botheration.  Now we've got to detect the exception model.
1453    dnl Link tests against libgcc.a are problematic since -- at least
1454    dnl as of this writing -- we've not been given proper -L bits for
1455    dnl single-tree newlib and libgloss.
1456    dnl
1457    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1458    dnl conftest files before we got a change to grep them first.
1459    cat > conftest.$ac_ext << EOF
1460 [#]line __oline__ "configure"
1461 struct S { ~S(); };
1462 void bar();
1463 void foo()
1464 {
1465   S s;
1466   bar();
1467 }
1468 EOF
1469    old_CXXFLAGS="$CXXFLAGS"
1470    CXXFLAGS=-S
1471    if AC_TRY_EVAL(ac_compile); then
1472      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1473        enable_sjlj_exceptions=yes
1474      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1475        enable_sjlj_exceptions=no
1476      fi
1477    fi
1478    CXXFLAGS="$old_CXXFLAGS"
1479    rm -f conftest*])
1480    if test x$enable_sjlj_exceptions = xyes; then
1481      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1482         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1483      ac_exception_model_name=sjlj
1484    elif test x$enable_sjlj_exceptions = xno; then
1485      ac_exception_model_name="call frame"
1486    else
1487      AC_MSG_ERROR([unable to detect exception model])
1488    fi
1489    AC_LANG_RESTORE
1490    AC_MSG_RESULT($ac_exception_model_name)
1491 ])
1492
1493
1494 dnl
1495 dnl Check for libunwind exception handling support. If enabled then
1496 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1497 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1498 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1499 dnl on libunwind as well as libgcc.
1500 dnl
1501 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1502 dnl --enable-libunwind-exceptions forces the use of libunwind.
1503 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1504 dnl
1505 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1506 dnl
1507 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1508   AC_MSG_CHECKING([for use of libunwind])
1509   AC_ARG_ENABLE(libunwind-exceptions,
1510   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1511   use_libunwind_exceptions=$enableval,
1512   use_libunwind_exceptions=no)
1513   AC_MSG_RESULT($use_libunwind_exceptions)
1514   dnl Option parsed, now set things appropriately
1515   if test x"$use_libunwind_exceptions" = xyes; then
1516     LIBUNWIND_FLAG="-lunwind"
1517   else
1518     LIBUNWIND_FLAG=""
1519   fi
1520   AC_SUBST(LIBUNWIND_FLAG)
1521 ])
1522
1523 dnl
1524 dnl Check for ISO/IEC 9899:1999 "C99" support.
1525 dnl
1526 dnl GLIBCPP_ENABLE_C99
1527 dnl --enable-c99 defines _GLIBCPP_USE_C99
1528 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1529 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1530 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1531 dnl       defaults to `no'.
1532 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1533 dnl
1534 dnl GLIBCPP_ENABLE_C99
1535 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1536   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1537
1538   AC_ARG_ENABLE(c99,
1539   changequote(<<, >>)dnl
1540   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1541   changequote([, ])dnl
1542   [case "$enableval" in
1543    yes) enable_c99=yes ;;
1544    no)  enable_c99=no ;;
1545    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1546    esac],
1547   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1548
1549   AC_LANG_SAVE
1550   AC_LANG_CPLUSPLUS
1551
1552   # Check for the existence of <math.h> functions used if C99 is enabled.
1553   ac_c99_math=yes;
1554   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1555   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1556   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1557   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1558   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1559   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1560   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1561   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1562   AC_TRY_COMPILE([#include <math.h>],
1563                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1564   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1565   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1566   AC_TRY_COMPILE([#include <math.h>],
1567                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1568   AC_TRY_COMPILE([#include <math.h>],
1569                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1570   AC_MSG_RESULT($ac_c99_math)
1571
1572   # Check for the existence in <stdio.h> of vscanf, et. al.
1573   ac_c99_stdio=yes;
1574   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1575   AC_TRY_COMPILE([#include <stdio.h>],
1576                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1577   AC_TRY_COMPILE([#include <stdio.h>
1578                   #include <stdarg.h>
1579                   void foo(char* fmt, ...)
1580                   {va_list args; va_start(args, fmt);
1581                   vfscanf(stderr, "%i", args);}],
1582                   [],, [ac_c99_stdio=no])
1583   AC_TRY_COMPILE([#include <stdio.h>
1584                   #include <stdarg.h>
1585                   void foo(char* fmt, ...)
1586                   {va_list args; va_start(args, fmt);
1587                   vscanf("%i", args);}],
1588                   [],, [ac_c99_stdio=no])
1589   AC_TRY_COMPILE([#include <stdio.h>
1590                   #include <stdarg.h>
1591                   void foo(char* fmt, ...)
1592                   {va_list args; va_start(args, fmt);
1593                   vsnprintf(fmt, 0, "%i", args);}],
1594                   [],, [ac_c99_stdio=no])
1595   AC_TRY_COMPILE([#include <stdio.h>
1596                   #include <stdarg.h>
1597                   void foo(char* fmt, ...)
1598                   {va_list args; va_start(args, fmt);
1599                   vsscanf(fmt, "%i", args);}],
1600                   [],, [ac_c99_stdio=no])
1601   AC_MSG_RESULT($ac_c99_stdio)
1602
1603   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1604   ac_c99_stdlib=yes;
1605   AC_MSG_CHECKING([for lldiv_t declaration])
1606   AC_CACHE_VAL(ac_c99_lldiv_t, [
1607   AC_TRY_COMPILE([#include <stdlib.h>],
1608                    [ lldiv_t mydivt;],
1609                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1610   ])
1611   AC_MSG_RESULT($ac_c99_lldiv_t)
1612
1613   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1614   AC_TRY_COMPILE([#include <stdlib.h>],
1615                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1616   AC_TRY_COMPILE([#include <stdlib.h>],
1617                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1618   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1619   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1620   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1621   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1622   if test x"$ac_c99_lldiv_t" = x"no"; then
1623     ac_c99_stdlib=no;
1624   fi;
1625   AC_MSG_RESULT($ac_c99_stdlib)
1626
1627   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1628   # XXX the wchar.h checks should be rolled into the general C99 bits.
1629   ac_c99_wchar=yes;
1630   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1631   AC_TRY_COMPILE([#include <wchar.h>],
1632                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1633   AC_TRY_COMPILE([#include <wchar.h>],
1634                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1635   AC_TRY_COMPILE([#include <wchar.h>],
1636                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1637   AC_MSG_RESULT($ac_c99_wchar)
1638
1639   AC_MSG_CHECKING([for enabled ISO C99 support])
1640   if test x"$ac_c99_math" = x"no" ||
1641      test x"$ac_c99_stdio" = x"no" ||
1642      test x"$ac_c99_stdlib" = x"no" ||
1643      test x"$ac_c99_wchar" = x"no"; then
1644     enable_c99=no;
1645   fi;
1646   AC_MSG_RESULT($enable_c99)
1647
1648   # Option parsed, now set things appropriately
1649   if test x"$enable_c99" = x"yes"; then
1650     AC_DEFINE(_GLIBCPP_USE_C99)
1651   fi
1652
1653   AC_LANG_RESTORE
1654 ])
1655
1656
1657 dnl
1658 dnl Check for template specializations for the 'long long' type extension.
1659 dnl The result determines only whether 'long long' I/O is enabled; things
1660 dnl like numeric_limits<> specializations are always available.
1661 dnl
1662 dnl GLIBCPP_ENABLE_LONG_LONG
1663 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1664 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1665 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1666 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1667 dnl       defaults to `no'.
1668 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1669 dnl
1670 dnl GLIBCPP_ENABLE_LONG_LONG
1671 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1672   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1673
1674   AC_ARG_ENABLE(long-long,
1675   changequote(<<, >>)dnl
1676   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1677   changequote([, ])dnl
1678   [case "$enableval" in
1679    yes) enable_long_long=yes ;;
1680    no)  enable_long_long=no ;;
1681    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1682    esac],
1683   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1684
1685   AC_LANG_SAVE
1686   AC_LANG_CPLUSPLUS
1687
1688   AC_MSG_CHECKING([for enabled long long I/O support])
1689   # iostreams require strtoll, strtoull to compile
1690   AC_TRY_COMPILE([#include <stdlib.h>],
1691                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1692   AC_TRY_COMPILE([#include <stdlib.h>],
1693                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1694
1695   # Option parsed, now set things appropriately
1696   if test x"$enable_long_long" = xyes; then
1697     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1698   fi
1699   AC_MSG_RESULT($enable_long_long)
1700
1701   AC_LANG_RESTORE
1702 ])
1703
1704
1705 dnl
1706 dnl Check for what type of C headers to use.
1707 dnl
1708 dnl GLIBCPP_ENABLE_CHEADERS
1709 dnl --enable-cheaders= [does stuff].
1710 dnl --disable-cheaders [does not do anything, really].
1711 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1712 dnl       Where DEFAULT is either `c' or `c_std'.
1713 dnl       If ommitted, it defaults to `c_std'.
1714 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1715 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1716 AC_MSG_CHECKING([for c header strategy to use])
1717 AC_ARG_ENABLE(cheaders,
1718 changequote(<<, >>)dnl
1719 <<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1720 changequote([, ])
1721   [case "$enableval" in
1722    c)
1723         enable_cheaders=c
1724         ;;
1725    c_std)
1726         enable_cheaders=c_std
1727         ;;
1728    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1729         ;;
1730   esac],
1731   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1732   AC_MSG_RESULT($enable_cheaders)
1733
1734   dnl Option parsed, now set things appropriately
1735   case "$enable_cheaders" in
1736     c_std)
1737         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1738         ;;
1739     c)
1740         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1741         ;;
1742   esac
1743
1744   AC_SUBST(C_INCLUDE_DIR)
1745   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1746   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1747   AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
1748 ])
1749
1750
1751 dnl
1752 dnl Check for wide character support.  Has the same effect as the option
1753 dnl in gcc's configure, but in a form that autoconf can mess with.
1754 dnl
1755 dnl GLIBCPP_ENABLE_C_MBCHAR
1756 dnl --enable-c-mbchar requests all the wchar_t stuff.
1757 dnl --disable-c-mbchar doesn't.
1758 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1759 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1760 dnl       defaults to `no'.
1761 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1762 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1763 AC_ARG_ENABLE(c-mbchar,
1764 changequote(<<, >>)dnl
1765 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1766 changequote([, ])dnl
1767 [case "$enableval" in
1768  yes) enable_c_mbchar=yes ;;
1769  no)  enable_c_mbchar=no ;;
1770  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1771  esac],
1772 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1773 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1774 ])
1775
1776
1777 dnl
1778 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1779 dnl
1780 dnl TOPLEVEL_INCLUDES
1781 dnl LIBMATH_INCLUDES
1782 dnl LIBSUPCXX_INCLUDES
1783 dnl
1784 dnl GLIBCPP_EXPORT_INCLUDES
1785 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1786   # Root level of the build directory include sources.
1787   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1788
1789   # Passed down for canadian crosses.
1790   if test x"$CANADIAN" = xyes; then
1791     TOPLEVEL_INCLUDES='-I$(includedir)'
1792   fi
1793
1794   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1795
1796   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1797
1798   # Now, export this to all the little Makefiles....
1799   AC_SUBST(GLIBCPP_INCLUDES)
1800   AC_SUBST(TOPLEVEL_INCLUDES)
1801   AC_SUBST(LIBMATH_INCLUDES)
1802   AC_SUBST(LIBSUPCXX_INCLUDES)
1803 ])
1804
1805
1806 dnl
1807 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1808 dnl
1809 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1810   # Optimization flags that are probably a good idea for thrill-seekers. Just
1811   # uncomment the lines below and make, everything else is ready to go...
1812   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1813   OPTIMIZE_CXXFLAGS=
1814   AC_SUBST(OPTIMIZE_CXXFLAGS)
1815
1816   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings'
1817   AC_SUBST(WARN_FLAGS)
1818 ])
1819
1820 dnl
1821 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1822 dnl  calculates gxx_install_dir
1823 dnl  exports glibcpp_toolexecdir
1824 dnl  exports glibcpp_toolexeclibdir
1825 dnl  exports glibcpp_prefixdir
1826 dnl
1827 dnl Assumes cross_compiling bits already done, and with_cross_host in
1828 dnl particular
1829 dnl
1830 dnl GLIBCPP_EXPORT_INSTALL_INFO
1831 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1832 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1833 # exported correctly in GLIBCPP_CONFIGURE.
1834 glibcpp_toolexecdir=no
1835 glibcpp_toolexeclibdir=no
1836 glibcpp_prefixdir=${prefix}
1837
1838 # Process the option --with-gxx-include-dir=<path to include-files directory>
1839 AC_MSG_CHECKING([for --with-gxx-include-dir])
1840 AC_ARG_WITH(gxx-include-dir,
1841 [  --with-gxx-include-dir  the installation directory for include files],
1842 [case "${withval}" in
1843   yes)
1844     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1845     gxx_include_dir=no
1846     ;;
1847   no)
1848     gxx_include_dir=no
1849     ;;
1850   *)
1851     gxx_include_dir=${withval}
1852     ;;
1853 esac], [gxx_include_dir=no])
1854 AC_MSG_RESULT($gxx_include_dir)
1855
1856 # Process the option "--enable-version-specific-runtime-libs"
1857 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1858 AC_ARG_ENABLE(version-specific-runtime-libs,
1859 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1860 [case "$enableval" in
1861  yes) version_specific_libs=yes ;;
1862  no)  version_specific_libs=no ;;
1863  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1864  esac],
1865 version_specific_libs=no)dnl
1866 # Option set, now we can test it.
1867 AC_MSG_RESULT($version_specific_libs)
1868
1869 # Default case for install directory for include files.
1870 if test $version_specific_libs = no && test $gxx_include_dir = no; then
1871   gxx_include_dir='$(prefix)'/include/c++/${gcc_version}
1872 fi
1873
1874 # Version-specific runtime libs processing.
1875 if test $version_specific_libs = yes; then
1876   # Need the gcc compiler version to know where to install libraries
1877   # and header files if --enable-version-specific-runtime-libs option
1878   # is selected.
1879   if test x"$gxx_include_dir" = x"no"; then
1880     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
1881   fi
1882   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1883   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1884 fi
1885
1886 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1887 # Install a library built with a cross compiler in tooldir, not libdir.
1888 if test x"$glibcpp_toolexecdir" = x"no"; then
1889   if test -n "$with_cross_host" &&
1890      test x"$with_cross_host" != x"no"; then
1891     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1892     glibcpp_toolexeclibdir='$(toolexecdir)/lib'
1893   else
1894     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1895     glibcpp_toolexeclibdir='$(libdir)'
1896   fi
1897   multi_os_directory=`$CC -print-multi-os-directory`
1898   case $multi_os_directory in
1899   .) ;; # Avoid trailing /.
1900   *) glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/$multi_os_directory ;;
1901   esac
1902 fi
1903
1904 AC_MSG_CHECKING([for install location])
1905 AC_MSG_RESULT($gxx_include_dir)
1906
1907 AC_SUBST(glibcpp_prefixdir)
1908 AC_SUBST(gxx_include_dir)
1909 AC_SUBST(glibcpp_toolexecdir)
1910 AC_SUBST(glibcpp_toolexeclibdir)
1911 ])
1912
1913
1914 # Check for functions in math library.
1915 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1916 #
1917 # This file can be copied and used freely without restrictions.  It can
1918 # be used in projects which are not available under the GNU Public License
1919 # but which still want to provide support for the GNU gettext functionality.
1920 # Please note that the actual code is *not* freely available.
1921
1922 # serial 1
1923
1924 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1925 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1926 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1927
1928
1929 dnl This macro searches for a GNU version of make.  If a match is found, the
1930 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1931 dnl set to "#". This is useful for  including a special features in a Makefile,
1932 dnl which cannot be handled by other versions of make.  The variable
1933 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1934 dnl the empty string otherwise.
1935 dnl
1936 dnl Here is an example of its use:
1937 dnl
1938 dnl Makefile.in might contain:
1939 dnl
1940 dnl     # A failsafe way of putting a dependency rule into a makefile
1941 dnl     $(DEPEND):
1942 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1943 dnl
1944 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1945 dnl     @ifGNUmake@ include $(DEPEND)
1946 dnl     @ifGNUmake@ endif
1947 dnl
1948 dnl Then configure.in would normally contain:
1949 dnl
1950 dnl     CHECK_GNU_MAKE()
1951 dnl     AC_OUTPUT(Makefile)
1952 dnl
1953 dnl Then perhaps to cause gnu make to override any other make, we could do
1954 dnl something like this (note that GNU make always looks for GNUmakefile first):
1955 dnl
1956 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1957 dnl             mv Makefile GNUmakefile
1958 dnl             echo .DEFAULT: > Makefile ;
1959 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1960 dnl     fi
1961 dnl
1962 dnl Then, if any (well almost any) other make is called, and GNU make also
1963 dnl exists, then the other make wraps the GNU make.
1964 dnl
1965 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1966 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1967 dnl
1968 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1969 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1970 dnl #### conditional's subshell (" --version" is not a command), using a
1971 dnl #### different option to grep(1).
1972 dnl #### -pme
1973 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1974 dnl #### ${MAKE:-make}).
1975 dnl #### -msokolov
1976 AC_DEFUN(
1977   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1978           _cv_gnu_make_command='' ;
1979 dnl Search all the common names for GNU make
1980           for a in "${MAKE-make}" make gmake gnumake ; do
1981                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1982                   then
1983                           _cv_gnu_make_command=$a ;
1984                           break;
1985                   fi
1986           done ;
1987   ) ;
1988 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1989 dnl string, '#' otherwise
1990   if test  "x$_cv_gnu_make_command" != "x"  ; then
1991           ifGNUmake='' ;
1992   else
1993           ifGNUmake='#' ;
1994   fi
1995   AC_SUBST(ifGNUmake)
1996 ])
1997
1998
1999 dnl Check for headers for, and arguments to, the setrlimit() function.
2000 dnl Used only in testsuite_hooks.h.
2001 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
2002   AC_TRY_COMPILE([#include <unistd.h>
2003                   #include <sys/time.h>
2004                   #include <sys/resource.h>
2005                  ], [ int f = RLIMIT_$1 ; ],
2006                  [glibcpp_mresult=1], [glibcpp_mresult=0])
2007   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
2008                      [Only used in build directory testsuite_hooks.h.])
2009 ])
2010 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
2011   setrlimit_have_headers=yes
2012   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
2013                    [],
2014                    setrlimit_have_headers=no)
2015   # If don't have the headers, then we can't run the tests now, and we
2016   # won't be seeing any of these during testsuite compilation.
2017   if test $setrlimit_have_headers = yes; then
2018     # Can't do these in a loop, else the resulting syntax is wrong.
2019     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
2020     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
2021     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
2022     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
2023
2024     # Check for rlimit, setrlimit.
2025     AC_CACHE_VAL(ac_setrlimit, [
2026       AC_TRY_COMPILE([#include <unistd.h>
2027                   #include <sys/time.h>
2028                   #include <sys/resource.h>
2029                      ],
2030                      [ struct rlimit r; setrlimit(0, &r);],
2031                      [ac_setrlimit=yes], [ac_setrlimit=no])
2032     ])
2033   fi
2034
2035   AC_MSG_CHECKING([for testsuite memory limit support])
2036   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2037     ac_mem_limits=yes
2038     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2039   else
2040     ac_mem_limits=no
2041   fi
2042   AC_MSG_RESULT($ac_mem_limits)
2043 ])
2044
2045
2046 dnl
2047 dnl Does any necessary configuration of the testsuite directory.  Generates
2048 dnl the testsuite_hooks.h header.
2049 dnl
2050 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2051 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2052
2053   if test  x"$GLIBCPP_IS_CROSS_COMPILING" = xfalse; then
2054     # Do checks for memory limit functions.
2055     GLIBCPP_CHECK_SETRLIMIT
2056
2057     # Look for setenv, so that extended locale tests can be performed.
2058     GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2059   fi
2060
2061   # Export file names for ABI checking.
2062   baseline_dir="${glibcpp_srcdir}/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
2063   AC_SUBST(baseline_dir)
2064
2065   # Determine if checking the ABI is desirable.
2066   if test x$enable_symvers = xno; then
2067     enable_abi_check=no
2068   else
2069     case "$host" in
2070       *-*-cygwin*)
2071         enable_abi_check=no ;;
2072       *)
2073         enable_abi_check=yes ;;
2074     esac
2075   fi
2076
2077   AM_CONDITIONAL(GLIBCPP_TEST_WCHAR_T, test "$enable_wchar_t" = yes)
2078   AM_CONDITIONAL(GLIBCPP_TEST_ABI, test "$enable_abi_check" = yes)
2079 ])
2080
2081
2082 sinclude(../libtool.m4)
2083 dnl The lines below arrange for aclocal not to bring an installed
2084 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2085 dnl add a definition of LIBTOOL to Makefile.in.
2086 ifelse(,,,[AC_SUBST(LIBTOOL)
2087 AC_DEFUN([AM_PROG_LIBTOOL])
2088 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2089 AC_DEFUN([AC_PROG_LD])
2090 ])
2091
2092 dnl
2093 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
2094 dnl
2095
2096 AC_DEFUN(GLIBCPP_CHECK_S_ISREG_OR_S_IFREG, [
2097   AC_CACHE_VAL(glibcpp_cv_S_ISREG, [
2098     AC_TRY_LINK([#include <sys/stat.h>],
2099                 [struct stat buffer; fstat(0, &buffer); S_ISREG(buffer.st_mode); ],
2100                 [glibcpp_cv_S_ISREG=yes],
2101                 [glibcpp_cv_S_ISREG=no])
2102   ])
2103   AC_CACHE_VAL(glibcpp_cv_S_IFREG, [
2104     AC_TRY_LINK([#include <sys/stat.h>],
2105                 [struct stat buffer; fstat(0, &buffer); S_IFREG & buffer.st_mode; ],
2106                 [glibcpp_cv_S_IFREG=yes],
2107                 [glibcpp_cv_S_IFREG=no])
2108   ])
2109   if test x$glibcpp_cv_S_ISREG = xyes; then
2110     AC_DEFINE(HAVE_S_ISREG)
2111   elif test x$glibcpp_cv_S_IFREG = xyes; then
2112     AC_DEFINE(HAVE_S_IFREG)
2113   fi
2114 ])
2115
2116 dnl
2117 dnl Check whether poll is available in <poll.h>.
2118 dnl
2119
2120 AC_DEFUN(GLIBCPP_CHECK_POLL, [
2121   AC_CACHE_VAL(glibcpp_cv_POLL, [
2122     AC_TRY_COMPILE([#include <poll.h>],
2123                 [struct pollfd pfd[1]; pfd[0].events = POLLIN; poll(pfd, 1, 0); ],
2124                 [glibcpp_cv_POLL=yes],
2125                 [glibcpp_cv_POLL=no])
2126   ])
2127   if test x$glibcpp_cv_POLL = xyes; then
2128     AC_DEFINE(HAVE_POLL)
2129   fi
2130 ])
2131
2132 # Check whether LC_MESSAGES is available in <locale.h>.
2133 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2134 #
2135 # This file file be copied and used freely without restrictions.  It can
2136 # be used in projects which are not available under the GNU Public License
2137 # but which still want to provide support for the GNU gettext functionality.
2138 # Please note that the actual code is *not* freely available.
2139
2140 # serial 1
2141
2142 AC_DEFUN(AC_LC_MESSAGES, [
2143   AC_CHECK_HEADER(locale.h, [
2144     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2145       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2146        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2147     if test $ac_cv_val_LC_MESSAGES = yes; then
2148       AC_DEFINE(HAVE_LC_MESSAGES)
2149     fi
2150   ])
2151 ])
2152
2153
2154 dnl
2155 dnl Check for whether the Boost-derived checks should be turned on.
2156 dnl
2157 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2158 dnl --enable-concept-checks turns them on.
2159 dnl --disable-concept-checks leaves them off.
2160 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2161 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2162 dnl       defaults to `no'.
2163 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2164 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2165 AC_ARG_ENABLE(concept-checks,
2166 changequote(<<, >>)dnl
2167 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2168 changequote([, ])dnl
2169 [case "$enableval" in
2170  yes) enable_concept_checks=yes ;;
2171  no)  enable_concept_checks=no ;;
2172  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2173  esac],
2174 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2175 dnl Option parsed, now set things appropriately
2176 if test x"$enable_concept_checks" = xyes; then
2177   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2178 fi
2179 ])
2180
2181
2182 dnl
2183 dnl Add version tags to symbols in shared library (or not), additionally
2184 dnl marking other symbols as private/local (or not).
2185 dnl
2186 dnl GLIBCPP_ENABLE_SYMVERS
2187 dnl --enable-symvers=style adds a version script to the linker call when
2188 dnl       creating the shared library.  The choice of version script is
2189 dnl       controlled by 'style'.
2190 dnl --disable-symvers does not.
2191 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2192 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2193 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2194 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2195 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2196 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2197 AC_ARG_ENABLE(symvers,
2198 changequote(<<, >>)dnl
2199 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2200 changequote([, ])dnl
2201 [case "$enableval" in
2202  yes) enable_symvers=yes ;;
2203  no)  enable_symvers=no ;;
2204  # other names here, just as sanity checks
2205  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2206  gnu) enable_symvers=$enableval ;;
2207  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2208  esac],
2209 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2210
2211 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2212 # don't know enough about $LD to do tricks...
2213 if test x$enable_shared = xno ||
2214         test "x$LD" = x ||
2215         test x$glibcpp_gnu_ld_version = x; then
2216   enable_symvers=no
2217 fi
2218
2219 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2220 if test $enable_symvers != no; then
2221   AC_MSG_CHECKING([for shared libgcc])
2222   ac_save_CFLAGS="$CFLAGS"
2223   CFLAGS=' -lgcc_s'
2224   AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2225   CFLAGS="$ac_save_CFLAGS"
2226   AC_MSG_RESULT($glibcpp_shared_libgcc)
2227 fi
2228
2229 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2230 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2231 glibcpp_min_gnu_ld_version=21200
2232
2233 # Check to see if unspecified "yes" value can win, given results
2234 # above.
2235 if test $enable_symvers = yes ; then
2236   if test $with_gnu_ld = yes &&
2237     test $glibcpp_shared_libgcc = yes ;
2238   then
2239     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2240         enable_symvers=gnu
2241     else
2242       ac_test_CFLAGS="${CFLAGS+set}"
2243       ac_save_CFLAGS="$CFLAGS"
2244       CFLAGS='-shared -Wl,--version-script,conftest.map'
2245       enable_symvers=no
2246       changequote(,)
2247       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2248       changequote([,])
2249       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2250       if test "$ac_test_CFLAGS" = set; then
2251         CFLAGS="$ac_save_CFLAGS"
2252       else
2253         # this is the suspicious part
2254         CFLAGS=''
2255       fi
2256       rm -f conftest.map
2257     fi
2258   else
2259     # just fail for now
2260     enable_symvers=no
2261   fi
2262 fi
2263
2264 dnl Everything parsed; figure out what file to use.
2265 case $enable_symvers in
2266   no)
2267       SYMVER_MAP=config/linker-map.dummy
2268       ;;
2269   gnu)
2270       SYMVER_MAP=config/linker-map.gnu
2271       AC_DEFINE(_GLIBCPP_SYMVER)
2272       ;;
2273 esac
2274
2275 AC_SUBST(SYMVER_MAP)
2276 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2277 AC_MSG_CHECKING([versioning on shared library symbols])
2278 AC_MSG_RESULT($enable_symvers)
2279 ])
2280