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 Because the builtins are picky picky picky about the arguments they take,
 595 dnl do an explict linkage tests here.
 596 dnl Check to see if the (math function) argument passed is
 597 dnl 1) declared when using the c++ compiler
 598 dnl 2) has "C" linkage
 599 dnl
 600 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 601 dnl
 602 dnl argument 1 is name of function to check
 603 dnl
 604 dnl ASSUMES argument is a math function with ONE parameter
 605 dnl
 606 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 607 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 608   AC_MSG_CHECKING([for $1 declaration])
 609   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 610     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 611       AC_LANG_SAVE
 612       AC_LANG_CPLUSPLUS
 613       AC_TRY_COMPILE([#include <math.h>],
 614                      [ $1(0);],
 615                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 616       AC_LANG_RESTORE
 617     ])
 618   fi
 619   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 620   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 621     AC_MSG_CHECKING([for $1 linkage])
 622     if test x${glibcpp_cv_func_$1_link+set} != xset; then
 623       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 624         AC_TRY_LINK([#include <math.h>],
 625                     [ $1(0);],
 626                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 627       ])
 628     fi
 629     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 630     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 631       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 632       AC_DEFINE_UNQUOTED(${ac_tr_func})
 633     fi
 634   fi
 635 ])
 636
 637
 638 dnl
 639 dnl Check to see what builtin math functions are supported
 640 dnl
 641 dnl check for __builtin_abs
 642 dnl check for __builtin_fabsf
 643 dnl check for __builtin_fabs
 644 dnl check for __builtin_fabl
 645 dnl check for __builtin_labs
 646 dnl check for __builtin_sqrtf
 647 dnl check for __builtin_sqrtl
 648 dnl check for __builtin_sqrt
 649 dnl check for __builtin_sinf
 650 dnl check for __builtin_sin
 651 dnl check for __builtin_sinl
 652 dnl check for __builtin_cosf
 653 dnl check for __builtin_cos
 654 dnl check for __builtin_cosl
 655 dnl
 656 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 657 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 658   dnl Test for builtin math functions.
 659   dnl These are made in gcc/c-common.c
 660   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 661   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 662   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 663   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 664   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 665
 666   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 667   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
 668   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 669
 670   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 671   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 672   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 673
 674   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 675   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 676   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 677
 678   dnl There is, without a doubt, a more elegant way to have these
 679   dnl names exported so that they won't be stripped out of acconfig.h by
 680   dnl autoheader. I leave this as an exercise to somebody less frustrated
 681   dnl than I.... please email the libstdc++ list if you can figure out a
 682   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 683   dnl AC_CHECK_FUNC for things to steal.)
 684   dummyvar=no
 685   if test x$dummyvar = x"yes"; then
 686     AC_DEFINE(HAVE___BUILTIN_ABS)
 687     AC_DEFINE(HAVE___BUILTIN_LABS)
 688     AC_DEFINE(HAVE___BUILTIN_COS)
 689     AC_DEFINE(HAVE___BUILTIN_COSF)
 690     AC_DEFINE(HAVE___BUILTIN_COSL)
 691     AC_DEFINE(HAVE___BUILTIN_FABS)
 692     AC_DEFINE(HAVE___BUILTIN_FABSF)
 693     AC_DEFINE(HAVE___BUILTIN_FABSL)
 694     AC_DEFINE(HAVE___BUILTIN_SIN)
 695     AC_DEFINE(HAVE___BUILTIN_SINF)
 696     AC_DEFINE(HAVE___BUILTIN_SINL)
 697     AC_DEFINE(HAVE___BUILTIN_SQRT)
 698     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 699     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 700   fi
 701 ])
 702
 703 dnl
 704 dnl Check to see what the underlying c library is like
 705 dnl These checks need to do two things:
 706 dnl 1) make sure the name is declared when using the c++ compiler
 707 dnl 2) make sure the name has "C" linkage
 708 dnl This might seem like overkill but experience has shown that it's not...
 709 dnl
 710 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 711 dnl Define HAVE_STRTOF if "strtof" is declared and links
 712 dnl Define HAVE_DRAND48 if "drand48" is declared and links
 713 dnl
 714 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
 715 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
 716   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 717   ac_save_CXXFLAGS="$CXXFLAGS"
 718   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 719
 720   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 721   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
 722   AC_CHECK_FUNCS(drand48)
 723
 724   CXXFLAGS="$ac_save_CXXFLAGS"
 725 ])
 726
 727 dnl
 728 dnl Check to see what the underlying c library or math library is like.
 729 dnl These checks need to do two things:
 730 dnl 1) make sure the name is declared when using the c++ compiler
 731 dnl 2) make sure the name has "C" linkage
 732 dnl This might seem like overkill but experience has shown that it's not...
 733 dnl
 734 dnl Define HAVE_CARGF etc if "cargf" is found.
 735 dnl
 736 dnl GLIBCPP_CHECK_MATH_SUPPORT
 737 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
 738   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 739   ac_save_CXXFLAGS="$CXXFLAGS"
 740   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 741
 742   dnl Check libm
 743   AC_CHECK_LIB(m, sin, libm="-lm")
 744   ac_save_LIBS="$LIBS"
 745   LIBS="$LIBS $libm"
 746
 747   dnl Check to see if certain C math functions exist.
 748   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 749   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 750   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 751   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 752   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 753   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 754   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 755   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
 756
 757   dnl Check to see if basic C math functions have float versions.
 758   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
 759                                           float_trig,
 760                                           acosf asinf atanf \
 761                                           cosf sinf tanf \
 762                                           coshf sinhf tanhf)
 763   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
 764                                           float_round,
 765                                           ceilf floorf)
 766   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
 767   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 768   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 769   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
 770   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 771   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 772   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 773   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
 774   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 775   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 776   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 777   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 778   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 779   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 780   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 781   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 782
 783   dnl Check to see if basic C math functions have long double versions.
 784   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
 785                                           long_double_trig,
 786                                           acosl asinl atanl \
 787                                           cosl sinl tanl \
 788                                           coshl sinhl tanhl)
 789   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
 790                                           long_double_round,
 791                                           ceill floorl)
 792   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 793   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 794   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 795   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 796   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 797   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 798   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 799   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 800   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
 801   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 802   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 803   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 804   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 805   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 806   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 807   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 808   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 809
 810   dnl Some runtimes have these functions with a preceding underscore. Please
 811   dnl keep this sync'd with the one above. And if you add any new symbol,
 812   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
 813   dnl Check to see if certain C math functions exist.
 814
 815   dnl Check to see if basic C math functions have float versions.
 816   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
 817                                           _float_trig,
 818                                           _acosf _asinf _atanf \
 819                                           _cosf _sinf _tanf \
 820                                           _coshf _sinhf _tanhf)
 821   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
 822                                           _float_round,
 823                                           _ceilf _floorf)
 824
 825   dnl Check to see if basic C math functions have long double versions.
 826   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
 827                                           _long_double_trig,
 828                                           _acosl _asinl _atanl \
 829                                           _cosl _sinl _tanl \
 830                                           _coshl _sinhl _tanhl)
 831   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
 832                                           _long_double_round,
 833                                           _ceill _floorl)
 834
 835   LIBS="$ac_save_LIBS"
 836   CXXFLAGS="$ac_save_CXXFLAGS"
 837 ])
 838
 839
 840 dnl
 841 dnl Check to see if there is native support for complex
 842 dnl
 843 dnl Don't compile bits in math/* if native support exits.
 844 dnl
 845 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found.
 846 dnl
 847 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
 848 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
 849   dnl Check for complex versions of math functions of platform.
 850   AC_CHECK_LIB(m, main)
 851   AC_REPLACE_MATHFUNCS(nan copysignf)
 852
 853   dnl For __signbit to signbit conversions.
 854   AC_CHECK_FUNCS([__signbit], , [LIBMATHOBJS="$LIBMATHOBJS signbit.lo"])
 855   AC_CHECK_FUNCS([__signbitf], , [LIBMATHOBJS="$LIBMATHOBJS signbitf.lo"])
 856
 857   dnl Compile the long double complex functions only if the function
 858   dnl provides the non-complex long double functions that are needed.
 859   dnl Currently this includes copysignl, which should be
 860   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
 861   if test x$ac_cv_func_copysignl = x"yes"; then
 862     AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"])
 863   fi
 864
 865   if test -n "$LIBMATHOBJS"; then
 866     need_libmath=yes
 867   fi
 868   AC_SUBST(LIBMATHOBJS)
 869   AM_CONDITIONAL(GLIBCPP_BUILD_LIBMATH,  test "$need_libmath" = yes)
 870 ])
 871
 872
 873 dnl Check to see what architecture and operating system we are compiling
 874 dnl for.  Also, if architecture- or OS-specific flags are required for
 875 dnl compilation, pick them up here.
 876 dnl
 877 dnl GLIBCPP_CHECK_TARGET
 878 AC_DEFUN(GLIBCPP_CHECK_TARGET, [
 879   . [$]{glibcpp_basedir}/configure.target
 880   AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
 881   AC_MSG_RESULT(OS config directory is $os_include_dir)
 882 ])
 883
 884
 885 dnl
 886 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 887 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 888 dnl must have been previously checked.)
 889 dnl
 890 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
 891 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
 892 dnl
 893 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
 894 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 895   dnl Wide characters disabled by default.
 896   enable_wchar_t=no
 897
 898   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
 899   dnl others even if wchar_t support is not on.
 900   AC_MSG_CHECKING([for mbstate_t])
 901   AC_TRY_COMPILE([#include <wchar.h>],
 902   [mbstate_t teststate;],
 903   have_mbstate_t=yes, have_mbstate_t=no)
 904   AC_MSG_RESULT($have_mbstate_t)
 905   if test x"$have_mbstate_t" = xyes; then
 906     AC_DEFINE(HAVE_MBSTATE_T)
 907   fi
 908
 909   dnl Sanity check for existence of ISO C99 headers for extended encoding.
 910   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 911   AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 912
 913   dnl Only continue checking if the ISO C99 headers exist and support is on.
 914   if test x"$ac_has_wchar_h" = xyes &&
 915      test x"$ac_has_wctype_h" = xyes &&
 916      test x"$enable_c_mbchar" != xno; then
 917
 918     dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
 919     dnl numeric_limits can instantiate type_traits<wchar_t>
 920     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
 921     AC_TRY_COMPILE([#include <wchar.h>],
 922     [int i = WCHAR_MIN; int j = WCHAR_MAX;],
 923     has_wchar_minmax=yes, has_wchar_minmax=no)
 924     AC_MSG_RESULT($has_wchar_minmax)
 925
 926     dnl Test wchar.h for WEOF, which is what we use to determine whether
 927     dnl to specialize for char_traits<wchar_t> or not.
 928     AC_MSG_CHECKING([for WEOF])
 929     AC_TRY_COMPILE([
 930       #include <wchar.h>
 931       #include <stddef.h>],
 932     [wint_t i = WEOF;],
 933     has_weof=yes, has_weof=no)
 934     AC_MSG_RESULT($has_weof)
 935
 936     dnl Tests for wide character functions used in char_traits<wchar_t>.
 937     ac_wfuncs=yes
 938     AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset,, \
 939     ac_wfuncs=no)
 940
 941     dnl Checks for names injected into std:: by the c_std headers.
 942     AC_CHECK_FUNCS(btowc wctob fgetwc fgetws fputwc fputws fwide \
 943     fwprintf fwscanf swprintf swscanf vfwprintf vfwscanf vswprintf vswscanf \
 944     vwprintf vwscanf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
 945     mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstof wcstol \
 946     wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
 947     wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr,, \
 948     ac_wfuncs=no)
 949
 950     AC_MSG_CHECKING([for ISO C99 wchar_t support])
 951     if test x"$has_weof" = xyes &&
 952        test x"$has_wchar_minmax" = xyes &&
 953        test x"$ac_wfuncs" = xyes; then
 954       ac_isoC99_wchar_t=yes
 955     else
 956       ac_isoC99_wchar_t=no
 957     fi
 958     AC_MSG_RESULT($ac_isoC99_wchar_t)
 959
 960     dnl Use iconv for wchar_t to char conversions. As such, check for
 961     dnl X/Open Portability Guide, version 2 features (XPG2).
 962     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 963     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 964
 965     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
 966     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
 967     ac_save_LIBS="$LIBS"
 968     LIBS="$LIBS $libiconv"
 969
 970     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
 971     ac_XPG2funcs=yes, ac_XPG2funcs=no)
 972
 973     LIBS="$ac_save_LIBS"
 974
 975     AC_MSG_CHECKING([for XPG2 wchar_t support])
 976     if test x"$ac_has_iconv_h" = xyes &&
 977        test x"$ac_has_langinfo_h" = xyes &&
 978        test x"$ac_XPG2funcs" = xyes; then
 979       ac_XPG2_wchar_t=yes
 980     else
 981       ac_XPG2_wchar_t=no
 982     fi
 983     AC_MSG_RESULT($ac_XPG2_wchar_t)
 984
 985     dnl At the moment, only enable wchar_t specializations if all the
 986     dnl above support is present.
 987     if test x"$ac_isoC99_wchar_t" = xyes &&
 988         test x"$ac_XPG2_wchar_t" = xyes; then
 989       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
 990       enable_wchar_t=yes
 991     fi
 992   fi
 993   AC_MSG_CHECKING([for enabled wchar_t specializations])
 994   AC_MSG_RESULT($enable_wchar_t)
 995   AM_CONDITIONAL(GLIBCPP_TEST_WCHAR_T, test "$enable_wchar_t" = yes)
 996 ])
 997
 998
 999 dnl
