libstdc++-v3/aclocal.m4

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