libstdc++-v3/acinclude.m4

   1 dnl
   2 dnl Initialize configure bits.
   3 dnl
   4 dnl Define OPTLEVEL='-O2' if new inlining code present.
   5 dnl
   6 dnl GLIBCPP_CONFIGURE
   7 AC_DEFUN(GLIBCPP_CONFIGURE, [
   8   dnl Default to --enable-multilib
   9   AC_ARG_ENABLE(multilib,
  10   [  --enable-multilib       build hella library versions (default)],
  11   [case "${enableval}" in
  12     yes) multilib=yes ;;
  13     no)  multilib=no ;;
  14     *)   AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
  15    esac], [multilib=yes])dnl
  16
  17   dnl We may get other options which we dont document:
  18   dnl --with-target-subdir, --with-multisrctop, --with-multisubdir
  19   if test "[$]{srcdir}" = "."; then
  20     if test "[$]{with_target_subdir}" != "."; then
  21       glibcpp_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1"
  22     else
  23       glibcpp_basedir="[$]{srcdir}/[$]{with_multisrctop}$1"
  24     fi
  25   else
  26     glibcpp_basedir="[$]{srcdir}/$1"
  27   fi
  28   AC_SUBST(glibcpp_basedir)
  29
  30   AM_INIT_AUTOMAKE(libstdc++, 2.90.8)
  31
  32   # Never versions of autoconf add an underscore to these functions.
  33   # Prevent future problems ...
  34   ifdef([AC_PROG_CC_G],[],[define([AC_PROG_CC_G],defn([_AC_PROG_CC_G]))])
  35   ifdef([AC_PROG_CC_GNU],[],[define([AC_PROG_CC_GNU],defn([_AC_PROG_CC_GNU]))])
  36   ifdef([AC_PROG_CXX_G],[],[define([AC_PROG_CXX_G],defn([_AC_PROG_CXX_G]))])
  37   ifdef([AC_PROG_CXX_GNU],[],[define([AC_PROG_CXX_GNU],defn([_AC_PROG_CXX_GNU]))])
  38
  39 #  AC_PROG_CC
  40
  41 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
  42 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
  43 # are probably using a cross compiler, which will not be able to fully
  44 # link an executable.  This should really be fixed in autoconf
  45 # itself.
  46
  47 AC_DEFUN(LIB_AC_PROG_CC,
  48 [AC_BEFORE([$0], [AC_PROG_CPP])dnl
  49 dnl Fool anybody using AC_PROG_CC.
  50 AC_PROVIDE([AC_PROG_CC])
  51 AC_CHECK_PROG(CC, gcc, gcc)
  52 if test -z "$CC"; then
  53   AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
  54   test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
  55 fi
  56
  57 AC_PROG_CC_GNU
  58
  59 if test $ac_cv_prog_gcc = yes; then
  60   GCC=yes
  61 dnl Check whether -g works, even if CFLAGS is set, in case the package
  62 dnl plays around with CFLAGS (such as to build both debugging and
  63 dnl normal versions of a library), tasteless as that idea is.
  64   ac_test_CFLAGS="${CFLAGS+set}"
  65   ac_save_CFLAGS="$CFLAGS"
  66   CFLAGS=
  67   AC_PROG_CC_G
  68   if test "$ac_test_CFLAGS" = set; then
  69     CFLAGS="$ac_save_CFLAGS"
  70   elif test $ac_cv_prog_cc_g = yes; then
  71     CFLAGS="-g -O2"
  72   else
  73     CFLAGS="-O2"
  74   fi
  75 else
  76   GCC=
  77   test "${CFLAGS+set}" = set || CFLAGS="-g"
  78 fi
  79 ])
  80
  81 LIB_AC_PROG_CC
  82
  83 # Can't just call these here as g++ requires libstc++ to be built....
  84 #  AC_PROG_CXX
  85
  86 # Likewise for AC_PROG_CXX.
  87 AC_DEFUN(LIB_AC_PROG_CXX,
  88 [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
  89 dnl Fool anybody using AC_PROG_CXX.
  90 AC_PROVIDE([AC_PROG_CXX])
  91 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
  92 # flags that come in CXX while configuring libstdc++.  They're different
  93 # from those used for all other target libraries.  If CXX is set in
  94 # the environment, respect that here.
  95 CXX_libstdcxx=$CXX
  96 AC_CHECK_PROGS(CXX_libstdcxx, $CCC c++ g++ gcc CC cxx cc++, gcc)
  97 CXX=$CXX_libstdcxx
  98 AC_SUBST(CXX)
  99 test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
 100
 101 AC_PROG_CXX_GNU
 102
 103 if test $ac_cv_prog_gxx = yes; then
 104   GXX=yes
 105 dnl Check whether -g works, even if CXXFLAGS is set, in case the package
 106 dnl plays around with CXXFLAGS (such as to build both debugging and
 107 dnl normal versions of a library), tasteless as that idea is.
 108   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 109   ac_save_CXXFLAGS="$CXXFLAGS"
 110   CXXFLAGS=
 111   AC_PROG_CXX_G
 112   if test "$ac_test_CXXFLAGS" = set; then
 113     CXXFLAGS="$ac_save_CXXFLAGS"
 114   elif test $ac_cv_prog_cxx_g = yes; then
 115     CXXFLAGS="-g -O2"
 116   else
 117     CXXFLAGS="-O2"
 118   fi
 119 else
 120   GXX=
 121   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
 122 fi
 123 ])
 124
 125 LIB_AC_PROG_CXX
 126
 127   AC_CHECK_TOOL(AS, as)
 128   AC_CHECK_TOOL(AR, ar)
 129   AC_CHECK_TOOL(RANLIB, ranlib, :)
 130
 131   AC_PROG_INSTALL
 132
 133   AM_MAINTAINER_MODE
 134
 135   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
 136   # at least currently, we never actually build a program, so we never
 137   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
 138   # fails, because we are probably configuring with a cross compiler
 139   # which cant create executables.  So we include AC_EXEEXT to keep
 140   # automake happy, but we dont execute it, since we dont care about
 141   # the result.
 142   if false; then
 143     AC_EXEEXT
 144   fi
 145
 146   # configure.host sets the following important variables
 147   #        glibcpp_cflags    - host specific C compiler flags
 148   #        glibcpp_cxxflags  - host specific C++ compiler flags
 149   glibcpp_cflags=
 150   glibcpp_cxxflags=
 151
 152   . [$]{glibcpp_basedir}/configure.host
 153
 154   case [$]{glibcpp_basedir} in
 155     /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
 156     *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
 157   esac
 158
 159   # This does for the target what configure.host does for the host.  In
 160   # addition to modifying the same flags, it also sets up symlinks.
 161   GLIBCPP_CHECK_TARGET
 162
 163   GLIBCPP_CFLAGS="[$]{glibcpp_cflags}"
 164   GLIBCPP_CXXFLAGS="[$]{glibcpp_cxxflags}"
 165   AC_SUBST(GLIBCPP_CFLAGS)
 166   AC_SUBST(GLIBCPP_CXXFLAGS)
 167 ])
 168
 169
 170 dnl
 171 dnl Check to see if g++ can compile this library, and if so, if any version-
 172 dnl specific precautions need to be taken.
 173 dnl
 174 dnl GLIBCPP_CHECK_COMPILER_VERSION
 175 AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
 176 if test ! -f stamp-sanity-compiler; then
 177   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
 178   AC_LANG_SAVE
 179   AC_LANG_CPLUSPLUS
 180   AC_EGREP_CPP(ok, [
 181   #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
 182     ok
 183   #endif
 184   ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to gcc-2.95 or above]))
 185   AC_LANG_RESTORE
 186   AC_MSG_RESULT($gpp_satisfactory)
 187   touch stamp-sanity-compiler
 188 fi
 189 ])
 190
 191
 192 dnl
 193 dnl Test for newer compiler features, or features that are present in newer
 194 dnl compiler version but not older compiler versions should be placed
 195 dnl here.
 196 dnl
 197 dnl Define WFMT_FLAGS='-fdiagnostics-show-location=once' if possible
 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 more sophisticated diagnostic control.
 223   AC_MSG_CHECKING([for g++ that supports -fdiagnostics-show-location=once])
 224   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
 225   AC_TRY_COMPILE(, [int foo;
 226   ], [ac_gabydiags=yes], [ac_gabydiags=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_gabydiags" = x"yes"; then
 234     WFMT_FLAGS='-fdiagnostics-show-location=once'
 235   fi
 236   AC_MSG_RESULT($ac_gabydiags)
 237
 238   # Check for -ffunction-sections -fdata-sections
 239   AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
 240   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
 241   AC_TRY_COMPILE(, [int foo;
 242   ], [ac_fdsections=yes], [ac_fdsections=no])
 243   if test "$ac_test_CXXFLAGS" = set; then
 244     CXXFLAGS="$ac_save_CXXFLAGS"
 245   else
 246     # this is the suspicious part
 247     CXXFLAGS=''
 248   fi
 249   if test x"$ac_fdsections" = x"yes" && test x"$enable_debug" = x"no"; then
 250     SECTION_FLAGS='-ffunction-sections -fdata-sections'
 251   fi
 252   AC_MSG_RESULT($ac_fdsections)
 253
 254   AC_LANG_RESTORE
 255   AC_SUBST(WERROR)
 256   AC_SUBST(WFMT_FLAGS)
 257   AC_SUBST(SECTION_FLAGS)
 258 ])
 259
 260
 261 dnl
 262 dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
 263 dnl the native linker is in use, all variables will be defined to something
 264 dnl safe (like an empty string).
 265 dnl
 266 dnl Define SECTION_LDFLAGS='-Wl,--gc-sections' if possible.
 267 dnl Define OPT_LDFLAGS='-Wl,-O1' if possible.
 268 dnl
 269 dnl GLIBCPP_CHECK_LINKER_FEATURES
 270 AC_DEFUN(GLIBCPP_CHECK_LINKER_FEATURES, [
 271   # If we're not using GNU ld, then there's no point in even trying these
 272   # tests.  Check for that first.  We should have already tested for gld
 273   # by now (in libtool), but require it now just to be safe...
 274   SECTION_LDFLAGS=''
 275   OPT_LDFLAGS=''
 276   AC_REQUIRE([AC_PROG_LD])
 277
 278   # Set --gc-sections.
 279   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
 280     # GNU ld it is!  Joy and bunny rabbits!
 281
 282     # All these tests are for C++; save the language and the compiler flags.
 283     # Need to do this so that g++ won't try to link in libstdc++
 284     ac_test_CFLAGS="${CFLAGS+set}"
 285     ac_save_CFLAGS="$CFLAGS"
 286     CFLAGS='-x c++  -Wl,--gc-sections'
 287
 288     # Check for -Wl,--gc-sections
 289     # XXX This test is broken at the moment, as symbols required for
 290     # linking are now in libsupc++ (not built yet.....). In addition,
 291     # this test has cored on solaris in the past. In addition,
 292     # --gc-sections doesn't really work at the moment (keeps on discarding
 293     # used sections, first .eh_frame and now some of the glibc sections for
 294     # iconv). Bzzzzt. Thanks for playing, maybe next time.
 295     AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
 296     AC_TRY_RUN([
 297      int main(void)
 298      {
 299        try { throw 1; }
 300        catch (...) { };
 301        return 0;
 302      }
 303     ], [ac_sectionLDflags=yes],[ac_sectionLFflags=no], [ac_sectionLDflags=yes])
 304     if test "$ac_test_CFLAGS" = set; then
 305       CFLAGS="$ac_save_CFLAGS"
 306     else
 307       # this is the suspicious part
 308       CFLAGS=''
 309     fi
 310     if test "$ac_sectionLDflags" = "yes"; then
 311       SECTION_LDFLAGS='-Wl,--gc-sections'
 312     fi
 313     AC_MSG_RESULT($ac_sectionLDflags)
 314   fi
 315
 316   # Set linker optimization flags.
 317   if test x"$ac_cv_prog_gnu_ld" = x"yes" && test x"$enable_debug" = x"no"; then
 318     OPT_LDFLAGS='-Wl,-O1'
 319   fi
 320
 321   AC_SUBST(SECTION_LDFLAGS)
 322   AC_SUBST(OPT_LDFLAGS)
 323 ])
 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
 331 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 332 dnl
 333 dnl argument 1 is name of function to check
 334 dnl
 335 dnl ASSUMES argument is a math function with ONE parameter
 336 dnl
 337 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1
 338 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, [
 339   AC_MSG_CHECKING([for $1 declaration])
 340   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 341     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 342       AC_LANG_SAVE
 343       AC_LANG_CPLUSPLUS
 344       AC_TRY_COMPILE([#include <math.h>],
 345                      [ $1(0);],
 346                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 347       AC_LANG_RESTORE
 348     ])
 349   fi
 350   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 351   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 352     AC_CHECK_FUNCS($1)
 353   fi
 354 ])
 355
 356 dnl
 357 dnl Like GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
 358 dnl of functions at once.  It's an all-or-nothing check -- either
 359 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
 360 dnl Doing it this way saves significant configure time.
 361 AC_DEFUN(GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1, [
 362   AC_MSG_CHECKING([for $1 functions])
 363   AC_CACHE_VAL(glibcpp_cv_func_$2_use, [
 364     AC_LANG_SAVE
 365     AC_LANG_CPLUSPLUS
 366     AC_TRY_COMPILE([#include <math.h>],
 367                    [ `for x in $3; do echo "$x (0);"; done` ],
 368                    [glibcpp_cv_func_$2_use=yes],
 369                    [glibcpp_cv_func_$2_use=no])
 370     AC_LANG_RESTORE])
 371   AC_MSG_RESULT($glibcpp_cv_func_$2_use)
 372   if test x$glibcpp_cv_func_$2_use = x"yes"; then
 373     AC_CHECK_FUNCS($3)
 374   fi
 375 ])
 376
 377 dnl
 378 dnl Check to see if the (math function) argument passed is
 379 dnl 1) declared when using the c++ compiler
 380 dnl 2) has "C" linkage
 381 dnl
 382 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 383 dnl
 384 dnl argument 1 is name of function to check
 385 dnl
 386 dnl ASSUMES argument is a math function with TWO parameters
 387 dnl
 388 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
 389 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
 390   AC_MSG_CHECKING([for $1 declaration])
 391   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 392     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 393       AC_LANG_SAVE
 394       AC_LANG_CPLUSPLUS
 395       AC_TRY_COMPILE([#include <math.h>],
 396                      [ $1(0, 0);],
 397                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 398       AC_LANG_RESTORE
 399     ])
 400   fi
 401   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 402   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 403     AC_CHECK_FUNCS($1)
 404   fi
 405 ])
 406
 407
 408 dnl
 409 dnl Check to see if the (math function) argument passed is
 410 dnl 1) declared when using the c++ compiler
 411 dnl 2) has "C" linkage
 412 dnl
 413 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 414 dnl
 415 dnl argument 1 is name of function to check
 416 dnl
 417 dnl ASSUMES argument is a math function with THREE parameters
 418 dnl
 419 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
 420 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
 421   AC_MSG_CHECKING([for $1 declaration])
 422   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 423     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 424       AC_LANG_SAVE
 425       AC_LANG_CPLUSPLUS
 426       AC_TRY_COMPILE([#include <math.h>],
 427                      [ $1(0, 0, 0);],
 428                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 429       AC_LANG_RESTORE
 430     ])
 431   fi
 432   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 433   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 434     AC_CHECK_FUNCS($1)
 435   fi
 436 ])
 437
 438
 439 dnl
 440 dnl Check to see if the (stdlib function) argument passed is
 441 dnl 1) declared when using the c++ compiler
 442 dnl 2) has "C" linkage
 443 dnl
 444 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 445 dnl Define HAVE_STRTOF if "strtof" 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 TWO parameters
 450 dnl
 451 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
 452 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
 453   AC_MSG_CHECKING([for $1 declaration])
 454   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 455     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 456       AC_LANG_SAVE
 457       AC_LANG_CPLUSPLUS
 458       AC_TRY_COMPILE([#include <stdlib.h>],
 459                      [ $1(0, 0);],
 460                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 461       AC_LANG_RESTORE
 462     ])
 463   fi
 464   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 465   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 466     AC_CHECK_FUNCS($1)
 467   fi
 468 ])
 469
 470
 471 dnl
 472 dnl Because the builtins are picky picky picky about the arguments they take,
 473 dnl do an explict linkage tests here.
 474 dnl Check to see if the (math 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_CARGF etc if "cargf" is declared and links
 479 dnl
 480 dnl argument 1 is name of function to check
 481 dnl
 482 dnl ASSUMES argument is a math function with ONE parameter
 483 dnl
 484 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 485 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 486   AC_MSG_CHECKING([for $1 declaration])
 487   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 488     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 489       AC_LANG_SAVE
 490       AC_LANG_CPLUSPLUS
 491       AC_TRY_COMPILE([#include <math.h>],
 492                      [ $1(0);],
 493                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 494       AC_LANG_RESTORE
 495     ])
 496   fi
 497   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 498   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 499     AC_MSG_CHECKING([for $1 linkage])
 500     if test x${glibcpp_cv_func_$1_link+set} != xset; then
 501       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 502         AC_TRY_LINK([#include <math.h>],
 503                     [ $1(0);],
 504                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 505       ])
 506     fi
 507     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 508     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 509       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 510       AC_DEFINE_UNQUOTED(${ac_tr_func})
 511     fi
 512   fi
 513 ])
 514
 515
 516 dnl
 517 dnl Check to see what builtin math functions are supported
 518 dnl
 519 dnl check for __builtin_abs
 520 dnl check for __builtin_fabsf
 521 dnl check for __builtin_fabs
 522 dnl check for __builtin_fabl
 523 dnl check for __builtin_labs
 524 dnl check for __builtin_sqrtf
 525 dnl check for __builtin_sqrtl
 526 dnl check for __builtin_fsqrt
 527 dnl check for __builtin_sinf
 528 dnl check for __builtin_sin
 529 dnl check for __builtin_sinl
 530 dnl check for __builtin_cosf
 531 dnl check for __builtin_cos
 532 dnl check for __builtin_cosl
 533 dnl
 534 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 535 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 536   dnl Test for builtin math functions.
 537   dnl These are made in gcc/c-common.c
 538   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 539   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 540   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 541   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 542   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 543
 544   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 545   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
 546   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 547
 548   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 549   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 550   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 551
 552   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 553   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 554   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 555
 556   dnl There is, without a doubt, a more elegant way to have these
 557   dnl names exported so that they won't be stripped out of acconfig.h by
 558   dnl autoheader. I leave this as an exercise to somebody less frustrated
 559   dnl than I.... please email the libstdc++ list if you can figure out a
 560   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 561   dnl AC_CHECK_FUNC for things to steal.)
 562   dummyvar=no
 563   if test x$dummyvar = x"yes"; then
 564     AC_DEFINE(HAVE___BUILTIN_ABS)
 565     AC_DEFINE(HAVE___BUILTIN_LABS)
 566     AC_DEFINE(HAVE___BUILTIN_COS)
 567     AC_DEFINE(HAVE___BUILTIN_COSF)
 568     AC_DEFINE(HAVE___BUILTIN_COSL)
 569     AC_DEFINE(HAVE___BUILTIN_FABS)
 570     AC_DEFINE(HAVE___BUILTIN_FABSF)
 571     AC_DEFINE(HAVE___BUILTIN_FABSL)
 572     AC_DEFINE(HAVE___BUILTIN_SIN)
 573     AC_DEFINE(HAVE___BUILTIN_SINF)
 574     AC_DEFINE(HAVE___BUILTIN_SINL)
 575     AC_DEFINE(HAVE___BUILTIN_FSQRT)
 576     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 577     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 578   fi
 579 ])
 580
 581
 582 dnl
 583 dnl Check to see what the underlying c library
 584 dnl These checks need to do two things:
 585 dnl 1) make sure the name is declared when using the c++ compiler
 586 dnl 2) make sure the name has "C" linkage
 587 dnl This might seem like overkill but experience has shown that it's not...
 588 dnl
 589 dnl Define HAVE_STRTOF etc if "strtof" is found.
 590 dnl Define HAVE_STRTOLD etc if "strtold" is found.
 591 dnl
 592 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
 593 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
 594   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 595   ac_save_CXXFLAGS="$CXXFLAGS"
 596   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 597
 598   AC_CHECK_FUNCS(strtof)
 599   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 600
 601   CXXFLAGS="$ac_save_CXXFLAGS"
 602 ])
 603
 604
 605 dnl
 606 dnl Check to see what the underlying c library or math library is like.
 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_CARGF etc if "cargf" is found.
 613 dnl
 614 dnl GLIBCPP_CHECK_MATH_SUPPORT
 615 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
 616   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 617   ac_save_CXXFLAGS="$CXXFLAGS"
 618   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 619
 620   dnl Check libm
 621   AC_CHECK_LIB(m, sin, libm="-lm")
 622   ac_save_LIBS="$LIBS"
 623   LIBS="$LIBS $libm"
 624
 625   dnl Check to see if certain C math functions exist.
 626   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 627   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 628   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 629   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 630   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 631   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 632   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 633
 634   dnl Check to see if basic C math functions have float versions.
 635   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
 636                                           float_trig,
 637                                           acosf asinf atanf \
 638                                           cosf sinf tanf \
 639                                           coshf sinhf tanhf)
 640   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
 641                                           float_round,
 642                                           ceilf floorf)
 643   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 644   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 645   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 646   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 647   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 648   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 649   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 650   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 651   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 652   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 653   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 654   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 655   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 656
 657   dnl Check to see if basic C math functions have long double versions.
 658   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
 659                                           long_double_trig,
 660                                           acosl asinl atanl \
 661                                           cosl sinl tanl \
 662                                           coshl sinhl tanhl)
 663   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
 664                                           long_double_round,
 665                                           ceill floorl)
 666   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 667   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 668   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 669   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 670   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 671   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 672   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 673   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 674   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 675   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 676   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 677   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 678   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 679   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 680   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 681   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 682
 683   dnl Some runtimes have these functions with a preceding underscore. Please
 684   dnl keep this sync'd with the one above. And if you add any new symbol,
 685   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
 686   dnl Check to see if certain C math functions exist.
 687   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinf)
 688   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnan)
 689   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finite)
 690   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_copysign)
 691   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincos)
 692   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fpclass)
 693   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_qfpclass)
 694
 695   dnl Check to see if basic C math functions have float versions.
 696   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float trig,
 697                                           _float_trig,
 698                                           _acosf _asinf _atanf \
 699                                           _cosf _sinf _tanf \
 700                                           _coshf _sinhf _tanhf)
 701   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_float round,
 702                                           _float_round,
 703                                           _ceilf _floorf)
 704   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnanf)
 705   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinff)
 706   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fabsf)
 707   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_fmodf)
 708   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_frexpf)
 709   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_ldexpf)
 710   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_logf)
 711   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10f)
 712   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modff)
 713   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powf)
 714   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtf)
 715   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincosf)
 716   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finitef)
 717
 718   dnl Check to see if basic C math functions have long double versions.
 719   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double trig,
 720                                           _long_double_trig,
 721                                           _acosl _asinl _atanl \
 722                                           _cosl _sinl _tanl \
 723                                           _coshl _sinhl _tanhl)
 724   GLIBCPP_CHECK_MATH_DECLS_AND_LINKAGES_1(_long double round,
 725                                           _long_double_round,
 726                                           _ceill _floorl)
 727   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnanl)
 728   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinfl)
 729   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_copysignl)
 730   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_atan2l)
 731   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_expl)
 732   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fabsl)
 733   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_fmodl)
 734   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_frexpl)
 735   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_ldexpl)
 736   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_logl)
 737   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10l)
 738   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modfl)
 739   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powl)
 740   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtl)
 741   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincosl)
 742   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finitel)
 743
 744   LIBS="$ac_save_LIBS"
 745   CXXFLAGS="$ac_save_CXXFLAGS"
 746 ])
 747
 748
 749 dnl
 750 dnl Check to see if there is native support for complex
 751 dnl
 752 dnl Don't compile bits in math/* if native support exits.
 753 dnl
 754 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "atan2l/copysignl" is found.
 755 dnl
 756 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
 757 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
 758   dnl Check for complex versions of math functions of platform.
 759   AC_CHECK_LIB(m, main)
 760   AC_REPLACE_MATHFUNCS(nan hypot hypotf atan2f expf copysignf)
 761
 762   dnl Compile the long double complex functions only if the function
 763   dnl provides the non-complex long double functions that are needed.
 764   dnl Currently this includes copysignl and atan2l, which should be
 765   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
 766   USE_COMPLEX_LONG_DOUBLE=no
 767   if test x$ac_cv_func_atan2l = x"yes" \
 768      && test x$ac_cv_func_copysignl = x"yes"; then
 769     USE_COMPLEX_LONG_DOUBLE=yes
 770     AC_REPLACE_MATHFUNCS(hypotl signbitl)
 771   fi
 772
 773   AC_SUBST(USE_COMPLEX_LONG_DOUBLE)
 774 ])
 775
 776
 777 dnl Check to see what architecture and operating system we are compiling
 778 dnl for.  Also, if architecture- or OS-specific flags are required for
 779 dnl compilation, pick them up here.
 780 dnl
 781 dnl GLIBCPP_CHECK_TARGET
 782 AC_DEFUN(GLIBCPP_CHECK_TARGET, [
 783     . [$]{glibcpp_basedir}/configure.target
 784     AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
 785     AC_MSG_RESULT(OS config directory is $os_include_dir)
 786     AC_LINK_FILES($os_include_dir/bits/os_defines.h, include/bits/os_defines.h)
 787 ])
 788
 789
 790 dnl
 791 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 792 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 793 dnl must have been previously checked.)
 794 dnl
 795 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
 796 dnl Define HAVE_MBSTATE_T if mbstate_t is not in wchar.h
 797 dnl
 798 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
 799 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 800
 801   dnl Test wchar.h for mbstate_t, which is needed for char_traits and
 802   dnl others even if wchar_t support is not on.
 803   AC_MSG_CHECKING([for mbstate_t])
 804   AC_TRY_COMPILE([#include <wchar.h>],
 805   [mbstate_t teststate;],
 806   have_mbstate_t=yes, have_mbstate_t=no)
 807   AC_MSG_RESULT($have_mbstate_t)
 808   if test x"$have_mbstate_t" = xyes; then
 809     AC_DEFINE(HAVE_MBSTATE_T)
 810   fi
 811
 812   dnl Sanity check for existence of ISO C99 headers for extended encoding.
 813   AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 814   AC_CHECK_HEADER(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 815
 816   dnl Only continue checking if the ISO C99 headers exist and support is on.
 817   if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes \
 818      && test x"$enable_c_mbchar" != xno; then
 819
 820     dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
 821     dnl numeric_limits can instantiate type_traits<wchar_t>
 822     AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
 823     AC_TRY_COMPILE([#include <wchar.h>],
 824     [int i = WCHAR_MIN; int j = WCHAR_MAX;],
 825     has_wchar_minmax=yes, has_wchar_minmax=no)
 826     AC_MSG_RESULT($has_wchar_minmax)
 827
 828     dnl Test wchar.h for WEOF, which is what we use to determine whether
 829     dnl to specialize for char_traits<wchar_t> or not.
 830     AC_MSG_CHECKING([for WEOF])
 831     AC_TRY_COMPILE([
 832       #include <wchar.h>
 833       #include <stddef.h>],
 834     [wint_t i = WEOF;],
 835     has_weof=yes, has_weof=no)
 836     AC_MSG_RESULT($has_weof)
 837
 838     dnl Tests for wide character functions used in char_traits<wchar_t>.
 839     AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
 840     wcsrtombs mbsrtowcs, ac_wfuncs=yes, ac_wfuncs=no)
 841
 842     AC_MSG_CHECKING([for ISO C99 wchar_t support])
 843     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
 844        && test x"$ac_wfuncs" = xyes; then
 845       ac_isoC99_wchar_t=yes
 846     else
 847       ac_isoC99_wchar_t=no
 848     fi
 849     AC_MSG_RESULT($ac_isoC99_wchar_t)
 850
 851     dnl Use iconv for wchar_t to char conversions. As such, check for
 852     dnl X/Open Portability Guide, version 2 features (XPG2).
 853     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 854     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 855
 856     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
 857     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
 858     ac_save_LIBS="$LIBS"
 859     LIBS="$LIBS $libiconv"
 860
 861     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
 862     ac_XPG2funcs=yes, ac_XPG2funcs=no)
 863
 864     LIBS="$ac_save_LIBS"
 865
 866     AC_MSG_CHECKING([for XPG2 wchar_t support])
 867     if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
 868        && test x"$ac_XPG2funcs" = xyes; then
 869       ac_XPG2_wchar_t=yes
 870     else
 871       ac_XPG2_wchar_t=no
 872     fi
 873     AC_MSG_RESULT($ac_XPG2_wchar_t)
 874
 875     dnl At the moment, only enable wchar_t specializations if all the
 876     dnl above support is present.
 877     AC_MSG_CHECKING([for enabled wchar_t specializations])
 878     if test x"$ac_isoC99_wchar_t" = xyes \
 879        && test x"$ac_XPG2_wchar_t" = xyes; then
 880       libinst_wstring_la="libinst-wstring.la"
 881       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
 882       AC_MSG_RESULT("yes")
 883     else
 884       libinst_wstring_la=""
 885       AC_MSG_RESULT("no")
 886     fi
 887     AC_SUBST(libinst_wstring_la)
 888
 889   else
 890     dnl Wide characters disabled by the user.
 891     AC_MSG_WARN([wchar_t support disabled.])
 892   fi
 893 ])
 894
 895
 896 dnl
 897 dnl Check to see if this version of GNU C++ is afflicted by bugs in
 898 dnl __complex__ float support.
 899 dnl
 900 dnl Define _GLIBCPP_BUGGY_FLOAT_COMPLEX if buggy.
 901 dnl
 902 dnl Check to see if this version of GNU C++ is afflicted by bugs in
 903 dnl __complex__ support.Check for buggy __complex__ that will cause ICE in
 904 dnl gcc-2.95.x when using the library, unless we define the default copy
 905 dnl ctor in the specializations of complex<>.
 906 dnl
 907 dnl Define _GLIBCPP_BUGGY_COMPLEX if buggy.
 908 dnl GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT
 909 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT, [
 910   AC_REQUIRE([AC_PROG_CXX])
 911
 912   AC_MSG_CHECKING([for GNU C++ __complex__ support])
 913   AC_CACHE_VAL(glibcpp_cv_complex, [
 914     AC_LANG_SAVE
 915     AC_LANG_CPLUSPLUS
 916     AC_TRY_COMPILE([struct dcomplex { __complex__ double x; }; \
 917                     dcomplex f(const dcomplex& x) { return dcomplex(x); }], \
 918                     [ dcomplex x; f(x); ],
 919       glibcpp_cv_complex=ok,
 920       glibcpp_cv_complex=buggy
 921     )
 922     AC_LANG_RESTORE
 923   ])
 924   AC_MSG_RESULT($glibcpp_cv_complex)
 925   if test $glibcpp_cv_complex = buggy; then
 926     AC_DEFINE(_GLIBCPP_BUGGY_COMPLEX)
 927   fi
 928
 929   AC_MSG_CHECKING([for GNU C++ __complex__ float support])
 930   AC_CACHE_VAL(glibcpp_cv_float_complex, [
 931     AC_LANG_SAVE
 932     AC_LANG_CPLUSPLUS
 933     rm -f conftest.h
 934     cat > conftest.h <<EOB
 935       //
 936       // Check for buggy __complex__ that causes ICE in most versions of egcs
 937       // and gcc-2.95.x on certain platforms (eg., x86-win32).
 938       //
 939       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
 940       // more info on the bug itself.
 941       //
 942       struct
 943       float_complex
 944       {
 945        __complex__ float m_value;
 946        float_complex (float = 0.0f, float = 0.0f);
 947        float_complex (__complex__ float val) : m_value (val) {}
 948        float_complex foo (const float_complex &val)
 949          { return float_complex (~val.m_value); }
 950       };
 951 EOB
 952     AC_TRY_COMPILE([#include "conftest.h"], ,
 953       glibcpp_cv_float_complex=ok,
 954       glibcpp_cv_float_complex=buggy
 955     )
 956     AC_LANG_RESTORE
 957   ])
 958   AC_MSG_RESULT($glibcpp_cv_float_complex)
 959   if test $glibcpp_cv_float_complex = buggy; then
 960     AC_DEFINE(_GLIBCPP_BUGGY_FLOAT_COMPLEX)
 961   fi
 962 ])
 963
 964
 965 dnl
 966 dnl Check for special debugging mode; not for production use.
 967 dnl
 968 dnl GLIBCPP_ENABLE_DEBUG
 969 dnl --enable-debug sets '-ggdb3 -O0'.
 970 dnl --disable-debug sets '-g' and whatever optimization options the
 971 dnl     compiler can handle.
 972 dnl  +  --enable-maintainer-mode automatically defaults this to on.
 973 dnl  +  Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...?
 974 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
 975 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 976 dnl       defaults to `no'.
 977 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
 978 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
 979 AC_ARG_ENABLE(debug,
 980 changequote(<<, >>)dnl
 981 <<  --enable-debug          extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
 982 changequote([, ])dnl
 983 [case "${enableval}" in
 984  yes) enable_debug=yes ;;
 985  no)  enable_debug=no ;;
 986  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
 987  esac],
 988 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
 989
 990 dnl Option parsed, now set things appropriately
 991 case "${enable_debug}" in
 992     yes)
 993         DEBUG_FLAGS='-O0 -ggdb3'
 994         ;;
 995     no)
 996         DEBUG_FLAGS='-g'
 997         ;;
 998 esac
 999 AC_SUBST(DEBUG_FLAGS)
1000 ])
1001
1002
1003 dnl
1004 dnl Check for "unusual" flags to pass to the compiler while building.
1005 dnl
1006 dnl GLIBCPP_ENABLE_CXX_FLAGS
1007 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1008 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
1009 dnl     Somehow this same set of flags must be passed when [re]building
1010 dnl     libgcc.
1011 dnl --disable-cxx-flags passes nothing.
1012 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1013 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1014 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1015 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1016 dnl       If "default flags" is an empty string (or "none"), the effect is
1017 dnl       the same as --disable or --enable=no.
1018 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1019 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1020 AC_ARG_ENABLE(cxx-flags,
1021 changequote(<<, >>)dnl
1022 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1023                                 [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1024 changequote([, ])dnl
1025 [case "x$enableval" in
1026  xyes)
1027         AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1028  xno|x)
1029         enable_cxx_flags='' ;;
1030  *)
1031         enable_cxx_flags="$enableval" ;;
1032  esac],
1033 enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT')
1034
1035 dnl Thinko on my part during design.  This kludge is the workaround.
1036 if test "$enable_cxx_flags" = "none"; then
1037   enable_cxx_flags='';
1038 fi
1039
1040 dnl Run through flags (either default or command-line) and set anything
1041 dnl extra (e.g., #defines) that must accompany particular g++ options.
1042 if test -n "$enable_cxx_flags"; then
1043     for f in $enable_cxx_flags; do
1044         case "$f" in
1045             -fhonor-std)  ;;
1046             -*)  ;;
1047             *)   # and we're trying to pass /what/ exactly?
1048                  AC_MSG_ERROR([compiler flags start with a -]) ;;
1049         esac
1050     done
1051 fi
1052 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1053 AC_SUBST(EXTRA_CXX_FLAGS)
1054 ])
1055
1056
1057 dnl
1058 dnl Check for which locale library to use:  gnu or generic.
1059 dnl
1060 dnl GLIBCPP_ENABLE_CLOCALE
1061 dnl --enable-clocale=gnu sets config/c_locale_gnu.cc and friends
1062 dnl --enable-clocale=generic sets config/c_locale_generic.cc and friends
1063 dnl
1064 dnl default is generic
1065 dnl
1066 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
1067   AC_MSG_CHECKING([for clocale to use])
1068   AC_ARG_ENABLE(clocale,
1069   [  --enable-clocale       enable model for target locale package.
1070      --enable-clocale=MODEL use MODEL target-speific locale package. [default=generic]
1071   ],
1072   if test x$enable_clocale = xno; then
1073      enable_clocale=generic
1074   fi,
1075      enable_clocale=generic)
1076
1077   enable_clocale_flag=$enable_clocale
1078
1079   dnl Check if a valid locale package
1080   case x${enable_clocale_flag} in
1081     xgnu)
1082       CLOCALE_H=config/c_locale_gnu.h
1083       CLOCALE_CC=config/c_locale_gnu.cc
1084       AC_MSG_RESULT(gnu)
1085       ;;
1086     xgeneric)
1087       CLOCALE_H=config/c_locale_generic.h
1088       CLOCALE_CC=config/c_locale_generic.cc
1089       AC_MSG_RESULT(generic)
1090       ;;
1091     *)
1092       echo "$enable_clocale is an unknown locale package" 1>&2
1093       exit 1
1094       ;;
1095   esac
1096
1097   AC_LINK_FILES($CLOCALE_H, include/bits/c++locale.h)
1098   AC_LINK_FILES($CLOCALE_CC, src/c++locale.cc)
1099 ])
1100
1101
1102 dnl
1103 dnl Check for which I/O library to use:  libio, or something specific.
1104 dnl
1105 dnl GLIBCPP_ENABLE_CSTDIO
1106 dnl --enable-cstdio=libio sets config/c_io_libio.h and friends
1107 dnl
1108 dnl default is stdio
1109 dnl
1110 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1111   AC_MSG_CHECKING([for cstdio to use])
1112   AC_ARG_ENABLE(cstdio,
1113   [  --enable-cstdio        enable stdio for target io package.
1114      --enable-cstdio=LIB    use LIB target-speific io package. [default=stdio]
1115   ],
1116   if test x$enable_cstdio = xno; then
1117      enable_cstdio=stdio
1118   fi,
1119      enable_cstdio=stdio)
1120
1121   enable_cstdio_flag=$enable_cstdio
1122
1123   dnl Check if a valid I/O package
1124   case x${enable_cstdio_flag} in
1125     xlibio)
1126       CSTDIO_H=config/c_io_libio.h
1127       CSTDIO_CC=config/c_io_libio.cc
1128       AC_MSG_RESULT(libio)
1129
1130       # see if we are on a system with libio native (ie, linux)
1131       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1132
1133       # Need to check and see what version of glibc is being used. If
1134       # it's not glibc-2.2 or higher, then we'll need to go ahead and
1135       # compile most of libio for linux systems.
1136       if test x$has_libio = x"yes"; then
1137         case "$target" in
1138           *-*-linux*)
1139               AC_MSG_CHECKING([for glibc version >= 2.2])
1140               AC_EGREP_CPP([ok], [
1141             #include <features.h>
1142               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1143                     ok
1144               #endif
1145               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1146               AC_MSG_RESULT($glibc_satisfactory)
1147             ;;
1148         esac
1149
1150         # XXX at the moment, admit defeat and force the recompilation
1151         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1152         glibc_satisfactory=no
1153
1154         if test x$glibc_satisfactory = x"yes"; then
1155            need_libio=no
1156            need_wlibio=no
1157         else
1158            need_libio=yes
1159            # bkoz XXX need to add checks to enable this
1160            # pme XXX here's a first pass at such a check
1161            if test x$enable_c_mbchar != xno; then
1162               need_wlibio=yes
1163            else
1164               need_wlibio=no
1165            fi
1166         fi
1167
1168       else
1169          # Using libio, but <libio.h> doesn't exist on the target system. . .
1170          need_libio=yes
1171          # bkoz XXX need to add checks to enable this
1172          # pme XXX here's a first pass at such a check
1173          if test x$enable_c_mbchar != xno; then
1174              need_wlibio=yes
1175          else
1176              need_wlibio=no
1177          fi
1178       fi
1179       ;;
1180     xstdio | x | xno | xnone | xyes)
1181       # default
1182       CSTDIO_H=config/c_io_stdio.h
1183       CSTDIO_CC=config/c_io_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($CSTDIO_CC, src/c++io.cc)
1199
1200   # 2000-08-04 bkoz hack
1201   CCODECVT_C=config/c_io_libio_codecvt.c
1202   AC_LINK_FILES($CCODECVT_C, libio/c_codecvt.c)
1203   # 2000-08-04 bkoz hack
1204
1205   AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO,
1206                  test "$need_libio" = yes || test "$need_wlibio" = yes)
1207   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1208   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1209   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1210     libio_la=../libio/libio.la
1211   else
1212     libio_la=
1213   fi
1214   AC_SUBST(libio_la)
1215 ])
1216
1217
1218 dnl
1219 dnl Check for which threading library to use.
1220 dnl
1221 dnl GLIBCPP_ENABLE_THREADS
1222 dnl --enable-threads=posix sets config/threads-posix.h et. al.
1223 dnl
1224 dnl Default is no threads, which also disables _IO_MTSAFE_IO in
1225 dnl libio.  Any actual thread package will enable it.
1226 dnl
1227 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1228   dnl Note this comes from the gcc/config.in and libjava/config.in
1229   dnl Efforts should be made to keep this in sync.
1230   AC_MSG_CHECKING([for threads package to use])
1231   AC_ARG_ENABLE(threads,
1232   [  --enable-threads       enable thread usage for target GCC.
1233      --enable-threads=LIB   use LIB thread package for target GCC. [default=no]
1234   ],
1235   if test x$enable_threads = xno; then
1236     enable_threads=''
1237   fi,
1238     enable_threads='')
1239
1240   enable_threads_flag=$enable_threads
1241
1242   dnl Check if a valid thread package
1243   case x${enable_threads_flag} in
1244         x | xno | xnone)
1245                 # No threads
1246                 target_thread_file='single'
1247                 ;;
1248         xyes)
1249                 # default
1250                 target_thread_file='posix'
1251                 ;;
1252         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
1253         xsolaris | xwin32 | xdce | xvxworks)
1254                 target_thread_file=$enable_threads_flag
1255                 ;;
1256         *)
1257                 echo "$enable_threads is an unknown thread package" 1>&2
1258                 exit 1
1259                 ;;
1260   esac
1261
1262   dnl Check for thread package actually supported in libstdc++
1263   THREADH=
1264   case "$target_thread_file" in
1265     no | none | single)
1266       THREADH=threads-no.h
1267       ;;
1268     posix | pthreads)
1269       THREADH=threads-posix.h
1270       ;;
1271     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
1272       AC_MSG_ERROR(thread package $THREADS not yet supported)
1273       ;;
1274     *)
1275       AC_MSG_ERROR($THREADS is an unsupported/unknown thread package)
1276       ;;
1277   esac
1278   AC_MSG_RESULT($THREADH)
1279
1280   AC_LINK_FILES(config/$THREADH, include/bits/c++threads.h)
1281   if test $THREADH != threads-no.h; then
1282     AC_DEFINE(_GLIBCPP_USE_THREADS)
1283   fi
1284 ])
1285
1286
1287 dnl
1288 dnl Check for template specializations for the 'long long' type extension.
1289 dnl
1290 dnl GLIBCPP_ENABLE_LONG_LONG
1291 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1292 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1293 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1294 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1295 dnl       defaults to `no'.
1296 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1297 dnl
1298 dnl GLIBCPP_ENABLE_LONG_LONG
1299 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1300   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1301
1302   AC_ARG_ENABLE(long-long,
1303   changequote(<<, >>)dnl
1304   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1305   changequote([, ])dnl
1306   [case "$enableval" in
1307    yes) enable_long_long=yes ;;
1308    no)  enable_long_long=no ;;
1309    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1310    esac],
1311   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1312
1313   # Allow use of os-dependent settings, so that macros that turn on
1314   # C99 capabilities can be defined and used in a consistent way.
1315   OS_INC_PATH=${srcdir}/$os_include_dir
1316   ac_test_CFLAGS="${CFLAGS+set}"
1317   ac_save_CFLAGS="$CFLAGS"
1318   CFLAGS="-I$OS_INC_PATH"
1319
1320   # Check for the existence of functions used if long long is enabled.
1321   AC_CHECK_FUNC(strtoll,,ac_strtoll=no)
1322   AC_CHECK_FUNC(strtoull,,ac_strtoull=no)
1323
1324   # Check for lldiv_t, et. al.
1325   AC_MSG_CHECKING([for lldiv_t declaration])
1326   AC_CACHE_VAL(glibcpp_lldiv_t_use, [
1327   AC_TRY_COMPILE([#include <bits/os_defines.h>
1328                   #include <stdlib.h>],
1329                    [ lldiv_t mydivt;],
1330                    [glibcpp_lldiv_t_use=yes], [glibcpp_lldiv_t_use=no])
1331   ])
1332   AC_MSG_RESULT($glibcpp_lldiv_t_use)
1333   if test x$glibcpp_lldiv_t_use = x"yes"; then
1334     AC_DEFINE(HAVE_LLDIV_T)
1335   fi
1336
1337   AC_MSG_CHECKING([for enabled long long])
1338   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
1339     enable_long_long=no;
1340   fi;
1341   AC_MSG_RESULT($enable_long_long)
1342
1343   # Option parsed, now set things appropriately
1344   if test x"$enable_long_long" = xyes; then
1345     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1346   fi
1347
1348   # Reset CFLAGS
1349   CFLAGS="$ac_save_CFLAGS"
1350 ])
1351
1352
1353 dnl
1354 dnl Check for what kind of C headers to use.
1355 dnl
1356 dnl GLIBCPP_ENABLE_CHEADERS
1357 dnl --enable-cheaders= [does stuff].
1358 dnl --disable-cheaders [does not do anything, really].
1359 dnl  +  This will eventually need to be 'c_shadow' by default.
1360 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1361 dnl       Where DEFAULT is either `c' or `c_std' or 'c_shadow'.
1362 dnl       If ommitted, it defaults to `c_std'.
1363 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1364 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1365 AC_MSG_CHECKING([for c header strategy to use])
1366 AC_ARG_ENABLE(cheaders,
1367 changequote(<<, >>)dnl
1368 <<  --enable-cheaders construct "C" header files for
1369                            g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1370 changequote([, ])
1371   [case "$enableval" in
1372    c)
1373         enable_cheaders=c
1374         ;;
1375    c_std)
1376         enable_cheaders=c_std
1377         ;;
1378    c_shadow)
1379         enable_cheaders=c_shadow
1380         ;;
1381    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1382         ;;
1383   esac],
1384   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1385   AC_MSG_RESULT($enable_cheaders)
1386
1387   dnl Option parsed, now set things appropriately
1388   case "$enable_cheaders" in
1389     c_shadow)
1390         CSHADOW_FLAGS="-fno-builtin"
1391         C_INCLUDE_DIR='${top_srcdir}/include/c_shadow'
1392         AC_DEFINE(_GLIBCPP_USE_SHADOW_HEADERS)
1393         ;;
1394     c_std)
1395         CSHADOW_FLAGS=""
1396         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
1397         ;;
1398     c)
1399         CSHADOW_FLAGS=""
1400         C_INCLUDE_DIR='${top_srcdir}/include/c'
1401         ;;
1402   esac
1403
1404   AC_SUBST(CSHADOW_FLAGS)
1405   AC_SUBST(C_INCLUDE_DIR)
1406   AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cheaders" = c_shadow)
1407 ])
1408
1409
1410 dnl
1411 dnl Check for wide character support.  Has the same effect as the option
1412 dnl in gcc's configure, but in a form that autoconf can mess with.
1413 dnl
1414 dnl GLIBCPP_ENABLE_C_MBCHAR
1415 dnl --enable-c-mbchar requests all the wchar_t stuff.
1416 dnl --disable-c-mbchar doesn't.
1417 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1418 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1419 dnl       defaults to `no'.
1420 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1421 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1422 AC_ARG_ENABLE(c-mbchar,
1423 changequote(<<, >>)dnl
1424 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1425 changequote([, ])dnl
1426 [case "$enableval" in
1427  yes) enable_c_mbchar=yes ;;
1428  no)  enable_c_mbchar=no ;;
1429  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1430  esac],
1431 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1432 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1433 ])
1434
1435
1436 dnl
1437 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1438 dnl
1439 dnl GLIBCPP_INCLUDE_DIR
1440 dnl C_INCLUDE_DIR
1441 dnl TOPLEVEL_INCLUDES
1442 dnl LIBMATH_INCLUDES
1443 dnl LIBSUPCXX_INCLUDES
1444 dnl LIBIO_INCLUDES
1445 dnl CSHADOW_INCLUDES
1446 dnl
1447 dnl GLIBCPP_EXPORT_INCLUDE
1448 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1449   # Root level of the include sources.
1450   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
1451
1452   # Can either use include/c or include/c_std to grab "C" headers. This
1453   # variable is set to the include directory currently in use.
1454   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_CHEADERS
1455
1456   # Passed down for canadian crosses.
1457   if  test x"$CANADIAN" = xyes; then
1458     TOPLEVEL_INCLUDES='-I$(includedir)'
1459   fi
1460
1461   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1462
1463   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1464
1465   #if GLIBCPP_NEED_LIBIO
1466   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1467   #else
1468   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
1469   #endif
1470
1471   #if GLIBCPP_USE_CSHADOW
1472   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
1473   #                   -I$(top_blddir)/cshadow'
1474   #else
1475   CSTD_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
1476   #endif
1477
1478   # Now, export this to all the little Makefiles....
1479   AC_SUBST(GLIBCPP_INCLUDE_DIR)
1480   AC_SUBST(TOPLEVEL_INCLUDES)
1481   AC_SUBST(LIBMATH_INCLUDES)
1482   AC_SUBST(LIBSUPCXX_INCLUDES)
1483   AC_SUBST(LIBIO_INCLUDES)
1484   AC_SUBST(CSTD_INCLUDES)
1485 ])
1486
1487
1488 dnl
1489 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1490 dnl
1491 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1492   # Optimization flags that are probably a good idea for thrill-seekers. Just
1493   # uncomment the lines below and make, everything else is ready to go...
1494   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1495   OPTIMIZE_CXXFLAGS=
1496   AC_SUBST(OPTIMIZE_CXXFLAGS)
1497
1498   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1499   AC_SUBST(WARN_FLAGS)
1500 ])
1501
1502
1503 # Check whether LC_MESSAGES is available in <locale.h>.
1504 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1505 #
1506 # This file file be copied and used freely without restrictions.  It can
1507 # be used in projects which are not available under the GNU Public License
1508 # but which still want to provide support for the GNU gettext functionality.
1509 # Please note that the actual code is *not* freely available.
1510
1511 # serial 1
1512
1513 AC_DEFUN(AC_LC_MESSAGES, [
1514   AC_CHECK_HEADER(locale.h, [
1515     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1516       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1517        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1518     if test $ac_cv_val_LC_MESSAGES = yes; then
1519       AC_DEFINE(HAVE_LC_MESSAGES)
1520     fi
1521   ])
1522 ])
1523
1524
1525 # Check for functions in math library.
1526 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1527 #
1528 # This file can be copied and used freely without restrictions.  It can
1529 # be used in projects which are not available under the GNU Public License
1530 # but which still want to provide support for the GNU gettext functionality.
1531 # Please note that the actual code is *not* freely available.
1532
1533 # serial 1
1534
1535 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1536 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1537 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])
1538 AC_SUBST(LIBMATHOBJS)dnl
1539 ])
1540
1541
1542 # Check for string functions.
1543 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1544 #
1545 # This file can be copied and used freely without restrictions.  It can
1546 # be used in projects which are not available under the GNU Public License
1547 # but which still want to provide support for the GNU gettext functionality.
1548 # Please note that the actual code is *not* freely available.
1549
1550 # serial 1
1551
1552 dnl AC_REPLACE_STRINGFUNCS(FUNCTION...)
1553 AC_DEFUN(AC_REPLACE_STRINGFUNCS,
1554 [AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"])
1555 AC_SUBST(LIBSTRINGOBJS)dnl
1556 ])
1557
1558
1559 dnl This macro searches for a GNU version of make.  If a match is found, the
1560 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1561 dnl set to "#". This is useful for  including a special features in a Makefile,
1562 dnl which cannot be handled by other versions of make.  The variable
1563 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1564 dnl the empty string otherwise.
1565 dnl
1566 dnl Here is an example of its use:
1567 dnl
1568 dnl Makefile.in might contain:
1569 dnl
1570 dnl     # A failsafe way of putting a dependency rule into a makefile
1571 dnl     $(DEPEND):
1572 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1573 dnl
1574 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1575 dnl     @ifGNUmake@ include $(DEPEND)
1576 dnl     @ifGNUmake@ endif
1577 dnl
1578 dnl Then configure.in would normally contain:
1579 dnl
1580 dnl     CHECK_GNU_MAKE()
1581 dnl     AC_OUTPUT(Makefile)
1582 dnl
1583 dnl Then perhaps to cause gnu make to override any other make, we could do
1584 dnl something like this (note that GNU make always looks for GNUmakefile first):
1585 dnl
1586 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1587 dnl             mv Makefile GNUmakefile
1588 dnl             echo .DEFAULT: > Makefile ;
1589 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1590 dnl     fi
1591 dnl
1592 dnl Then, if any (well almost any) other make is called, and GNU make also
1593 dnl exists, then the other make wraps the GNU make.
1594 dnl
1595 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1596 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1597 dnl
1598 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1599 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1600 dnl #### conditional's subshell (" --version" is not a command), using a
1601 dnl #### different option to grep(1).
1602 dnl #### -pme
1603 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1604 dnl #### ${MAKE:-make}).
1605 dnl #### -msokolov
1606 AC_DEFUN(
1607   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1608           _cv_gnu_make_command='' ;
1609 dnl Search all the common names for GNU make
1610           for a in "${MAKE-make}" make gmake gnumake ; do
1611                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1612                   then
1613                           _cv_gnu_make_command=$a ;
1614                           break;
1615                   fi
1616           done ;
1617   ) ;
1618 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1619 dnl string, '#' otherwise
1620   if test  "x$_cv_gnu_make_command" != "x"  ; then
1621           ifGNUmake='' ;
1622   else
1623           ifGNUmake='#' ;
1624   fi
1625   AC_SUBST(ifGNUmake)
1626 ])
1627
1628 sinclude(../libtool.m4)
1629 dnl The lines below arrange for aclocal not to bring an installed
1630 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1631 dnl add a definition of LIBTOOL to Makefile.in.
1632 ifelse(,,,[AC_SUBST(LIBTOOL)
1633 AC_DEFUN([AM_PROG_LIBTOOL])
1634 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1635 AC_DEFUN([AC_PROG_LD])
1636 ])
1637