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