1000 dnl Check to see if debugging libraries are to be built.
1001 dnl
1002 dnl GLIBCPP_ENABLE_DEBUG
1003 dnl
1004 dnl --enable-debug
1005 dnl builds a separate set of debugging libraries in addition to the
1006 dnl normal (shared, static) libstdc++ binaries.
1007 dnl
1008 dnl --disable-debug
1009 dnl builds only one (non-debug) version of libstdc++.
1010 dnl
1011 dnl --enable-debug-flags=FLAGS
1012 dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
1013 dnl
1014 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
1015 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1016 dnl       defaults to `no'.
1017 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
1018 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
1019 AC_ARG_ENABLE(debug,
1020 changequote(<<, >>)dnl
1021 <<  --enable-debug          build extra debug library [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
1022 changequote([, ])dnl
1023 [case "${enableval}" in
1024  yes) enable_debug=yes ;;
1025  no)  enable_debug=no ;;
1026  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
1027  esac],
1028 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
1029 AC_MSG_CHECKING([for additional debug build])
1030 AC_MSG_RESULT($enable_debug)
1031 AM_CONDITIONAL(GLIBCPP_BUILD_DEBUG, test "$enable_debug" = yes)
1032 ])
1033
1034
1035 dnl Check for explicit debug flags.
1036 dnl
1037 dnl GLIBCPP_ENABLE_DEBUG_FLAGS
1038 dnl
1039 dnl --enable-debug-flags='-O1'
1040 dnl is a general method for passing flags to be used when
1041 dnl building debug libraries with --enable-debug.
1042 dnl
1043 dnl --disable-debug-flags does nothing.
1044 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG_FLAGS(default flags)
1045 dnl       If "default flags" is an empty string (or "none"), the effect is
1046 dnl       the same as --disable or --enable=no.
1047 AC_DEFUN(GLIBCPP_ENABLE_DEBUG_FLAGS, [dnl
1048 define([GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1049 AC_ARG_ENABLE(debug_flags,
1050 changequote(<<, >>)dnl
1051 <<  --enable-debug-flags=FLAGS    pass compiler FLAGS when building debug
1052                         library;[default=>>GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT],
1053 changequote([, ])dnl
1054 [case "${enableval}" in
1055  none)  ;;
1056  -*) enable_debug_flags="${enableval}" ;;
1057  *)   AC_MSG_ERROR([Unknown argument to extra debugging flags]) ;;
1058  esac],
1059 enable_debug_flags=GLIBCPP_ENABLE_DEBUG_FLAGS_DEFAULT)dnl
1060
1061 dnl Option parsed, now set things appropriately
1062 case x"$enable_debug" in
1063     xyes)
1064         case "$enable_debug_flags" in
1065           none)
1066             DEBUG_FLAGS="-g3 -O0";;
1067           -*) #valid input
1068             DEBUG_FLAGS="${enableval}"
1069         esac
1070         ;;
1071     xno)
1072         DEBUG_FLAGS=""
1073         ;;
1074 esac
1075 AC_SUBST(DEBUG_FLAGS)
1076
1077 AC_MSG_CHECKING([for debug build flags])
1078 AC_MSG_RESULT($DEBUG_FLAGS)
1079 ])
1080
1081
1082 dnl
1083 dnl Check for "unusual" flags to pass to the compiler while building.
1084 dnl
1085 dnl GLIBCPP_ENABLE_CXX_FLAGS
1086 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1087 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
1088 dnl     Somehow this same set of flags must be passed when [re]building
1089 dnl     libgcc.
1090 dnl --disable-cxx-flags passes nothing.
1091 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1092 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1093 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1094 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1095 dnl       If "default flags" is an empty string (or "none"), the effect is
1096 dnl       the same as --disable or --enable=no.
1097 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1098 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1099 AC_MSG_CHECKING([for extra compiler flags for building])
1100 AC_ARG_ENABLE(cxx_flags,
1101 changequote(<<, >>)dnl
1102 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1103                                   [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1104 changequote([, ])dnl
1105 [case "x$enable_cxx_flags" in
1106   xyes)
1107     AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1108   xno | xnone | x)
1109     enable_cxx_flags='' ;;
1110   *)
1111     enable_cxx_flags="$enableval" ;;
1112 esac],
1113 enable_cxx_flags=GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT)
1114
1115 dnl Run through flags (either default or command-line) and set anything
1116 dnl extra (e.g., #defines) that must accompany particular g++ options.
1117 if test -n "$enable_cxx_flags"; then
1118   for f in $enable_cxx_flags; do
1119     case "$f" in
1120       -fhonor-std)  ;;
1121       -*)  ;;
1122       *)   # and we're trying to pass /what/ exactly?
1123            AC_MSG_ERROR([compiler flags start with a -]) ;;
1124     esac
1125   done
1126 fi
1127 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1128 AC_MSG_RESULT($EXTRA_CXX_FLAGS)
1129 AC_SUBST(EXTRA_CXX_FLAGS)
1130 ])
1131
1132
1133 dnl
1134 dnl Check for which locale library to use:  gnu or generic.
1135 dnl
1136 dnl GLIBCPP_ENABLE_CLOCALE
1137 dnl --enable-clocale=gnu sets config/locale/c_locale_gnu.cc and friends
1138 dnl --enable-clocale=generic sets config/locale/c_locale_generic.cc and friends
1139 dnl
1140 dnl default is generic
1141 dnl
1142 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
1143   AC_MSG_CHECKING([for clocale to use])
1144   AC_ARG_ENABLE(clocale,
1145   [  --enable-clocale        enable model for target locale package.
1146   --enable-clocale=MODEL  use MODEL target-speific locale package. [default=generic]
1147   ],
1148   if test x$enable_clocale = xno; then
1149      enable_clocale=no
1150   fi,
1151      enable_clocale=no)
1152
1153   enable_clocale_flag=$enable_clocale
1154
1155   dnl Probe for locale support if no specific model is specified.
1156   dnl Default to "generic"
1157   if test x$enable_clocale_flag = xno; then
1158     case x${target_os} in
1159       xlinux* | xgnu*)
1160         AC_EGREP_CPP([_GLIBCPP_ok], [
1161         #include <features.h>
1162         #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1163           _GLIBCPP_ok
1164         #endif
1165         ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1166
1167         # Test for bugs early in glibc-2.2.x series
1168         if test x$enable_clocale_flag = xgnu; then
1169           AC_TRY_RUN([
1170           #define _GNU_SOURCE 1
1171           #include <locale.h>
1172           #include <string.h>
1173           #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
1174           extern __typeof(newlocale) __newlocale;
1175           extern __typeof(duplocale) __duplocale;
1176           extern __typeof(strcoll_l) __strcoll_l;
1177           #endif
1178           int main()
1179           {
1180             const char __one[] = "Äuglein Augmen";
1181             const char __two[] = "Äuglein";
1182             int i;
1183             int j;
1184             __locale_t  loc;
1185             __locale_t  loc_dup;
1186             loc = __newlocale(1 << LC_ALL, "de_DE", 0);
1187             loc_dup = __duplocale(loc);
1188             i = __strcoll_l(__one, __two, loc);
1189             j = __strcoll_l(__one, __two, loc_dup);
1190             return 0;
1191           }
1192           ],
1193           [enable_clocale_flag=gnu],[enable_clocale_flag=generic],
1194           [enable_clocale_flag=generic])
1195         fi
1196
1197         # ... at some point put __strxfrm_l tests in as well.
1198         ;;
1199       *)
1200         enable_clocale_flag=generic
1201         ;;
1202     esac
1203   fi
1204
1205   dnl Deal with gettext issues.
1206   AC_ARG_ENABLE(nls,
1207   [  --enable-nls            use Native Language Support (default)],
1208   , enable_nls=yes)
1209   USE_NLS=no
1210
1211   dnl Set configure bits for specified locale package
1212   case x${enable_clocale_flag} in
1213     xgeneric)
1214       AC_MSG_RESULT(generic)
1215
1216       CLOCALE_H=config/locale/generic/c_locale.h
1217       CLOCALE_CC=config/locale/generic/c_locale.cc
1218       CCODECVT_H=config/locale/generic/codecvt_specializations.h
1219       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1220       CCOLLATE_CC=config/locale/generic/collate_members.cc
1221       CCTYPE_CC=config/locale/generic/ctype_members.cc
1222       CMESSAGES_H=config/locale/generic/messages_members.h
1223       CMESSAGES_CC=config/locale/generic/messages_members.cc
1224       CMONEY_CC=config/locale/generic/monetary_members.cc
1225       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1226       CTIME_H=config/locale/generic/time_members.h
1227       CTIME_CC=config/locale/generic/time_members.cc
1228       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1229       ;;
1230     xgnu)
1231       AC_MSG_RESULT(gnu)
1232
1233       # Declare intention to use gettext, and add support for specific
1234       # languages.
1235       # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1236       ALL_LINGUAS="de fr"
1237
1238       # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
1239       AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
1240       if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
1241         USE_NLS=yes
1242       fi
1243       # Export the build objects.
1244       for ling in $ALL_LINGUAS; do \
1245         glibcpp_MOFILES="$glibcpp_MOFILES $ling.mo"; \
1246         glibcpp_POFILES="$glibcpp_POFILES $ling.po"; \
1247       done
1248       AC_SUBST(glibcpp_MOFILES)
1249       AC_SUBST(glibcpp_POFILES)
1250
1251       CLOCALE_H=config/locale/gnu/c_locale.h
1252       CLOCALE_CC=config/locale/gnu/c_locale.cc
1253       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1254       CCODECVT_CC=config/locale/gnu/codecvt_members.cc
1255       CCOLLATE_CC=config/locale/gnu/collate_members.cc
1256       CCTYPE_CC=config/locale/gnu/ctype_members.cc
1257       CMESSAGES_H=config/locale/gnu/messages_members.h
1258       CMESSAGES_CC=config/locale/gnu/messages_members.cc
1259       CMONEY_CC=config/locale/gnu/monetary_members.cc
1260       CNUMERIC_CC=config/locale/gnu/numeric_members.cc
1261       CTIME_H=config/locale/gnu/time_members.h
1262       CTIME_CC=config/locale/gnu/time_members.cc
1263       CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
1264       ;;
1265     xieee_1003.1-2001)
1266       AC_MSG_RESULT(generic)
1267
1268       CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
1269       CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
1270       CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
1271       CCODECVT_CC=config/locale/generic/codecvt_members.cc
1272       CCOLLATE_CC=config/locale/generic/collate_members.cc
1273       CCTYPE_CC=config/locale/generic/ctype_members.cc
1274       CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
1275       CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
1276       CMONEY_CC=config/locale/generic/monetary_members.cc
1277       CNUMERIC_CC=config/locale/generic/numeric_members.cc
1278       CTIME_H=config/locale/generic/time_members.h
1279       CTIME_CC=config/locale/generic/time_members.cc
1280       CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1281       ;;
1282     *)
1283       echo "$enable_clocale is an unknown locale package" 1>&2
1284       exit 1
1285       ;;
1286   esac
1287
1288   # This is where the testsuite looks for locale catalogs, using the
1289   # -DLOCALEDIR define during testsuite compilation.
1290   glibcpp_localedir=${glibcpp_builddir}/po/share/locale
1291   AC_SUBST(glibcpp_localedir)
1292
1293   AC_SUBST(USE_NLS)
1294   AC_SUBST(CLOCALE_H)
1295   AC_SUBST(CCODECVT_H)
1296   AC_SUBST(CMESSAGES_H)
1297   AC_SUBST(CCODECVT_CC)
1298   AC_SUBST(CCOLLATE_CC)
1299   AC_SUBST(CCTYPE_CC)
1300   AC_SUBST(CMESSAGES_CC)
1301   AC_SUBST(CMONEY_CC)
1302   AC_SUBST(CNUMERIC_CC)
1303   AC_SUBST(CTIME_H)
1304   AC_SUBST(CTIME_CC)
1305   AC_SUBST(CLOCALE_CC)
1306   AC_SUBST(CLOCALE_INTERNAL_H)
1307 ])
1308
1309
1310 dnl
1311 dnl Check for which I/O library to use:  libio, or something specific.
1312 dnl
1313 dnl GLIBCPP_ENABLE_CSTDIO
1314 dnl --enable-cstdio=libio sets config/io/c_io_libio.h and friends
1315 dnl
1316 dnl default is stdio
1317 dnl
1318 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1319   AC_MSG_CHECKING([for cstdio to use])
1320   AC_ARG_ENABLE(cstdio,
1321   [  --enable-cstdio         enable stdio for target io package.
1322   --enable-cstdio=LIB     use LIB target-speific io package. [default=stdio]
1323   ],
1324   if test x$enable_cstdio = xno; then
1325      enable_cstdio=stdio
1326   fi,
1327      enable_cstdio=stdio)
1328
1329   enable_cstdio_flag=$enable_cstdio
1330
1331   dnl Check if a valid I/O package
1332   case x${enable_cstdio_flag} in
1333     xlibio)
1334       CSTDIO_H=config/io/c_io_libio.h
1335       BASIC_FILE_H=config/io/basic_file_libio.h
1336       BASIC_FILE_CC=config/io/basic_file_libio.cc
1337       AC_MSG_RESULT(libio)
1338
1339       # see if we are on a system with libio native (ie, linux)
1340       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1341
1342       # Need to check and see what version of glibc is being used. If
1343       # it's not glibc-2.2 or higher, then we'll need to go ahead and
1344       # compile most of libio for linux systems.
1345       if test x$has_libio = x"yes"; then
1346         case "$target" in
1347           *-*-linux*)
1348               AC_MSG_CHECKING([for glibc version >= 2.2])
1349               AC_EGREP_CPP([ok], [
1350             #include <features.h>
1351               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1352                     ok
1353               #endif
1354               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1355               AC_MSG_RESULT($glibc_satisfactory)
1356             ;;
1357         esac
1358
1359         # XXX at the moment, admit defeat and force the recompilation
1360         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1361         glibc_satisfactory=no
1362
1363         if test x$glibc_satisfactory = x"yes"; then
1364            need_libio=no
1365            need_wlibio=no
1366         else
1367            need_libio=yes
1368            # bkoz XXX need to add checks to enable this
1369            # pme XXX here's a first pass at such a check
1370            if test x$enable_c_mbchar != xno; then
1371               need_wlibio=yes
1372            else
1373               need_wlibio=no
1374            fi
1375         fi
1376
1377       else
1378          # Using libio, but <libio.h> doesn't exist on the target system. . .
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     xstdio | x | xno | xnone | xyes)
1390       # default
1391       CSTDIO_H=config/io/c_io_stdio.h
1392       BASIC_FILE_H=config/io/basic_file_stdio.h
1393       BASIC_FILE_CC=config/io/basic_file_stdio.cc
1394       AC_MSG_RESULT(stdio)
1395
1396       # We're not using stdio.
1397       need_libio=no
1398       need_wlibio=no
1399       ;;
1400     *)
1401       echo "$enable_cstdio is an unknown io package" 1>&2
1402       exit 1
1403       ;;
1404   esac
1405   AC_SUBST(CSTDIO_H)
1406   AC_SUBST(BASIC_FILE_H)
1407   AC_SUBST(BASIC_FILE_CC)
1408
1409   # 2000-08-04 bkoz hack
1410   CCODECVT_C=config/io/c_io_libio_codecvt.c
1411   AC_SUBST(CCODECVT_C)
1412   # 2000-08-04 bkoz hack
1413
1414   AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO,
1415                  test "$need_libio" = yes || test "$need_wlibio" = yes)
1416   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1417   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1418   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1419     libio_la=../libio/libio.la
1420   else
1421     libio_la=
1422   fi
1423   AC_SUBST(libio_la)
1424 ])
1425
1426
1427 dnl
1428 dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
1429 dnl We must stage the required headers so that they will be installed
1430 dnl with the library (unlike libgcc, the STL implementation is provided
1431 dnl solely within headers).  Since we must not inject random user-space
1432 dnl macro names into user-provided C++ code, we first stage into <file>-in
1433 dnl and process to <file> with an output command.  The reason for a two-
1434 dnl stage process here is to correctly handle $srcdir!=$objdir without
1435 dnl having to write complex code (the sed commands to clean the macro
1436 dnl namespace are complex and fragile enough as it is).  We must also
1437 dnl add a relative path so that -I- is supported properly.
1438 dnl
1439 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1440   AC_MSG_CHECKING([for thread model used by GCC])
1441   target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
1442   AC_MSG_RESULT([$target_thread_file])
1443
1444   if test $target_thread_file != single; then
1445     AC_DEFINE(HAVE_GTHR_DEFAULT)
1446     AC_DEFINE(_GLIBCPP_SUPPORTS_WEAK, __GXX_WEAK__)
1447   fi
1448
1449   glibcpp_thread_h=gthr-$target_thread_file.h
1450   AC_SUBST(glibcpp_thread_h)
1451 ])
1452
1453
1454 dnl
1455 dnl Check for exception handling support.  If an explicit enable/disable
1456 dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
1457 dnl target may or may not support call frame exceptions.
1458 dnl
1459 dnl GLIBCPP_ENABLE_SJLJ_EXCEPTIONS
1460 dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
1461 dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
1462 dnl
1463 dnl Define _GLIBCPP_SJLJ_EXCEPTIONS if the compiler is configured for it.
1464 dnl
1465 AC_DEFUN(GLIBCPP_ENABLE_SJLJ_EXCEPTIONS, [
1466   AC_MSG_CHECKING([for exception model to use])
1467   AC_LANG_SAVE
1468   AC_LANG_CPLUSPLUS
1469   AC_ARG_ENABLE(sjlj-exceptions,
1470   [  --enable-sjlj-exceptions  force use of builtin_setjmp for exceptions],
1471   [:],
1472   [dnl Botheration.  Now we've got to detect the exception model.
1473    dnl Link tests against libgcc.a are problematic since -- at least
1474    dnl as of this writing -- we've not been given proper -L bits for
1475    dnl single-tree newlib and libgloss.
1476    dnl
1477    dnl This is what AC_TRY_COMPILE would do if it didn't delete the
1478    dnl conftest files before we got a change to grep them first.
1479    cat > conftest.$ac_ext << EOF
1480 [#]line __oline__ "configure"
1481 struct S { ~S(); };
1482 void bar();
1483 void foo()
1484 {
1485   S s;
1486   bar();
1487 }
1488 EOF
1489    old_CXXFLAGS="$CXXFLAGS"
1490    CXXFLAGS=-S
1491    if AC_TRY_EVAL(ac_compile); then
1492      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
1493        enable_sjlj_exceptions=yes
1494      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
1495        enable_sjlj_exceptions=no
1496      fi
1497    fi
1498    CXXFLAGS="$old_CXXFLAGS"
1499    rm -f conftest*])
1500    if test x$enable_sjlj_exceptions = xyes; then
1501      AC_DEFINE(_GLIBCPP_SJLJ_EXCEPTIONS, 1,
1502         [Define if the compiler is configured for setjmp/longjmp exceptions.])
1503      ac_exception_model_name=sjlj
1504    elif test x$enable_sjlj_exceptions = xno; then
1505      ac_exception_model_name="call frame"
1506    else
1507      AC_MSG_ERROR([unable to detect exception model])
1508    fi
1509    AC_LANG_RESTORE
1510    AC_MSG_RESULT($ac_exception_model_name)
1511 ])
1512
1513
1514 dnl
1515 dnl Check for libunwind exception handling support. If enabled then
1516 dnl we assume that the _Unwind_* functions that make up the Unwind ABI
1517 dnl (_Unwind_RaiseException, _Unwind_Resume, etc.) are defined by
1518 dnl libunwind instead of libgcc and that libstdc++ has a dependency
1519 dnl on libunwind as well as libgcc.
1520 dnl
1521 dnl GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS
1522 dnl --enable-libunwind-exceptions forces the use of libunwind.
1523 dnl --disable-libunwind-exceptions assumes there is no libunwind.
1524 dnl
1525 dnl Define _GLIBCPP_LIBUNWIND_EXCEPTIONS if requested.
1526 dnl
1527 AC_DEFUN(GLIBCPP_ENABLE_LIBUNWIND_EXCEPTIONS, [
1528   AC_MSG_CHECKING([for use of libunwind])
1529   AC_ARG_ENABLE(libunwind-exceptions,
1530   [  --enable-libunwind-exceptions  force use of libunwind for exceptions],
1531   use_libunwind_exceptions=$enableval,
1532   use_libunwind_exceptions=no)
1533   AC_MSG_RESULT($use_libunwind_exceptions)
1534   dnl Option parsed, now set things appropriately
1535   if test x"$use_libunwind_exceptions" = xyes; then
1536     LIBUNWIND_FLAG="-lunwind"
1537   else
1538     LIBUNWIND_FLAG=""
1539   fi
1540   AC_SUBST(LIBUNWIND_FLAG)
1541 ])
1542
1543 dnl
1544 dnl Check for ISO/IEC 9899:1999 "C99" support.
1545 dnl
1546 dnl GLIBCPP_ENABLE_C99
1547 dnl --enable-c99 defines _GLIBCPP_USE_C99
1548 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1549 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1550 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1551 dnl       defaults to `no'.
1552 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1553 dnl
1554 dnl GLIBCPP_ENABLE_C99
1555 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1556   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1557
1558   AC_ARG_ENABLE(c99,
1559   changequote(<<, >>)dnl
1560   <<--enable-c99            turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1561   changequote([, ])dnl
1562   [case "$enableval" in
1563    yes) enable_c99=yes ;;
1564    no)  enable_c99=no ;;
1565    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1566    esac],
1567   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1568
1569   AC_LANG_SAVE
1570   AC_LANG_CPLUSPLUS
1571
1572   # Check for the existence of <math.h> functions used if C99 is enabled.
1573   ac_c99_math=yes;
1574   AC_MSG_CHECKING([for ISO C99 support in <math.h>])
1575   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1576   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1577   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1578   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1579   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1580   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1581   AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
1582   AC_TRY_COMPILE([#include <math.h>],
1583                  [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
1584   AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
1585   AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
1586   AC_TRY_COMPILE([#include <math.h>],
1587                  [islessgreater(0.0,0.0);],, [ac_c99_math=no])
1588   AC_TRY_COMPILE([#include <math.h>],
1589                  [isunordered(0.0,0.0);],, [ac_c99_math=no])
1590   AC_MSG_RESULT($ac_c99_math)
1591
1592   # Check for the existence in <stdio.h> of vscanf, et. al.
1593   ac_c99_stdio=yes;
1594   AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1595   AC_TRY_COMPILE([#include <stdio.h>],
1596                  [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
1597   AC_TRY_COMPILE([#include <stdio.h>
1598                   #include <stdarg.h>
1599                   void foo(char* fmt, ...)
1600                   {va_list args; va_start(args, fmt);
1601                   vfscanf(stderr, "%i", args);}],
1602                   [],, [ac_c99_stdio=no])
1603   AC_TRY_COMPILE([#include <stdio.h>
1604                   #include <stdarg.h>
1605                   void foo(char* fmt, ...)
1606                   {va_list args; va_start(args, fmt);
1607                   vscanf("%i", args);}],
1608                   [],, [ac_c99_stdio=no])
1609   AC_TRY_COMPILE([#include <stdio.h>
1610                   #include <stdarg.h>
1611                   void foo(char* fmt, ...)
1612                   {va_list args; va_start(args, fmt);
1613                   vsnprintf(fmt, 0, "%i", args);}],
1614                   [],, [ac_c99_stdio=no])
1615   AC_TRY_COMPILE([#include <stdio.h>
1616                   #include <stdarg.h>
1617                   void foo(char* fmt, ...)
1618                   {va_list args; va_start(args, fmt);
1619                   vsscanf(fmt, "%i", args);}],
1620                   [],, [ac_c99_stdio=no])
1621   AC_MSG_RESULT($ac_c99_stdio)
1622
1623   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1624   ac_c99_stdlib=yes;
1625   AC_MSG_CHECKING([for lldiv_t declaration])
1626   AC_CACHE_VAL(ac_c99_lldiv_t, [
1627   AC_TRY_COMPILE([#include <stdlib.h>],
1628                    [ lldiv_t mydivt;],
1629                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1630   ])
1631   AC_MSG_RESULT($ac_c99_lldiv_t)
1632
1633   AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1634   AC_TRY_COMPILE([#include <stdlib.h>],
1635                  [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
1636   AC_TRY_COMPILE([#include <stdlib.h>],
1637                  [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
1638   AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
1639   AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
1640   AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
1641   AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
1642   if test x"$ac_c99_lldiv_t" = x"no"; then
1643     ac_c99_stdlib=no;
1644   fi;
1645   AC_MSG_RESULT($ac_c99_stdlib)
1646
1647   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1648   # XXX the wchar.h checks should be rolled into the general C99 bits.
1649   ac_c99_wchar=yes;
1650   AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
1651   AC_TRY_COMPILE([#include <wchar.h>],
1652                  [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
1653   AC_TRY_COMPILE([#include <wchar.h>],
1654                  [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
1655   AC_TRY_COMPILE([#include <wchar.h>],
1656                  [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
1657   AC_MSG_RESULT($ac_c99_wchar)
1658
1659   AC_MSG_CHECKING([for enabled ISO C99 support])
1660   if test x"$ac_c99_math" = x"no" ||
1661      test x"$ac_c99_stdio" = x"no" ||
1662      test x"$ac_c99_stdlib" = x"no" ||
1663      test x"$ac_c99_wchar" = x"no"; then
1664     enable_c99=no;
1665   fi;
1666   AC_MSG_RESULT($enable_c99)
1667
1668   # Option parsed, now set things appropriately
1669   if test x"$enable_c99" = x"yes"; then
1670     AC_DEFINE(_GLIBCPP_USE_C99)
1671   fi
1672
1673   AC_LANG_RESTORE
1674 ])
1675
1676
1677 dnl
1678 dnl Check for template specializations for the 'long long' type extension.
1679 dnl The result determines only whether 'long long' I/O is enabled; things
1680 dnl like numeric_limits<> specializations are always available.
1681 dnl
1682 dnl GLIBCPP_ENABLE_LONG_LONG
1683 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1684 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1685 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1686 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1687 dnl       defaults to `no'.
1688 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1689 dnl
1690 dnl GLIBCPP_ENABLE_LONG_LONG
1691 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1692   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1693
1694   AC_ARG_ENABLE(long-long,
1695   changequote(<<, >>)dnl
1696   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1697   changequote([, ])dnl
1698   [case "$enableval" in
1699    yes) enable_long_long=yes ;;
1700    no)  enable_long_long=no ;;
1701    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1702    esac],
1703   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1704
1705   AC_LANG_SAVE
1706   AC_LANG_CPLUSPLUS
1707
1708   AC_MSG_CHECKING([for enabled long long I/O support])
1709   # iostreams require strtoll, strtoull to compile
1710   AC_TRY_COMPILE([#include <stdlib.h>],
1711                  [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
1712   AC_TRY_COMPILE([#include <stdlib.h>],
1713                  [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
1714
1715   # Option parsed, now set things appropriately
1716   if test x"$enable_long_long" = xyes; then
1717     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1718   fi
1719   AC_MSG_RESULT($enable_long_long)
1720
1721   AC_LANG_RESTORE
1722 ])
1723
1724
1725 dnl
1726 dnl Check for what type of C headers to use.
1727 dnl
1728 dnl GLIBCPP_ENABLE_CHEADERS
1729 dnl --enable-cheaders= [does stuff].
1730 dnl --disable-cheaders [does not do anything, really].
1731 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1732 dnl       Where DEFAULT is either `c' or `c_std'.
1733 dnl       If ommitted, it defaults to `c_std'.
1734 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1735 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1736 AC_MSG_CHECKING([for c header strategy to use])
1737 AC_ARG_ENABLE(cheaders,
1738 changequote(<<, >>)dnl
1739 <<  --enable-cheaders=MODEL       construct "C" header files for g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1740 changequote([, ])
1741   [case "$enableval" in
1742    c)
1743         enable_cheaders=c
1744         ;;
1745    c_std)
1746         enable_cheaders=c_std
1747         ;;
1748    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1749         ;;
1750   esac],
1751   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1752   AC_MSG_RESULT($enable_cheaders)
1753
1754   dnl Option parsed, now set things appropriately
1755   case "$enable_cheaders" in
1756     c_std)
1757         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c_std'
1758         ;;
1759     c)
1760         C_INCLUDE_DIR='${glibcpp_srcdir}/include/c'
1761         ;;
1762   esac
1763
1764   AC_SUBST(C_INCLUDE_DIR)
1765   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C, test "$enable_cheaders" = c)
1766   AM_CONDITIONAL(GLIBCPP_C_HEADERS_C_STD, test "$enable_cheaders" = c_std)
1767   AM_CONDITIONAL(GLIBCPP_C_HEADERS_COMPATIBILITY, test "$c_compatibility" = yes)
1768 ])
1769
1770
1771 dnl
1772 dnl Check for wide character support.  Has the same effect as the option
1773 dnl in gcc's configure, but in a form that autoconf can mess with.
1774 dnl
1775 dnl GLIBCPP_ENABLE_C_MBCHAR
1776 dnl --enable-c-mbchar requests all the wchar_t stuff.
1777 dnl --disable-c-mbchar doesn't.
1778 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1779 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1780 dnl       defaults to `no'.
1781 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1782 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1783 AC_ARG_ENABLE(c-mbchar,
1784 changequote(<<, >>)dnl
1785 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1786 changequote([, ])dnl
1787 [case "$enableval" in
1788  yes) enable_c_mbchar=yes ;;
1789  no)  enable_c_mbchar=no ;;
1790  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1791  esac],
1792 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1793 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1794 ])
1795
1796
1797 dnl
1798 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1799 dnl
1800 dnl TOPLEVEL_INCLUDES
1801 dnl LIBMATH_INCLUDES
1802 dnl LIBSUPCXX_INCLUDES
1803 dnl LIBIO_INCLUDES
1804 dnl
1805 dnl GLIBCPP_EXPORT_INCLUDES
1806 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1807   # Root level of the build directory include sources.
1808   GLIBCPP_INCLUDES="-I${glibcpp_builddir}/include/${target_alias} -I${glibcpp_builddir}/include"
1809
1810   # Passed down for canadian crosses.
1811   if test x"$CANADIAN" = xyes; then
1812     TOPLEVEL_INCLUDES='-I$(includedir)'
1813   fi
1814
1815   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1816
1817   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1818
1819   if test x"$need_libio" = xyes; then
1820     LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1821     AC_SUBST(LIBIO_INCLUDES)
1822   fi
1823
1824   # Now, export this to all the little Makefiles....
1825   AC_SUBST(GLIBCPP_INCLUDES)
1826   AC_SUBST(TOPLEVEL_INCLUDES)
1827   AC_SUBST(LIBMATH_INCLUDES)
1828   AC_SUBST(LIBSUPCXX_INCLUDES)
1829 ])
1830
1831
1832 dnl
1833 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1834 dnl
1835 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1836   # Optimization flags that are probably a good idea for thrill-seekers. Just
1837   # uncomment the lines below and make, everything else is ready to go...
1838   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1839   OPTIMIZE_CXXFLAGS=
1840   AC_SUBST(OPTIMIZE_CXXFLAGS)
1841
1842   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1843   AC_SUBST(WARN_FLAGS)
1844 ])
1845
1846 dnl
1847 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1848 dnl  calculates gxx_install_dir
1849 dnl  exports glibcpp_toolexecdir
1850 dnl  exports glibcpp_toolexeclibdir
1851 dnl  exports glibcpp_prefixdir
1852 dnl
1853 dnl Assumes cross_compiling bits already done, and with_cross_host in
1854 dnl particular
1855 dnl
1856 dnl GLIBCPP_EXPORT_INSTALL_INFO
1857 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1858 # Assumes glibcpp_builddir, glibcpp_srcdir are alreay set up and
1859 # exported correctly in GLIBCPP_CONFIGURE.
1860 glibcpp_toolexecdir=no
1861 glibcpp_toolexeclibdir=no
1862 glibcpp_prefixdir=${prefix}
1863
1864 # Process the option --with-gxx-include-dir=<path to include-files directory>
1865 AC_MSG_CHECKING([for --with-gxx-include-dir])
1866 AC_ARG_WITH(gxx-include-dir,
1867 [  --with-gxx-include-dir  the installation directory for include files],
1868 [case "${withval}" in
1869   yes)
1870     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1871     gxx_include_dir=no
1872     ;;
1873   no)
1874     gxx_include_dir=no
1875     ;;
1876   *)
1877     gxx_include_dir=${withval}
1878     ;;
1879 esac], [gxx_include_dir=no])
1880 AC_MSG_RESULT($gxx_include_dir)
1881
1882 # Process the option "--enable-version-specific-runtime-libs"
1883 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1884 AC_ARG_ENABLE(version-specific-runtime-libs,
1885 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1886 [case "$enableval" in
1887  yes) version_specific_libs=yes ;;
1888  no)  version_specific_libs=no ;;
1889  *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
1890  esac],
1891 version_specific_libs=no)dnl
1892 # Option set, now we can test it.
1893 AC_MSG_RESULT($version_specific_libs)
1894
1895 # Default case for install directory for include files.
1896 if test $version_specific_libs = no && test $gxx_include_dir = no; then
1897   gxx_include_dir='$(prefix)'/include/c++/${gcc_version}
1898 fi
1899
1900 # Version-specific runtime libs processing.
1901 if test $version_specific_libs = yes; then
1902   # Need the gcc compiler version to know where to install libraries
1903   # and header files if --enable-version-specific-runtime-libs option
1904   # is selected.
1905   if test x"$gxx_include_dir" = x"no"; then
1906     gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/c++
1907   fi
1908   glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1909   glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}'$(MULTISUBDIR)'
1910 fi
1911
1912 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1913 # Install a library built with a cross compiler in tooldir, not libdir.
1914 if test x"$glibcpp_toolexecdir" = x"no"; then
1915   if test -n "$with_cross_host" &&
1916      test x"$with_cross_host" != x"no"; then
1917     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1918     glibcpp_toolexeclibdir='$(toolexecdir)/lib'
1919   else
1920     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1921     glibcpp_toolexeclibdir='$(libdir)'
1922   fi
1923   glibcpp_toolexeclibdir=$glibcpp_toolexeclibdir/`$CC -print-multi-os-directory`
1924 fi
1925
1926 AC_MSG_CHECKING([for install location])
1927 AC_MSG_RESULT($gxx_include_dir)
1928
1929 AC_SUBST(glibcpp_prefixdir)
1930 AC_SUBST(gxx_include_dir)
1931 AC_SUBST(glibcpp_toolexecdir)
1932 AC_SUBST(glibcpp_toolexeclibdir)
1933 ])
1934
1935
1936 # Check for functions in math library.
1937 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1938 #
1939 # This file can be copied and used freely without restrictions.  It can
1940 # be used in projects which are not available under the GNU Public License
1941 # but which still want to provide support for the GNU gettext functionality.
1942 # Please note that the actual code is *not* freely available.
1943
1944 # serial 1
1945
1946 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1947 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1948 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])
1949
1950
1951 dnl This macro searches for a GNU version of make.  If a match is found, the
1952 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1953 dnl set to "#". This is useful for  including a special features in a Makefile,
1954 dnl which cannot be handled by other versions of make.  The variable
1955 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1956 dnl the empty string otherwise.
1957 dnl
1958 dnl Here is an example of its use:
1959 dnl
1960 dnl Makefile.in might contain:
1961 dnl
1962 dnl     # A failsafe way of putting a dependency rule into a makefile
1963 dnl     $(DEPEND):
1964 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1965 dnl
1966 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1967 dnl     @ifGNUmake@ include $(DEPEND)
1968 dnl     @ifGNUmake@ endif
1969 dnl
1970 dnl Then configure.in would normally contain:
1971 dnl
1972 dnl     CHECK_GNU_MAKE()
1973 dnl     AC_OUTPUT(Makefile)
1974 dnl
1975 dnl Then perhaps to cause gnu make to override any other make, we could do
1976 dnl something like this (note that GNU make always looks for GNUmakefile first):
1977 dnl
1978 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1979 dnl             mv Makefile GNUmakefile
1980 dnl             echo .DEFAULT: > Makefile ;
1981 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1982 dnl     fi
1983 dnl
1984 dnl Then, if any (well almost any) other make is called, and GNU make also
1985 dnl exists, then the other make wraps the GNU make.
1986 dnl
1987 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1988 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1989 dnl
1990 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1991 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1992 dnl #### conditional's subshell (" --version" is not a command), using a
1993 dnl #### different option to grep(1).
1994 dnl #### -pme
1995 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1996 dnl #### ${MAKE:-make}).
1997 dnl #### -msokolov
1998 AC_DEFUN(
1999   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
2000           _cv_gnu_make_command='' ;
2001 dnl Search all the common names for GNU make
2002           for a in "${MAKE-make}" make gmake gnumake ; do
2003                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2004                   then
2005                           _cv_gnu_make_command=$a ;
2006                           break;
2007                   fi
2008           done ;
2009   ) ;
2010 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
2011 dnl string, '#' otherwise
2012   if test  "x$_cv_gnu_make_command" != "x"  ; then
2013           ifGNUmake='' ;
2014   else
2015           ifGNUmake='#' ;
2016   fi
2017   AC_SUBST(ifGNUmake)
2018 ])
2019
2020
2021 dnl Check for headers for, and arguments to, the setrlimit() function.
2022 dnl Used only in testsuite_hooks.h.
2023 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT_ancilliary, [
2024   AC_TRY_COMPILE([#include <unistd.h>
2025                   #include <sys/time.h>
2026                   #include <sys/resource.h>
2027                  ], [ int f = RLIMIT_$1 ; ],
2028                  [glibcpp_mresult=1], [glibcpp_mresult=0])
2029   AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcpp_mresult,
2030                      [Only used in build directory testsuite_hooks.h.])
2031 ])
2032 AC_DEFUN(GLIBCPP_CHECK_SETRLIMIT, [
2033   setrlimit_have_headers=yes
2034   AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
2035                    [],
2036                    setrlimit_have_headers=no)
2037   # If don't have the headers, then we can't run the tests now, and we
2038   # won't be seeing any of these during testsuite compilation.
2039   if test $setrlimit_have_headers = yes; then
2040     # Can't do these in a loop, else the resulting syntax is wrong.
2041     GLIBCPP_CHECK_SETRLIMIT_ancilliary(DATA)
2042     GLIBCPP_CHECK_SETRLIMIT_ancilliary(RSS)
2043     GLIBCPP_CHECK_SETRLIMIT_ancilliary(VMEM)
2044     GLIBCPP_CHECK_SETRLIMIT_ancilliary(AS)
2045
2046     # Check for rlimit, setrlimit.
2047     AC_CACHE_VAL(ac_setrlimit, [
2048       AC_TRY_COMPILE([#include <unistd.h>
2049                   #include <sys/time.h>
2050                   #include <sys/resource.h>
2051                      ],
2052                      [ struct rlimit r; setrlimit(0, &r);],
2053                      [ac_setrlimit=yes], [ac_setrlimit=no])
2054     ])
2055   fi
2056
2057   AC_MSG_CHECKING([for testsuite memory limit support])
2058   if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
2059     ac_mem_limits=yes
2060     AC_DEFINE(_GLIBCPP_MEM_LIMITS)
2061   else
2062     ac_mem_limits=no
2063   fi
2064   AC_MSG_RESULT($ac_mem_limits)
2065 ])
2066
2067
2068 dnl
2069 dnl Does any necessary configuration of the testsuite directory.  Generates
2070 dnl the testsuite_hooks.h header.
2071 dnl
2072 dnl GLIBCPP_CONFIGURE_TESTSUITE  [no args]
2073 AC_DEFUN(GLIBCPP_CONFIGURE_TESTSUITE, [
2074   GLIBCPP_CHECK_SETRLIMIT
2075
2076   # Look for setenv, so that extended locale tests can be performed.
2077   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
2078
2079   # Export file names for ABI checking.
2080   baseline_file="${glibcpp_srcdir}/config/abi/${abi_baseline_triplet}/baseline_symbols.txt"
2081   AC_SUBST(baseline_file)
2082
2083   case "$target" in
2084     *-*-cygwin* ) enable_abi_check=no ;;
2085     * ) enable_abi_check=yes ;;
2086   esac
2087
2088   # Don't do ABI checking unless native.
2089   AM_CONDITIONAL(GLIBCPP_BUILD_ABI_CHECK,
2090                  test x"$build" = x"$host" && test -z "$with_cross_host" \
2091                  && test "$enable_abi_check" = yes )
2092 ])
2093
2094
2095 sinclude(../libtool.m4)
2096 dnl The lines below arrange for aclocal not to bring an installed
2097 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
2098 dnl add a definition of LIBTOOL to Makefile.in.
2099 ifelse(,,,[AC_SUBST(LIBTOOL)
2100 AC_DEFUN([AM_PROG_LIBTOOL])
2101 AC_DEFUN([AC_LIBTOOL_DLOPEN])
2102 AC_DEFUN([AC_PROG_LD])
2103 ])
2104
2105
2106 # Check whether LC_MESSAGES is available in <locale.h>.
2107 # Ulrich Drepper <drepper@cygnus.com>, 1995.
2108 #
2109 # This file file be copied and used freely without restrictions.  It can
2110 # be used in projects which are not available under the GNU Public License
2111 # but which still want to provide support for the GNU gettext functionality.
2112 # Please note that the actual code is *not* freely available.
2113
2114 # serial 1
2115
2116 AC_DEFUN(AC_LC_MESSAGES, [
2117   AC_CHECK_HEADER(locale.h, [
2118     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
2119       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2120        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
2121     if test $ac_cv_val_LC_MESSAGES = yes; then
2122       AC_DEFINE(HAVE_LC_MESSAGES)
2123     fi
2124   ])
2125 ])
2126
2127
2128 dnl
2129 dnl Check for whether the Boost-derived checks should be turned on.
2130 dnl
2131 dnl GLIBCPP_ENABLE_CONCEPT_CHECKS
2132 dnl --enable-concept-checks turns them on.
2133 dnl --disable-concept-checks leaves them off.
2134 dnl  +  Usage:  GLIBCPP_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2135 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2136 dnl       defaults to `no'.
2137 AC_DEFUN(GLIBCPP_ENABLE_CONCEPT_CHECKS, [dnl
2138 define([GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT], ifelse($1, yes, yes, no))dnl
2139 AC_ARG_ENABLE(concept-checks,
2140 changequote(<<, >>)dnl
2141 <<  --enable-concept-checks use Boost-derived template checks [default=>>GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT],
2142 changequote([, ])dnl
2143 [case "$enableval" in
2144  yes) enable_concept_checks=yes ;;
2145  no)  enable_concept_checks=no ;;
2146  *)   AC_MSG_ERROR([Unknown argument to enable/disable concept checks]) ;;
2147  esac],
2148 enable_concept_checks=GLIBCPP_ENABLE_CONCEPT_CHECKS_DEFAULT)dnl
2149 dnl Option parsed, now set things appropriately
2150 if test x"$enable_concept_checks" = xyes; then
2151   AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS)
2152 fi
2153 ])
2154
2155
2156 dnl
2157 dnl Add version tags to symbols in shared library (or not), additionally
2158 dnl marking other symbols as private/local (or not).
2159 dnl
2160 dnl GLIBCPP_ENABLE_SYMVERS
2161 dnl --enable-symvers=style adds a version script to the linker call when
2162 dnl       creating the shared library.  The choice of version script is
2163 dnl       controlled by 'style'.
2164 dnl --disable-symvers does not.
2165 dnl  +  Usage:  GLIBCPP_ENABLE_SYMVERS[(DEFAULT)]
2166 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
2167 dnl       defaults to `no'.  Passing `yes' tries to choose a default style
2168 dnl       based on linker characteristics.  Passing 'no' disables versioning.
2169 AC_DEFUN(GLIBCPP_ENABLE_SYMVERS, [dnl
2170 define([GLIBCPP_ENABLE_SYMVERS_DEFAULT], ifelse($1, yes, yes, no))dnl
2171 AC_ARG_ENABLE(symvers,
2172 changequote(<<, >>)dnl
2173 <<  --enable-symvers=style  enables symbol versioning of the shared library [default=>>GLIBCPP_ENABLE_SYMVERS_DEFAULT],
2174 changequote([, ])dnl
2175 [case "$enableval" in
2176  yes) enable_symvers=yes ;;
2177  no)  enable_symvers=no ;;
2178  # other names here, just as sanity checks
2179  #gnu|sun|etcetera) enable_symvers=$enableval ;;
2180  gnu) enable_symvers=$enableval ;;
2181  *)   AC_MSG_ERROR([Unknown argument to enable/disable symvers]) ;;
2182  esac],
2183 enable_symvers=GLIBCPP_ENABLE_SYMVERS_DEFAULT)dnl
2184
2185 # If we never went through the GLIBCPP_CHECK_LINKER_FEATURES macro, then we
2186 # don't know enough about $LD to do tricks...
2187 if test x$enable_shared = xno ||
2188         test "x$LD" = x ||
2189         test x$glibcpp_gnu_ld_version = x; then
2190   enable_symvers=no
2191 fi
2192
2193 # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
2194 if test $enable_symvers != no; then
2195   AC_MSG_CHECKING([for shared libgcc])
2196   ac_save_CFLAGS="$CFLAGS"
2197   CFLAGS=' -lgcc_s'
2198   AC_TRY_LINK(, [return 0], glibcpp_shared_libgcc=yes, glibcpp_shared_libgcc=no)
2199   CFLAGS="$ac_save_CFLAGS"
2200   AC_MSG_RESULT($glibcpp_shared_libgcc)
2201 fi
2202
2203 # For GNU ld, we need at least this version.  It's 2.12 in the same format
2204 # as the tested-for version.  See GLIBCPP_CHECK_LINKER_FEATURES for more.
2205 glibcpp_min_gnu_ld_version=21200
2206
2207 # Check to see if unspecified "yes" value can win, given results
2208 # above.
2209 if test $enable_symvers = yes ; then
2210   if test $with_gnu_ld = yes &&
2211     test $glibcpp_shared_libgcc = yes ;
2212   then
2213     if test $glibcpp_gnu_ld_version -ge $glibcpp_min_gnu_ld_version ; then
2214         enable_symvers=gnu
2215     else
2216       ac_test_CFLAGS="${CFLAGS+set}"
2217       ac_save_CFLAGS="$CFLAGS"
2218       CFLAGS='-shared -Wl,--version-script,conftest.map'
2219       enable_symvers=no
2220       changequote(,)
2221       echo 'FOO { global: f[a-z]o; local: *; };' > conftest.map
2222       changequote([,])
2223       AC_TRY_LINK([int foo;],, enable_symvers=gnu)
2224       if test "$ac_test_CFLAGS" = set; then
2225         CFLAGS="$ac_save_CFLAGS"
2226       else
2227         # this is the suspicious part
2228         CFLAGS=''
2229       fi
2230       rm -f conftest.map
2231     fi
2232   else
2233     # just fail for now
2234     enable_symvers=no
2235   fi
2236 fi
2237
2238 dnl Everything parsed; figure out what file to use.
2239 case $enable_symvers in
2240   no)
2241       SYMVER_MAP=config/linker-map.dummy
2242       ;;
2243   gnu)
2244       SYMVER_MAP=config/linker-map.gnu
2245       AC_DEFINE(_GLIBCPP_SYMVER)
2246       ;;
2247 esac
2248
2249 AC_SUBST(SYMVER_MAP)
2250 AM_CONDITIONAL(GLIBCPP_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
2251 AC_MSG_CHECKING([versioning on shared library symbols])
2252 AC_MSG_RESULT($enable_symvers)
2253 ])
2254