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