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.91)
  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 CXX_libstdcxx 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 CXX_libstdcxx=$CXX
  98 AC_CHECK_PROGS(CXX_libstdcxx, $CCC c++ g++ gcc CC cxx cc++, gcc)
  99 CXX=$CXX_libstdcxx
 100 AC_SUBST(CXX)
 101 test -z "$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, :)
 132
 133   AC_PROG_INSTALL
 134
 135   AM_MAINTAINER_MODE
 136
 137   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
 138   # at least currently, we never actually build a program, so we never
 139   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
 140   # fails, because we are probably configuring with a cross compiler
 141   # which cant create executables.  So we include AC_EXEEXT to keep
 142   # automake happy, but we dont execute it, since we dont care about
 143   # the result.
 144   if false; then
 145     AC_EXEEXT
 146   fi
 147
 148   . [$]{glibcpp_basedir}/configure.host
 149
 150   case [$]{glibcpp_basedir} in
 151     /* | [A-Za-z]:[\\/]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;;
 152     *) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;;
 153   esac
 154
 155   # This does for the target what configure.host does for the host.  In
 156   # addition to possibly modifying the same flags, it also sets up symlinks.
 157   GLIBCPP_CHECK_TARGET
 158 ])
 159
 160
 161 dnl
 162 dnl Check to see if g++ can compile this library, and if so, if any version-
 163 dnl specific precautions need to be taken.
 164 dnl
 165 dnl GLIBCPP_CHECK_COMPILER_VERSION
 166 AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [
 167 if test ! -f stamp-sanity-compiler; then
 168   AC_MSG_CHECKING([for g++ that will successfully compile libstdc++-v3])
 169   AC_LANG_SAVE
 170   AC_LANG_CPLUSPLUS
 171   AC_EGREP_CPP(ok, [
 172   #if __GNUC__ >= 3
 173     ok
 174   #endif
 175   ], gpp_satisfactory=yes, AC_MSG_ERROR([please upgrade to GCC 3.0 or above]))
 176   AC_LANG_RESTORE
 177   AC_MSG_RESULT($gpp_satisfactory)
 178   touch stamp-sanity-compiler
 179 fi
 180 ])
 181
 182
 183 dnl
 184 dnl Test for newer compiler features, or features that are present in newer
 185 dnl compiler version but not older compiler versions should be placed
 186 dnl here.
 187 dnl
 188 dnl Define WERROR='-Werror' if requested and possible; g++'s that lack the
 189 dnl new inlining code or the new system_header pragma will die on -Werror.
 190 dnl Leave it out by default and use maint-mode to use it.
 191 dnl
 192 dnl Define SECTION_FLAGS='-ffunction-sections -fdata-sections' if
 193 dnl compiler supports it.
 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 Define HAVE_STRTOLD if "strtold" is declared and links
 468 dnl Define HAVE_STRTOF if "strtof" is declared and links
 469 dnl
 470 dnl argument 1 is name of function to check
 471 dnl
 472 dnl ASSUMES argument is a math function with TWO parameters
 473 dnl
 474 dnl GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2
 475 AC_DEFUN(GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2, [
 476   AC_MSG_CHECKING([for $1 declaration])
 477   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 478     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 479       AC_LANG_SAVE
 480       AC_LANG_CPLUSPLUS
 481       AC_TRY_COMPILE([#include <stdlib.h>],
 482                      [ $1(0, 0);],
 483                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 484       AC_LANG_RESTORE
 485     ])
 486   fi
 487   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 488   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 489     AC_CHECK_FUNCS($1)
 490   fi
 491 ])
 492
 493
 494 dnl
 495 dnl Because the builtins are picky picky picky about the arguments they take,
 496 dnl do an explict linkage tests here.
 497 dnl Check to see if the (math function) argument passed is
 498 dnl 1) declared when using the c++ compiler
 499 dnl 2) has "C" linkage
 500 dnl
 501 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 502 dnl
 503 dnl argument 1 is name of function to check
 504 dnl
 505 dnl ASSUMES argument is a math function with ONE parameter
 506 dnl
 507 dnl GLIBCPP_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 508 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1, [
 509   AC_MSG_CHECKING([for $1 declaration])
 510   if test x${glibcpp_cv_func_$1_use+set} != xset; then
 511     AC_CACHE_VAL(glibcpp_cv_func_$1_use, [
 512       AC_LANG_SAVE
 513       AC_LANG_CPLUSPLUS
 514       AC_TRY_COMPILE([#include <math.h>],
 515                      [ $1(0);],
 516                      [glibcpp_cv_func_$1_use=yes], [glibcpp_cv_func_$1_use=no])
 517       AC_LANG_RESTORE
 518     ])
 519   fi
 520   AC_MSG_RESULT($glibcpp_cv_func_$1_use)
 521   if test x$glibcpp_cv_func_$1_use = x"yes"; then
 522     AC_MSG_CHECKING([for $1 linkage])
 523     if test x${glibcpp_cv_func_$1_link+set} != xset; then
 524       AC_CACHE_VAL(glibcpp_cv_func_$1_link, [
 525         AC_TRY_LINK([#include <math.h>],
 526                     [ $1(0);],
 527                     [glibcpp_cv_func_$1_link=yes], [glibcpp_cv_func_$1_link=no])
 528       ])
 529     fi
 530     AC_MSG_RESULT($glibcpp_cv_func_$1_link)
 531     if test x$glibcpp_cv_func_$1_link = x"yes"; then
 532       ac_tr_func=HAVE_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 533       AC_DEFINE_UNQUOTED(${ac_tr_func})
 534     fi
 535   fi
 536 ])
 537
 538
 539 dnl
 540 dnl Check to see what builtin math functions are supported
 541 dnl
 542 dnl check for __builtin_abs
 543 dnl check for __builtin_fabsf
 544 dnl check for __builtin_fabs
 545 dnl check for __builtin_fabl
 546 dnl check for __builtin_labs
 547 dnl check for __builtin_sqrtf
 548 dnl check for __builtin_sqrtl
 549 dnl check for __builtin_fsqrt
 550 dnl check for __builtin_sinf
 551 dnl check for __builtin_sin
 552 dnl check for __builtin_sinl
 553 dnl check for __builtin_cosf
 554 dnl check for __builtin_cos
 555 dnl check for __builtin_cosl
 556 dnl
 557 dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
 558 AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [
 559   dnl Test for builtin math functions.
 560   dnl These are made in gcc/c-common.c
 561   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 562   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 563   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 564   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 565   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 566
 567   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 568   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fsqrt)
 569   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 570
 571   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 572   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 573   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 574
 575   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 576   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 577   GLIBCPP_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 578
 579   dnl There is, without a doubt, a more elegant way to have these
 580   dnl names exported so that they won't be stripped out of acconfig.h by
 581   dnl autoheader. I leave this as an exercise to somebody less frustrated
 582   dnl than I.... please email the libstdc++ list if you can figure out a
 583   dnl more elegant approach (see autoconf/acgen.m4 and specifically
 584   dnl AC_CHECK_FUNC for things to steal.)
 585   dummyvar=no
 586   if test x$dummyvar = x"yes"; then
 587     AC_DEFINE(HAVE___BUILTIN_ABS)
 588     AC_DEFINE(HAVE___BUILTIN_LABS)
 589     AC_DEFINE(HAVE___BUILTIN_COS)
 590     AC_DEFINE(HAVE___BUILTIN_COSF)
 591     AC_DEFINE(HAVE___BUILTIN_COSL)
 592     AC_DEFINE(HAVE___BUILTIN_FABS)
 593     AC_DEFINE(HAVE___BUILTIN_FABSF)
 594     AC_DEFINE(HAVE___BUILTIN_FABSL)
 595     AC_DEFINE(HAVE___BUILTIN_SIN)
 596     AC_DEFINE(HAVE___BUILTIN_SINF)
 597     AC_DEFINE(HAVE___BUILTIN_SINL)
 598     AC_DEFINE(HAVE___BUILTIN_FSQRT)
 599     AC_DEFINE(HAVE___BUILTIN_SQRTF)
 600     AC_DEFINE(HAVE___BUILTIN_SQRTL)
 601   fi
 602 ])
 603
 604
 605 dnl
 606 dnl Check to see what the underlying c library
 607 dnl These checks need to do two things:
 608 dnl 1) make sure the name is declared when using the c++ compiler
 609 dnl 2) make sure the name has "C" linkage
 610 dnl This might seem like overkill but experience has shown that it's not...
 611 dnl
 612 dnl Define HAVE_STRTOF etc if "strtof" is found.
 613 dnl Define HAVE_STRTOLD etc if "strtold" is found.
 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   AC_CHECK_FUNCS(strtof)
 622   GLIBCPP_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 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_CHECK_FUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
 827     wcsrtombs mbsrtowcs, ac_wfuncs=yes, ac_wfuncs=no)
 828
 829     AC_MSG_CHECKING([for ISO C99 wchar_t support])
 830     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
 831        && test x"$ac_wfuncs" = xyes; then
 832       ac_isoC99_wchar_t=yes
 833     else
 834       ac_isoC99_wchar_t=no
 835     fi
 836     AC_MSG_RESULT($ac_isoC99_wchar_t)
 837
 838     dnl Use iconv for wchar_t to char conversions. As such, check for
 839     dnl X/Open Portability Guide, version 2 features (XPG2).
 840     AC_CHECK_HEADER(iconv.h, ac_has_iconv_h=yes, ac_has_iconv_h=no)
 841     AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
 842
 843     dnl Check for existence of libiconv.a providing XPG2 wchar_t support.
 844     AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
 845     ac_save_LIBS="$LIBS"
 846     LIBS="$LIBS $libiconv"
 847
 848     AC_CHECK_FUNCS(iconv_open iconv_close iconv nl_langinfo, \
 849     ac_XPG2funcs=yes, ac_XPG2funcs=no)
 850
 851     LIBS="$ac_save_LIBS"
 852
 853     AC_MSG_CHECKING([for XPG2 wchar_t support])
 854     if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
 855        && test x"$ac_XPG2funcs" = xyes; then
 856       ac_XPG2_wchar_t=yes
 857     else
 858       ac_XPG2_wchar_t=no
 859     fi
 860     AC_MSG_RESULT($ac_XPG2_wchar_t)
 861
 862     dnl At the moment, only enable wchar_t specializations if all the
 863     dnl above support is present.
 864     AC_MSG_CHECKING([for enabled wchar_t specializations])
 865     if test x"$ac_isoC99_wchar_t" = xyes \
 866        && test x"$ac_XPG2_wchar_t" = xyes; then
 867       libinst_wstring_la="libinst-wstring.la"
 868       AC_DEFINE(_GLIBCPP_USE_WCHAR_T)
 869       AC_MSG_RESULT("yes")
 870     else
 871       libinst_wstring_la=""
 872       AC_MSG_RESULT("no")
 873     fi
 874     AC_SUBST(libinst_wstring_la)
 875
 876   else
 877     dnl Wide characters disabled by the user.
 878     AC_MSG_WARN([wchar_t support disabled.])
 879   fi
 880 ])
 881
 882
 883 dnl
 884 dnl Check to see if this version of GNU C++ is afflicted by bugs in
 885 dnl __complex__ float support.
 886 dnl
 887 dnl Define _GLIBCPP_BUGGY_FLOAT_COMPLEX if buggy.
 888 dnl
 889 dnl Check to see if this version of GNU C++ is afflicted by bugs in
 890 dnl __complex__ support.Check for buggy __complex__ that will cause ICE in
 891 dnl gcc-2.95.x when using the library, unless we define the default copy
 892 dnl ctor in the specializations of complex<>.
 893 dnl
 894 dnl Define _GLIBCPP_BUGGY_COMPLEX if buggy.
 895 dnl GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT
 896 AC_DEFUN(GLIBCPP_CHECK_COMPLEX_MATH_COMPILER_SUPPORT, [
 897   AC_REQUIRE([AC_PROG_CXX])
 898
 899   AC_MSG_CHECKING([for GNU C++ __complex__ support])
 900   AC_CACHE_VAL(glibcpp_cv_complex, [
 901     AC_LANG_SAVE
 902     AC_LANG_CPLUSPLUS
 903     AC_TRY_COMPILE([struct dcomplex { __complex__ double x; }; \
 904                     dcomplex f(const dcomplex& x) { return dcomplex(x); }], \
 905                     [ dcomplex x; f(x); ],
 906       glibcpp_cv_complex=ok,
 907       glibcpp_cv_complex=buggy
 908     )
 909     AC_LANG_RESTORE
 910   ])
 911   AC_MSG_RESULT($glibcpp_cv_complex)
 912   if test $glibcpp_cv_complex = buggy; then
 913     AC_DEFINE(_GLIBCPP_BUGGY_COMPLEX)
 914   fi
 915
 916   AC_MSG_CHECKING([for GNU C++ __complex__ float support])
 917   AC_CACHE_VAL(glibcpp_cv_float_complex, [
 918     AC_LANG_SAVE
 919     AC_LANG_CPLUSPLUS
 920     rm -f conftest.h
 921     cat > conftest.h <<EOB
 922       //
 923       // Check for buggy __complex__ that causes ICE in most versions of egcs
 924       // and gcc-2.95.x on certain platforms (eg., x86-win32).
 925       //
 926       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
 927       // more info on the bug itself.
 928       //
 929       struct
 930       float_complex
 931       {
 932        __complex__ float m_value;
 933        float_complex (float = 0.0f, float = 0.0f);
 934        float_complex (__complex__ float val) : m_value (val) {}
 935        float_complex foo (const float_complex &val)
 936          { return float_complex (~val.m_value); }
 937       };
 938 EOB
 939     AC_TRY_COMPILE([#include "conftest.h"], ,
 940       glibcpp_cv_float_complex=ok,
 941       glibcpp_cv_float_complex=buggy
 942     )
 943     AC_LANG_RESTORE
 944   ])
 945   AC_MSG_RESULT($glibcpp_cv_float_complex)
 946   if test $glibcpp_cv_float_complex = buggy; then
 947     AC_DEFINE(_GLIBCPP_BUGGY_FLOAT_COMPLEX)
 948   fi
 949 ])
 950
 951
 952 dnl
 953 dnl Check for special debugging mode; not for production use.
 954 dnl
 955 dnl GLIBCPP_ENABLE_DEBUG
 956 dnl --enable-debug sets '-ggdb3 -O0'.
 957 dnl --disable-debug sets '-g' and whatever optimization options the
 958 dnl     compiler can handle.
 959 dnl  +  --enable-maintainer-mode automatically defaults this to on.
 960 dnl  +  Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...?
 961 dnl  +  Usage:  GLIBCPP_ENABLE_DEBUG[(DEFAULT)]
 962 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
 963 dnl       defaults to `no'.
 964 AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl
 965 define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl
 966 AC_ARG_ENABLE(debug,
 967 changequote(<<, >>)dnl
 968 <<  --enable-debug          extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT],
 969 changequote([, ])dnl
 970 [case "${enableval}" in
 971  yes) enable_debug=yes ;;
 972  no)  enable_debug=no ;;
 973  *)   AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;;
 974  esac],
 975 enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl
 976
 977 dnl Option parsed, now set things appropriately
 978 case "${enable_debug}" in
 979     yes)
 980         DEBUG_FLAGS='-O0 -ggdb3'
 981         ;;
 982     no)
 983         DEBUG_FLAGS='-g'
 984         ;;
 985 esac
 986 AC_SUBST(DEBUG_FLAGS)
 987 ])
 988
 989
 990 dnl
 991 dnl Check for "unusual" flags to pass to the compiler while building.
 992 dnl
 993 dnl GLIBCPP_ENABLE_CXX_FLAGS
 994 dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
 995 dnl     experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc.
 996 dnl     Somehow this same set of flags must be passed when [re]building
 997 dnl     libgcc.
 998 dnl --disable-cxx-flags passes nothing.
 999 dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
1000 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
1001 dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
1002 dnl  +  Usage:  GLIBCPP_ENABLE_CXX_FLAGS(default flags)
1003 dnl       If "default flags" is an empty string (or "none"), the effect is
1004 dnl       the same as --disable or --enable=no.
1005 AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl
1006 define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl
1007 AC_ARG_ENABLE(cxx-flags,
1008 changequote(<<, >>)dnl
1009 <<  --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
1010                                 [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT],
1011 changequote([, ])dnl
1012 [case "x$enableval" in
1013  xyes)
1014         AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;;
1015  xno|x)
1016         enable_cxx_flags='' ;;
1017  *)
1018         enable_cxx_flags="$enableval" ;;
1019  esac],
1020 enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT')
1021
1022 dnl Thinko on my part during design.  This kludge is the workaround.
1023 if test "$enable_cxx_flags" = "none"; then
1024   enable_cxx_flags='';
1025 fi
1026
1027 dnl Run through flags (either default or command-line) and set anything
1028 dnl extra (e.g., #defines) that must accompany particular g++ options.
1029 if test -n "$enable_cxx_flags"; then
1030     for f in $enable_cxx_flags; do
1031         case "$f" in
1032             -fhonor-std)  ;;
1033             -*)  ;;
1034             *)   # and we're trying to pass /what/ exactly?
1035                  AC_MSG_ERROR([compiler flags start with a -]) ;;
1036         esac
1037     done
1038 fi
1039 EXTRA_CXX_FLAGS="$enable_cxx_flags"
1040 AC_SUBST(EXTRA_CXX_FLAGS)
1041 ])
1042
1043
1044 dnl
1045 dnl Check for which locale library to use:  gnu or generic.
1046 dnl
1047 dnl GLIBCPP_ENABLE_CLOCALE
1048 dnl --enable-clocale=gnu sets config/c_locale_gnu.cc and friends
1049 dnl --enable-clocale=generic sets config/c_locale_generic.cc and friends
1050 dnl
1051 dnl default is generic
1052 dnl
1053 AC_DEFUN(GLIBCPP_ENABLE_CLOCALE, [
1054   AC_MSG_CHECKING([for clocale to use])
1055   AC_ARG_ENABLE(clocale,
1056   [  --enable-clocale       enable model for target locale package.
1057      --enable-clocale=MODEL use MODEL target-speific locale package. [default=generic]
1058   ],
1059   if test x$enable_clocale = xno; then
1060      enable_clocale=generic
1061   fi,
1062      enable_clocale=generic)
1063
1064   enable_clocale_flag=$enable_clocale
1065
1066   dnl Check if a valid locale package
1067   case x${enable_clocale_flag} in
1068     xgnu)
1069       CLOCALE_H=config/c_locale_gnu.h
1070       CLOCALE_CC=config/c_locale_gnu.cc
1071       AC_MSG_RESULT(gnu)
1072       ;;
1073     xgeneric)
1074       CLOCALE_H=config/c_locale_generic.h
1075       CLOCALE_CC=config/c_locale_generic.cc
1076       AC_MSG_RESULT(generic)
1077       ;;
1078     *)
1079       echo "$enable_clocale is an unknown locale package" 1>&2
1080       exit 1
1081       ;;
1082   esac
1083
1084   AC_LINK_FILES($CLOCALE_H, include/bits/c++locale.h)
1085   AC_LINK_FILES($CLOCALE_CC, src/c++locale.cc)
1086 ])
1087
1088
1089 dnl
1090 dnl Check for which I/O library to use:  libio, or something specific.
1091 dnl
1092 dnl GLIBCPP_ENABLE_CSTDIO
1093 dnl --enable-cstdio=libio sets config/c_io_libio.h and friends
1094 dnl
1095 dnl default is stdio
1096 dnl
1097 AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [
1098   AC_MSG_CHECKING([for cstdio to use])
1099   AC_ARG_ENABLE(cstdio,
1100   [  --enable-cstdio        enable stdio for target io package.
1101      --enable-cstdio=LIB    use LIB target-speific io package. [default=stdio]
1102   ],
1103   if test x$enable_cstdio = xno; then
1104      enable_cstdio=stdio
1105   fi,
1106      enable_cstdio=stdio)
1107
1108   enable_cstdio_flag=$enable_cstdio
1109
1110   dnl Check if a valid I/O package
1111   case x${enable_cstdio_flag} in
1112     xlibio)
1113       CSTDIO_H=config/c_io_libio.h
1114       BASIC_FILE_H=config/basic_file_libio.h
1115       BASIC_FILE_CC=config/basic_file_libio.cc
1116       AC_MSG_RESULT(libio)
1117
1118       # see if we are on a system with libio native (ie, linux)
1119       AC_CHECK_HEADER(libio.h,  has_libio=yes, has_libio=no)
1120
1121       # Need to check and see what version of glibc is being used. If
1122       # it's not glibc-2.2 or higher, then we'll need to go ahead and
1123       # compile most of libio for linux systems.
1124       if test x$has_libio = x"yes"; then
1125         case "$target" in
1126           *-*-linux*)
1127               AC_MSG_CHECKING([for glibc version >= 2.2])
1128               AC_EGREP_CPP([ok], [
1129             #include <features.h>
1130               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
1131                     ok
1132               #endif
1133               ], glibc_satisfactory=yes, glibc_satisfactory=no)
1134               AC_MSG_RESULT($glibc_satisfactory)
1135             ;;
1136         esac
1137
1138         # XXX at the moment, admit defeat and force the recompilation
1139         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
1140         glibc_satisfactory=no
1141
1142         if test x$glibc_satisfactory = x"yes"; then
1143            need_libio=no
1144            need_wlibio=no
1145         else
1146            need_libio=yes
1147            # bkoz XXX need to add checks to enable this
1148            # pme XXX here's a first pass at such a check
1149            if test x$enable_c_mbchar != xno; then
1150               need_wlibio=yes
1151            else
1152               need_wlibio=no
1153            fi
1154         fi
1155
1156       else
1157          # Using libio, but <libio.h> doesn't exist on the target system. . .
1158          need_libio=yes
1159          # bkoz XXX need to add checks to enable this
1160          # pme XXX here's a first pass at such a check
1161          if test x$enable_c_mbchar != xno; then
1162              need_wlibio=yes
1163          else
1164              need_wlibio=no
1165          fi
1166       fi
1167       ;;
1168     xstdio | x | xno | xnone | xyes)
1169       # default
1170       CSTDIO_H=config/c_io_stdio.h
1171       BASIC_FILE_H=config/basic_file_stdio.h
1172       BASIC_FILE_CC=config/basic_file_stdio.cc
1173       AC_MSG_RESULT(stdio)
1174
1175       # We're not using stdio.
1176       need_libio=no
1177       need_wlibio=no
1178       # Wide characters are not supported with this package.
1179       enable_c_mbchar=no
1180       ;;
1181     *)
1182       echo "$enable_cstdio is an unknown io package" 1>&2
1183       exit 1
1184       ;;
1185   esac
1186   AC_LINK_FILES($CSTDIO_H, include/bits/c++io.h)
1187   AC_LINK_FILES($BASIC_FILE_H, include/bits/basic_file_model.h)
1188   AC_LINK_FILES($BASIC_FILE_CC, src/basic_file.cc)
1189
1190   # 2000-08-04 bkoz hack
1191   CCODECVT_C=config/c_io_libio_codecvt.c
1192   AC_LINK_FILES($CCODECVT_C, libio/c_codecvt.c)
1193   # 2000-08-04 bkoz hack
1194
1195   AM_CONDITIONAL(GLIBCPP_BUILD_LIBIO,
1196                  test "$need_libio" = yes || test "$need_wlibio" = yes)
1197   AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes)
1198   AM_CONDITIONAL(GLIBCPP_NEED_WLIBIO, test "$need_wlibio" = yes)
1199   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
1200     libio_la=../libio/libio.la
1201   else
1202     libio_la=
1203   fi
1204   AC_SUBST(libio_la)
1205 ])
1206
1207
1208 dnl
1209 dnl Check for which threading library to use.
1210 dnl
1211 dnl GLIBCPP_ENABLE_THREADS
1212 dnl --enable-threads=posix sets config/threads-posix.h et. al.
1213 dnl
1214 dnl Default is no threads, which also disables _IO_MTSAFE_IO in
1215 dnl libio.  Any actual thread package will enable it.
1216 dnl
1217 AC_DEFUN(GLIBCPP_ENABLE_THREADS, [
1218   dnl Note this comes from the gcc/config.in and libjava/config.in
1219   dnl Efforts should be made to keep this in sync.
1220   AC_MSG_CHECKING([for threads package to use])
1221   AC_ARG_ENABLE(threads,
1222   [  --enable-threads       enable thread usage for target GCC.
1223      --enable-threads=LIB   use LIB thread package for target GCC. [default=no]
1224   ],
1225   if test x$enable_threads = xno; then
1226     enable_threads=''
1227   fi,
1228     enable_threads='')
1229
1230   enable_threads_flag=$enable_threads
1231
1232   dnl Check if a valid thread package
1233   case x${enable_threads_flag} in
1234         x | xno | xnone)
1235                 # No threads
1236                 target_thread_file='single'
1237                 ;;
1238         xyes)
1239                 # default
1240                 target_thread_file='posix'
1241                 ;;
1242         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
1243         xsolaris | xwin32 | xdce | xvxworks)
1244                 target_thread_file=$enable_threads_flag
1245                 ;;
1246         *)
1247                 echo "$enable_threads is an unknown thread package" 1>&2
1248                 exit 1
1249                 ;;
1250   esac
1251
1252   dnl Check for thread package actually supported in libstdc++
1253   THREADH=
1254   case "$target_thread_file" in
1255     no | none | single)
1256       THREADH=threads-no.h
1257       ;;
1258     posix | pthreads)
1259       THREADH=threads-posix.h
1260       ;;
1261     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
1262       AC_MSG_ERROR(thread package $THREADS not yet supported)
1263       ;;
1264     *)
1265       AC_MSG_ERROR($THREADS is an unsupported/unknown thread package)
1266       ;;
1267   esac
1268   AC_MSG_RESULT($THREADH)
1269
1270   AC_LINK_FILES(config/$THREADH, include/bits/c++threads.h)
1271   if test $THREADH != threads-no.h; then
1272     AC_DEFINE(_GLIBCPP_USE_THREADS)
1273   fi
1274 ])
1275
1276
1277 dnl
1278 dnl Check for template specializations for the 'long long' type extension.
1279 dnl
1280 dnl GLIBCPP_ENABLE_LONG_LONG
1281 dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG
1282 dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined
1283 dnl  +  Usage:  GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)]
1284 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1285 dnl       defaults to `no'.
1286 dnl  +  If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
1287 dnl
1288 dnl GLIBCPP_ENABLE_LONG_LONG
1289 AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl
1290   define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl
1291
1292   AC_ARG_ENABLE(long-long,
1293   changequote(<<, >>)dnl
1294   <<--enable-long-long      turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT],
1295   changequote([, ])dnl
1296   [case "$enableval" in
1297    yes) enable_long_long=yes ;;
1298    no)  enable_long_long=no ;;
1299    *)   AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;;
1300    esac],
1301   enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl
1302
1303   # Allow use of os-dependent settings, so that macros that turn on
1304   # C99 capabilities can be defined and used in a consistent way.
1305   OS_INC_PATH=${srcdir}/$os_include_dir
1306   ac_test_CFLAGS="${CFLAGS+set}"
1307   ac_save_CFLAGS="$CFLAGS"
1308   CFLAGS="-I$OS_INC_PATH"
1309
1310   # Check for the existence of functions used if long long is enabled.
1311   AC_CHECK_FUNC(strtoll,,ac_strtoll=no)
1312   AC_CHECK_FUNC(strtoull,,ac_strtoull=no)
1313
1314   # Check for lldiv_t, et. al.
1315   AC_MSG_CHECKING([for lldiv_t declaration])
1316   AC_CACHE_VAL(glibcpp_lldiv_t_use, [
1317   AC_TRY_COMPILE([#include <bits/os_defines.h>
1318                   #include <stdlib.h>],
1319                    [ lldiv_t mydivt;],
1320                    [glibcpp_lldiv_t_use=yes], [glibcpp_lldiv_t_use=no])
1321   ])
1322   AC_MSG_RESULT($glibcpp_lldiv_t_use)
1323   if test x$glibcpp_lldiv_t_use = x"yes"; then
1324     AC_DEFINE(HAVE_LLDIV_T)
1325   fi
1326
1327   AC_MSG_CHECKING([for enabled long long])
1328   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
1329     enable_long_long=no;
1330   fi;
1331   AC_MSG_RESULT($enable_long_long)
1332
1333   # Option parsed, now set things appropriately
1334   if test x"$enable_long_long" = xyes; then
1335     AC_DEFINE(_GLIBCPP_USE_LONG_LONG)
1336   fi
1337
1338   # Reset CFLAGS
1339   CFLAGS="$ac_save_CFLAGS"
1340 ])
1341
1342
1343 dnl
1344 dnl Check for what kind of C headers to use.
1345 dnl
1346 dnl GLIBCPP_ENABLE_CHEADERS
1347 dnl --enable-cheaders= [does stuff].
1348 dnl --disable-cheaders [does not do anything, really].
1349 dnl  +  This will eventually need to be 'c_shadow' by default.
1350 dnl  +  Usage:  GLIBCPP_ENABLE_CHEADERS[(DEFAULT)]
1351 dnl       Where DEFAULT is either `c' or `c_std' or 'c_shadow'.
1352 dnl       If ommitted, it defaults to `c_std'.
1353 AC_DEFUN(GLIBCPP_ENABLE_CHEADERS, [dnl
1354 define([GLIBCPP_ENABLE_CHEADERS_DEFAULT], ifelse($1, c_std, c_std, c_std))dnl
1355 AC_MSG_CHECKING([for c header strategy to use])
1356 AC_ARG_ENABLE(cheaders,
1357 changequote(<<, >>)dnl
1358 <<  --enable-cheaders construct "C" header files for
1359                            g++ [default=>>GLIBCPP_ENABLE_CHEADERS_DEFAULT],
1360 changequote([, ])
1361   [case "$enableval" in
1362    c)
1363         enable_cheaders=c
1364         ;;
1365    c_std)
1366         enable_cheaders=c_std
1367         ;;
1368    c_shadow)
1369         enable_cheaders=c_shadow
1370         ;;
1371    *)   AC_MSG_ERROR([Unknown argument to enable/disable "C" headers])
1372         ;;
1373   esac],
1374   enable_cheaders=GLIBCPP_ENABLE_CHEADERS_DEFAULT)
1375   AC_MSG_RESULT($enable_cheaders)
1376
1377   dnl Option parsed, now set things appropriately
1378   case "$enable_cheaders" in
1379     c_shadow)
1380         CSHADOW_FLAGS="-fno-builtin"
1381         C_INCLUDE_DIR='${top_srcdir}/include/c_shadow'
1382         AC_DEFINE(_GLIBCPP_USE_SHADOW_HEADERS)
1383         ;;
1384     c_std)
1385         CSHADOW_FLAGS=""
1386         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
1387         ;;
1388     c)
1389         CSHADOW_FLAGS=""
1390         C_INCLUDE_DIR='${top_srcdir}/include/c'
1391         ;;
1392   esac
1393
1394   AC_SUBST(CSHADOW_FLAGS)
1395   AC_SUBST(C_INCLUDE_DIR)
1396   AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cheaders" = c_shadow)
1397 ])
1398
1399
1400 dnl
1401 dnl Check for wide character support.  Has the same effect as the option
1402 dnl in gcc's configure, but in a form that autoconf can mess with.
1403 dnl
1404 dnl GLIBCPP_ENABLE_C_MBCHAR
1405 dnl --enable-c-mbchar requests all the wchar_t stuff.
1406 dnl --disable-c-mbchar doesn't.
1407 dnl  +  Usage:  GLIBCPP_ENABLE_C_MBCHAR[(DEFAULT)]
1408 dnl       Where DEFAULT is either `yes' or `no'.  If ommitted, it
1409 dnl       defaults to `no'.
1410 AC_DEFUN(GLIBCPP_ENABLE_C_MBCHAR, [dnl
1411 define([GLIBCPP_ENABLE_C_MBCHAR_DEFAULT], ifelse($1, yes, yes, no))dnl
1412 AC_ARG_ENABLE(c-mbchar,
1413 changequote(<<, >>)dnl
1414 <<  --enable-c-mbchar       enable multibyte (wide) characters [default=>>GLIBCPP_ENABLE_C_MBCHAR_DEFAULT],
1415 changequote([, ])dnl
1416 [case "$enableval" in
1417  yes) enable_c_mbchar=yes ;;
1418  no)  enable_c_mbchar=no ;;
1419  *)   AC_MSG_ERROR([Unknown argument to enable/disable c-mbchar]) ;;
1420  esac],
1421 enable_c_mbchar=GLIBCPP_ENABLE_C_MBCHAR_DEFAULT)dnl
1422 dnl Option parsed, now other scripts can test enable_c_mbchar for yes/no.
1423 ])
1424
1425
1426 dnl
1427 dnl Set up *_INCLUDES and *_INCLUDE_DIR variables for all sundry Makefile.am's.
1428 dnl
1429 dnl GLIBCPP_INCLUDE_DIR
1430 dnl C_INCLUDE_DIR
1431 dnl TOPLEVEL_INCLUDES
1432 dnl LIBMATH_INCLUDES
1433 dnl LIBSUPCXX_INCLUDES
1434 dnl LIBIO_INCLUDES
1435 dnl CSHADOW_INCLUDES
1436 dnl
1437 dnl GLIBCPP_EXPORT_INCLUDE
1438 AC_DEFUN(GLIBCPP_EXPORT_INCLUDES, [
1439   # Root level of the include sources.
1440   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
1441
1442   # Can either use include/c or include/c_std to grab "C" headers. This
1443   # variable is set to the include directory currently in use.
1444   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_CHEADERS
1445
1446   # Passed down for canadian crosses.
1447   if  test x"$CANADIAN" = xyes; then
1448     TOPLEVEL_INCLUDES='-I$(includedir)'
1449   fi
1450
1451   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
1452
1453   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
1454
1455   #if GLIBCPP_NEED_LIBIO
1456   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
1457   #else
1458   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
1459   #endif
1460
1461   #if GLIBCPP_USE_CSHADOW
1462   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
1463   #                   -I$(top_blddir)/cshadow'
1464   #else
1465   CSTD_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
1466   #endif
1467
1468   # Now, export this to all the little Makefiles....
1469   AC_SUBST(GLIBCPP_INCLUDE_DIR)
1470   AC_SUBST(TOPLEVEL_INCLUDES)
1471   AC_SUBST(LIBMATH_INCLUDES)
1472   AC_SUBST(LIBSUPCXX_INCLUDES)
1473   AC_SUBST(LIBIO_INCLUDES)
1474   AC_SUBST(CSTD_INCLUDES)
1475 ])
1476
1477
1478 dnl
1479 dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
1480 dnl
1481 AC_DEFUN(GLIBCPP_EXPORT_FLAGS, [
1482   # Optimization flags that are probably a good idea for thrill-seekers. Just
1483   # uncomment the lines below and make, everything else is ready to go...
1484   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
1485   OPTIMIZE_CXXFLAGS=
1486   AC_SUBST(OPTIMIZE_CXXFLAGS)
1487
1488   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
1489   AC_SUBST(WARN_FLAGS)
1490 ])
1491
1492 dnl
1493 dnl  GLIBCPP_EXPORT_INSTALL_INFO
1494 dnl  calculates gxx_install_dir
1495 dnl  exports glibcpp_toolexecdir
1496 dnl  exports glibcpp_toolexeclibdir
1497 dnl
1498 dnl Assumes cross_compiling bits already done, and with_cross_host in
1499 dnl particular
1500 dnl
1501 dnl GLIBCPP_EXPORT_INSTALL_INFO
1502 AC_DEFUN(GLIBCPP_EXPORT_INSTALL_INFO, [
1503
1504 glibcpp_toolexecdir=no
1505 glibcpp_toolexeclibdir=no
1506
1507 AC_MSG_CHECKING([for interface version number])
1508 libstdcxx_interface=$INTERFACE
1509 AC_MSG_RESULT($libstdcxx_interface)
1510
1511 # Process the option --with-gxx-include-dir=<path to include-files directory>
1512 AC_MSG_CHECKING([for --with-gxx-include-dir])
1513 AC_ARG_WITH(gxx-include-dir,
1514 [ --with-gxx-include-dir  the installation directory for include files],
1515 [case "${withval}" in
1516   yes)
1517     AC_MSG_ERROR(Missing directory for --with-gxx-include-dir)
1518     gxx_include_dir=no
1519     ;;
1520   no)
1521     gxx_include_dir=no
1522     ;;
1523   *)
1524     gxx_include_dir=${withval}
1525     ;;
1526 esac], [gxx_include_dir=no])
1527 AC_MSG_RESULT($gxx_include_dir)
1528
1529 # Process the option "--enable-version-specific-runtime-libs"
1530 AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
1531 AC_ARG_ENABLE(version-specific-runtime-libs,
1532 [  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
1533 [  version_specific_libs=yes
1534 # Need the gcc compiler version to know where to install libraries
1535 # and header files if --enable-version-specific-runtime-libs option
1536 # is selected.
1537 changequote(,)dnl
1538 gcc_version_trigger=${srcdir}/../gcc/version.c
1539 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
1540 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1541 gxx_include_dir='$(libdir)/gcc-lib/$(target_alias)/'${gcc_version}/include/g++
1542 glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1543 glibcpp_toolexeclibdir='$(toolexecdir)/'${gcc_version}
1544 changequote([,])dnl
1545 ],version_specific_libs=no)
1546 AC_MSG_RESULT($version_specific_libs)
1547
1548 # Default case for install directory for include files.
1549 if test x"$version_specific_libs" = x"no" \
1550    && test x"$gxx_include_dir"=x"no"; then
1551   gxx_include_dir='$(prefix)'/include/g++-${libstdcxx_interface}
1552 fi
1553
1554 # Calculate glibcpp_toolexecdir, glibcpp_toolexeclibdir
1555 # Install a library built with a cross compiler in tooldir, not libdir.
1556 if test x"$glibcpp_toolexecdir" = x"no"; then
1557   if test -n "$with_cross_host" && test x"$with_cross_host" != x"no"; then
1558     glibcpp_toolexecdir='$(exec_prefix)/$(target_alias)'
1559     glibcpp_toolexeclibdir='$(toolexecdir)/lib$(MULTISUBDIR)'
1560   else
1561     glibcpp_toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1562     glibcpp_toolexeclibdir='$(libdir)$(MULTISUBDIR)'
1563   fi
1564 fi
1565
1566 AC_MSG_CHECKING([for install location])
1567 AC_MSG_RESULT($gxx_include_dir)
1568
1569 AC_SUBST(gxx_include_dir)
1570 AC_SUBST(glibcpp_toolexecdir)
1571 AC_SUBST(glibcpp_toolexeclibdir)
1572 ])
1573
1574
1575 # Check whether LC_MESSAGES is available in <locale.h>.
1576 # Ulrich Drepper <drepper@cygnus.com>, 1995.
1577 #
1578 # This file file be copied and used freely without restrictions.  It can
1579 # be used in projects which are not available under the GNU Public License
1580 # but which still want to provide support for the GNU gettext functionality.
1581 # Please note that the actual code is *not* freely available.
1582
1583 # serial 1
1584
1585 AC_DEFUN(AC_LC_MESSAGES, [
1586   AC_CHECK_HEADER(locale.h, [
1587     AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
1588       [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
1589        ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
1590     if test $ac_cv_val_LC_MESSAGES = yes; then
1591       AC_DEFINE(HAVE_LC_MESSAGES)
1592     fi
1593   ])
1594 ])
1595
1596
1597 # Check for functions in math library.
1598 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1599 #
1600 # This file can be copied and used freely without restrictions.  It can
1601 # be used in projects which are not available under the GNU Public License
1602 # but which still want to provide support for the GNU gettext functionality.
1603 # Please note that the actual code is *not* freely available.
1604
1605 # serial 1
1606
1607 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
1608 AC_DEFUN(AC_REPLACE_MATHFUNCS,
1609 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])
1610 AC_SUBST(LIBMATHOBJS)dnl
1611 ])
1612
1613
1614 # Check for string functions.
1615 # Ulrich Drepper <drepper@cygnus.com>, 1998.
1616 #
1617 # This file can be copied and used freely without restrictions.  It can
1618 # be used in projects which are not available under the GNU Public License
1619 # but which still want to provide support for the GNU gettext functionality.
1620 # Please note that the actual code is *not* freely available.
1621
1622 # serial 1
1623
1624 dnl AC_REPLACE_STRINGFUNCS(FUNCTION...)
1625 AC_DEFUN(AC_REPLACE_STRINGFUNCS,
1626 [AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"])
1627 AC_SUBST(LIBSTRINGOBJS)dnl
1628 ])
1629
1630
1631 dnl This macro searches for a GNU version of make.  If a match is found, the
1632 dnl makefile variable `ifGNUmake' is set to the empty string, otherwise it is
1633 dnl set to "#". This is useful for  including a special features in a Makefile,
1634 dnl which cannot be handled by other versions of make.  The variable
1635 dnl _cv_gnu_make_command is set to the command to invoke GNU make if it exists,
1636 dnl the empty string otherwise.
1637 dnl
1638 dnl Here is an example of its use:
1639 dnl
1640 dnl Makefile.in might contain:
1641 dnl
1642 dnl     # A failsafe way of putting a dependency rule into a makefile
1643 dnl     $(DEPEND):
1644 dnl             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
1645 dnl
1646 dnl     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
1647 dnl     @ifGNUmake@ include $(DEPEND)
1648 dnl     @ifGNUmake@ endif
1649 dnl
1650 dnl Then configure.in would normally contain:
1651 dnl
1652 dnl     CHECK_GNU_MAKE()
1653 dnl     AC_OUTPUT(Makefile)
1654 dnl
1655 dnl Then perhaps to cause gnu make to override any other make, we could do
1656 dnl something like this (note that GNU make always looks for GNUmakefile first):
1657 dnl
1658 dnl     if  ! test x$_cv_gnu_make_command = x ; then
1659 dnl             mv Makefile GNUmakefile
1660 dnl             echo .DEFAULT: > Makefile ;
1661 dnl             echo \  $_cv_gnu_make_command \$@ >> Makefile;
1662 dnl     fi
1663 dnl
1664 dnl Then, if any (well almost any) other make is called, and GNU make also
1665 dnl exists, then the other make wraps the GNU make.
1666 dnl
1667 dnl @author John Darrington <j.darrington@elvis.murdoch.edu.au>
1668 dnl @version 1.1 #### replaced Id string now that Id is for lib-v3; pme
1669 dnl
1670 dnl #### Changes for libstdc++-v3:  reformatting and linewrapping; prepending
1671 dnl #### GLIBCPP_ to the macro name; adding the :-make fallback in the
1672 dnl #### conditional's subshell (" --version" is not a command), using a
1673 dnl #### different option to grep(1).
1674 dnl #### -pme
1675 dnl #### Fixed Bourne shell portability bug (use ${MAKE-make}, not
1676 dnl #### ${MAKE:-make}).
1677 dnl #### -msokolov
1678 AC_DEFUN(
1679   GLIBCPP_CHECK_GNU_MAKE, [AC_CACHE_CHECK( for GNU make,_cv_gnu_make_command,
1680           _cv_gnu_make_command='' ;
1681 dnl Search all the common names for GNU make
1682           for a in "${MAKE-make}" make gmake gnumake ; do
1683                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
1684                   then
1685                           _cv_gnu_make_command=$a ;
1686                           break;
1687                   fi
1688           done ;
1689   ) ;
1690 dnl If there was a GNU version, then set @ifGNUmake@ to the empty
1691 dnl string, '#' otherwise
1692   if test  "x$_cv_gnu_make_command" != "x"  ; then
1693           ifGNUmake='' ;
1694   else
1695           ifGNUmake='#' ;
1696   fi
1697   AC_SUBST(ifGNUmake)
1698 ])
1699
1700 sinclude(../libtool.m4)
1701 dnl The lines below arrange for aclocal not to bring an installed
1702 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
1703 dnl add a definition of LIBTOOL to Makefile.in.
1704 ifelse(,,,[AC_SUBST(LIBTOOL)
1705 AC_DEFUN([AM_PROG_LIBTOOL])
1706 AC_DEFUN([AC_LIBTOOL_DLOPEN])
1707 AC_DEFUN([AC_PROG_LD])
1708 ])
1709
1710
1711 # Do all the work for Automake.  This macro actually does too much --
1712 # some checks are only needed if your package does certain things.
1713 # But this isn't really a big deal.
1714
1715 # serial 1
1716
1717 dnl Usage:
1718 dnl AM_INIT_AUTOMAKE(package,version, [no-define])
1719
1720 AC_DEFUN(AM_INIT_AUTOMAKE,
1721 [AC_REQUIRE([AC_PROG_INSTALL])
1722 PACKAGE=[$1]
1723 AC_SUBST(PACKAGE)
1724 VERSION=[$2]
1725 AC_SUBST(VERSION)
1726 dnl test to see if srcdir already configured
1727 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
1728   AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
1729 fi
1730 ifelse([$3],,
1731 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
1732 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))
1733 AC_REQUIRE([AM_SANITY_CHECK])
1734 AC_REQUIRE([AC_ARG_PROGRAM])
1735 dnl FIXME This is truly gross.
1736 missing_dir=`cd $ac_aux_dir && pwd`
1737 AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
1738 AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
1739 AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
1740 AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
1741 AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
1742 AC_REQUIRE([AC_PROG_MAKE_SET])])
1743
1744 #
1745 # Check to make sure that the build environment is sane.
1746 #
1747
1748 AC_DEFUN(AM_SANITY_CHECK,
1749 [AC_MSG_CHECKING([whether build environment is sane])
1750 # Just in case
1751 sleep 1
1752 echo timestamp > conftestfile
1753 # Do `set' in a subshell so we don't clobber the current shell's
1754 # arguments.  Must try -L first in case configure is actually a
1755 # symlink; some systems play weird games with the mod time of symlinks
1756 # (eg FreeBSD returns the mod time of the symlink's containing
1757 # directory).
1758 if (
1759    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
1760    if test "[$]*" = "X"; then
1761       # -L didn't work.
1762       set X `ls -t $srcdir/configure conftestfile`
1763    fi
1764    if test "[$]*" != "X $srcdir/configure conftestfile" \
1765       && test "[$]*" != "X conftestfile $srcdir/configure"; then
1766
1767       # If neither matched, then we have a broken ls.  This can happen
1768       # if, for instance, CONFIG_SHELL is bash and it inherits a
1769       # broken ls alias from the environment.  This has actually
1770       # happened.  Such a system could not be considered "sane".
1771       AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
1772 alias in your environment])
1773    fi
1774
1775    test "[$]2" = conftestfile
1776    )
1777 then
1778    # Ok.
1779    :
1780 else
1781    AC_MSG_ERROR([newly created file is older than distributed files!
1782 Check your system clock])
1783 fi
1784 rm -f conftest*
1785 AC_MSG_RESULT(yes)])
1786
1787 dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
1788 dnl The program must properly implement --version.
1789 AC_DEFUN(AM_MISSING_PROG,
1790 [AC_MSG_CHECKING(for working $2)
1791 # Run test in a subshell; some versions of sh will print an error if
1792 # an executable is not found, even if stderr is redirected.
1793 # Redirect stdin to placate older versions of autoconf.  Sigh.
1794 if ($2 --version) < /dev/null > /dev/null 2>&1; then
1795    $1=$2
1796    AC_MSG_RESULT(found)
1797 else
1798    $1="$3/missing $2"
1799    AC_MSG_RESULT(missing)
1800 fi
1801 AC_SUBST($1)])
1802
1803 # Add --enable-maintainer-mode option to configure.
1804 # From Jim Meyering
1805
1806 # serial 1
1807
1808 AC_DEFUN(AM_MAINTAINER_MODE,
1809 [AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
1810   dnl maintainer-mode is disabled by default
1811   AC_ARG_ENABLE(maintainer-mode,
1812 [  --enable-maintainer-mode enable make rules and dependencies not useful
1813                           (and sometimes confusing) to the casual installer],
1814       USE_MAINTAINER_MODE=$enableval,
1815       USE_MAINTAINER_MODE=no)
1816   AC_MSG_RESULT($USE_MAINTAINER_MODE)
1817   AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes)
1818   MAINT=$MAINTAINER_MODE_TRUE
1819   AC_SUBST(MAINT)dnl
1820 ]
1821 )
1822
1823 # Define a conditional.
1824
1825 AC_DEFUN(AM_CONDITIONAL,
1826 [AC_SUBST($1_TRUE)
1827 AC_SUBST($1_FALSE)
1828 if $2; then
1829   $1_TRUE=
1830   $1_FALSE='#'
1831 else
1832   $1_TRUE='#'
1833   $1_FALSE=
1834 fi])
1835
1836 # Like AC_CONFIG_HEADER, but automatically create stamp file.
1837
1838 AC_DEFUN(AM_CONFIG_HEADER,
1839 [AC_PREREQ([2.12])
1840 AC_CONFIG_HEADER([$1])
1841 dnl When config.status generates a header, we must update the stamp-h file.
1842 dnl This file resides in the same directory as the config header
1843 dnl that is generated.  We must strip everything past the first ":",
1844 dnl and everything past the last "/".
1845 AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl
1846 ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,
1847 <<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>,
1848 <<am_indx=1
1849 for am_file in <<$1>>; do
1850   case " <<$>>CONFIG_HEADERS " in
1851   *" <<$>>am_file "*<<)>>
1852     echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx
1853     ;;
1854   esac
1855   am_indx=`expr "<<$>>am_indx" + 1`
1856 done<<>>dnl>>)
1857 changequote([,]))])
1858