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 template specializations for the 'long long' type extension.
1335 dnl
1336 dnl GLIBCPP_ENABLE_LONG_LONG
1337 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1338 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1339 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1340 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1341 dnl       defaults to `no'.
1342 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1343 dnl
1344 dnl GLIBCPP_ENABLE_LONG_LONG
1345 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1346   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1347
1348   AC_ARG_ENABLE(long-long,
1349   changequote(<<, >>)dnl
1350   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1351   changequote([, ])dnl
1352   [case "$enableval" in
1353    yes) enable_long_long=yes ;;
1354    no)  enable_long_long=no ;;
1355    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1356    esac],
1357   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1358
1359   # Option parsed, now set things appropriately
1360   if test x"$enable_long_long" = xyes; then
1361     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1362   fi
1363 ])
1364
1365
1366 dnl
1367 dnl Check for ISO/IEC 9899:1999 "C99" support.
1368 dnl
1369 dnl GLIBCPP_ENABLE_C99
1370 dnl --enable-c99 defines _GLIBCPP_USE_C99
1371 dnl --disable-c99 leaves _GLIBCPP_USE_C99 undefined
1372 dnl  +  Usage:  GLIBCPP_ENABLE_C99[(DEFAULT)]
1373 dnl       Where DEFAULT is either `yes' or `no'.  If omitted, it
1374 dnl       defaults to `no'.
1375 dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
1376 dnl
1377 dnl GLIBCPP_ENABLE_C99
1378 AC_DEFUN(GLIBCPP_ENABLE_C99, [dnl
1379   define([GLIBCPP_ENABLE_C99_DEFAULT], ifelse($1, yes, yes, no))dnl
1380
1381   AC_ARG_ENABLE(c99,
1382   changequote(<<, >>)dnl
1383   <<--enable-c99      turns on 'ISO/IEC 9899:1999 support' [default=>>GLIBCPP_ENABLE_C99_DEFAULT],
1384   changequote([, ])dnl
1385   [case "$enableval" in
1386    yes) enable_c99=yes ;;
1387    no)  enable_c99=no ;;
1388    *)   AC_MSG_ERROR([Unknown argument to enable/disable C99]) ;;
1389    esac],
1390   enable_c99=GLIBCPP_ENABLE_C99_DEFAULT)dnl
1391
1392   AC_LANG_SAVE
1393   AC_LANG_CPLUSPLUS
1394
1395   # Check for the existence of <math.h> functions used if C99 is enabled.
1396   AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
1397   AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
1398   AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
1399   AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
1400   AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
1401   AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
1402   AC_TRY_COMPILE([#include <math.h>],[isgreater(0,0);],, [ac_c99_math=no])
1403   AC_TRY_COMPILE([#include <math.h>],[isgreaterequal(0,0);],, [ac_c99_math=no])
1404   AC_TRY_COMPILE([#include <math.h>],[isless(0,0);],, [ac_c99_math=no])
1405   AC_TRY_COMPILE([#include <math.h>],[islessequal(0,0);],, [ac_c99_math=no])
1406   AC_TRY_COMPILE([#include <math.h>],[islessgreater(0,0);],, [ac_c99_math=no])
1407   AC_TRY_COMPILE([#include <math.h>],[isunordered(0,0);],, [ac_c99_math=no])
1408
1409   # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1410   AC_CHECK_FUNC(strtoll,,ac_c99_stdlib=no)
1411   AC_CHECK_FUNC(strtoull,,ac_c99_stdlib=no)
1412   AC_CHECK_FUNC(llabs,,ac_c99_stdlib=no)
1413   AC_CHECK_FUNC(lldiv,,ac_c99_stdlib=no)
1414   AC_CHECK_FUNC(atoll,,ac_c99_stdlib=no)
1415
1416   AC_MSG_CHECKING([for lldiv_t declaration])
1417   AC_CACHE_VAL(ac_c99_lldiv_t, [
1418   AC_TRY_COMPILE([#include <stdlib.h>],
1419                    [ lldiv_t mydivt;],
1420                    [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
1421   ])
1422   AC_MSG_RESULT($ac_c99_lldiv_t)
1423   if test x"$ac_c99_lldiv_t" = x"no"; then
1424     ac_c99_stdlib=no;
1425   fi;
1426
1427   # Check for the existence of <wchar.h> functions used if C99 is enabled.
1428   AC_CHECK_FUNC(wcstold,,ac_c99_wchar=no)
1429   AC_CHECK_FUNC(wcstoll,,ac_c99_wchar=no)
1430   AC_CHECK_FUNC(wcstoull,,ac_c99_wchar=no)
1431
1432   AC_MSG_CHECKING([for enabled ISO C99 support])
1433   if test x"$ac_c99_math" = x"no" || test x"$ac_c99_wchar" = x"no" \
1434         || test x"$ac_c99_stdlib" = x"no"; then
1435     enable_c99=no;
1436   fi;
1437   AC_MSG_RESULT($enable_c99)
1438
1439   # Option parsed, now set things appropriately
1440   if test x"$enable_c99" = x"yes"; then
1441     AC_DEFINE(_GLIBCPP_USE_C99)
1442   fi
1443
1444   AC_LANG_RESTORE
1445 ])
1446
1447
1448 dnl
1449 dnl Check for what kind of C headers to use.
1450 dnl
1451 dnl GLIBCPP_ENABLE_CHEADERS
1452 dnl --enable-cheaders= [does stuff].
1453 dnl --disable-cheaders [does not do anything, really].
1454 dnl  +  This will eventually need to be 'c_shadow' by default.
1455 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1456 dnl       Where DEFAULT is either `c' or `c_std' or 'c_shadow'.
1457 dnl       If ommitted, it defaults to `c_std'.
1458 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1459 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1460 AC_MSG_CHECKING([for c header strategy to use])
1461 AC_ARG_ENABLE(cheaders,
1462 changequote(<<, >>)dnl
1463 <<  --enable-cheaders construct "C" header files for
1464                            g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1465 changequote([, ])
1466   [case "$enableval" in
1467    c)
1468         enable_cheaders=c
1469         ;;
1470    c_std)
1471         enable_cheaders=c_std
1472         ;;
1473    c_shadow)
1474         enable_cheaders=c_shadow
1475         ;;
1476    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1477         ;;
1478   esac],
1479   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1480   AC_MSG_RESULT($enable_cheaders)
1481
1482   dnl Option parsed, now set things appropriately
1483   case "$enable_cheaders" in
1484     c_shadow)
1485         CSHADOW_FLAGS="-fno-builtin"
1486         C_INCLUDE_DIR='${top_srcdir}/include/c_shadow'
1487         AC_DEFINE(_GLIBCPP_USE_SHADOW_HEADERS)
1488         ;;
1489     c_std)
1490         CSHADOW_FLAGS=""
1491         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
1492         ;;
1493     c)
1494         CSHADOW_FLAGS=""
1495         C_INCLUDE_DIR='${top_srcdir}/include/c'
1496         ;;
1497   esac
1498
1499   AC_SUBST(CSHADOW_FLAGS)
1500   AC_SUBST(C_INCLUDE_DIR)
1501   AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cheaders" = c_shadow)
1502 ])
1503
1504
1505 dnl
1506 dnl Check for wide character support.  Has the same effect as the option
1507 dnl in gcc's configure, but in a form that autoconf can mess with.
1508 dnl
1509 dnl GLIBCPP_ENABLE_C_MBCHAR
1510 dnl --enable-c-mbchar requests all the wchar_t stuff.
1511 dnl --disable-c-mbchar doesn't.
1512 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1513 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1514 dnl       defaults to `no'.
1515 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1516 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1517 AC_ARG_ENABLE(c-mbchar,
1518 changequote(<<, >>)dnl
1519 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1520 changequote([, ])dnl
1521 [case "$enableval" in
1522  yes) enable_c_mbchar=yes ;;
1523  no)  enable_c_mbchar=no ;;
1524  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1525  esac],
1526 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1527 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1528 ])
1529
1530
1531 dnl
1532 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1533 dnl
1534 dnl GLIBCPP_INCLUDE_DIR
1535 dnl C_INCLUDE_DIR
1536 dnl TOPLEVEL_INCLUDES
1537 dnl LIBMATH_INCLUDES
1538 dnl LIBSUPCXX_INCLUDES
1539 dnl LIBIO_INCLUDES
1540 dnl CSHADOW_INCLUDES
1541 dnl
1542 dnl GLIBCPP_EXPORT_INCLUDE
1543 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1544   # Root level of the include sources.
1545   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
1546
1547   # Can either use include/c or include/c_std to grab "C" headers. This
1548   # variable is set to the include directory currently in use.
1549   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_CHEADERS
1550
1551   # Passed down for canadian crosses.
1552   if  test x"$CANADIAN" = xyes; then
1553     TOPLEVEL_INCLUDES='-I$(includedir)'
1554   fi
1555
1556   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1557
1558   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1559
1560   #if GLIBCPP_NEED_LIBIO
1561   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1562   #else
1563   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
1564   #endif
1565
1566   #if GLIBCPP_USE_CSHADOW
1567   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
1568   #                   -I$(top_blddir)/cshadow'
1569   #else
1570   CSTD_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
1571   #endif
1572
1573   # Now, export this to all the little Makefiles....
1574   AC_SUBST(GLIBCPP_INCLUDE_DIR)
1575   AC_SUBST(TOPLEVEL_INCLUDES)
1576   AC_SUBST(LIBMATH_INCLUDES)
1577   AC_SUBST(LIBSUPCXX_INCLUDES)
1578   AC_SUBST(LIBIO_INCLUDES)
1579   AC_SUBST(CSTD_INCLUDES)
1580 ])
1581
1582
1583 dnl
1584 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1585 dnl
1586 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1587   # Optimization flags that are probably a good idea for thrill-seekers. Just
1588   # uncomment the lines below and make, everything else is ready to go...
1589   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1590   OPTIMIZE_CXXFLAGS=
1591   AC_SUBST(OPTIMIZE_CXXFLAGS)
1592
1593   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1594   AC_SUBST(WARN_FLAGS)
1595 ])
1596
1597 dnl
1598 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1599 dnl  calculates gxx_install_dir
1600 dnl  exports glibcpp_toolexecdir
1601 dnl  exports glibcpp_toolexeclibdir
1602 dnl
1603 dnl Assumes cross_compiling bits already done, and with_cross_host in
1604 dnl particular
1605 dnl
1606 dnl GLIBCPP_EXPORT_INSTALL_INFO
1607 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1608
1609 glibcpp_toolexecdir=no
1610 glibcpp_toolexeclibdir=no
1611
1612 AC_MSG_CHECKING([for interface version number])
1613 libstdcxx_interface=$INTERFACE
1614 AC_MSG_RESULT($libstdcxx_interface)
1615
1616 # Process the option --with-gxx-include-dir=<path to include-files directory>
1617 AC_MSG_CHECKING([for --with-gxx-include-dir])
1618 AC_ARG_WITH(gxx-include-dir,
1619 [ --with-gxx-include-dir  the installation directory for include files],
1620 [case "${withval}" in
1621   yes)
1622     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1623     gxx_include_dir=no
1624     ;;
1625   no)
1626     gxx_include_dir=no
1627     ;;
1628   *)
1629     gxx_include_dir=${withval}
1630     ;;
1631 esac], [gxx_include_dir=no])
1632 AC_MSG_RESULT($gxx_include_dir)
1633
1634 # Process the option "--enable-version-specific-runtime-libs"
1635 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1636 AC_ARG_ENABLE(version-specific-runtime-libs,
1637 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1638 [  version_specific_libs=yes
1639 # Need the gcc compiler version to know where to install libraries
1640 # and header files if --enable-version-specific-runtime-libs option
1641 # is selected.
1642 changequote(,)dnl
1643 gcc_version_trigger=${srcdir}/../gcc/version.c
1644 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
1645 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1646 gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/g++
1647 glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1648 glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}
1649 changequote([,])dnl
1650 ],version_specific_libs=no)
1651 AC_MSG_RESULT($version_specific_libs)
1652
1653 # Default case for install directory for include files.
1654 if test x"$version_specific_libs" = x"no" \
1655    && test x"$gxx_include_dir" = x"no"; then
1656   gxx_include_dir='$(prefix)'/include/g++-${libstdcxx_interface}
1657 fi
1658
1659 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1660 # Install a library built with a cross compiler in tooldir, not libdir.
1661 if test x"$glibcpp_toolexecdir" = x"no"; then
1662   if test -n "$with_cross_host" && test x"$with_cross_host" != x"no"; then
1663     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1664     glibcpp_toolexeclibdir='$(toolexecdir)/lib$(MULTISUBDIR)'
1665   else
1666     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1667     glibcpp_toolexeclibdir='$(libdir)$(MULTISUBDIR)'
1668   fi
1669 fi
1670
1671 AC_MSG_CHECKING([for install location])
1672 AC_MSG_RESULT($gxx_include_dir)
1673
1674 AC_SUBST(gxx_include_dir)
1675 AC_SUBST(glibcpp_toolexecdir)
1676 AC_SUBST(glibcpp_toolexeclibdir)
1677 ])
1678
1679
1680 # Check whether LC_MESSAGES is available in <locale.h>.
1681 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1682 #
1683 # This file file be copied and used freely without restrictions.  It can
1684 # be used in projects which are not available under the GNU Public License
1685 # but which still want to provide support for the GNU gettext functionality.
1686 # Please note that the actual code is *not* freely available.
1687
1688 # serial 1
1689
1690 AC_DEFUN(AC_LC_MESSAGES, [
1691   AC_CHECK_HEADER(locale.h, [
1692     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1693       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1694        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1695     if test $ac_cv_val_LC_MESSAGES = yes; then
1696       AC_DEFINE(HAVE_LC_MESSAGES)
1697     fi
1698   ])
1699 ])
1700
1701
1702 # Check for functions in math library.
1703 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1704 #
1705 # This file can be copied and used freely without restrictions.  It can
1706 # be used in projects which are not available under the GNU Public License
1707 # but which still want to provide support for the GNU gettext functionality.
1708 # Please note that the actual code is *not* freely available.
1709
1710 # serial 1
1711
1712 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1713 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1714 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])
1715 AC_SUBST(LIBMATHOBJS)dnl
1716 ])
1717
1718
1719 # Check for string functions.
1720 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1721 #
1722 # This file can be copied and used freely without restrictions.  It can
1723 # be used in projects which are not available under the GNU Public License
1724 # but which still want to provide support for the GNU gettext functionality.
1725 # Please note that the actual code is *not* freely available.
1726
1727 # serial 1
1728
1729 dnl AC_REPLACE_STRINGFUNCS(FUNCTION...)
1730 AC_DEFUN(AC_REPLACE_STRINGFUNCS,
1731 [AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"])
1732 AC_SUBST(LIBSTRINGOBJS)dnl
1733 ])
1734
1735
1736 dnl This macro searches for a GNU version of make.  If a match is found, the
1737 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1738 dnl set to "#". This is useful for  including a special features in a Makefile,
1739 dnl which cannot be handled by other versions of make.  The variable
1740 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1741 dnl the empty string otherwise.
1742 dnl
1743 dnl Here is an example of its use:
1744 dnl
1745 dnl Makefile.in might contain:
1746 dnl
1747 dnl     # A failsafe way of putting a dependency rule into a makefile
1748 dnl     $(DEPEND):
1749 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1750 dnl
1751 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1752 dnl     @ifGNUmake@ include $(DEPEND)
1753 dnl     @ifGNUmake@ endif
1754 dnl
1755 dnl Then configure.in would normally contain:
1756 dnl
1757 dnl     CHECK_GNU_MAKE()
1758 dnl     AC_OUTPUT(Makefile)
1759 dnl
1760 dnl Then perhaps to cause gnu make to override any other make, we could do
1761 dnl something like this (note that GNU make always looks for GNUmakefile first):
1762 dnl
1763 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1764 dnl             mv Makefile GNUmakefile
1765 dnl             echo .DEFAULT: > Makefile ;
1766 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1767 dnl     fi
1768 dnl
1769 dnl Then, if any (well almost any) other make is called, and GNU make also
1770 dnl exists, then the other make wraps the GNU make.
1771 dnl
1772 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1773 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1774 dnl
1775 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1776 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1777 dnl #### conditional's subshell (" --version" is not a command), using a
1778 dnl #### different option to grep(1).
1779 dnl #### -pme
1780 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1781 dnl #### ${MAKE:-make}).
1782 dnl #### -msokolov
1783 AC_DEFUN(
1784   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1785           _cv_gnu_make_command='' ;
1786 dnl Search all the common names for GNU make
1787           for a in "${MAKE-make}" make gmake gnumake ; do
1788                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1789                   then
1790                           _cv_gnu_make_command=$a ;
1791                           break;
1792                   fi
1793           done ;
1794   ) ;
1795 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1796 dnl string, '#' otherwise
1797   if test  "x$_cv_gnu_make_command" != "x"  ; then
1798           ifGNUmake='' ;
1799   else
1800           ifGNUmake='#' ;
1801   fi
1802   AC_SUBST(ifGNUmake)
1803 ])
1804
1805 sinclude(../libtool.m4)
1806 dnl The lines below arrange for aclocal not to bring an installed
1807 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1808 dnl add a definition of LIBTOOL to Makefile.in.
1809 ifelse(,,,[AC_SUBST(LIBTOOL)
1810 AC_DEFUN([AM_PROG_LIBTOOL])
1811 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1812 AC_DEFUN([AC_PROG_LD])
1813 ])
1814
1815
1816
1817 # Do all the work for Automake.  This macro actually does too much --
1818 # some checks are only needed if your package does certain things.
1819 # But this isn't really a big deal.
1820
1821 # serial 1
1822
1823 dnl Usage:
1824 dnl AM_INIT_AUTOMAKE(package,version, [no-define])
1825
1826 AC_DEFUN(AM_INIT_AUTOMAKE,
1827 [AC_REQUIRE([AC_PROG_INSTALL])
1828 PACKAGE=[$1]
1829 AC_SUBST(PACKAGE)
1830 VERSION=[$2]
1831 AC_SUBST(VERSION)
1832 dnl test to see if srcdir already configured
1833 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
1834   AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
1835 fi
1836 ifelse([$3],,
1837 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
1838 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))
1839 AC_REQUIRE([AM_SANITY_CHECK])
1840 AC_REQUIRE([AC_ARG_PROGRAM])
1841 dnl FIXME This is truly gross.
1842 missing_dir=`cd $ac_aux_dir && pwd`
1843 AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
1844 AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
1845 AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
1846 AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
1847 AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
1848 AC_REQUIRE([AC_PROG_MAKE_SET])])
1849
1850 #
1851 # Check to make sure that the build environment is sane.
1852 #
1853
1854 AC_DEFUN(AM_SANITY_CHECK,
1855 [AC_MSG_CHECKING([whether build environment is sane])
1856 # Just in case
1857 sleep 1
1858 echo timestamp > conftestfile
1859 # Do `set' in a subshell so we don't clobber the current shell's
1860 # arguments.  Must try -L first in case configure is actually a
1861 # symlink; some systems play weird games with the mod time of symlinks
1862 # (eg FreeBSD returns the mod time of the symlink's containing
1863 # directory).
1864 if (
1865    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
1866    if test "[$]*" = "X"; then
1867       # -L didn't work.
1868       set X `ls -t $srcdir/configure conftestfile`
1869    fi
1870    if test "[$]*" != "X $srcdir/configure conftestfile" \
1871       && test "[$]*" != "X conftestfile $srcdir/configure"; then
1872
1873       # If neither matched, then we have a broken ls.  This can happen
1874       # if, for instance, CONFIG_SHELL is bash and it inherits a
1875       # broken ls alias from the environment.  This has actually
1876       # happened.  Such a system could not be considered "sane".
1877       AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
1878 alias in your environment])
1879    fi
1880
1881    test "[$]2" = conftestfile
1882    )
1883 then
1884    # Ok.
1885    :
1886 else
1887    AC_MSG_ERROR([newly created file is older than distributed files!
1888 Check your system clock])
1889 fi
1890 rm -f conftest*
1891 AC_MSG_RESULT(yes)])
1892
1893 dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
1894 dnl The program must properly implement --version.
1895 AC_DEFUN(AM_MISSING_PROG,
1896 [AC_MSG_CHECKING(for working $2)
1897 # Run test in a subshell; some versions of sh will print an error if
1898 # an executable is not found, even if stderr is redirected.
1899 # Redirect stdin to placate older versions of autoconf.  Sigh.
1900 if ($2 --version) < /dev/null > /dev/null 2>&1; then
1901    $1=$2
1902    AC_MSG_RESULT(found)
1903 else
1904    $1="$3/missing $2"
1905    AC_MSG_RESULT(missing)
1906 fi
1907 AC_SUBST($1)])
1908
1909 # Add --enable-maintainer-mode option to configure.
1910 # From Jim Meyering
1911
1912 # serial 1
1913
1914 AC_DEFUN(AM_MAINTAINER_MODE,
1915 [AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
1916   dnl maintainer-mode is disabled by default
1917   AC_ARG_ENABLE(maintainer-mode,
1918 [  --enable-maintainer-mode enable make rules and dependencies not useful
1919                           (and sometimes confusing) to the casual installer],
1920       USE_MAINTAINER_MODE=$enableval,
1921       USE_MAINTAINER_MODE=no)
1922   AC_MSG_RESULT($USE_MAINTAINER_MODE)
1923   AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes)
1924   MAINT=$MAINTAINER_MODE_TRUE
1925   AC_SUBST(MAINT)dnl
1926 ]
1927 )
1928
1929 # Define a conditional.
1930
1931 AC_DEFUN(AM_CONDITIONAL,
1932 [AC_SUBST($1_TRUE)
1933 AC_SUBST($1_FALSE)
1934 if $2; then
1935   $1_TRUE=
1936   $1_FALSE='#'
1937 else
1938   $1_TRUE='#'
1939   $1_FALSE=
1940 fi])
1941
1942 # Like AC_CONFIG_HEADER, but automatically create stamp file.
1943
1944 AC_DEFUN(AM_CONFIG_HEADER,
1945 [AC_PREREQ([2.12])
1946 AC_CONFIG_HEADER([$1])
1947 dnl When config.status generates a header, we must update the stamp-h file.
1948 dnl This file resides in the same directory as the config header
1949 dnl that is generated.  We must strip everything past the first ":",
1950 dnl and everything past the last "/".
1951 AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl
1952 ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,
1953 <<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>,
1954 <<am_indx=1
1955 for am_file in <<$1>>; do
1956   case " <<$>>CONFIG_HEADERS " in
1957   *" <<$>>am_file "*<<)>>
1958     echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx
1959     ;;
1960   esac
1961   am_indx=`expr "<<$>>am_indx" + 1`
1962 done<<>>dnl>>)
1963 changequote([,]))])
1964