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