libstdc++-v3/acinclude.m4

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