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=`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 Set configure bits for specified locale package
1149   case x${enable_clocale_flag} in
1150     xgeneric)
1151       AC_MSG_RESULT(generic)
1152
1153       # Don't use gettext.
1154       USE_NLS=no
1155
1156       CLOCALE_H=config/locale/generic/c_locale.h
1157       CLOCALE_CC=config/locale/generic/c_locale.cc
1158       CCODECVT_H=config/locale/generic/codecvt_specializations.h
1159       CCOLLATE_CC=config/locale/generic/collate_members.cc
1160       CCTYPE_CC=config/locale/generic/ctype_members.cc
1161       CMESSAGES_H=config/locale/generic/messages_members.h
1162       CMESSAGES_CC=config/locale/generic/messages_members.cc
1163       CMONEY_CC=config/locale/generic/monetary_members.cc
1164       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1165       CTIME_CC=config/locale/generic/time_members.cc
1166       ;;
1167     xgnu)
1168       AC_MSG_RESULT(gnu)
1169
1170       # Declare intention to use gettext, and add support for specific
1171       # languages.
1172       # For some reason, ALL_LINGUAS has to be before AM_GNU_GETTEXT
1173       ALL_LINGUAS="de fr"
1174       # Don't call AM_GNU_GETTEXT here. Instead, assume glibc.
1175       # Need to deal with MSGFMT, USE_NLS, and glibcpp_[P,M]OFILES
1176       USE_NLS=yes
1177
1178       # Export the build objects.
1179       for ling in $ALL_LINGUAS; do \
1180         glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \
1181         glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \
1182       done
1183       AC_SUBST(glibcpp_MOFILES)
1184       AC_SUBST(glibcpp_POFILES)
1185
1186       CLOCALE_H=config/locale/gnu/c_locale.h
1187       CLOCALE_CC=config/locale/gnu/c_locale.cc
1188       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1189       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1190       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1191       CMESSAGES_H=config/locale/gnu/messages_members.h
1192       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1193       CMONEY_CC=config/locale/gnu/monetary_members.cc
1194       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1195       CTIME_CC=config/locale/gnu/time_members.cc
1196       ;;
1197     xieee_1003.1-2001)
1198       AC_MSG_RESULT(generic)
1199
1200       # Don't use gettext.
1201       USE_NLS=no
1202
1203       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1204       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1205       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1206       CCOLLATE_CC=config/locale/generic/collate_members.cc
1207       CCTYPE_CC=config/locale/generic/ctype_members.cc
1208       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1209       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1210       CMONEY_CC=config/locale/generic/monetary_members.cc
1211       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1212       CTIME_CC=config/locale/generic/time_members.cc
1213       ;;
1214     *)
1215       echo "$enable_clocale is an unknown locale package" 1>&2
1216       exit 1
1217       ;;
1218   esac
1219
1220   # This is where the testsuite looks for locale catalogs, using the
1221   # -DLOCALEDIR define during testsuite compilation.
1222   glibcpp_localedir=${glibcpp_builddir}/po/share/locale
1223   AC_SUBST(glibcpp_localedir)
1224
1225   AC_SUBST(USE_NLS)
1226   AC_SUBST(CLOCALE_H)
1227   AC_SUBST(CCODECVT_H)
1228   AC_SUBST(CMESSAGES_H)
1229   AC_LINK_FILES($CLOCALE_CC, src/c++locale.cc)
1230   AC_LINK_FILES($CCOLLATE_CC, src/collate.cc)
1231   AC_LINK_FILES($CCTYPE_CC, src/ctype.cc)
1232   AC_LINK_FILES($CMESSAGES_CC, src/messages.cc)
1233   AC_LINK_FILES($CMONEY_CC, src/monetary.cc)
1234   AC_LINK_FILES($CNUMERIC_CC, src/numeric.cc)
1235   AC_LINK_FILES($CTIME_CC, src/time.cc)
1236 ])
1237
1238
1239 dnl
1240 dnl Check for which I/O library to use:  libio, or something specific.
1241 dnl
1242 dnl GLIBCPP_ENABLE_CSTDIO
1243 dnl --enable-cstdio=libio sets config/io/c_io_libio.h and friends
1244 dnl
1245 dnl default is stdio
1246 dnl
1247 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1248   AC_MSG_CHECKING([for cstdio to use])
1249   AC_ARG_ENABLE(cstdio,
1250   [  --enable-cstdio         enable stdio for target io package.
1251   --enable-cstdio=LIB     use LIB target-speific io package. [default=stdio]
1252   ],
1253   if test x$enable_cstdio = xno; then
1254      enable_cstdio=stdio
1255   fi,
1256      enable_cstdio=stdio)
1257
1258   enable_cstdio_flag=$enable_cstdio
1259
1260   dnl Check if a valid I/O package
1261   case x${enable_cstdio_flag} in
1262     xlibio)
1263       CSTDIO_H=config/io/c_io_libio.h
1264       BASIC_FILE_H=config/io/basic_file_libio.h
1265       BASIC_FILE_CC=config/io/basic_file_libio.cc
1266       AC_MSG_RESULT(libio)
1267
1268       # see if we are on a system with libio native (ie, linux)
1269       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1270
1271       # Need to check and see what version of glibc is being used. If
1272       # it's not glibc-2.2 or higher, then we'll need to go ahead and
1273       # compile most of libio for linux systems.
1274       if test x$has_libio = x"yes"; then
1275         case "$target" in
1276           *-*-linux*)
1277               AC_MSG_CHECKING([for glibc version >= 2.2])
1278               AC_EGREP_CPP([ok], [
1279             #include <features.h>
1280               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1281                     ok
1282               #endif
1283               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1284               AC_MSG_RESULT($glibc_satisfactory)
1285             ;;
1286         esac
1287
1288         # XXX at the moment, admit defeat and force the recompilation
1289         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1290         glibc_satisfactory=no
1291
1292         if test x$glibc_satisfactory = x"yes"; then
1293            need_libio=no
1294            need_wlibio=no
1295         else
1296            need_libio=yes
1297            # bkoz XXX need to add checks to enable this
1298            # pme XXX here's a first pass at such a check
1299            if test x$enable_c_mbchar != xno; then
1300               need_wlibio=yes
1301            else
1302               need_wlibio=no
1303            fi
1304         fi
1305
1306       else
1307          # Using libio, but <libio.h> doesn't exist on the target system. . .
1308          need_libio=yes
1309          # bkoz XXX need to add checks to enable this
1310          # pme XXX here's a first pass at such a check
1311          if test x$enable_c_mbchar != xno; then
1312              need_wlibio=yes
1313          else
1314              need_wlibio=no
1315          fi
1316       fi
1317       ;;
1318     xstdio | x | xno | xnone | xyes)
1319       # default
1320       CSTDIO_H=config/io/c_io_stdio.h
1321       BASIC_FILE_H=config/io/basic_file_stdio.h
1322       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1323       AC_MSG_RESULT(stdio)
1324
1325       # We're not using stdio.
1326       need_libio=no
1327       need_wlibio=no
1328       ;;
1329     *)
1330       echo "$enable_cstdio is an unknown io package" 1>&2
1331       exit 1
1332       ;;
1333   esac
1334   AC_SUBST(CSTDIO_H)
1335   AC_SUBST(BASIC_FILE_H)
1336   AC_LINK_FILES($BASIC_FILE_CC, src/basic_file.cc)
1337
1338   # 2000-08-04 bkoz hack
1339   CCODECVT_C=config/io/c_io_libio_codecvt.c
1340   AC_SUBST(CCODECVT_C)
1341   # 2000-08-04 bkoz hack
1342
1343   AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO,
1344                  test "$need_libio" = yes || test "$need_wlibio" = yes)
1345   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1346   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1347   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1348     libio_la=../libio/libio.la
1349   else
1350     libio_la=
1351   fi
1352   AC_SUBST(libio_la)
1353 ])
1354
1355
1356 dnl
1357 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1358 dnl We must stage the required headers so that they will be installed
1359 dnl with the library (unlike libgcc, the STL implementation is provided
1360 dnl solely within headers).  Since we must not inject random user-space
1361 dnl macro names into user-provided C++ code, we first stage into <file>-in
1362 dnl and process to <file> with an output command.  The reason for a two-
1363 dnl stage process here is to correctly handle $srcdir!=$objdir without
1364 dnl having to write complex code (the sed commands to clean the macro
1365 dnl namespace are complex and fragile enough as it is).  We must also
1366 dnl add a relative path so that -I- is supported properly.
1367 dnl
1368 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1369   AC_MSG_CHECKING([for thread model used by GCC])
1370   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1371   AC_MSG_RESULT([$target_thread_file])
1372
1373   if test $target_thread_file != single; then
1374     AC_DEFINE(HAVE_GTHR_DEFAULT)
1375     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1376   fi
1377
1378   glibcpp_thread_h=gthr-$target_thread_file.h
1379   AC_SUBST(glibcpp_thread_h)
1380 ])
1381
1382
1383 dnl
1384 dnl Check for exception handling support.  If an explicit enable/disable
1385 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1386 dnl target may or may not support call frame exceptions.
1387 dnl
1388 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1389 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1390 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1391 dnl
1392 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1393 dnl
1394 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1395   AC_MSG_CHECKING([for exception model to use])
1396   AC_LANG_SAVE
1397   AC_LANG_CPLUSPLUS
1398   AC_ARG_ENABLE(sjlj-exceptions,
1399   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1400   [:],
1401   [dnl Botheration.  Now we've got to detect the exception model.
1402    dnl Link tests against libgcc.a are problematic since -- at least
1403    dnl as of this writing -- we've not been given proper -L bits for
1404    dnl single-tree newlib and libgloss.
1405    dnl
1406    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1407    dnl conftest files before we got a change to grep them first.
1408    cat > conftest.$ac_ext << EOF
1409 [#]line __oline__ "configure"
1410 struct S { ~S(); };
1411 void bar();
1412 void foo()
1413 {
1414   S s;
1415   bar();
1416 }
1417 EOF
1418    old_CXXFLAGS="$CXXFLAGS"
1419    CXXFLAGS=-S
1420    if AC_TRY_EVAL(ac_compile); then
1421      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1422        enable_sjlj_exceptions=yes
1423      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1424        enable_sjlj_exceptions=no
1425      fi
1426    fi
1427    CXXFLAGS="$old_CXXFLAGS"
1428    rm -f conftest*])
1429    if test x$enable_sjlj_exceptions = xyes; then
1430      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1431         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1432      ac_exception_model_name=sjlj
1433    elif test x$enable_sjlj_exceptions = xno; then
1434      ac_exception_model_name="call frame"
1435    else
1436      AC_MSG_ERROR([unable to detect exception model])
1437    fi
1438    AC_LANG_RESTORE
1439    AC_MSG_RESULT($ac_exception_model_name)
1440 ])
1441
1442
1443 dnl
1444 dnl Check for libunwind exception handling support. If enabled then
1445 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1446 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1447 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1448 dnl on libunwind as well as libgcc.
1449 dnl
1450 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1451 dnl --enable-libunwind-exceptions forces the use of libunwind.
1452 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1453 dnl
1454 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1455 dnl
1456 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1457   AC_MSG_CHECKING([for use of libunwind])
1458   AC_ARG_ENABLE(libunwind-exceptions,
1459   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1460   use_libunwind_exceptions=$enableval,
1461   use_libunwind_exceptions=no)
1462   AC_MSG_RESULT($use_libunwind_exceptions)
1463   dnl Option parsed, now set things appropriately
1464   if test x"$use_libunwind_exceptions" = xyes; then
1465     LIBUNWIND_FLAG="-lunwind"
1466   else
1467     LIBUNWIND_FLAG=""
1468   fi
1469   AC_SUBST(LIBUNWIND_FLAG)
1470 ])
1471
1472 dnl
1473 dnl Check for ISO/IEC 9899:1999 "C99" support.
1474 dnl
1475 dnl GLIBCPP_ENABLE_C99
1476 dnl --enable-c99 defines _GLIBCPP_USE_C99
1477 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1478 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1479 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1480 dnl       defaults to `no'.
1481 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1482 dnl
1483 dnl GLIBCPP_ENABLE_C99
1484 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1485   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1486
1487   AC_ARG_ENABLE(c99,
1488   changequote(<<, >>)dnl
1489   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1490   changequote([, ])dnl
1491   [case "$enableval" in
1492    yes) enable_c99=yes ;;
1493    no)  enable_c99=no ;;
1494    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1495    esac],
1496   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1497
1498   AC_LANG_SAVE
1499   AC_LANG_CPLUSPLUS
1500
1501   # Check for the existence of <math.h> functions used if C99 is enabled.
1502   ac_c99_math=yes;
1503   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1504   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1505   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1506   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1507   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1508   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1509   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1510   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1511   AC_TRY_COMPILE([#include <math.h>],
1512                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1513   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1514   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1515   AC_TRY_COMPILE([#include <math.h>],
1516                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1517   AC_TRY_COMPILE([#include <math.h>],
1518                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1519   AC_MSG_RESULT($ac_c99_math)
1520
1521   # Check for the existence in <stdio.h> of vscanf, et. al.
1522   ac_c99_stdio=yes;
1523   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1524   AC_TRY_COMPILE([#include <stdio.h>],
1525                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1526   AC_TRY_COMPILE([#include <stdio.h>
1527                   #include <stdarg.h>
1528                   void foo(char* fmt, ...)
1529                   {va_list args; va_start(args, fmt);
1530                   vfscanf(stderr, "%i", args);}],
1531                   [],, [ac_c99_stdio=no])
1532   AC_TRY_COMPILE([#include <stdio.h>
1533                   #include <stdarg.h>
1534                   void foo(char* fmt, ...)
1535                   {va_list args; va_start(args, fmt);
1536                   vscanf("%i", args);}],
1537                   [],, [ac_c99_stdio=no])
1538   AC_TRY_COMPILE([#include <stdio.h>
1539                   #include <stdarg.h>
1540                   void foo(char* fmt, ...)
1541                   {va_list args; va_start(args, fmt);
1542                   vsnprintf(fmt, 0, "%i", args);}],
1543                   [],, [ac_c99_stdio=no])
1544   AC_TRY_COMPILE([#include <stdio.h>
1545                   #include <stdarg.h>
1546                   void foo(char* fmt, ...)
1547                   {va_list args; va_start(args, fmt);
1548                   vsscanf(fmt, "%i", args);}],
1549                   [],, [ac_c99_stdio=no])
1550   AC_MSG_RESULT($ac_c99_stdio)
1551
1552   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1553   ac_c99_stdlib=yes;
1554   AC_MSG_CHECKING([for lldiv_t declaration])
1555   AC_CACHE_VAL(ac_c99_lldiv_t, [
1556   AC_TRY_COMPILE([#include <stdlib.h>],
1557                    [ lldiv_t mydivt;],
1558                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1559   ])
1560   AC_MSG_RESULT($ac_c99_lldiv_t)
1561
1562   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1563   AC_TRY_COMPILE([#include <stdlib.h>],
1564                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1565   AC_TRY_COMPILE([#include <stdlib.h>],
1566                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1567   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1568   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1569   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1570   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1571   if test x"$ac_c99_lldiv_t" = x"no"; then
1572     ac_c99_stdlib=no;
1573   fi;
1574   AC_MSG_RESULT($ac_c99_stdlib)
1575
1576   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1577   # XXX the wchar.h checks should be rolled into the general C99 bits.
1578   ac_c99_wchar=yes;
1579   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1580   AC_TRY_COMPILE([#include <wchar.h>],
1581                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1582   AC_TRY_COMPILE([#include <wchar.h>],
1583                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1584   AC_TRY_COMPILE([#include <wchar.h>],
1585                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1586   AC_MSG_RESULT($ac_c99_wchar)
1587
1588   AC_MSG_CHECKING([for enabled ISO C99 support])
1589   if test x"$ac_c99_math" = x"no" ||
1590      test x"$ac_c99_stdio" = x"no" ||
1591      test x"$ac_c99_stdlib" = x"no" ||
1592      test x"$ac_c99_wchar" = x"no"; then
1593     enable_c99=no;
1594   fi;
1595   AC_MSG_RESULT($enable_c99)
1596
1597   # Option parsed, now set things appropriately
1598   if test x"$enable_c99" = x"yes"; then
1599     AC_DEFINE(_GLIBCPP_USE_C99)
1600   fi
1601
1602   AC_LANG_RESTORE
1603 ])
1604
1605
1606 dnl
1607 dnl Check for template specializations for the 'long long' type extension.
1608 dnl The result determines only whether 'long long' I/O is enabled; things
1609 dnl like numeric_limits<> specializations are always available.
1610 dnl
1611 dnl GLIBCPP_ENABLE_LONG_LONG
1612 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1613 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1614 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1615 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1616 dnl       defaults to `no'.
1617 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1618 dnl
1619 dnl GLIBCPP_ENABLE_LONG_LONG
1620 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1621   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1622
1623   AC_ARG_ENABLE(long-long,
1624   changequote(<<, >>)dnl
1625   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1626   changequote([, ])dnl
1627   [case "$enableval" in
1628    yes) enable_long_long=yes ;;
1629    no)  enable_long_long=no ;;
1630    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1631    esac],
1632   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1633
1634   AC_LANG_SAVE
1635   AC_LANG_CPLUSPLUS
1636
1637   AC_MSG_CHECKING([for enabled long long I/O support])
1638   # iostreams require strtoll, strtoull to compile
1639   AC_TRY_COMPILE([#include <stdlib.h>],
1640                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1641   AC_TRY_COMPILE([#include <stdlib.h>],
1642                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1643
1644   # Option parsed, now set things appropriately
1645   if test x"$enable_long_long" = xyes; then
1646     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1647   fi
1648   AC_MSG_RESULT($enable_long_long)
1649
1650   AC_LANG_RESTORE
1651 ])
1652
1653
1654 dnl
1655 dnl Check for what kind of C headers to use.
1656 dnl
1657 dnl GLIBCPP_ENABLE_CHEADERS
1658 dnl --enable-cheaders= [does stuff].
1659 dnl --disable-cheaders [does not do anything, really].
1660 dnl  +  This will eventually need to be 'c_shadow' by default.
1661 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1662 dnl       Where DEFAULT is either `c' or `c_std' or 'c_shadow'.
1663 dnl       If ommitted, it defaults to `c_std'.
1664 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1665 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1666 AC_MSG_CHECKING([for c header strategy to use])
1667 AC_ARG_ENABLE(cheaders,
1668 changequote(<<, >>)dnl
1669 <<  --enable-cheaders       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1670 changequote([, ])
1671   [case "$enableval" in
1672    c)
1673         enable_cheaders=c
1674         ;;
1675    c_std)
1676         enable_cheaders=c_std
1677         ;;
1678    c_shadow)
1679         enable_cheaders=c_shadow
1680         ;;
1681    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1682         ;;
1683   esac],
1684   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1685   AC_MSG_RESULT($enable_cheaders)
1686
1687   dnl Option parsed, now set things appropriately
1688   case "$enable_cheaders" in
1689     c_shadow)
1690         CSHADOW_FLAGS="-fno-builtin"
1691         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_shadow'
1692         ;;
1693     c_std)
1694         CSHADOW_FLAGS=""
1695         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1696         ;;
1697     c)
1698         CSHADOW_FLAGS=""
1699         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1700         ;;
1701   esac
1702
1703   AC_SUBST(CSHADOW_FLAGS)
1704   AC_SUBST(C_INCLUDE_DIR)
1705   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1706   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1707 ])
1708
1709
1710 dnl
1711 dnl Check for wide character support.  Has the same effect as the option
1712 dnl in gcc's configure, but in a form that autoconf can mess with.
1713 dnl
1714 dnl GLIBCPP_ENABLE_C_MBCHAR
1715 dnl --enable-c-mbchar requests all the wchar_t stuff.
1716 dnl --disable-c-mbchar doesn't.
1717 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1718 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1719 dnl       defaults to `no'.
1720 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1721 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1722 AC_ARG_ENABLE(c-mbchar,
1723 changequote(<<, >>)dnl
1724 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1725 changequote([, ])dnl
1726 [case "$enableval" in
1727  yes) enable_c_mbchar=yes ;;
1728  no)  enable_c_mbchar=no ;;
1729  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1730  esac],
1731 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1732 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1733 ])
1734
1735
1736 dnl
1737 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1738 dnl
1739 dnl TOPLEVEL_INCLUDES
1740 dnl LIBMATH_INCLUDES
1741 dnl LIBSUPCXX_INCLUDES
1742 dnl LIBIO_INCLUDES
1743 dnl CSHADOW_INCLUDES
1744 dnl
1745 dnl GLIBCPP_EXPORT_INCLUDES
1746 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1747   # Root level of the build directory include sources.
1748   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1749
1750   # Passed down for canadian crosses.
1751   if test x"$CANADIAN" = xyes; then
1752     TOPLEVEL_INCLUDES='-I$(includedir)'
1753   fi
1754
1755   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1756
1757   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1758
1759   if test x"$need_libio" = xyes; then
1760     LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1761     AC_SUBST(LIBIO_INCLUDES)
1762   fi
1763
1764   # Now, export this to all the little Makefiles....
1765   AC_SUBST(GLIBCPP_INCLUDES)
1766   AC_SUBST(TOPLEVEL_INCLUDES)
1767   AC_SUBST(LIBMATH_INCLUDES)
1768   AC_SUBST(LIBSUPCXX_INCLUDES)
1769 ])
1770
1771
1772 dnl
1773 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1774 dnl
1775 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1776   # Optimization flags that are probably a good idea for thrill-seekers. Just
1777   # uncomment the lines below and make, everything else is ready to go...
1778   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1779   OPTIMIZE_CXXFLAGS=
1780   AC_SUBST(OPTIMIZE_CXXFLAGS)
1781
1782   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1783   AC_SUBST(WARN_FLAGS)
1784 ])
1785
1786 dnl
1787 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1788 dnl  calculates gxx_install_dir
1789 dnl  exports glibcpp_toolexecdir
1790 dnl  exports glibcpp_toolexeclibdir
1791 dnl  exports glibcpp_prefixdir
1792 dnl
1793 dnl Assumes cross_compiling bits already done, and with_cross_host in
1794 dnl particular
1795 dnl
1796 dnl GLIBCPP_EXPORT_INSTALL_INFO
1797 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1798 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1799 # exported correctly in GLIBCPP_CONFIGURE.
1800 glibcpp_toolexecdir=no
1801 glibcpp_toolexeclibdir=no
1802 glibcpp_prefixdir=${prefix}
1803
1804 AC_MSG_CHECKING([for interface version number])
1805 libstdcxx_interface=$INTERFACE
1806 AC_MSG_RESULT($libstdcxx_interface)
1807
1808 # Process the option --with-gxx-include-dir=<path to include-files directory>
1809 AC_MSG_CHECKING([for --with-gxx-include-dir])
1810 AC_ARG_WITH(gxx-include-dir,
1811 [  --with-gxx-include-dir  the installation directory for include files],
1812 [case "${withval}" in
1813   yes)
1814     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1815     gxx_include_dir=no
1816     ;;
1817   no)
1818     gxx_include_dir=no
1819     ;;
1820   *)
1821     gxx_include_dir=${withval}
1822     ;;
1823 esac], [gxx_include_dir=no])
1824 AC_MSG_RESULT($gxx_include_dir)
1825
1826 # Process the option "--enable-version-specific-runtime-libs"
1827 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1828 AC_ARG_ENABLE(version-specific-runtime-libs,
1829 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1830 [case "$enableval" in
1831  yes) version_specific_libs=yes ;;
1832  no)  version_specific_libs=no ;;
1833  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1834  esac],
1835 version_specific_libs=no)dnl
1836 # Option set, now we can test it.
1837 AC_MSG_RESULT($version_specific_libs)
1838
1839 if test $version_specific_libs = yes; then
1840   # Need the gcc compiler version to know where to install libraries
1841   # and header files if --enable-version-specific-runtime-libs option
1842   # is selected.
1843   changequote(,)dnl
1844   gcc_version_trigger=${srcdir}/../gcc/version.c
1845   gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
1846   gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1847   gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/g++
1848   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1849   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1850   changequote([,])dnl
1851 fi
1852
1853 # Default case for install directory for include files.
1854 if test $version_specific_libs = no &&
1855    test $gxx_include_dir = no; then
1856   gxx_include_dir='$(prefix)'/include/g++-${libstdcxx_interface}
1857 fi
1858
1859 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1860 # Install a library built with a cross compiler in tooldir, not libdir.
1861 if test x"$glibcpp_toolexecdir" = x"no"; then
1862   if test -n "$with_cross_host" &&
1863      test x"$with_cross_host" != x"no"; then
1864     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1865     glibcpp_toolexeclibdir='$(toolexecdir)/lib$(MULTISUBDIR)'
1866   else
1867     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1868     glibcpp_toolexeclibdir='$(libdir)$(MULTISUBDIR)'
1869   fi
1870 fi
1871
1872 AC_MSG_CHECKING([for install location])
1873 AC_MSG_RESULT($gxx_include_dir)
1874
1875 AC_SUBST(glibcpp_prefixdir)
1876 AC_SUBST(gxx_include_dir)
1877 AC_SUBST(glibcpp_toolexecdir)
1878 AC_SUBST(glibcpp_toolexeclibdir)
1879 ])
1880
1881
1882 # Check for functions in math library.
1883 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1884 #
1885 # This file can be copied and used freely without restrictions.  It can
1886 # be used in projects which are not available under the GNU Public License
1887 # but which still want to provide support for the GNU gettext functionality.
1888 # Please note that the actual code is *not* freely available.
1889
1890 # serial 1
1891
1892 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1893 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1894 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1895
1896
1897 dnl This macro searches for a GNU version of make.  If a match is found, the
1898 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1899 dnl set to "#". This is useful for  including a special features in a Makefile,
1900 dnl which cannot be handled by other versions of make.  The variable
1901 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1902 dnl the empty string otherwise.
1903 dnl
1904 dnl Here is an example of its use:
1905 dnl
1906 dnl Makefile.in might contain:
1907 dnl
1908 dnl     # A failsafe way of putting a dependency rule into a makefile
1909 dnl     $(DEPEND):
1910 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1911 dnl
1912 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1913 dnl     @ifGNUmake@ include $(DEPEND)
1914 dnl     @ifGNUmake@ endif
1915 dnl
1916 dnl Then configure.in would normally contain:
1917 dnl
1918 dnl     CHECK_GNU_MAKE()
1919 dnl     AC_OUTPUT(Makefile)
1920 dnl
1921 dnl Then perhaps to cause gnu make to override any other make, we could do
1922 dnl something like this (note that GNU make always looks for GNUmakefile first):
1923 dnl
1924 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1925 dnl             mv Makefile GNUmakefile
1926 dnl             echo .DEFAULT: > Makefile ;
1927 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1928 dnl     fi
1929 dnl
1930 dnl Then, if any (well almost any) other make is called, and GNU make also
1931 dnl exists, then the other make wraps the GNU make.
1932 dnl
1933 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1934 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1935 dnl
1936 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1937 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1938 dnl #### conditional's subshell (" --version" is not a command), using a
1939 dnl #### different option to grep(1).
1940 dnl #### -pme
1941 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1942 dnl #### ${MAKE:-make}).
1943 dnl #### -msokolov
1944 AC_DEFUN(
1945   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1946           _cv_gnu_make_command='' ;
1947 dnl Search all the common names for GNU make
1948           for a in "${MAKE-make}" make gmake gnumake ; do
1949                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1950                   then
1951                           _cv_gnu_make_command=$a ;
1952                           break;
1953                   fi
1954           done ;
1955   ) ;
1956 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1957 dnl string, '#' otherwise
1958   if test  "x$_cv_gnu_make_command" != "x"  ; then
1959           ifGNUmake='' ;
1960   else
1961           ifGNUmake='#' ;
1962   fi
1963   AC_SUBST(ifGNUmake)
1964 ])
1965
1966
1967 dnl Check for headers for, and arguments to, the setrlimit() function.
1968 dnl Used only in testsuite_hooks.h.
1969 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
1970   AC_TRY_COMPILE([#include <sys/resource.h>
1971                   #include <unistd.h>
1972                  ], [ int f = RLIMIT_$1 ; ],
1973                  [glibcpp_mresult=1], [glibcpp_mresult=0])
1974   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
1975                      [Only used in build directory testsuite_hooks.h.])
1976 ])
1977 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
1978   setrlimit_have_headers=yes
1979   AC_CHECK_HEADERS(sys/resource.h unistd.h,
1980                    [],
1981                    setrlimit_have_headers=no)
1982   # If don't have the headers, then we can't run the tests now, and we
1983   # won't be seeing any of these during testsuite compilation.
1984   if test $setrlimit_have_headers = yes; then
1985     # Can't do these in a loop, else the resulting syntax is wrong.
1986     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
1987     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
1988     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
1989     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
1990
1991     # Check for rlimit, setrlimit.
1992     AC_CACHE_VAL(ac_setrlimit, [
1993       AC_TRY_COMPILE([#include <sys/resource.h>
1994                       #include <unistd.h>
1995                      ],
1996                      [ struct rlimit r; setrlimit(0, &r);],
1997                      [ac_setrlimit=yes], [ac_setrlimit=no])
1998     ])
1999   fi
2000
2001   AC_MSG_CHECKING([for testsuite memory limit support])
2002   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2003     ac_mem_limits=yes
2004     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2005   else
2006     ac_mem_limits=no
2007   fi
2008   AC_MSG_RESULT($ac_mem_limits)
2009 ])
2010
2011
2012 dnl
2013 dnl Does any necessary configuration of the testsuite directory.  Generates
2014 dnl the testsuite_hooks.h header.
2015 dnl
2016 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2017 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2018   GLIBCPP_CHECK_SETRLIMIT
2019
2020   # Look for setenv, so that extended locale tests can be performed.
2021   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2022 ])
2023
2024
2025 sinclude(../libtool.m4)
2026 dnl The lines below arrange for aclocal not to bring an installed
2027 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2028 dnl add a definition of LIBTOOL to Makefile.in.
2029 ifelse(,,,[AC_SUBST(LIBTOOL)
2030 AC_DEFUN([AM_PROG_LIBTOOL])
2031 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2032 AC_DEFUN([AC_PROG_LD])
2033 ])
2034
2035
2036 # Check whether LC_MESSAGES is available in <locale.h>.
2037 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2038 #
2039 # This file file be copied and used freely without restrictions.  It can
2040 # be used in projects which are not available under the GNU Public License
2041 # but which still want to provide support for the GNU gettext functionality.
2042 # Please note that the actual code is *not* freely available.
2043
2044 # serial 1
2045
2046 AC_DEFUN(AC_LC_MESSAGES, [
2047   AC_CHECK_HEADER(locale.h, [
2048     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2049       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2050        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2051     if test $ac_cv_val_LC_MESSAGES = yes; then
2052       AC_DEFINE(HAVE_LC_MESSAGES)
2053     fi
2054   ])
2055 ])
2056
2057
2058 dnl
2059 dnl Check for whether the Boost-derived checks should be turned on.
2060 dnl
2061 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2062 dnl --enable-concept-checks turns them on.
2063 dnl --disable-concept-checks leaves them off.
2064 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2065 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2066 dnl       defaults to `no'.
2067 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2068 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2069 AC_ARG_ENABLE(concept-checks,
2070 changequote(<<, >>)dnl
2071 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2072 changequote([, ])dnl
2073 [case "$enableval" in
2074  yes) enable_concept_checks=yes ;;
2075  no)  enable_concept_checks=no ;;
2076  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2077  esac],
2078 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2079 dnl Option parsed, now set things appropriately
2080 if test x"$enable_concept_checks" = xyes; then
2081   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2082 fi
2083 ])
2084
2085
2086 dnl
2087 dnl Add version tags to symbols in shared library (or not), additionally
2088 dnl marking other symbols as private/local (or not).
2089 dnl
2090 dnl GLIBCPP_ENABLE_SYMVERS
2091 dnl --enable-symvers=style adds a version script to the linker call when
2092 dnl       creating the shared library.  The choice of version script is
2093 dnl       controlled by 'style'.
2094 dnl --disable-symvers does not.
2095 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2096 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2097 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2098 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2099 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2100 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2101 AC_ARG_ENABLE(symvers,
2102 changequote(<<, >>)dnl
2103 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2104 changequote([, ])dnl
2105 [case "$enableval" in
2106  yes) enable_symvers=yes ;;
2107  no)  enable_symvers=no ;;
2108  # other names here, just as sanity checks
2109  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2110  gnu) enable_symvers=$enableval ;;
2111  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2112  esac],
2113 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2114
2115 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2116 # don't know enough about $LD to do tricks...
2117 if test x$enable_shared = xno ||
2118         test x$LD = x ||
2119         test x$glibcpp_gnu_ld_version = x; then
2120   enable_symvers=no
2121 fi
2122
2123 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2124 AC_MSG_CHECKING([for shared libgcc])
2125 ac_save_CFLAGS="$CFLAGS"
2126 CFLAGS=' -lgcc_s'
2127 AC_TRY_LINK( , [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2128 CFLAGS="$ac_save_CFLAGS"
2129 AC_MSG_RESULT($glibcpp_shared_libgcc)
2130
2131 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2132 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2133 glibcpp_min_gnu_ld_version=21200
2134
2135 # Check to see if unspecified "yes" value can win, given results
2136 # above.
2137 if test $enable_symvers = yes ; then
2138   if test $with_gnu_ld = yes &&
2139     test $glibcpp_shared_libgcc = yes ;
2140   then
2141     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2142         enable_symvers=gnu
2143     else
2144       ac_test_CFLAGS="${CFLAGS+set}"
2145       ac_save_CFLAGS="$CFLAGS"
2146       CFLAGS='-shared -Wl,--version-script,conftest.map'
2147       enable_symvers=no
2148       changequote(,)
2149       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2150       changequote([,])
2151       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2152       if test "$ac_test_CFLAGS" = set; then
2153         CFLAGS="$ac_save_CFLAGS"
2154       else
2155         # this is the suspicious part
2156         CFLAGS=''
2157       fi
2158       rm -f conftest.map
2159     fi
2160   else
2161     # just fail for now
2162     enable_symvers=no
2163   fi
2164 fi
2165
2166 dnl Everything parsed; figure out what file to use.
2167 case $enable_symvers in
2168   no)
2169       LINKER_MAP=config/linker-map.dummy
2170       ;;
2171   gnu)
2172       LINKER_MAP=config/linker-map.gnu
2173       ;;
2174 esac
2175
2176 AC_LINK_FILES($LINKER_MAP, src/linker.map)
2177 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2178 AC_MSG_CHECKING([versioning on shared library symbols])
2179 AC_MSG_RESULT($enable_symvers)
2180 ])
2181