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