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