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 "$ac_gabydiags" = "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 "$ac_fdsections" = "yes"; 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" = "broken"; 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 "$ac_cv_prog_gnu_ld" = "yes"; 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   AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 341     AC_LANG_SAVE
 342     AC_LANG_CPLUSPLUS
 343     AC_TRY_COMPILE([#include <math.h>],
 344                    [ $1(0);],
 345                    [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 346     AC_LANG_RESTORE
 347   ])
 348   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 349   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 350     AC_CHECK_FUNCS($1)
 351   fi
 352 ])
 353
 354
 355 dnl
 356 dnl Check to see if the (math function) argument passed is
 357 dnl 1) declared when using the c++ compiler
 358 dnl 2) has "C" linkage
 359 dnl
 360 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 361 dnl
 362 dnl argument 1 is name of function to check
 363 dnl
 364 dnl ASSUMES argument is a math function with TWO parameters
 365 dnl
 366 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2
 367 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2, [
 368   AC_MSG_CHECKING([for $1 declaration])
 369   AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 370     AC_LANG_SAVE
 371     AC_LANG_CPLUSPLUS
 372     AC_TRY_COMPILE([#include <math.h>],
 373                    [ $1(0, 0);],
 374                    [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 375     AC_LANG_RESTORE
 376   ])
 377   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 378   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 379     AC_CHECK_FUNCS($1)
 380   fi
 381 ])
 382
 383
 384 dnl
 385 dnl Check to see if the (math function) argument passed is
 386 dnl 1) declared when using the c++ compiler
 387 dnl 2) has "C" linkage
 388 dnl
 389 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 390 dnl
 391 dnl argument 1 is name of function to check
 392 dnl
 393 dnl ASSUMES argument is a math function with THREE parameters
 394 dnl
 395 dnl GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3
 396 AC_DEFUN(GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3, [
 397   AC_MSG_CHECKING([for $1 declaration])
 398   AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 399     AC_LANG_SAVE
 400     AC_LANG_CPLUSPLUS
 401     AC_TRY_COMPILE([#include <math.h>],
 402                    [ $1(0, 0, 0);],
 403                    [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 404     AC_LANG_RESTORE
 405   ])
 406   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 407   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 408     AC_CHECK_FUNCS($1)
 409   fi
 410 ])
 411
 412
 413 dnl
 414 dnl Check to see if the (stdlib function) argument passed is
 415 dnl 1) declared when using the c++ compiler
 416 dnl 2) has "C" linkage
 417 dnl
 418 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 419 dnl Define HAVE_STRTOF if "strtof" is declared and links
 420 dnl
 421 dnl argument 1 is name of function to check
 422 dnl
 423 dnl ASSUMES argument is a math function with TWO parameters
 424 dnl
 425 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
 426 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
 427   AC_MSG_CHECKING([for $1 declaration])
 428   AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 429     AC_LANG_SAVE
 430     AC_LANG_CPLUSPLUS
 431     AC_TRY_COMPILE([#include <stdlib.h>],
 432                    [ $1(0, 0);],
 433                    [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 434     AC_LANG_RESTORE
 435   ])
 436   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 437   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 438     AC_CHECK_FUNCS($1)
 439   fi
 440 ])
 441
 442
 443 dnl
 444 dnl Because the builtins are picky picky picky about the arguments they take,
 445 dnl do an explict linkage tests here.
 446 dnl Check to see if the (math function) argument passed is
 447 dnl 1) declared when using the c++ compiler
 448 dnl 2) has "C" linkage
 449 dnl
 450 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 451 dnl
 452 dnl argument 1 is name of function to check
 453 dnl
 454 dnl ASSUMES argument is a math function with ONE parameter
 455 dnl
 456 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 457 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 458   AC_MSG_CHECKING([for $1 declaration])
 459   AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 460     AC_LANG_SAVE
 461     AC_LANG_CPLUSPLUS
 462     AC_TRY_COMPILE([#include <math.h>],
 463                    [ $1(0);],
 464                    [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 465     AC_LANG_RESTORE
 466   ])
 467   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 468   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 469     AC_MSG_CHECKING([for $1 linkage])
 470     AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 471       AC_TRY_LINK([#include <math.h>],
 472                   [ $1(0);],
 473                   [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 474     ])
 475     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 476     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 477       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 478       AC_DEFINE_UNQUOTED(${ac_tr_func})
 479     fi
 480   fi
 481 ])
 482
 483
 484 dnl
 485 dnl Check to see what builtin math functions are supported
 486 dnl
 487 dnl check for __builtin_abs
 488 dnl check for __builtin_fabsf
 489 dnl check for __builtin_fabs
 490 dnl check for __builtin_fabl
 491 dnl check for __builtin_labs
 492 dnl check for __builtin_sqrtf
 493 dnl check for __builtin_sqrtl
 494 dnl check for __builtin_fsqrt
 495 dnl check for __builtin_sinf
 496 dnl check for __builtin_sin
 497 dnl check for __builtin_sinl
 498 dnl check for __builtin_cosf
 499 dnl check for __builtin_cos
 500 dnl check for __builtin_cosl
 501 dnl
 502 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 503 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 504   dnl Test for builtin math functions.
 505   dnl These are made in gcc/c-common.c
 506   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 507   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 508   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 509   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 510   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 511
 512   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 513   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
 514   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 515
 516   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 517   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 518   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 519
 520   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 521   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 522   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 523
 524   dnl There is, without a doubt, a more elegant way to have these
 525   dnl names exported so that they won't be stripped out of acconfig.h by
 526   dnl autoheader. I leave this as an exercise to somebody less frustrated
 527   dnl than I.... please email the libstdc++ list if you can figure out a
 528   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 529   dnl AC_CHECK_FUNC for things to steal.)
 530   dummyvar=no
 531   if test x$dummyvar = x"yes"; then
 532     AC_DEFINE(HAVE___BUILTIN_ABS)
 533     AC_DEFINE(HAVE___BUILTIN_LABS)
 534     AC_DEFINE(HAVE___BUILTIN_COS)
 535     AC_DEFINE(HAVE___BUILTIN_COSF)
 536     AC_DEFINE(HAVE___BUILTIN_COSL)
 537     AC_DEFINE(HAVE___BUILTIN_FABS)
 538     AC_DEFINE(HAVE___BUILTIN_FABSF)
 539     AC_DEFINE(HAVE___BUILTIN_FABSL)
 540     AC_DEFINE(HAVE___BUILTIN_SIN)
 541     AC_DEFINE(HAVE___BUILTIN_SINF)
 542     AC_DEFINE(HAVE___BUILTIN_SINL)
 543     AC_DEFINE(HAVE___BUILTIN_FSQRT)
 544     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 545     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 546   fi
 547 ])
 548
 549
 550 dnl
 551 dnl Check to see what the underlying c library
 552 dnl These checks need to do two things:
 553 dnl 1) make sure the name is declared when using the c++ compiler
 554 dnl 2) make sure the name has "C" linkage
 555 dnl This might seem like overkill but experience has shown that it's not...
 556 dnl
 557 dnl Define HAVE_STRTOF etc if "strtof" is found.
 558 dnl Define HAVE_STRTOLD etc if "strtold" is found.
 559 dnl
 560 dnl GLIBCPP_CHECK_STDLIB_SUPPORT
 561 AC_DEFUN(GLIBCPP_CHECK_STDLIB_SUPPORT, [
 562   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 563   ac_save_CXXFLAGS="$CXXFLAGS"
 564   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 565
 566   AC_CHECK_FUNCS(strtof)
 567   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 568
 569   CXXFLAGS="$ac_save_CXXFLAGS"
 570 ])
 571
 572
 573 dnl
 574 dnl Check to see what the underlying c library or math library is like.
 575 dnl These checks need to do two things:
 576 dnl 1) make sure the name is declared when using the c++ compiler
 577 dnl 2) make sure the name has "C" linkage
 578 dnl This might seem like overkill but experience has shown that it's not...
 579 dnl
 580 dnl Define HAVE_CARGF etc if "cargf" is found.
 581 dnl
 582 dnl GLIBCPP_CHECK_MATH_SUPPORT
 583 AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [
 584   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 585   ac_save_CXXFLAGS="$CXXFLAGS"
 586   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
 587
 588   dnl Check libm
 589   AC_CHECK_LIB(m, sin, libm="-lm")
 590   ac_save_LIBS="$LIBS"
 591   LIBS="$LIBS $libm"
 592
 593   dnl Check to see if certain C math functions exist.
 594   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 595   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 596   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 597   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 598   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 599   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 600   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 601
 602   dnl Check to see if basic C math functions have float versions.
 603   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 604   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 605   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(acosf)
 606   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(asinf)
 607   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(atanf)
 608   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
 609   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(ceilf)
 610   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(cosf)
 611   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(coshf)
 612   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
 613   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 614   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(floorf)
 615   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 616   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 617   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 618   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 619   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 620   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 621   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 622   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinf)
 623   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinhf)
 624   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 625   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanf)
 626   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanhf)
 627   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 628   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 629
 630   dnl Check to see if basic C math functions have long double versions.
 631   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 632   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 633   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 634   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(acosl)
 635   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(asinl)
 636   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(atanl)
 637   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 638   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(ceill)
 639   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(cosl)
 640   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(coshl)
 641   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 642   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 643   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(floorl)
 644   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 645   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 646   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 647   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 648   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 649   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 650   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 651   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinl)
 652   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sinhl)
 653   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 654   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanl)
 655   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(tanhl)
 656   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 657   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 658
 659   dnl Some runtimes have these functions with a preceding underscore. Please
 660   dnl keep this sync'd with the one above. And if you add any new symbol,
 661   dnl please add the corresponding block in the @BOTTOM@ section of acconfig.h.
 662   dnl Check to see if certain C math functions exist.
 663   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinf)
 664   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnan)
 665   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finite)
 666   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_copysign)
 667   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincos)
 668   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fpclass)
 669   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_qfpclass)
 670
 671   dnl Check to see if basic C math functions have float versions.
 672   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isnanf)
 673   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_isinff)
 674   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_acosf)
 675   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_asinf)
 676   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_atanf)
 677   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_atan2f)
 678   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_ceilf)
 679   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_cosf)
 680   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_coshf)
 681   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_expf)
 682   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fabsf)
 683   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_floorf)
 684   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_fmodf)
 685   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_frexpf)
 686   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_ldexpf)
 687   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_logf)
 688   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10f)
 689   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modff)
 690   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powf)
 691   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinf)
 692   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinhf)
 693   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtf)
 694   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanf)
 695   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanhf)
 696   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincosf)
 697   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finitef)
 698
 699   dnl Check to see if basic C math functions have long double versions.
 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_1(_acosl)
 704   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_asinl)
 705   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_atanl)
 706   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_atan2l)
 707   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_ceill)
 708   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_cosl)
 709   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_coshl)
 710   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_expl)
 711   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_fabsl)
 712   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_floorl)
 713   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_fmodl)
 714   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_frexpl)
 715   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_ldexpl)
 716   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_logl)
 717   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_log10l)
 718   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_modfl)
 719   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_2(_powl)
 720   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinl)
 721   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sinhl)
 722   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_sqrtl)
 723   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanl)
 724   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_tanhl)
 725   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_3(_sincosl)
 726   GLIBCPP_CHECK_MATH_DECL_AND_LINKAGE_1(_finitel)
 727
 728   LIBS="$ac_save_LIBS"
 729   CXXFLAGS="$ac_save_CXXFLAGS"
 730 ])
 731
 732
 733 dnl
 734 dnl Check to see if there is native support for complex
 735 dnl
 736 dnl Don't compile bits in math/* if native support exits.
 737 dnl
 738 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "atan2l/copysignl" is found.
 739 dnl
 740 dnl GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT
 741 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_SUPPORT, [
 742   dnl Check for complex versions of math functions of platform.
 743   AC_CHECK_HEADERS([complex.h])
 744   AC_CHECK_LIB(m, main)
 745   AC_REPLACE_MATHFUNCS(ccos ccosf ccosh ccoshf cexp cexpf \
 746   csin csinf csinh csinhf csqrt \
 747   csqrtf ctan ctanf ctanh ctanhf nan hypot hypotf atan2f expf \
 748   copysignf)
 749
 750   dnl Compile the long double complex functions only if the function
 751   dnl provides the non-complex long double functions that are needed.
 752   dnl Currently this includes copysignl and atan2l, which should be
 753   dnl cached from the GLIBCPP_CHECK_MATH_SUPPORT macro, above.
 754   USE_COMPLEX_LONG_DOUBLE=no
 755   if test x$ac_cv_func_atan2l = x"yes" \
 756      && test x$ac_cv_func_copysignl = x"yes"; then
 757     USE_COMPLEX_LONG_DOUBLE=yes
 758     AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \
 759     csqrtl ctanhl ctanl hypotl signbitl clog10l)
 760   fi
 761
 762   AC_SUBST(USE_COMPLEX_LONG_DOUBLE)
 763 ])
 764
 765
 766 dnl Check to see what architecture and operating system we are compiling
 767 dnl for.  Also, if architecture- or OS-specific flags are required for
 768 dnl compilation, pick them up here.
 769 dnl
 770 dnl GLIBCPP_CHECK_TARGET
 771 AC_DEFUN(GLIBCPP_CHECK_TARGET, [
 772     . [$]{glibcpp_basedir}/configure.target
 773     AC_MSG_RESULT(CPU config directory is $cpu_include_dir)
 774     AC_MSG_RESULT(OS config directory is $os_include_dir)
 775     AC_LINK_FILES($os_include_dir/bits/os_defines.h, include/bits/os_defines.h)
 776 ])
 777
 778
 779 dnl
 780 dnl Check to see what the underlying c library's interface to ctype looks
 781 dnl like. Bits of locale rely on things like isspace, toupper, etc. This
 782 dnl stuff makes sure the right bits from the clibrary get called.
 783 dnl
 784 dnl Depending on what is found, select various configure/*/bits/ctype_base.h
 785 dnl Depending on what is found, select various configure/*/ctype.cc
 786 dnl
 787 dnl GLIBCPP_CHECK_CTYPE_SUPPORT
 788 AC_DEFUN(GLIBCPP_CHECK_CTYPE_SUPPORT, [
 789   AC_CHECK_HEADER(ctype.h, [
 790
 791     dnl If doesn't match any specified, go with defaults.
 792     ctype_default=yes
 793
 794     dnl Test for <ctype> functionality -- GNU/Linux
 795     AC_MSG_CHECKING([<ctype> for GNU/Linux])
 796     AC_TRY_COMPILE([#include <ctype.h>],
 797     [int
 798     foo (int a)
 799     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
 800         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
 801         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}], \
 802     ctype_linux=yes, ctype_linux=no)
 803     AC_MSG_RESULT($ctype_linux)
 804     if test $ctype_linux = "yes"; then
 805       ctype_include_dir="config/os/gnu-linux"
 806       ctype_default=no
 807     fi
 808
 809     dnl Test for <ctype> functionality -- FreeBSD 4.0
 810     if test $ctype_default = "yes"; then
 811     AC_MSG_CHECKING([<ctype> for FreeBSD 4.0])
 812     AC_TRY_COMPILE([#include <ctype.h>],
 813     [int
 814     foo (int a)
 815     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
 816         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}], \
 817     ctype_bsd=yes, ctype_bsd=no)
 818     AC_MSG_RESULT($ctype_bsd)
 819     if test $ctype_bsd = "yes"; then
 820       ctype_include_dir="config/os/bsd"
 821       ctype_default=no
 822     fi
 823     fi
 824
 825     dnl Test for <ctype> functionality -- FreeBSD 3.4
 826     if test $ctype_default = "yes"; then
 827     AC_MSG_CHECKING([<ctype> for FreeBSD 3.4])
 828     AC_TRY_COMPILE([#include <ctype.h>],
 829     [int
 830     foo (int a)
 831     { return _S + _R + _C + _U + _L + _A \
 832       + _D + _P + _X + _G + __istype (a, 0);}], \
 833     ctype_freebsd34=yes, ctype_freebsd34=no)
 834     AC_MSG_RESULT($ctype_freebsd34)
 835     if test $ctype_freebsd34 = "yes"; then
 836       ctype_include_dir="config/os/bsd"
 837       ctype_default=no
 838     fi
 839     fi
 840
 841     dnl Test for <ctype> functionality -- Solaris 2.6 and up
 842     if test $ctype_default = "yes"; then
 843     AC_MSG_CHECKING([<ctype> for Solaris 2.6,7,8])
 844     AC_TRY_COMPILE([#include <ctype.h>],
 845     [int
 846     foo (int a)
 847     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
 848         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
 849         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}], \
 850     ctype_solaris=yes, ctype_solaris=no)
 851     AC_MSG_RESULT($ctype_solaris)
 852
 853     if test $ctype_solaris = "yes"; then
 854       AC_MSG_CHECKING([  for version])
 855       AC_LANG_CPLUSPLUS
 856       AC_TRY_COMPILE([#include <ctype.h>],
 857       [typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;],\
 858       ctype_solaris26=yes, ctype_solaris26=no)
 859       AC_LANG_C
 860       if test $ctype_solaris26 = "yes"; then
 861         ctype_include_dir="config/os/solaris/solaris2.6"
 862         AC_MSG_RESULT([Solaris 2.6])
 863         ctype_default=no
 864       else
 865         ctype_include_dir="config/os/solaris/solaris2.7"
 866         AC_MSG_RESULT([Solaris 7,8])
 867         ctype_default=no
 868       fi
 869     fi
 870     fi
 871
 872     dnl Test for <ctype> functionality -- Solaris 2.5.1
 873     if test $ctype_default = "yes"; then
 874     AC_MSG_CHECKING([<ctype> for Solaris 2.5.1])
 875     AC_TRY_COMPILE([#include <ctype.h>],
 876     [int
 877     foo (int a)
 878     { return _U + _L + _N + _S + _P + _C + _X + _B \
 879         + __ctype[a];}], \
 880     ctype_solaris25=yes, ctype_solaris25=no)
 881     AC_MSG_RESULT($ctype_solaris25)
 882     if test $ctype_solaris25 = "yes"; then
 883       ctype_include_dir="config/os/solaris/solaris2.5"
 884       ctype_default=no
 885     fi
 886     fi
 887
 888     dnl Test for <ctype> functionality -- AIX
 889     if test $ctype_default = "yes"; then
 890     AC_MSG_CHECKING([<ctype> for AIX])
 891     AC_TRY_COMPILE([#include <ctype.h>],
 892     [int
 893     foo (int a)
 894     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
 895         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
 896         + _VALC('a') + _IS('c', 0);}], \
 897     ctype_aix=yes, ctype_aix=no)
 898     AC_MSG_RESULT($ctype_aix)
 899     if test $ctype_aix = "yes"; then
 900       ctype_include_dir="config/os/aix"
 901       ctype_default=no
 902     fi
 903     fi
 904
 905     dnl Test for <ctype> functionality -- IRIX
 906     if test $ctype_default = "yes"; then
 907     AC_MSG_CHECKING([<ctype> for IRIX])
 908     AC_TRY_COMPILE([#include <ctype.h>],
 909     [int
 910     foo (int a)
 911     { return _U + _L + _N + _S + _P + _C + _B + _X + \
 912              _A + _PR + _G + _BL;}], \
 913     ctype_irix=yes, ctype_irix=no)
 914     AC_MSG_RESULT($ctype_irix)
 915     if test $ctype_irix = "yes"; then
 916       ctype_include_dir="config/os/irix"
 917       ctype_default=no
 918     fi
 919     fi
 920
 921     dnl Test for <ctype> functionality -- newlib
 922     if test $ctype_default = "yes"; then
 923     AC_MSG_CHECKING([<ctype> for newlib])
 924     AC_TRY_COMPILE([#include <ctype.h>],
 925     [int
 926     foo (int a)
 927     { return _U + _L + _N + _S + _P + _C + _X + _B \
 928         + _ctype_[a];}], \
 929     ctype_newlib=yes, ctype_newlib=no)
 930     AC_MSG_RESULT($ctype_newlib)
 931     if test $ctype_newlib = "yes"; then
 932       ctype_include_dir="config/os/newlib"
 933       ctype_default=no
 934     fi
 935     fi
 936
 937     if test $ctype_default = "yes"; then
 938       ctype_include_dir="config/os/generic"
 939       AC_MSG_WARN("Using default ctype headers.")
 940     fi
 941
 942     AC_LINK_FILES($ctype_include_dir/bits/ctype_base.h,
 943     include/bits/ctype_base.h)
 944     AC_LINK_FILES($ctype_include_dir/bits/ctype_inline.h,
 945     include/bits/ctype_inline.h)
 946     AC_LINK_FILES($ctype_include_dir/bits/ctype_noninline.h, \
 947     include/bits/ctype_noninline.h)
 948   ])
 949 ])
 950
 951
 952 dnl
 953 dnl Check to see if this target can enable the wchar_t parts of libstdc++.
 954 dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled.  (This
 955 dnl must have been previously checked.)
 956 dnl
 957 dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found
 958 dnl Define _GLIBCPP_NEED_MBSTATE_T if mbstate_t is not in wchar.h
 959 dnl
 960 dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT
 961 AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [
 962   if test x$enable_c_mbchar != xno; then
 963
 964     dnl Sanity check for existence of ISO C99 headers for extended encoding.
 965     AC_CHECK_HEADER(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
 966     AC_CHECK_HEADER(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
 967
 968     dnl Only continue checking if the ISO C99 headers exist.
 969     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
 970
 971       dnl Test wchar.h for mbstate_t, which is needed for char_traits
 972       dnl and others.
 973       AC_MSG_CHECKING([for mbstate_t])
 974       AC_TRY_COMPILE([#include <wchar.h>],
 975       [mbstate_t teststate;],
 976       use_native_mbstatet=yes, use_native_mbstatet=no)
 977       AC_MSG_RESULT($use_native_mbstatet)
 978       if test x"$use_native_mbstatet" = xno; then
 979         AC_DEFINE(_GLIBCPP_NEED_MBSTATE_T)
 980       fi
 981
 982       dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
 983       dnl numeric_limits can instantiate type_traits<wchar_t>
 984       AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX])
 985       AC_TRY_COMPILE([#include <wchar.h>],
 986       [int i = WCHAR_MIN; int j = WCHAR_MAX;],
 987       has_wchar_minmax=yes, has_wchar_minmax=no)
 988       AC_MSG_RESULT($has_wchar_minmax)
 989
 990       dnl Test wchar.h for WEOF, which is what we use to determine whether
 991       dnl to specialize for char_traits<wchar_t> or not.
 992       AC_MSG_CHECKING([for WEOF])
 993       AC_TRY_COMPILE([
 994         #include <wchar.h>
 995         #include <stddef.h>],
 996       [wint_t i = WEOF;],
 997       has_weof=yes, has_weof=no)
 998       AC_MSG_RESULT($has_weof)
 999
1000       dnl Tests for wide character functions used in char_traits<wchar_t>.
1001       AC_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
1002       wcsrtombs mbsrtowcs, ac_wfuncs=yes, ac_wfuncs=no)
1003
1004       AC_MSG_CHECKING([for ISO C99 wchar_t support])
1005       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
1006          && test x"$ac_wfuncs" = xyes; then
1007         ac_isoC99_wchar_t=yes
1008       else
1009         ac_isoC99_wchar_t=no
1010       fi
1011       AC_MSG_RESULT($ac_isoC99_wchar_t)
1012
1013       dnl Use iconv for wchar_t to char conversions. As such, check for
1014       dnl X/Open Portability Guide, version 2 features (XPG2).
1015       AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
1016       AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
1017
1018       dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
1019       AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
1020       ac_save_LIBS="$LIBS"
1021       LIBS="$LIBS $libiconv"
1022
1023       AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
1024       ac_XPG2funcs=yes, ac_XPG2funcs=no)
1025
1026       LIBS="$ac_save_LIBS"
1027
1028       AC_MSG_CHECKING([for XPG2 wchar_t support])
1029       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
1030          && test x"$ac_XPG2funcs" = xyes; then
1031         ac_XPG2_wchar_t=yes
1032       else
1033         ac_XPG2_wchar_t=no
1034       fi
1035       AC_MSG_RESULT($ac_XPG2_wchar_t)
1036
1037       dnl At the moment, only enable wchar_t specializations if all the
1038       dnl above support is present.
1039       AC_MSG_CHECKING([for enabled wchar_t specializations])
1040       if test x"$ac_isoC99_wchar_t" = xyes \
1041          && test x"$ac_XPG2_wchar_t" = xyes; then
1042         libinst_wstring_la="libinst-wstring.la"
1043         AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
1044         AC_MSG_RESULT("yes")
1045       else
1046         libinst_wstring_la=""
1047         AC_MSG_RESULT("no")
1048       fi
1049       AC_SUBST(libinst_wstring_la)
1050
1051     else
1052       AC_MSG_WARN([<wchar.h> not found])
1053       AC_DEFINE(_GLIBCPP_NEED_MBSTATE_T)
1054     fi
1055
1056   else
1057     dnl Wide characters disabled by the user.  Maybe print a warning?
1058     :
1059   fi
1060 ])
1061
1062
1063 dnl
1064 dnl Check to see if this version of GNU C++ is afflicted by bugs in
1065 dnl __complex__ float support.
1066 dnl
1067 dnl Define _GLIBCPP_BUGGY_FLOAT_COMPLEX if buggy.
1068 dnl
1069 dnl Check to see if this version of GNU C++ is afflicted by bugs in
1070 dnl __complex__ support.Check for buggy __complex__ that will cause ICE in
1071 dnl gcc-2.95.x when using the library, unless we define the default copy
1072 dnl ctor in the specializations of complex<>.
1073 dnl
1074 dnl Define _GLIBCPP_BUGGY_COMPLEX if buggy.
1075 dnl GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT
1076 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT, [
1077   AC_REQUIRE([AC_PROG_CXX])
1078
1079   AC_MSG_CHECKING([for GNU C++ __complex__ support])
1080   AC_CACHE_VAL(glibcpp_cv_complex, [
1081     AC_LANG_SAVE
1082     AC_LANG_CPLUSPLUS
1083     AC_TRY_COMPILE([struct dcomplex { __complex__ double x; }; \
1084                     dcomplex f(const dcomplex& x) { return dcomplex(x); }], \
1085                     [ dcomplex x; f(x); ],
1086       glibcpp_cv_complex=ok,
1087       glibcpp_cv_complex=buggy
1088     )
1089     AC_LANG_RESTORE
1090   ])
1091   AC_MSG_RESULT($glibcpp_cv_complex)
1092   if test $glibcpp_cv_complex = buggy; then
1093     AC_DEFINE(_GLIBCPP_BUGGY_COMPLEX)
1094   fi
1095
1096   AC_MSG_CHECKING([for GNU C++ __complex__ float support])
1097   AC_CACHE_VAL(glibcpp_cv_float_complex, [
1098     AC_LANG_SAVE
1099     AC_LANG_CPLUSPLUS
1100     rm -f conftest.h
1101     cat > conftest.h <<EOB
1102       //
1103       // Check for buggy __complex__ that causes ICE in most versions of egcs
1104       // and gcc-2.95.x on certain platforms (eg., x86-win32).
1105       //
1106       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
1107       // more info on the bug itself.
1108       //
1109       struct
1110       float_complex
1111       {
1112        __complex__ float m_value;
1113        float_complex (float = 0.0f, float = 0.0f);
1114        float_complex (__complex__ float val) : m_value (val) {}
1115        float_complex foo (const float_complex &val)
1116          { return float_complex (~val.m_value); }
1117       };
1118 EOB
1119     AC_TRY_COMPILE([#include "conftest.h"], ,
1120       glibcpp_cv_float_complex=ok,
1121       glibcpp_cv_float_complex=buggy
1122     )
1123     AC_LANG_RESTORE
1124   ])
1125   AC_MSG_RESULT($glibcpp_cv_float_complex)
1126   if test $glibcpp_cv_float_complex = buggy; then
1127     AC_DEFINE(_GLIBCPP_BUGGY_FLOAT_COMPLEX)
1128   fi
1129 ])
1130
1131
1132 dnl
1133 dnl Check for special debugging mode; not for production use.
1134 dnl
1135 dnl GLIBCPP_ENABLE_DEBUG
1136 dnl --enable-debug sets '-ggdb3 -O0'.
1137 dnl --disable-debug sets '-g' and whatever optimization options the
1138 dnl     compiler can handle.
1139 dnl  +  --enable-maintainer-mode automatically defaults this to on.
1140 dnl  +  Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...?
1141 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
1142 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1143 dnl       defaults to `no'.
1144 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
1145 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
1146 AC_ARG_ENABLE(debug,
1147 changequote(<<, >>)dnl
1148 <<  --enable-debug          extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
1149 changequote([, ])dnl
1150 [case "${enableval}" in
1151  yes) enable_debug=yes ;;
1152  no)  enable_debug=no ;;
1153  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
1154  esac],
1155 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
1156
1157 dnl Option parsed, now set things appropriately
1158 case "${enable_debug}" in
1159     yes)
1160         DEBUG_FLAGS='-O0 -ggdb3'
1161         ;;
1162     no)
1163         DEBUG_FLAGS='-g'
1164         ;;
1165 esac
1166 AC_SUBST(DEBUG_FLAGS)
1167 ])
1168
1169
1170 dnl
1171 dnl Check for "unusual" flags to pass to the compiler while building.
1172 dnl
1173 dnl GLIBCPP_ENABLE_CXX_FLAGS
1174 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
1175 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
1176 dnl     Somehow this same set of flags must be passed when [re]building
1177 dnl     libgcc.
1178 dnl --disable-cxx-flags passes nothing.
1179 dnl  +  See http://sourceware.cygnus.com/ml/libstdc++/2000-q2/msg00131.html
1180 dnl         http://sourceware.cygnus.com/ml/libstdc++/2000-q2/msg00284.html
1181 dnl         http://sourceware.cygnus.com/ml/libstdc++/2000-q1/msg00035.html
1182 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1183 dnl       If "default flags" is an empty string (or "none"), the effect is
1184 dnl       the same as --disable or --enable=no.
1185 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1186 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1187 AC_ARG_ENABLE(cxx-flags,
1188 changequote(<<, >>)dnl
1189 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1190                                 [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1191 changequote([, ])dnl
1192 [case "x$enableval" in
1193  xyes)
1194         AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1195  xno|x)
1196         enable_cxx_flags='' ;;
1197  *)
1198         enable_cxx_flags="$enableval" ;;
1199  esac],
1200 enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT')
1201
1202 dnl Thinko on my part during design.  This kludge is the workaround.
1203 if test "$enable_cxx_flags" = "none"; then
1204   enable_cxx_flags='';
1205 fi
1206
1207 dnl Run through flags (either default or command-line) and set anything
1208 dnl extra (e.g., #defines) that must accompany particular g++ options.
1209 if test -n "$enable_cxx_flags"; then
1210     for f in $enable_cxx_flags; do
1211         case "$f" in
1212             -fhonor-std)  ;;
1213             -*)  ;;
1214             *)   # and we're trying to pass /what/ exactly?
1215                  AC_MSG_ERROR([compiler flags start with a -]) ;;
1216         esac
1217     done
1218 fi
1219 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1220 AC_SUBST(EXTRA_CXX_FLAGS)
1221 ])
1222
1223
1224 dnl
1225 dnl Check for which I/O library to use:  libio, or something specific.
1226 dnl
1227 dnl GLIBCPP_ENABLE_CSTDIO
1228 dnl --enable-cstdio=libio sets config/c_io_libio.h and friends
1229 dnl
1230 dnl default is stdio
1231 dnl
1232 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1233   AC_MSG_CHECKING([for cstdio to use])
1234   AC_ARG_ENABLE(cstdio,
1235   [  --enable-cstdio        enable stdio for target io package. (default)
1236      --enable-cstdio=LIB    use LIB target-speific io package.],
1237   if test x$enable_cstdio = xno; then
1238      enable_cstdio=stdio
1239   fi,
1240      enable_cstdio=stdio)
1241
1242   enable_cstdio_flag=$enable_cstdio
1243
1244   dnl Check if a valid I/O package
1245   case x${enable_cstdio_flag} in
1246     xlibio)
1247       CSTDIO_H=config/c_io_libio.h
1248       CSTDIO_CC=config/c_io_libio.cc
1249       AC_MSG_RESULT(libio)
1250
1251       # see if we are on a system with libio native (ie, linux)
1252       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1253
1254       # Need to check and see what version of glibc is being used. If
1255       # it's not glibc-2.2 or higher, then we'll need to go ahead and
1256       # compile most of libio for linux systems.
1257       if test x$has_libio = x"yes"; then
1258         case "$target" in
1259           *-*-linux*)
1260               AC_MSG_CHECKING([for glibc version >= 2.2])
1261               AC_EGREP_CPP([ok], [
1262             #include <features.h>
1263               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1264                     ok
1265               #endif
1266               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1267               AC_MSG_RESULT($glibc_satisfactory)
1268             ;;
1269         esac
1270
1271         # XXX at the moment, admit defeat and force the recompilation
1272         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1273         glibc_satisfactory=no
1274
1275         if test x$glibc_satisfactory = x"yes"; then
1276            need_libio=no
1277            need_wlibio=no
1278         else
1279            need_libio=yes
1280            # bkoz XXX need to add checks to enable this
1281            # pme XXX here's a first pass at such a check
1282            if test x$enable_c_mbchar != xno; then
1283               need_wlibio=yes
1284            else
1285               need_wlibio=no
1286            fi
1287         fi
1288
1289       else
1290          # Using libio, but <libio.h> doesn't exist on the target system. . .
1291          need_libio=yes
1292          # bkoz XXX need to add checks to enable this
1293          # pme XXX here's a first pass at such a check
1294          if test x$enable_c_mbchar != xno; then
1295              need_wlibio=yes
1296          else
1297              need_wlibio=no
1298          fi
1299       fi
1300       ;;
1301     xstdio | x | xno | xnone | xyes)
1302       # default
1303       CSTDIO_H=config/c_io_stdio.h
1304       CSTDIO_CC=config/c_io_stdio.cc
1305       AC_MSG_RESULT(stdio)
1306
1307       # We're not using stdio.
1308       need_libio=no
1309       need_wlibio=no
1310       # Wide characters are not supported with this package.
1311       enable_c_mbchar=no
1312       ;;
1313     *)
1314       echo "$enable_cstdio is an unknown io package" 1>&2
1315       exit 1
1316       ;;
1317   esac
1318   AC_LINK_FILES($CSTDIO_H, include/bits/c++io.h)
1319   AC_LINK_FILES($CSTDIO_CC, src/c++io.cc)
1320
1321   # 2000-08-04 bkoz hack
1322   CCODECVT_C=config/c_io_libio_codecvt.c
1323   AC_LINK_FILES($CCODECVT_C, libio/c_codecvt.c)
1324   # 2000-08-04 bkoz hack
1325
1326   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1327   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1328   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1329         libio_la=../libio/libio.la
1330   else
1331         libio_la=
1332   fi
1333   AC_SUBST(libio_la)
1334 ])
1335
1336
1337 dnl
1338 dnl Check for which threading library to use.
1339 dnl
1340 dnl GLIBCPP_ENABLE_THREADS
1341 dnl --enable-threads=posix sets config/threads-posix.h et. al.
1342 dnl
1343 dnl Default is no threads, which also disables _IO_MTSAFE_IO in
1344 dnl libio.  Any actual thread package will enable it.
1345 dnl
1346 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1347   dnl Note this comes from the gcc/config.in and libjava/config.in
1348   dnl Efforts should be made to keep this in sync.
1349   AC_MSG_CHECKING([for threads package to use])
1350   AC_ARG_ENABLE(threads,
1351   [  --enable-threads        enable thread usage for target GCC.
1352      --enable-threads=LIB    use LIB thread package for target GCC.],
1353   if test x$enable_threads = xno; then
1354     enable_threads=''
1355   fi,
1356     enable_threads='')
1357
1358   enable_threads_flag=$enable_threads
1359
1360   dnl Check if a valid thread package
1361   case x${enable_threads_flag} in
1362         x | xno | xnone)
1363                 # No threads
1364                 target_thread_file='single'
1365                 ;;
1366         xyes)
1367                 # default
1368                 target_thread_file='posix'
1369                 ;;
1370         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
1371         xsolaris | xwin32 | xdce | xvxworks)
1372                 target_thread_file=$enable_threads_flag
1373                 ;;
1374         *)
1375                 echo "$enable_threads is an unknown thread package" 1>&2
1376                 exit 1
1377                 ;;
1378   esac
1379
1380   dnl Check for thread package actually supported in libstdc++
1381   THREADH=
1382   case "$target_thread_file" in
1383     no | none | single)
1384       THREADH=threads-no.h
1385       ;;
1386     posix | pthreads)
1387       THREADH=threads-posix.h
1388       ;;
1389     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
1390       AC_MSG_ERROR(thread package $THREADS not yet supported)
1391       ;;
1392     *)
1393       AC_MSG_ERROR($THREADS is an unsupported/unknown thread package)
1394       ;;
1395   esac
1396   AC_MSG_RESULT($THREADH)
1397
1398   AC_LINK_FILES(config/$THREADH, include/bits/c++threads.h)
1399   if test $THREADH != threads-no.h; then
1400     AC_DEFINE(_GLIBCPP_USE_THREADS)
1401   fi
1402 ])
1403
1404
1405 dnl Enable atomic locking
1406 dnl GLIBCPP_ENABLE_ATOMICITY
1407 AC_DEFUN(GLIBCPP_ENABLE_ATOMICITY, [
1408     AC_MSG_CHECKING([for atomicity.h])
1409     # We have ATOMICITY already from GLIBCPP_CONFIGURE
1410     if test "$ATOMICITYH" = "config/cpu/generic"; then
1411       AC_MSG_WARN([No ATOMICITY settings found, using generic atomic ops.])
1412     fi
1413     AC_MSG_RESULT($ATOMICITYH/bits/atomicity.h)
1414     AC_LINK_FILES($ATOMICITYH/bits/atomicity.h, include/bits/atomicity.h)
1415 ])
1416
1417
1418 dnl
1419 dnl Check for template specializations for the 'long long' type extension.
1420 dnl
1421 dnl GLIBCPP_ENABLE_LONG_LONG
1422 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1423 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1424 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1425 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1426 dnl       defaults to `no'.
1427 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1428 dnl
1429 dnl GLIBCPP_ENABLE_LONG_LONG
1430 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1431   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1432
1433   AC_ARG_ENABLE(long-long,
1434   changequote(<<, >>)dnl
1435   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1436   changequote([, ])dnl
1437   [case "$enableval" in
1438    yes) enable_long_long=yes ;;
1439    no)  enable_long_long=no ;;
1440    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1441    esac],
1442   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1443
1444   # Check for the existance of functions used if long long is enabled.
1445   AC_CHECK_FUNC(strtoll,,ac_strtoll=no)
1446   AC_CHECK_FUNC(strtoull,,ac_strtoull=no)
1447
1448   AC_MSG_CHECKING([for enabled long long])
1449   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
1450     enable_long_long=no;
1451   fi;
1452   AC_MSG_RESULT($enable_long_long)
1453
1454   dnl Option parsed, now set things appropriately
1455   if test x"$enable_long_long" = xyes; then
1456     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1457   fi
1458 ])
1459
1460
1461 dnl
1462 dnl Check for whether or not to do shadowed C headers.
1463 dnl
1464 dnl GLIBCPP_ENABLE_SHADOW
1465 dnl --enable-cshadow-headers [does stuff].
1466 dnl --disable-cshadow-headers [does not do stuff].
1467 dnl  +  This will eventually need to be on by default.
1468 dnl  +  Usage:  GLIBCPP_ENABLE_SHADOW[(DEFAULT)]
1469 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1470 dnl       defaults to `no'.
1471 AC_DEFUN(GLIBCPP_ENABLE_SHADOW, [dnl
1472 define([GLIBCPP_ENABLE_SHADOW_DEFAULT], ifelse($1, yes, yes, no))dnl
1473 AC_MSG_CHECKING([for enabled cshadow headers])
1474 AC_ARG_ENABLE(cshadow-headers,
1475 changequote(<<, >>)dnl
1476 <<  --enable-cshadow-headers construct "shadowed" C header files for
1477                            g++ [default=>>GLIBCPP_ENABLE_SHADOW_DEFAULT],
1478 changequote([, ])
1479   [case "$enableval" in
1480    yes) enable_cshadow_headers=yes
1481         ;;
1482    no)  enable_cshadow_headers=no
1483         ;;
1484    *)   AC_MSG_ERROR([Unknown argument to enable/disable shadowed C headers])
1485         ;;
1486   esac],
1487   enable_cshadow_headers=GLIBCPP_ENABLE_SHADOW_DEFAULT)
1488   AC_MSG_RESULT($enable_cshadow_headers)
1489
1490   dnl Option parsed, now set things appropriately
1491   dnl NB: these things may be duplicated in c++config.h as well.
1492   case "$enable_cshadow_headers" in
1493     yes)
1494         CSHADOW_FLAGS="-fno-builtin"
1495         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
1496         AC_DEFINE(_GLIBCPP_USE_SHADOW_HEADERS)
1497         ;;
1498     no)
1499         CSHADOW_FLAGS=""
1500         C_INCLUDE_DIR='${top_srcdir}/include/c'
1501         ;;
1502   esac
1503
1504   AC_SUBST(CSHADOW_FLAGS)
1505   AC_SUBST(C_INCLUDE_DIR)
1506   AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cshadow_headers" = yes)
1507 ])
1508
1509
1510 dnl
1511 dnl Check for wide character support.  Has the same effect as the option
1512 dnl in gcc's configure, but in a form that autoconf can mess with.
1513 dnl
1514 dnl GLIBCPP_ENABLE_C_MBCHAR
1515 dnl --enable-c-mbchar requests all the wchar_t stuff.
1516 dnl --disable-c-mbchar doesn't.
1517 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1518 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1519 dnl       defaults to `no'.
1520 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1521 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1522 AC_ARG_ENABLE(c-mbchar,
1523 changequote(<<, >>)dnl
1524 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1525 changequote([, ])dnl
1526 [case "$enableval" in
1527  yes) enable_c_mbchar=yes ;;
1528  no)  enable_c_mbchar=no ;;
1529  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1530  esac],
1531 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1532 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1533 ])
1534
1535
1536 dnl
1537 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1538 dnl
1539 dnl GLIBCPP_INCLUDE_DIR
1540 dnl C_INCLUDE_DIR
1541 dnl TOPLEVEL_INCLUDES
1542 dnl LIBMATH_INCLUDES
1543 dnl LIBSUPCXX_INCLUDES
1544 dnl LIBIO_INCLUDES
1545 dnl CSHADOW_INCLUDES
1546 dnl
1547 dnl GLIBCPP_EXPORT_INCLUDE
1548 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1549   # Root level of the include sources.
1550   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
1551
1552   # Can either use include/c or include/c_std to grab "C" headers. This
1553   # variable is set to the include directory currently in use.
1554   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
1555
1556   # Passed down for canadian crosses.
1557   if  test x"$CANADIAN" = xyes; then
1558     TOPLEVEL_INCLUDES='-I$(includedir)'
1559   fi
1560
1561   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1562
1563   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1564
1565   #if GLIBCPP_NEED_LIBIO
1566   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1567   #else
1568   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
1569   #endif
1570
1571   #if GLIBCPP_USE_CSHADOW
1572   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
1573   #                   -I$(top_blddir)/cshadow'
1574   #else
1575   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
1576   #endif
1577
1578   # Now, export this to all the little Makefiles....
1579   AC_SUBST(GLIBCPP_INCLUDE_DIR)
1580   AC_SUBST(TOPLEVEL_INCLUDES)
1581   AC_SUBST(LIBMATH_INCLUDES)
1582   AC_SUBST(LIBSUPCXX_INCLUDES)
1583   AC_SUBST(LIBIO_INCLUDES)
1584   AC_SUBST(CSHADOW_INCLUDES)
1585 ])
1586
1587
1588 dnl
1589 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1590 dnl
1591 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1592   # Optimization flags that are probably a good idea for thrill-seekers. Just
1593   # uncomment the lines below and make, everything else is ready to go...
1594   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1595   OPTIMIZE_CXXFLAGS=
1596   AC_SUBST(OPTIMIZE_CXXFLAGS)
1597
1598   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1599   AC_SUBST(WARN_FLAGS)
1600 ])
1601
1602
1603 # Check whether LC_MESSAGES is available in <locale.h>.
1604 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1605 #
1606 # This file file be copied and used freely without restrictions.  It can
1607 # be used in projects which are not available under the GNU Public License
1608 # but which still want to provide support for the GNU gettext functionality.
1609 # Please note that the actual code is *not* freely available.
1610
1611 # serial 1
1612
1613 AC_DEFUN(AC_LC_MESSAGES, [
1614   AC_CHECK_HEADER(locale.h, [
1615     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1616       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1617        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1618     if test $ac_cv_val_LC_MESSAGES = yes; then
1619       AC_DEFINE(HAVE_LC_MESSAGES)
1620     fi
1621   ])
1622 ])
1623
1624
1625 # Check for functions in math library.
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_MATHFUNCS(FUNCTION...)
1636 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1637 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])
1638 AC_SUBST(LIBMATHOBJS)dnl
1639 ])
1640
1641
1642 # Check for string functions.
1643 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1644 #
1645 # This file can be copied and used freely without restrictions.  It can
1646 # be used in projects which are not available under the GNU Public License
1647 # but which still want to provide support for the GNU gettext functionality.
1648 # Please note that the actual code is *not* freely available.
1649
1650 # serial 1
1651
1652 dnl AC_REPLACE_STRINGFUNCS(FUNCTION...)
1653 AC_DEFUN(AC_REPLACE_STRINGFUNCS,
1654 [AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"])
1655 AC_SUBST(LIBSTRINGOBJS)dnl
1656 ])
1657
1658
1659 dnl This macro searches for a GNU version of make.  If a match is found, the
1660 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1661 dnl set to "#". This is useful for  including a special features in a Makefile,
1662 dnl which cannot be handled by other versions of make.  The variable
1663 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1664 dnl the empty string otherwise.
1665 dnl
1666 dnl Here is an example of its use:
1667 dnl
1668 dnl Makefile.in might contain:
1669 dnl
1670 dnl     # A failsafe way of putting a dependency rule into a makefile
1671 dnl     $(DEPEND):
1672 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1673 dnl
1674 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1675 dnl     @ifGNUmake@ include $(DEPEND)
1676 dnl     @ifGNUmake@ endif
1677 dnl
1678 dnl Then configure.in would normally contain:
1679 dnl
1680 dnl     CHECK_GNU_MAKE()
1681 dnl     AC_OUTPUT(Makefile)
1682 dnl
1683 dnl Then perhaps to cause gnu make to override any other make, we could do
1684 dnl something like this (note that GNU make always looks for GNUmakefile first):
1685 dnl
1686 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1687 dnl             mv Makefile GNUmakefile
1688 dnl             echo .DEFAULT: > Makefile ;
1689 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1690 dnl     fi
1691 dnl
1692 dnl Then, if any (well almost any) other make is called, and GNU make also
1693 dnl exists, then the other make wraps the GNU make.
1694 dnl
1695 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1696 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1697 dnl
1698 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1699 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1700 dnl #### conditional's subshell (" --version" is not a command), using a
1701 dnl #### different option to grep(1).
1702 dnl #### -pme
1703 AC_DEFUN(
1704   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1705           _cv_gnu_make_command='' ;
1706 dnl Search all the common names for GNU make
1707           for a in "${MAKE:-make}" make gmake gnumake ; do
1708                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1709                   then
1710                           _cv_gnu_make_command=$a ;
1711                           break;
1712                   fi
1713           done ;
1714   ) ;
1715 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1716 dnl string, '#' otherwise
1717   if test  "x$_cv_gnu_make_command" != "x"  ; then
1718           ifGNUmake='' ;
1719   else
1720           ifGNUmake='#' ;
1721   fi
1722   AC_SUBST(ifGNUmake)
1723 ])
1724
1725 sinclude(../libtool.m4)
1726 dnl The lines below arrange for aclocal not to bring an installed
1727 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1728 dnl add a definition of LIBTOOL to Makefile.in.
1729 ifelse(,,,[AC_SUBST(LIBTOOL)
1730 AC_DEFUN([AM_PROG_LIBTOOL])
1731 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1732 AC_DEFUN([AC_PROG_LD])
1733 ])
1734