libstdc++-v3/acinclude.m4

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