libstdc++-v3/acinclude.m4

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