libstdc++-v3/acinclude.m4

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