libstdc++-v3/aclocal.m4

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