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