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