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 ])
1468
1469 dnl
1470 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1471 dnl We must stage the required headers so that they will be installed
1472 dnl with the library (unlike libgcc, the STL implementation is provided
1473 dnl solely within headers).  Since we must not inject random user-space
1474 dnl macro names into user-provided C++ code, we first stage into <file>-in
1475 dnl and process to <file> with an output command.  The reason for a two-
1476 dnl stage process here is to correctly handle $srcdir!=$objdir without
1477 dnl having to write complex code (the sed commands to clean the macro
1478 dnl namespace are complex and fragile enough as it is).  We must also
1479 dnl add a relative path so that -I- is supported properly.
1480 dnl
1481 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1482   AC_MSG_CHECKING([for thread model used by GCC])
1483   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1484   AC_MSG_RESULT([$target_thread_file])
1485
1486   if test $target_thread_file != single; then
1487     AC_DEFINE(HAVE_GTHR_DEFAULT)
1488     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1489   fi
1490
1491   glibcpp_thread_h=gthr-$target_thread_file.h
1492   AC_SUBST(glibcpp_thread_h)
1493 ])
1494
1495
1496 dnl
1497 dnl Check for exception handling support.  If an explicit enable/disable
1498 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1499 dnl target may or may not support call frame exceptions.
1500 dnl
1501 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1502 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1503 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1504 dnl
1505 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1506 dnl
1507 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1508   AC_MSG_CHECKING([for exception model to use])
1509   AC_LANG_SAVE
1510   AC_LANG_CPLUSPLUS
1511   AC_ARG_ENABLE(sjlj-exceptions,
1512   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1513   [:],
1514   [dnl Botheration.  Now we've got to detect the exception model.
1515    dnl Link tests against libgcc.a are problematic since -- at least
1516    dnl as of this writing -- we've not been given proper -L bits for
1517    dnl single-tree newlib and libgloss.
1518    dnl
1519    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1520    dnl conftest files before we got a change to grep them first.
1521    cat > conftest.$ac_ext << EOF
1522 [#]line __oline__ "configure"
1523 struct S { ~S(); };
1524 void bar();
1525 void foo()
1526 {
1527   S s;
1528   bar();
1529 }
1530 EOF
1531    old_CXXFLAGS="$CXXFLAGS"
1532    CXXFLAGS=-S
1533    if AC_TRY_EVAL(ac_compile); then
1534      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1535        enable_sjlj_exceptions=yes
1536      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1537        enable_sjlj_exceptions=no
1538      fi
1539    fi
1540    CXXFLAGS="$old_CXXFLAGS"
1541    rm -f conftest*])
1542    if test x$enable_sjlj_exceptions = xyes; then
1543      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1544         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1545      ac_exception_model_name=sjlj
1546    elif test x$enable_sjlj_exceptions = xno; then
1547      ac_exception_model_name="call frame"
1548    else
1549      AC_MSG_ERROR([unable to detect exception model])
1550    fi
1551    AC_LANG_RESTORE
1552    AC_MSG_RESULT($ac_exception_model_name)
1553 ])
1554
1555
1556 dnl
1557 dnl Check for libunwind exception handling support. If enabled then
1558 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1559 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1560 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1561 dnl on libunwind as well as libgcc.
1562 dnl
1563 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1564 dnl --enable-libunwind-exceptions forces the use of libunwind.
1565 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1566 dnl
1567 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1568 dnl
1569 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1570   AC_MSG_CHECKING([for use of libunwind])
1571   AC_ARG_ENABLE(libunwind-exceptions,
1572   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1573   use_libunwind_exceptions=$enableval,
1574   use_libunwind_exceptions=no)
1575   AC_MSG_RESULT($use_libunwind_exceptions)
1576   dnl Option parsed, now set things appropriately
1577   if test x"$use_libunwind_exceptions" = xyes; then
1578     LIBUNWIND_FLAG="-lunwind"
1579   else
1580     LIBUNWIND_FLAG=""
1581   fi
1582   AC_SUBST(LIBUNWIND_FLAG)
1583 ])
1584
1585 dnl
1586 dnl Check for ISO/IEC 9899:1999 "C99" support.
1587 dnl
1588 dnl GLIBCPP_ENABLE_C99
1589 dnl --enable-c99 defines _GLIBCPP_USE_C99
1590 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1591 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1592 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1593 dnl       defaults to `no'.
1594 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1595 dnl
1596 dnl GLIBCPP_ENABLE_C99
1597 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1598   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1599
1600   AC_ARG_ENABLE(c99,
1601   changequote(<<, >>)dnl
1602   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1603   changequote([, ])dnl
1604   [case "$enableval" in
1605    yes) enable_c99=yes ;;
1606    no)  enable_c99=no ;;
1607    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1608    esac],
1609   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1610
1611   AC_LANG_SAVE
1612   AC_LANG_CPLUSPLUS
1613
1614   # Check for the existence of <math.h> functions used if C99 is enabled.
1615   ac_c99_math=yes;
1616   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1617   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1618   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1619   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1620   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1621   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1622   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1623   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1624   AC_TRY_COMPILE([#include <math.h>],
1625                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1626   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1627   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1628   AC_TRY_COMPILE([#include <math.h>],
1629                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1630   AC_TRY_COMPILE([#include <math.h>],
1631                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1632   AC_MSG_RESULT($ac_c99_math)
1633
1634   # Check for the existence in <stdio.h> of vscanf, et. al.
1635   ac_c99_stdio=yes;
1636   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1637   AC_TRY_COMPILE([#include <stdio.h>],
1638                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1639   AC_TRY_COMPILE([#include <stdio.h>
1640                   #include <stdarg.h>
1641                   void foo(char* fmt, ...)
1642                   {va_list args; va_start(args, fmt);
1643                   vfscanf(stderr, "%i", args);}],
1644                   [],, [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                   vscanf("%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                   vsnprintf(fmt, 0, "%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                   vsscanf(fmt, "%i", args);}],
1662                   [],, [ac_c99_stdio=no])
1663   AC_MSG_RESULT($ac_c99_stdio)
1664
1665   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1666   ac_c99_stdlib=yes;
1667   AC_MSG_CHECKING([for lldiv_t declaration])
1668   AC_CACHE_VAL(ac_c99_lldiv_t, [
1669   AC_TRY_COMPILE([#include <stdlib.h>],
1670                    [ lldiv_t mydivt;],
1671                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1672   ])
1673   AC_MSG_RESULT($ac_c99_lldiv_t)
1674
1675   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1676   AC_TRY_COMPILE([#include <stdlib.h>],
1677                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1678   AC_TRY_COMPILE([#include <stdlib.h>],
1679                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1680   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1681   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1682   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1683   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1684   if test x"$ac_c99_lldiv_t" = x"no"; then
1685     ac_c99_stdlib=no;
1686   fi;
1687   AC_MSG_RESULT($ac_c99_stdlib)
1688
1689   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1690   # XXX the wchar.h checks should be rolled into the general C99 bits.
1691   ac_c99_wchar=yes;
1692   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1693   AC_TRY_COMPILE([#include <wchar.h>],
1694                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1695   AC_TRY_COMPILE([#include <wchar.h>],
1696                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1697   AC_TRY_COMPILE([#include <wchar.h>],
1698                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1699   AC_MSG_RESULT($ac_c99_wchar)
1700
1701   AC_MSG_CHECKING([for enabled ISO C99 support])
1702   if test x"$ac_c99_math" = x"no" ||
1703      test x"$ac_c99_stdio" = x"no" ||
1704      test x"$ac_c99_stdlib" = x"no" ||
1705      test x"$ac_c99_wchar" = x"no"; then
1706     enable_c99=no;
1707   fi;
1708   AC_MSG_RESULT($enable_c99)
1709
1710   # Option parsed, now set things appropriately
1711   if test x"$enable_c99" = x"yes"; then
1712     AC_DEFINE(_GLIBCPP_USE_C99)
1713   fi
1714
1715   AC_LANG_RESTORE
1716 ])
1717
1718
1719 dnl
1720 dnl Check for template specializations for the 'long long' type extension.
1721 dnl The result determines only whether 'long long' I/O is enabled; things
1722 dnl like numeric_limits<> specializations are always available.
1723 dnl
1724 dnl GLIBCPP_ENABLE_LONG_LONG
1725 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1726 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1727 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1728 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1729 dnl       defaults to `no'.
1730 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1731 dnl
1732 dnl GLIBCPP_ENABLE_LONG_LONG
1733 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1734   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1735
1736   AC_ARG_ENABLE(long-long,
1737   changequote(<<, >>)dnl
1738   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1739   changequote([, ])dnl
1740   [case "$enableval" in
1741    yes) enable_long_long=yes ;;
1742    no)  enable_long_long=no ;;
1743    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1744    esac],
1745   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1746
1747   AC_LANG_SAVE
1748   AC_LANG_CPLUSPLUS
1749
1750   AC_MSG_CHECKING([for enabled long long I/O support])
1751   # iostreams require strtoll, strtoull to compile
1752   AC_TRY_COMPILE([#include <stdlib.h>],
1753                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1754   AC_TRY_COMPILE([#include <stdlib.h>],
1755                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1756
1757   # Option parsed, now set things appropriately
1758   if test x"$enable_long_long" = xyes; then
1759     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1760   fi
1761   AC_MSG_RESULT($enable_long_long)
1762
1763   AC_LANG_RESTORE
1764 ])
1765
1766
1767 dnl
1768 dnl Check for what type of C headers to use.
1769 dnl
1770 dnl GLIBCPP_ENABLE_CHEADERS
1771 dnl --enable-cheaders= [does stuff].
1772 dnl --disable-cheaders [does not do anything, really].
1773 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1774 dnl       Where DEFAULT is either `c' or `c_std'.
1775 dnl       If ommitted, it defaults to `c_std'.
1776 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1777 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1778 AC_MSG_CHECKING([for c header strategy to use])
1779 AC_ARG_ENABLE(cheaders,
1780 changequote(<<, >>)dnl
1781 <<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1782 changequote([, ])
1783   [case "$enableval" in
1784    c)
1785         enable_cheaders=c
1786         ;;
1787    c_std)
1788         enable_cheaders=c_std
1789         ;;
1790    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1791         ;;
1792   esac],
1793   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1794   AC_MSG_RESULT($enable_cheaders)
1795
1796   dnl Option parsed, now set things appropriately
1797   case "$enable_cheaders" in
1798     c_std)
1799         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1800         ;;
1801     c)
1802         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1803         ;;
1804   esac
1805
1806   AC_SUBST(C_INCLUDE_DIR)
1807   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1808   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1809   AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
1810 ])
1811
1812
1813 dnl
1814 dnl Check for wide character support.  Has the same effect as the option
1815 dnl in gcc's configure, but in a form that autoconf can mess with.
1816 dnl
1817 dnl GLIBCPP_ENABLE_C_MBCHAR
1818 dnl --enable-c-mbchar requests all the wchar_t stuff.
1819 dnl --disable-c-mbchar doesn't.
1820 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1821 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1822 dnl       defaults to `no'.
1823 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1824 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1825 AC_ARG_ENABLE(c-mbchar,
1826 changequote(<<, >>)dnl
1827 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1828 changequote([, ])dnl
1829 [case "$enableval" in
1830  yes) enable_c_mbchar=yes ;;
1831  no)  enable_c_mbchar=no ;;
1832  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1833  esac],
1834 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1835 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1836 ])
1837
1838
1839 dnl
1840 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1841 dnl
1842 dnl TOPLEVEL_INCLUDES
1843 dnl LIBMATH_INCLUDES
1844 dnl LIBSUPCXX_INCLUDES
1845 dnl LIBIO_INCLUDES
1846 dnl
1847 dnl GLIBCPP_EXPORT_INCLUDES
1848 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1849   # Root level of the build directory include sources.
1850   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1851
1852   # Passed down for canadian crosses.
1853   if test x"$CANADIAN" = xyes; then
1854     TOPLEVEL_INCLUDES='-I$(includedir)'
1855   fi
1856
1857   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1858
1859   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1860
1861   if test x"$need_libio" = xyes; then
1862     LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1863     AC_SUBST(LIBIO_INCLUDES)
1864   fi
1865
1866   # Now, export this to all the little Makefiles....
1867   AC_SUBST(GLIBCPP_INCLUDES)
1868   AC_SUBST(TOPLEVEL_INCLUDES)
1869   AC_SUBST(LIBMATH_INCLUDES)
1870   AC_SUBST(LIBSUPCXX_INCLUDES)
1871 ])
1872
1873
1874 dnl
1875 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1876 dnl
1877 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1878   # Optimization flags that are probably a good idea for thrill-seekers. Just
1879   # uncomment the lines below and make, everything else is ready to go...
1880   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1881   OPTIMIZE_CXXFLAGS=
1882   AC_SUBST(OPTIMIZE_CXXFLAGS)
1883
1884   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings'
1885   AC_SUBST(WARN_FLAGS)
1886 ])
1887
1888 dnl
1889 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1890 dnl  calculates gxx_install_dir
1891 dnl  exports glibcpp_toolexecdir
1892 dnl  exports glibcpp_toolexeclibdir
1893 dnl  exports glibcpp_prefixdir
1894 dnl
1895 dnl Assumes cross_compiling bits already done, and with_cross_host in
1896 dnl particular
1897 dnl
1898 dnl GLIBCPP_EXPORT_INSTALL_INFO
1899 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1900 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1901 # exported correctly in GLIBCPP_CONFIGURE.
1902 glibcpp_toolexecdir=no
1903 glibcpp_toolexeclibdir=no
1904 glibcpp_prefixdir=${prefix}
1905
1906 # Process the option --with-gxx-include-dir=<path to include-files directory>
1907 AC_MSG_CHECKING([for --with-gxx-include-dir])
1908 AC_ARG_WITH(gxx-include-dir,
1909 [  --with-gxx-include-dir  the installation directory for include files],
1910 [case "${withval}" in
1911   yes)
1912     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1913     gxx_include_dir=no
1914     ;;
1915   no)
1916     gxx_include_dir=no
1917     ;;
1918   *)
1919     gxx_include_dir=${withval}
1920     ;;
1921 esac], [gxx_include_dir=no])
1922 AC_MSG_RESULT($gxx_include_dir)
1923
1924 # Process the option "--enable-version-specific-runtime-libs"
1925 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1926 AC_ARG_ENABLE(version-specific-runtime-libs,
1927 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1928 [case "$enableval" in
1929  yes) version_specific_libs=yes ;;
1930  no)  version_specific_libs=no ;;
1931  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1932  esac],
1933 version_specific_libs=no)dnl
1934 # Option set, now we can test it.
1935 AC_MSG_RESULT($version_specific_libs)
1936
1937 # Default case for install directory for include files.
1938 if test $version_specific_libs = no && test $gxx_include_dir = no; then
1939   gxx_include_dir='$(prefix)'/include/c++/${gcc_version}
1940 fi
1941
1942 # Version-specific runtime libs processing.
1943 if test $version_specific_libs = yes; then
1944   # Need the gcc compiler version to know where to install libraries
1945   # and header files if --enable-version-specific-runtime-libs option
1946   # is selected.
1947   if test x"$gxx_include_dir" = x"no"; then
1948     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
1949   fi
1950   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1951   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1952 fi
1953
1954 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1955 # Install a library built with a cross compiler in tooldir, not libdir.
1956 if test x"$glibcpp_toolexecdir" = x"no"; then
1957   if test -n "$with_cross_host" &&
1958      test x"$with_cross_host" != x"no"; then
1959     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1960     glibcpp_toolexeclibdir='$(toolexecdir)/lib'
1961   else
1962     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1963     glibcpp_toolexeclibdir='$(libdir)'
1964   fi
1965   multi_os_directory=`$CC -print-multi-os-directory`
1966   case $multi_os_directory in
1967   .) ;; # Avoid trailing /.
1968   *) glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/$multi_os_directory ;;
1969   esac
1970 fi
1971
1972 AC_MSG_CHECKING([for install location])
1973 AC_MSG_RESULT($gxx_include_dir)
1974
1975 AC_SUBST(glibcpp_prefixdir)
1976 AC_SUBST(gxx_include_dir)
1977 AC_SUBST(glibcpp_toolexecdir)
1978 AC_SUBST(glibcpp_toolexeclibdir)
1979 ])
1980
1981
1982 # Check for functions in math library.
1983 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1984 #
1985 # This file can be copied and used freely without restrictions.  It can
1986 # be used in projects which are not available under the GNU Public License
1987 # but which still want to provide support for the GNU gettext functionality.
1988 # Please note that the actual code is *not* freely available.
1989
1990 # serial 1
1991
1992 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1993 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1994 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1995
1996
1997 dnl This macro searches for a GNU version of make.  If a match is found, the
1998 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1999 dnl set to "#". This is useful for  including a special features in a Makefile,
2000 dnl which cannot be handled by other versions of make.  The variable
2001 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
2002 dnl the empty string otherwise.
2003 dnl
2004 dnl Here is an example of its use:
2005 dnl
2006 dnl Makefile.in might contain:
2007 dnl
2008 dnl     # A failsafe way of putting a dependency rule into a makefile
2009 dnl     $(DEPEND):
2010 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
2011 dnl
2012 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
2013 dnl     @ifGNUmake@ include $(DEPEND)
2014 dnl     @ifGNUmake@ endif
2015 dnl
2016 dnl Then configure.in would normally contain:
2017 dnl
2018 dnl     CHECK_GNU_MAKE()
2019 dnl     AC_OUTPUT(Makefile)
2020 dnl
2021 dnl Then perhaps to cause gnu make to override any other make, we could do
2022 dnl something like this (note that GNU make always looks for GNUmakefile first):
2023 dnl
2024 dnl     if  ! test x$_cv_gnu_make_command = x ; then
2025 dnl             mv Makefile GNUmakefile
2026 dnl             echo .DEFAULT: > Makefile ;
2027 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
2028 dnl     fi
2029 dnl
2030 dnl Then, if any (well almost any) other make is called, and GNU make also
2031 dnl exists, then the other make wraps the GNU make.
2032 dnl
2033 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
2034 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
2035 dnl
2036 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
2037 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
2038 dnl #### conditional's subshell (" --version" is not a command), using a
2039 dnl #### different option to grep(1).
2040 dnl #### -pme
2041 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
2042 dnl #### ${MAKE:-make}).
2043 dnl #### -msokolov
2044 AC_DEFUN(
2045   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
2046           _cv_gnu_make_command='' ;
2047 dnl Search all the common names for GNU make
2048           for a in "${MAKE-make}" make gmake gnumake ; do
2049                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2050                   then
2051                           _cv_gnu_make_command=$a ;
2052                           break;
2053                   fi
2054           done ;
2055   ) ;
2056 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
2057 dnl string, '#' otherwise
2058   if test  "x$_cv_gnu_make_command" != "x"  ; then
2059           ifGNUmake='' ;
2060   else
2061           ifGNUmake='#' ;
2062   fi
2063   AC_SUBST(ifGNUmake)
2064 ])
2065
2066
2067 dnl Check for headers for, and arguments to, the setrlimit() function.
2068 dnl Used only in testsuite_hooks.h.
2069 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
2070   AC_TRY_COMPILE([#include <unistd.h>
2071                   #include <sys/time.h>
2072                   #include <sys/resource.h>
2073                  ], [ int f = RLIMIT_$1 ; ],
2074                  [glibcpp_mresult=1], [glibcpp_mresult=0])
2075   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
2076                      [Only used in build directory testsuite_hooks.h.])
2077 ])
2078 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
2079   setrlimit_have_headers=yes
2080   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
2081                    [],
2082                    setrlimit_have_headers=no)
2083   # If don't have the headers, then we can't run the tests now, and we
2084   # won't be seeing any of these during testsuite compilation.
2085   if test $setrlimit_have_headers = yes; then
2086     # Can't do these in a loop, else the resulting syntax is wrong.
2087     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
2088     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
2089     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
2090     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
2091
2092     # Check for rlimit, setrlimit.
2093     AC_CACHE_VAL(ac_setrlimit, [
2094       AC_TRY_COMPILE([#include <unistd.h>
2095                   #include <sys/time.h>
2096                   #include <sys/resource.h>
2097                      ],
2098                      [ struct rlimit r; setrlimit(0, &r);],
2099                      [ac_setrlimit=yes], [ac_setrlimit=no])
2100     ])
2101   fi
2102
2103   AC_MSG_CHECKING([for testsuite memory limit support])
2104   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2105     ac_mem_limits=yes
2106     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2107   else
2108     ac_mem_limits=no
2109   fi
2110   AC_MSG_RESULT($ac_mem_limits)
2111 ])
2112
2113
2114 dnl
2115 dnl Does any necessary configuration of the testsuite directory.  Generates
2116 dnl the testsuite_hooks.h header.
2117 dnl
2118 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2119 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2120   GLIBCPP_CHECK_SETRLIMIT
2121
2122   # Look for setenv, so that extended locale tests can be performed.
2123   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2124
2125   # Export file names for ABI checking.
2126   baseline_file="${glibcpp_srcdir}/config/abi/${abi_baseline_triplet}/baseline_symbols.txt"
2127   AC_SUBST(baseline_file)
2128
2129   case "$target" in
2130     *-*-cygwin* ) enable_abi_check=no ;;
2131     * ) enable_abi_check=yes ;;
2132   esac
2133
2134   # Don't do ABI checking unless native.
2135   AM_CONDITIONAL(GLIBCPP_BUILD_ABI_CHECK,
2136                  test x"$build" = x"$host" && test -z "$with_cross_host" \
2137                  && test "$enable_abi_check" = yes )
2138 ])
2139
2140
2141 sinclude(../libtool.m4)
2142 dnl The lines below arrange for aclocal not to bring an installed
2143 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2144 dnl add a definition of LIBTOOL to Makefile.in.
2145 ifelse(,,,[AC_SUBST(LIBTOOL)
2146 AC_DEFUN([AM_PROG_LIBTOOL])
2147 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2148 AC_DEFUN([AC_PROG_LD])
2149 ])
2150
2151 dnl
2152 dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
2153 dnl
2154
2155 AC_DEFUN(GLIBCPP_CHECK_S_ISREG_OR_S_IFREG, [
2156   AC_CACHE_VAL(glibcpp_cv_S_ISREG, [
2157     AC_TRY_LINK([#include <sys/stat.h>],
2158                 [struct stat buffer; fstat(0, &buffer); S_ISREG(buffer.st_mode); ],
2159                 [glibcpp_cv_S_ISREG=yes],
2160                 [glibcpp_cv_S_ISREG=no])
2161   ])
2162   AC_CACHE_VAL(glibcpp_cv_S_IFREG, [
2163     AC_TRY_LINK([#include <sys/stat.h>],
2164                 [struct stat buffer; fstat(0, &buffer); S_IFREG & buffer.st_mode; ],
2165                 [glibcpp_cv_S_IFREG=yes],
2166                 [glibcpp_cv_S_IFREG=no])
2167   ])
2168   if test x$glibcpp_cv_S_ISREG = xyes; then
2169     AC_DEFINE(HAVE_S_ISREG)
2170   elif test x$glibcpp_cv_S_IFREG = xyes; then
2171     AC_DEFINE(HAVE_S_IFREG)
2172   fi
2173 ])
2174
2175 dnl
2176 dnl Check whether poll is available in <poll.h>.
2177 dnl
2178
2179 AC_DEFUN(GLIBCPP_CHECK_POLL, [
2180   AC_CACHE_VAL(glibcpp_cv_POLL, [
2181     AC_TRY_COMPILE([#include <poll.h>],
2182                 [struct pollfd pfd[1]; pfd[0].events = POLLIN; poll(pfd, 1, 0); ],
2183                 [glibcpp_cv_POLL=yes],
2184                 [glibcpp_cv_POLL=no])
2185   ])
2186   if test x$glibcpp_cv_POLL = xyes; then
2187     AC_DEFINE(HAVE_POLL)
2188   fi
2189 ])
2190
2191 # Check whether LC_MESSAGES is available in <locale.h>.
2192 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2193 #
2194 # This file file be copied and used freely without restrictions.  It can
2195 # be used in projects which are not available under the GNU Public License
2196 # but which still want to provide support for the GNU gettext functionality.
2197 # Please note that the actual code is *not* freely available.
2198
2199 # serial 1
2200
2201 AC_DEFUN(AC_LC_MESSAGES, [
2202   AC_CHECK_HEADER(locale.h, [
2203     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2204       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2205        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2206     if test $ac_cv_val_LC_MESSAGES = yes; then
2207       AC_DEFINE(HAVE_LC_MESSAGES)
2208     fi
2209   ])
2210 ])
2211
2212
2213 dnl
2214 dnl Check for whether the Boost-derived checks should be turned on.
2215 dnl
2216 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2217 dnl --enable-concept-checks turns them on.
2218 dnl --disable-concept-checks leaves them off.
2219 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2220 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2221 dnl       defaults to `no'.
2222 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2223 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2224 AC_ARG_ENABLE(concept-checks,
2225 changequote(<<, >>)dnl
2226 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2227 changequote([, ])dnl
2228 [case "$enableval" in
2229  yes) enable_concept_checks=yes ;;
2230  no)  enable_concept_checks=no ;;
2231  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2232  esac],
2233 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2234 dnl Option parsed, now set things appropriately
2235 if test x"$enable_concept_checks" = xyes; then
2236   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2237 fi
2238 ])
2239
2240
2241 dnl
2242 dnl Add version tags to symbols in shared library (or not), additionally
2243 dnl marking other symbols as private/local (or not).
2244 dnl
2245 dnl GLIBCPP_ENABLE_SYMVERS
2246 dnl --enable-symvers=style adds a version script to the linker call when
2247 dnl       creating the shared library.  The choice of version script is
2248 dnl       controlled by 'style'.
2249 dnl --disable-symvers does not.
2250 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2251 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2252 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2253 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2254 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2255 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2256 AC_ARG_ENABLE(symvers,
2257 changequote(<<, >>)dnl
2258 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2259 changequote([, ])dnl
2260 [case "$enableval" in
2261  yes) enable_symvers=yes ;;
2262  no)  enable_symvers=no ;;
2263  # other names here, just as sanity checks
2264  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2265  gnu) enable_symvers=$enableval ;;
2266  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2267  esac],
2268 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2269
2270 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2271 # don't know enough about $LD to do tricks...
2272 if test x$enable_shared = xno ||
2273         test "x$LD" = x ||
2274         test x$glibcpp_gnu_ld_version = x; then
2275   enable_symvers=no
2276 fi
2277
2278 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2279 if test $enable_symvers != no; then
2280   AC_MSG_CHECKING([for shared libgcc])
2281   ac_save_CFLAGS="$CFLAGS"
2282   CFLAGS=' -lgcc_s'
2283   AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2284   CFLAGS="$ac_save_CFLAGS"
2285   AC_MSG_RESULT($glibcpp_shared_libgcc)
2286 fi
2287
2288 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2289 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2290 glibcpp_min_gnu_ld_version=21200
2291
2292 # Check to see if unspecified "yes" value can win, given results
2293 # above.
2294 if test $enable_symvers = yes ; then
2295   if test $with_gnu_ld = yes &&
2296     test $glibcpp_shared_libgcc = yes ;
2297   then
2298     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2299         enable_symvers=gnu
2300     else
2301       ac_test_CFLAGS="${CFLAGS+set}"
2302       ac_save_CFLAGS="$CFLAGS"
2303       CFLAGS='-shared -Wl,--version-script,conftest.map'
2304       enable_symvers=no
2305       changequote(,)
2306       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2307       changequote([,])
2308       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2309       if test "$ac_test_CFLAGS" = set; then
2310         CFLAGS="$ac_save_CFLAGS"
2311       else
2312         # this is the suspicious part
2313         CFLAGS=''
2314       fi
2315       rm -f conftest.map
2316     fi
2317   else
2318     # just fail for now
2319     enable_symvers=no
2320   fi
2321 fi
2322
2323 dnl Everything parsed; figure out what file to use.
2324 case $enable_symvers in
2325   no)
2326       SYMVER_MAP=config/linker-map.dummy
2327       ;;
2328   gnu)
2329       SYMVER_MAP=config/linker-map.gnu
2330       AC_DEFINE(_GLIBCPP_SYMVER)
2331       ;;
2332 esac
2333
2334 AC_SUBST(SYMVER_MAP)
2335 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2336 AC_MSG_CHECKING([versioning on shared library symbols])
2337 AC_MSG_RESULT($enable_symvers)
2338 ])
2339