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