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