libstdc++-v3/acinclude.m4

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