diff options
Diffstat (limited to 'libstdc++-v3/aclocal.m4')
| -rw-r--r-- | libstdc++-v3/aclocal.m4 | 1503 |
1 files changed, 1503 insertions, 0 deletions
diff --git a/libstdc++-v3/aclocal.m4 b/libstdc++-v3/aclocal.m4 new file mode 100644 index 00000000000..00ff575d40b --- /dev/null +++ b/libstdc++-v3/aclocal.m4 @@ -0,0 +1,1503 @@ +dnl aclocal.m4 generated automatically by aclocal 1.4 + +dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl This program is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without +dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A +dnl PARTICULAR PURPOSE. + +dnl +dnl Initialize configure bits. +dnl +dnl Define OPTLEVEL='-O2' if new inlining code present. +dnl +dnl GLIBCPP_CONFIGURE +AC_DEFUN(GLIBCPP_CONFIGURE, [ + dnl Default to --enable-multilib + AC_ARG_ENABLE(multilib, + [ --enable-multilib build hella library versions (default)], + [case "${enableval}" in + yes) multilib=yes ;; + no) multilib=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;; + esac], [multilib=yes])dnl + + dnl We may get other options which we dont document: + dnl --with-target-subdir, --with-multisrctop, --with-multisubdir + if test "[$]{srcdir}" = "."; then + if test "[$]{with_target_subdir}" != "."; then + glibcpp_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1" + else + glibcpp_basedir="[$]{srcdir}/[$]{with_multisrctop}$1" + fi + else + glibcpp_basedir="[$]{srcdir}/$1" + fi + AC_SUBST(glibcpp_basedir) + + AC_CANONICAL_HOST + + AM_INIT_AUTOMAKE(libstdc++, 2.90.8) + +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + +AC_DEFUN(LIB_AC_PROG_CC, +[AC_BEFORE([$0], [AC_PROG_CPP])dnl +dnl Fool anybody using AC_PROG_CC. +AC_PROVIDE([AC_PROG_CC]) +AC_CHECK_PROG(CC, gcc, gcc) +if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) + test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) +fi + +AC_PROG_CC_GNU + +if test $ac_cv_prog_gcc = yes; then + GCC=yes +dnl Check whether -g works, even if CFLAGS is set, in case the package +dnl plays around with CFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + AC_PROG_CC_G + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-O2" + fi +else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" +fi +]) + +LIB_AC_PROG_CC + +# Likewise for AC_PROG_CXX. +AC_DEFUN(LIB_AC_PROG_CXX, +[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl +dnl Fool anybody using AC_PROG_CXX. +AC_PROVIDE([AC_PROG_CXX]) +AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc) +test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH]) + +AC_PROG_CXX_GNU + +if test $ac_cv_prog_gxx = yes; then + GXX=yes +dnl Check whether -g works, even if CXXFLAGS is set, in case the package +dnl plays around with CXXFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + AC_PROG_CXX_G + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-O2" + fi +else + GXX= + test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" +fi +]) + +LIB_AC_PROG_CXX + +# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we dont +# run it explicitly here, it will be run implicitly before +# LIBGCJ_CONFIGURE, which doesn't work because that means that it will +# be run before AC_CANONICAL_HOST. +AC_CANONICAL_BUILD + +AC_CHECK_TOOL(AS, as) +AC_CHECK_TOOL(AR, ar) +AC_CHECK_TOOL(RANLIB, ranlib, :) + +AC_PROG_INSTALL + +AM_MAINTAINER_MODE + +# We need AC_EXEEXT to keep automake happy in cygnus mode. However, +# at least currently, we never actually build a program, so we never +# need to use $(EXEEXT). Moreover, the test for EXEEXT normally +# fails, because we are probably configuring with a cross compiler +# which cant create executables. So we include AC_EXEEXT to keep +# automake happy, but we dont execute it, since we dont care about +# the result. +if false; then + AC_EXEEXT +fi + +# configure.host sets the following important variables +# glibcpp_cflags - host specific C compiler flags +# glibcpp_cxxflags - host specific C++ compiler flags + +glibcpp_cflags= +glibcpp_cxxflags= + +. [$]{glibcpp_basedir}/configure.host + +case [$]{glibcpp_basedir} in +/* | [A-Za-z]:[/\\]*) libgcj_flagbasedir=[$]{glibcpp_basedir} ;; +*) glibcpp_flagbasedir='[$](top_builddir)/'[$]{glibcpp_basedir} ;; +esac + +GLIBCPP_CFLAGS="[$]{glibcpp_cflags}" +GLIBCPP_CXXFLAGS="[$]{glibcpp_cxxflags}" +AC_SUBST(GLIBCPP_CFLAGS) +AC_SUBST(GLIBCPP_CXXFLAGS) +]) + + +dnl +dnl Check to see if g++ can compile this library. +dnl +dnl Define OPTLEVEL='-O2' if new inlining code present. +dnl +dnl GLIBCPP_CHECK_COMPILER_VERSION +AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [ + AC_MSG_CHECKING([for g++ that will successfullly compile this code]) + AC_EGREP_CPP([ok], [ + #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) + ok + #endif + ], gpp_satisfactory=yes, AC_MSG_ERROR("please upgrade to gcc-2.95 or above")) + AC_MSG_RESULT($gpp_satisfactory) + + AC_MSG_CHECKING([for g++ that supports new inlining mechanism]) + AC_EGREP_CPP([ok], [ + #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 95) + ok + #endif + ], [OPTLEVEL='-O2' + WERRORSUPPRESS= + ], [OPTLEVEL= + WERRORSUPPRESS=-Wno-error + ]) + if test "$OPTLEVEL" = ""; then + AC_MSG_RESULT(no) + else + AC_MSG_RESULT(yes) + fi + AC_SUBST(OPTLEVEL) + AC_SUBST(WERRORSUPPRESS) +]) + + +dnl +dnl Check to see what builtin math functions are supported +dnl +dnl Define _GLIBCPP_HAS_BUILTIN_SINF if __builtin_sinf +dnl Define _GLIBCPP_HAS_BUILTIN_COSF if __builtin_cosf +dnl Define _GLIBCPP_HAS_BUILTIN_FABSF if __builtin_fabsf +dnl Define _GLIBCPP_HAS_BUILTIN_SQRTF if __builtin_sqrtf +dnl +dnl GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT, [ + dnl Test for builtin math functions. + AC_MSG_CHECKING([for __builtin_sinf]) + AC_TRY_COMPILE([#include <math.h>], + [float foo(void) { __builtin_sinf(0.0); }], + use_builtin_sinf=yes, use_builtin_sinf=no) + AC_MSG_RESULT($use_builtin_sinf) + if test $use_builtin_sinf = "yes"; then + AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SINF) + fi + + AC_MSG_CHECKING([for __builtin_cosf]) + AC_TRY_COMPILE([#include <math.h>], + [float foo(void) { __builtin_cosf(0.0); }], + use_builtin_cosf=yes, use_builtin_cosf=no) + AC_MSG_RESULT($use_builtin_cosf) + if test $use_builtin_cosf = "yes"; then + AC_DEFINE(_GLIBCPP_HAS_BUILTIN_COSF) + fi + + AC_MSG_CHECKING([for __builtin_fabsf]) + AC_TRY_COMPILE([#include <math.h>], + [float foo(void) { __builtin_fabsf(0.0); }], + use_builtin_fabsf=yes, use_builtin_fabsf=no) + AC_MSG_RESULT($use_builtin_fabsf) + if test $use_builtin_fabsf = "yes"; then + AC_DEFINE(_GLIBCPP_HAS_BUILTIN_FABSF) + fi + + AC_MSG_CHECKING([for __builtin_sqrtf]) + AC_TRY_COMPILE([#include <math.h>], + [float foo(void) { __builtin_sqrtf(0.0); }], + use_builtin_sqrtf=yes, use_builtin_sqrtf=no) + AC_MSG_RESULT($use_builtin_sqrtf) + if test $use_builtin_sqrtf = "yes"; then + AC_DEFINE(_GLIBCPP_HAS_BUILTIN_SQRTF) + fi +]) + + +dnl +dnl Check to see what architecture we are compiling for. If it's +dnl supported, use special hand-crafted routines to provide thread +dnl primitives. +dnl +dnl Depending on what is found, select various configure/cpu/*/atomicity.h +dnl If not found, select configure/cpu/generic/atomicity.h +dnl +dnl GLIBCPP_CHECK_CPU +AC_DEFUN(GLIBCPP_CHECK_CPU, [ + AC_MSG_CHECKING([for cpu primitives directory]) + case "$target_cpu" in + alpha*) + cpu_include_dir="config/cpu/alpha" + ;; + arm*) + cpu_include_dir="config/cpu/arm" + ;; + i486 | i586 | i686 | i786) + cpu_include_dir="config/cpu/i386" + ;; + powerpc | rs6000) + cpu_include_dir="config/cpu/powerpc" + ;; + sparc64 | ultrasparc) + cpu_include_dir="config/cpu/sparc/sparc64" + ;; + sparc*) + cpu_include_dir="config/cpu/sparc/sparc32" + ;; + *) + cpu_include_dir="config/cpu/generic" + ;; + esac + AC_MSG_RESULT($cpu_include_dir) + AC_SUBST(cpu_include_dir) +]) + + +dnl +dnl Check to see what the underlying c library's interface to ctype looks +dnl like. Bits of locale rely on things like isspace, toupper, etc. This +dnl stuff makes sure the right bits from the clibrary get called. +dnl +dnl Depending on what is found, select various configure/*/bits/ctype_base.h +dnl Depending on what is found, select various configure/*/ctype.cc +dnl +dnl GLIBCPP_CHECK_CTYPE +AC_DEFUN(GLIBCPP_CHECK_CTYPE, [ + AC_CHECK_HEADER(ctype.h, [ + + dnl If doesn't match any specified, go with defaults. + ctype_default=yes + + dnl Test for <ctype> functionality -- gnu-linux + AC_MSG_CHECKING([for gnu-linux <ctype>]) + AC_TRY_COMPILE([#include <ctype.h>], + [int + foo (int a) + { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \ + + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \ + + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}], \ + ctype_linux=yes, ctype_linux=no) + AC_MSG_RESULT($ctype_linux) + if test $ctype_linux = "yes"; then + ctype_include_dir="config/gnu-linux" + ctype_default=no + fi + + dnl Test for <ctype> functionality -- solaris 2.6 and 2.7 + if test $ctype_default = "yes"; then + AC_MSG_CHECKING([for solaris 2.6 or 2.7 <ctype>]) + AC_TRY_COMPILE([#include <ctype.h>], + [int + foo (int a) + { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \ + + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \ + + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}], \ + ctype_solaris=yes, ctype_solaris=no) + AC_MSG_RESULT($ctype_solaris) + + if test $ctype_solaris = "yes"; then + AC_MSG_CHECKING([ for version]) + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <ctype.h>], + [typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;],\ + ctype_solaris26=yes, ctype_solaris26=no) + AC_LANG_C + if test $ctype_solaris26 = "yes"; then + ctype_include_dir="config/solaris/solaris2.6" + AC_MSG_RESULT("solaris2.6") + ctype_default=no + else + ctype_include_dir="config/solaris/solaris2.7" + AC_MSG_RESULT("solaris2.7") + ctype_default=no + fi + fi + fi + + dnl Test for <ctype> functionality -- solaris 2.5.1 + if test $ctype_default = "yes"; then + AC_MSG_CHECKING([for solaris 2.5.1 <ctype>]) + AC_TRY_COMPILE([#include <ctype.h>], + [int + foo (int a) + { return _U + _L + _N + _S + _P + _C + _X + _B \ + + __ctype[a];}], \ + ctype_solaris25=yes, ctype_solaris25=no) + AC_MSG_RESULT($ctype_solaris25) + if test $ctype_solaris25 = "yes"; then + ctype_include_dir="config/solaris/solaris2.5" + ctype_default=no + fi + fi + + dnl Test for <ctype> functionality -- aix + if test $ctype_default = "yes"; then + AC_MSG_CHECKING([for aix <ctype>]) + AC_TRY_COMPILE([#include <ctype.h>], + [int + foo (int a) + { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \ + + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \ + + _VALC('a') + _IS('c', 0);}], \ + ctype_aix=yes, ctype_aix=no) + AC_MSG_RESULT($ctype_aix) + if test $ctype_aix = "yes"; then + ctype_include_dir="config/aix" + ctype_default=no + fi + fi + + dnl Test for <ctype> functionality -- newlib + if test $ctype_default = "yes"; then + AC_MSG_CHECKING([for newlib <ctype>]) + AC_TRY_COMPILE([#include <ctype.h>], + [int + foo (int a) + { return _U + _L + _N + _S + _P + _C + _X + _B \ + + _ctype_[a];}], \ + ctype_newlib=yes, ctype_newlib=no) + AC_MSG_RESULT($ctype_newlib) + if test $ctype_newlib = "yes"; then + ctype_include_dir="config/newlib" + ctype_default=no + fi + fi + + if test $ctype_default = "yes"; then + ctype_include_dir="config/generic" + AC_MSG_WARN("Using default ctype headers.") + fi + AC_SUBST(ctype_include_dir) + ]) +]) + + +dnl +dnl Check to see what the underlying c library or math library is like. +dnl +dnl Define HAVE_CARGF etc if "cargf" is found. +dnl +dnl GLIBCPP_CHECK_MATH_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_MATH_SUPPORT, [ + AC_CHECK_LIB(m, sin, libm="-lm") + save_LIBS="$LIBS" + LIBS="$LIBS $libm" + + dnl Check for complex versions of math functions of platform. + AC_CHECK_HEADERS([complex.h]) + AC_REPLACE_MATHFUNCS(ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \ + clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \ + ctan ctanf ctanh ctanhf \ + carg cargf nan hypot hypotf atan2f expf copysignf) + + dnl We compile the long double complex functions only if the function + dnl provides the non-complex functions. + USE_LONG_DOUBLE=no + AC_CHECK_FUNC(sinl, + USE_LONG_DOUBLE=yes + AC_REPLACE_MATHFUNCS(ccoshl ccosl cexpl cpowl csinhl csinl \ + csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l)) + AC_SUBST(USE_LONG_DOUBLE) + + dnl Check to see if basic C math functions have faster float versions. + AC_CHECK_FUNCS(modf isnan isnanf isnanl isinf isinff isinfl copysign \ + copysignl cosf coshf logf log10f powf sinf sinhf sqrtf tanf tanhf \ + strtof strtold fabsf sincos sincosf sincosl finite finite fqfinite \ + fpclass qfpclass) + +#Some runtimes have these functions with a preceding underscore. Please +# keep this sync'd with the one above. And if you add any new symbol, +# please add the corresponding block in the @BOTTOM@ section of +# acconfig.h. +AC_CHECK_FUNCS(_modf _isnan _isnanf _isnanl _isinf _isinff _isinfl _copysign \ +_copysignl _cosf _coshf _logf _log10f _powf _sinf _sinhf _sqrtf _tanf _tanhf \ +_strtof _strtold _fabsf _sincos _sincosf _sincosl _finite _finitef _qfinite \ +_fpclass _qfpclass) + +LIBS="$save_LIBS" +]) + + +dnl +dnl Check to see if this target can enable the wchar_t parts of libstdc++. +dnl +dnl Define _GLIBCPP_USE_WCHAR_T if all the bits are found +dnl Define _GLIBCPP_NEED_MBSTATE_T if mbstate_t is not in wchar.h +dnl Define _GLIBCPP_HAS_WCHAR_MIN_MAX if WCHAR_MIN, WCHAR_MAX in wchar.h +dnl +dnl GLIBCPP_CHECK_WCHAR_T_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_WCHAR_T_SUPPORT, [ + AC_CHECK_HEADER(wchar.h,[ + dnl Test wchar.h for mbstate_t, which is needed for char_traits and others. + AC_MSG_CHECKING([for native mbstate_t]) + AC_TRY_COMPILE([#include <wchar.h>], + [mbstate_t teststate;], + use_native_mbstatet=yes, use_native_mbstatet=no) + AC_MSG_RESULT($use_native_mbstatet) + if test $use_native_mbstatet = "no"; then + AC_DEFINE(_GLIBCPP_NEED_MBSTATE_T) + fi + + dnl Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before + dnl numeric_limits can instantiate type_traits<wchar_t> + AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX]) + AC_TRY_COMPILE([#include <wchar.h>], + [int i = WCHAR_MIN; int j = WCHAR_MAX;], + has_wchar_minmax=yes, has_wchar_minmax=no) + AC_MSG_RESULT($has_wchar_minmax) + if test $has_wchar_minmax = "yes"; then + AC_DEFINE(_GLIBCPP_HAS_WCHAR_MIN_MAX) + fi + + # Test wchar.h for WEOF, which is what we use to determine whether + # to specialize for wchar_t or not. + AC_MSG_CHECKING([for WEOF]) + AC_TRY_COMPILE([ + #include <wchar.h> + #include <stddef.h>], + [wint_t i = WEOF;], + has_weof=yes, has_weof=no) + AC_MSG_RESULT($has_weof) + + dnl Tests for wide character functions. + AC_REPLACE_STRINGFUNCS(wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset) + + AC_MSG_CHECKING([for wide character support]) + if test $has_weof = "yes" && test $has_wchar_minmax = "yes"; then + AC_DEFINE(_GLIBCPP_USE_WCHAR_T) + AC_MSG_RESULT(ok) + else + AC_MSG_RESULT("not specializing for wchar_t") + fi + ],[ + AC_MSG_WARN([<wchar.h> not found]) + AC_DEFINE(_GLIBCPP_NEED_MBSTATE_T) + ]) +]) + + +dnl +dnl Check to see if this version of GNU C++ is afflicted by bugs in +dnl __complex__ float support. +dnl +dnl Define _GLIBCPP_BUGGY_FLOAT_COMPLEX if buggy. +dnl +dnl GLIBCPP_CHECK_COMPLEX_FLOAT_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_COMPLEX_FLOAT_SUPPORT, [ + AC_REQUIRE([AC_PROG_CXX]) + AC_MSG_CHECKING([for GNU C++ __complex__ float support]) + AC_CACHE_VAL(glibcpp_cv_float_complex, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + rm -f conftest.h + cat > conftest.h <<EOB + // + // Check for buggy __complex__ that causes ICE in most versions of egcs + // and gcc-2.95.x on certain platforms (eg., x86-win32). + // + // See http://egcs.cygnus.com/ml/gcc-bugs/1999-07/msg00845.html for + // more info on the bug itself. + // + struct + float_complex + { + __complex__ float m_value; + float_complex (float = 0.0f, float = 0.0f); + float_complex (__complex__ float val) : m_value (val) {} + float_complex foo (const float_complex &val) + { return float_complex (~val.m_value); } + }; +EOB + AC_TRY_COMPILE([#include "conftest.h"], , + glibcpp_cv_float_complex=ok, + glibcpp_cv_float_complex=buggy + ) + AC_LANG_RESTORE + ]) + AC_MSG_RESULT($glibcpp_cv_float_complex) + if test $glibcpp_cv_float_complex = buggy; then + AC_DEFINE(_GLIBCPP_BUGGY_FLOAT_COMPLEX) + fi +]) + + +dnl +dnl +dnl Check to see if this version of GNU C++ is afflicted by bugs in +dnl __complex__ support.Check for buggy __complex__ that will cause ICE in +dnl gcc-2.95.x when using the library, unless we define the default copy +dnl ctor in the specializations of complex<>. +dnl +dnl Define _GLIBCPP_BUGGY_COMPLEX if buggy. +dnl +dnl GLIBCPP_CHECK_COMPLEX_SUPPORT +AC_DEFUN(GLIBCPP_CHECK_COMPLEX_SUPPORT, [ + AC_REQUIRE([AC_PROG_CXX]) + AC_MSG_CHECKING([for GNU C++ __complex__ support]) + AC_CACHE_VAL(glibcpp_cv_complex, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([struct dcomplex { __complex__ double x; }; \ + dcomplex f(const dcomplex& x) { return dcomplex(x); }], \ + [ dcomplex x; f(x); ], + glibcpp_cv_complex=ok, + glibcpp_cv_complex=buggy + ) + AC_LANG_RESTORE + ]) + AC_MSG_RESULT($glibcpp_cv_complex) + if test $glibcpp_cv_complex = buggy; then + AC_DEFINE(_GLIBCPP_BUGGY_COMPLEX) + fi +]) + + +dnl +dnl Check for certain special build configurations. +dnl +dnl GLIBCPP_ENABLE_DEBUG +dnl --enable-debug sets '-ggdb -O0'. +dnl --disable-debug sets '-g' and whatever optimization options the +dnl compiler can handle. +dnl + Perhaps --enable-maintainer-mode should automatically turn this on? +dnl + Perhaps -D/-U of NDEBUG, DEBUG, DEBUG_ASSERT, ...? +dnl + Usage: GLIBCPP_ENABLE_DEBUG[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +AC_DEFUN(GLIBCPP_ENABLE_DEBUG, [dnl +define([GLIBCPP_ENABLE_DEBUG_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(debug, +changequote(<<, >>)dnl +<< --enable-debug extra debugging, turn off optimization [default=>>GLIBCPP_ENABLE_DEBUG_DEFAULT], +changequote([, ])dnl +[case "$enableval" in + yes) enable_debug=yes ;; + no) enable_debug=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable extra debugging]) ;; + esac], +enable_debug=GLIBCPP_ENABLE_DEBUG_DEFAULT)dnl +dnl Option parsed, now set things appropriately +case "$enable_debug" in + yes) DEBUGFLAGS='-ggdb -O0' + ;; + no) DEBUGFLAGS='-g' + ;; +esac +AC_SUBST(DEBUGFLAGS) +]) + + +dnl +dnl Check for certain special build configurations. +dnl +dnl GLIBCPP_ENABLE_NAMESPACES +dnl --enable-namespaces sets '-fhonor-std' and defines _GLIBCPP_USE_NAMESPACES +dnl --disable-namespaces sets '-fno-honor-std' (the macro should be +dnl undefined by default in whatever.h.in). +dnl + Eventually, this will go away. +dnl + Usage: GLIBCPP_ENABLE_NAMESPACES[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +AC_DEFUN(GLIBCPP_ENABLE_NAMESPACES, [dnl +define([GLIBCPP_ENABLE_NAMESPACES_DEFAULT], ifelse($1, yes, yes, no))dnl +AC_ARG_ENABLE(namespaces, +changequote(<<, >>)dnl +<< --enable-namespaces turns on 'std' [default=>>GLIBCPP_ENABLE_NAMESPACES_DEFAULT], +changequote([, ])dnl +[case "$enableval" in + yes) enable_namespaces=yes ;; + no) enable_namespaces=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable namespaces]) ;; + esac], +enable_namespaces=GLIBCPP_ENABLE_NAMESPACES_DEFAULT)dnl +dnl Option parsed, now set things appropriately +case "$enable_namespaces" in + yes) NAMESPACES='-fhonor-std' + AC_DEFINE(_GLIBCPP_USE_NAMESPACES) + ;; + no) NAMESPACES='-fno-honor-std' + ;; +esac +AC_SUBST(NAMESPACES) +]) + + +dnl +dnl Check for instructions to automatically rebuild libgcc.a. Requires, +dnl of course, the location of the gcc objdir. Note that if --disable- +dnl namespaces is in effect, rebuilding libgcc.a is an expensive no-op. +dnl +dnl GLIBCPP_ENABLE_RELIBGCC +dnl --enable-libgcc-rebuild=/absolute/path/to/gcc/objdir sets GCC_OBJDIR +dnl (presumably in the top-level Makefile) to /absol.../objdir +dnl --disable-libgcc-rebuild will not touch libgcc.a at all (maybe print +dnl a warning if this is given along with --enable-namespaces), by +dnl setting GCC_OBJDIR to `no'. +dnl + Doing this by default is going to be interesting. What default +dnl "on" value can there be? +dnl + Usage: GLIBCPP_ENABLE_RELIBGCC[(DEFAULT)] +dnl The default path should be ../.. if bundled with GCC source. +dnl If ommitted, it defaults to `no'. +dnl +AC_DEFUN(GLIBCPP_ENABLE_RELIBGCC, [dnl +define([GLIBCPP_ENABLE_RELIBGCC_DEFAULT], ifelse($1,, no, $1))dnl +AC_ARG_ENABLE(libgcc-rebuild, +changequote(<<, >>)dnl +<< --enable-libgcc-rebuild=DIR also rebuild libgcc.a; DIR is + the GCC objdir; see install.html>>, +changequote([, ])dnl +[case "$enableval" in + yes) AC_MSG_ERROR([--enable-libgcc-rebuild needs a pathname]) ;; + no) enable_libgcc_rebuild=no ;; + *) if test -d "$enableval" && test -d "${enableval}/gcc" && \ + test -d "${enableval}/libiberty" + then + enable_libgcc_rebuild="$enableval" + else + AC_MSG_ERROR(["$enableval" does not appear to be the GCC objdir]) + fi + ;; + esac], +enable_libgcc_rebuild=GLIBCPP_ENABLE_RELIBGCC_DEFAULT)dnl +GCC_OBJDIR="$enable_libgcc_rebuild" +AC_SUBST(GCC_OBJDIR) +]) + + +dnl +dnl Check for certain special build configurations. +dnl +dnl GLIBCPP_ENABLE_CSTDIO +dnl --enable-cstdio=libio sets config/c_io_libio.h and friends +dnl +dnl default is libio +dnl +AC_DEFUN(GLIBCPP_ENABLE_CSTDIO, [ + AC_MSG_CHECKING([for cstdio to use]) + AC_ARG_ENABLE(cstdio, + [ --enable-cstdio enable GNU libio for target io package. (default) + --enable-cstdio=LIB use LIB target-speific io package.], + if test x$enable_cstdio = xno; then + enable_cstdio=libio + fi, + enable_cstdio=libio) + + enable_cstdio_flag=$enable_cstdio + + dnl Check if a valid thread package + case x${enable_cstdio_flag} in + xlibio | x | xno | xnone | xyes) + # default + CSTDIO_H=c_io_libio.h + CSTDIO_CC=c_io_libio.cc + AC_MSG_RESULT(libio) + + # see if we are on a system with libio native (ie, linux) + AC_CHECK_HEADER(libio.h, has_libio=yes, has_libio=no) + if test $has_libio = "yes"; then + BUILD_LIBIO_INCLUDE= + need_libio=no + else + BUILD_LIBIO_INCLUDE='-I../libio' + need_libio=yes + fi + AC_SUBST(BUILD_LIBIO_INCLUDE) + ;; + xwince) + CSTDIO_H=c_io_wince.h + CSTDIO_CC=c_io_wince.cc + AC_MSG_RESULT(wince) + + need_libio=no + BUILD_LIBIO_INCLUDE= + AC_SUBST(BUILD_LIBIO_INCLUDE) + ;; + *) + echo "$enable_cstdio is an unknown io package" 1>&2 + exit 1 + ;; + esac + AC_SUBST(CSTDIO_H) + AC_SUBST(CSTDIO_CC) + AM_CONDITIONAL(GLIBCPP_NEED_LIBIO, test "$need_libio" = yes) +]) + + +dnl +dnl Check for certain special build configurations. +dnl +dnl GLIBCPP_ENABLE_THREADS +dnl --enable-threads=posix sets config/threads-posix.h et. al. +dnl +dnl default is no threads +dnl +AC_DEFUN(GLIBCPP_ENABLE_THREADS, [ + dnl Note this comes from the gcc/config.in and libjava/config.in + dnl Efforts should be made to keep this in sync. + AC_MSG_CHECKING([for threads package to use]) + AC_ARG_ENABLE(threads, + [ --enable-threads enable thread usage for target GCC. + --enable-threads=LIB use LIB thread package for target GCC.], + if test x$enable_threads = xno; then + enable_threads='' + fi, + enable_threads='') + + enable_threads_flag=$enable_threads + + dnl Check if a valid thread package + case x${enable_threads_flag} in + x | xno | xnone) + # No threads + target_thread_file='single' + ;; + xyes) + # default + target_thread_file='' + ;; + xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \ + xsolaris | xwin32 | xdce | xvxworks) + target_thread_file=$enable_threads_flag + ;; + *) + echo "$enable_threads is an unknown thread package" 1>&2 + exit 1 + ;; + esac + + dnl Check for thread package actually supported in libstdc++ + case "$target_thread_file" in + no | none | single) + THREADS=none + ;; + posix | pthreads) + THREADS=posix + case "$host" in + *-*-linux*) + ;; + esac + ;; + decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks) + AC_MSG_ERROR(thread package $THREADS not yet supported) + ;; + *) + AC_MSG_ERROR($THREADS is an unknown thread package) + ;; + esac + AC_MSG_RESULT($THREADS) + + THREADLIBS= + THREADINCS= + THREADDEPS= + THREADOBJS= + THREADH= + THREADSPEC= + case "$THREADS" in + posix) + AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=]) + THREADLIBS=-lpthread + THREADSPEC=-lpthread + dnl Not presently used + dnl THREADOBJS=threads-posix.lo + THREADH=threads-posix.h + ;; + none) + dnl Not presently used + dnl THREADOBJS=threads-no.lo + THREADH=threads-no.h + ;; + esac + AC_SUBST(THREADLIBS) + AC_SUBST(THREADINCS) + AC_SUBST(THREADDEPS) + AC_SUBST(THREADOBJS) + AC_SUBST(THREADSPEC) +]) + + +dnl +dnl Check for certain special build configurations. +dnl +dnl GLIBCPP_ENABLE_LONG_LONG +dnl --enable-long-long defines _GLIBCPP_USE_LONG_LONG +dnl --disable-long-long leaves _GLIBCPP_USE_LONG_LONG undefined +dnl + Usage: GLIBCPP_ENABLE_LONG_LONG[(DEFAULT)] +dnl Where DEFAULT is either `yes' or `no'. If ommitted, it +dnl defaults to `no'. +dnl +dnl GLIBCPP_ENABLE_LONG_LONG +AC_DEFUN(GLIBCPP_ENABLE_LONG_LONG, [dnl + define([GLIBCPP_ENABLE_LONG_LONG_DEFAULT], ifelse($1, yes, yes, no))dnl + AC_ARG_ENABLE(long-long, + changequote(<<, >>)dnl + <<--enable-long_long turns on 'long long' [default=>>GLIBCPP_ENABLE_LONG_LONG_DEFAULT], + changequote([, ])dnl + [case "$enableval" in + yes) enable_long_long=yes ;; + no) enable_long_long=no ;; + *) AC_MSG_ERROR([Unknown argument to enable/disable long long]) ;; + esac], + enable_long_long=GLIBCPP_ENABLE_LONG_LONG_DEFAULT)dnl + dnl Option parsed, now set things appropriately + case "$enable_long_long" in + yes) AC_DEFINE(_GLIBCPP_USE_LONG_LONG) + ;; + esac +]) + + + + + + + + + + + + + +# Do all the work for Automake. This macro actually does too much -- +# some checks are only needed if your package does certain things. +# But this isn't really a big deal. + +# serial 1 + +dnl Usage: +dnl AM_INIT_AUTOMAKE(package,version, [no-define]) + +AC_DEFUN(AM_INIT_AUTOMAKE, +[AC_REQUIRE([AC_PROG_INSTALL]) +PACKAGE=[$1] +AC_SUBST(PACKAGE) +VERSION=[$2] +AC_SUBST(VERSION) +dnl test to see if srcdir already configured +if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) +fi +ifelse([$3],, +AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package]) +AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])) +AC_REQUIRE([AM_SANITY_CHECK]) +AC_REQUIRE([AC_ARG_PROGRAM]) +dnl FIXME This is truly gross. +missing_dir=`cd $ac_aux_dir && pwd` +AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir) +AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir) +AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir) +AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir) +AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir) +AC_REQUIRE([AC_PROG_MAKE_SET])]) + +# +# Check to make sure that the build environment is sane. +# + +AC_DEFUN(AM_SANITY_CHECK, +[AC_MSG_CHECKING([whether build environment is sane]) +# Just in case +sleep 1 +echo timestamp > conftestfile +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null` + if test "[$]*" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftestfile` + fi + if test "[$]*" != "X $srcdir/configure conftestfile" \ + && test "[$]*" != "X conftestfile $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken +alias in your environment]) + fi + + test "[$]2" = conftestfile + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +rm -f conftest* +AC_MSG_RESULT(yes)]) + +dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY) +dnl The program must properly implement --version. +AC_DEFUN(AM_MISSING_PROG, +[AC_MSG_CHECKING(for working $2) +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if ($2 --version) < /dev/null > /dev/null 2>&1; then + $1=$2 + AC_MSG_RESULT(found) +else + $1="$3/missing $2" + AC_MSG_RESULT(missing) +fi +AC_SUBST($1)]) + +# Add --enable-maintainer-mode option to configure. +# From Jim Meyering + +# serial 1 + +AC_DEFUN(AM_MAINTAINER_MODE, +[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) + dnl maintainer-mode is disabled by default + AC_ARG_ENABLE(maintainer-mode, +[ --enable-maintainer-mode enable make rules and dependencies not useful + (and sometimes confusing) to the casual installer], + USE_MAINTAINER_MODE=$enableval, + USE_MAINTAINER_MODE=no) + AC_MSG_RESULT($USE_MAINTAINER_MODE) + AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes) + MAINT=$MAINTAINER_MODE_TRUE + AC_SUBST(MAINT)dnl +] +) + +# Define a conditional. + +AC_DEFUN(AM_CONDITIONAL, +[AC_SUBST($1_TRUE) +AC_SUBST($1_FALSE) +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi]) + +# Check for functions in math library. +# Ulrich Drepper <drepper@cygnus.com>, 1998. +# +# This file can be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +# serial 1 + +dnl AC_REPLACE_MATHFUNCS(FUNCTION...) +AC_DEFUN(AC_REPLACE_MATHFUNCS, +[AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"]) +AC_SUBST(LIBMATHOBJS)dnl +]) + +# Check for string functions. +# Ulrich Drepper <drepper@cygnus.com>, 1998. +# +# This file can be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +# serial 1 + +dnl AC_REPLACE_STRINGFUNCS(FUNCTION...) +AC_DEFUN(AC_REPLACE_STRINGFUNCS, +[AC_CHECK_FUNCS([$1], , [LIBSTRINGOBJS="$LIBSTRINGOBJS ${ac_func}.lo"]) +AC_SUBST(LIBSTRINGOBJS)dnl +]) + + +# serial 40 AC_PROG_LIBTOOL +AC_DEFUN(AC_PROG_LIBTOOL, +[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl + +# Save cache, so that ltconfig can load it +AC_CACHE_SAVE + +# Actually configure libtool. ac_aux_dir is where install-sh is found. +CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \ +LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \ +LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \ +DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \ +${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \ +$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \ +|| AC_MSG_ERROR([libtool configure failed]) + +# Reload cache, that may have been modified by ltconfig +AC_CACHE_LOAD + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +# Redirect the config.log output again, so that the ltconfig log is not +# clobbered by the next message. +exec 5>>./config.log +]) + +AC_DEFUN(AC_LIBTOOL_SETUP, +[AC_PREREQ(2.13)dnl +AC_REQUIRE([AC_ENABLE_SHARED])dnl +AC_REQUIRE([AC_ENABLE_STATIC])dnl +AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([AC_PROG_RANLIB])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_LD])dnl +AC_REQUIRE([AC_PROG_NM])dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +dnl + +case "$target" in +NONE) lt_target="$host" ;; +*) lt_target="$target" ;; +esac + +# Check for any special flags to pass to ltconfig. +libtool_flags="--cache-file=$cache_file" +test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared" +test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static" +test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install" +test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc" +test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld" +ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN], +[libtool_flags="$libtool_flags --enable-dlopen"]) +ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL], +[libtool_flags="$libtool_flags --enable-win32-dll"]) +AC_ARG_ENABLE(libtool-lock, + [ --disable-libtool-lock avoid locking (might break parallel builds)]) +test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock" +test x"$silent" = xyes && libtool_flags="$libtool_flags --silent" + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case "$lt_target" in +*-*-irix6*) + # Find out which ABI we are using. + echo '[#]line __oline__ "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case "`/usr/bin/file conftest.o`" in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])]) + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; + +ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL], +[*-*-cygwin* | *-*-mingw*) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; +]) +esac +]) + +# AC_LIBTOOL_DLOPEN - enable checks for dlopen support +AC_DEFUN(AC_LIBTOOL_DLOPEN, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])]) + +# AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's +AC_DEFUN(AC_LIBTOOL_WIN32_DLL, [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])]) + +# AC_ENABLE_SHARED - implement the --enable-shared flag +# Usage: AC_ENABLE_SHARED[(DEFAULT)] +# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to +# `yes'. +AC_DEFUN(AC_ENABLE_SHARED, [dnl +define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE(shared, +changequote(<<, >>)dnl +<< --enable-shared[=PKGS] build shared libraries [default=>>AC_ENABLE_SHARED_DEFAULT], +changequote([, ])dnl +[p=${PACKAGE-default} +case "$enableval" in +yes) enable_shared=yes ;; +no) enable_shared=no ;; +*) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," + for pkg in $enableval; do + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$ac_save_ifs" + ;; +esac], +enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl +]) + +# AC_DISABLE_SHARED - set the default shared flag to --disable-shared +AC_DEFUN(AC_DISABLE_SHARED, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_SHARED(no)]) + +# AC_ENABLE_STATIC - implement the --enable-static flag +# Usage: AC_ENABLE_STATIC[(DEFAULT)] +# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to +# `yes'. +AC_DEFUN(AC_ENABLE_STATIC, [dnl +define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE(static, +changequote(<<, >>)dnl +<< --enable-static[=PKGS] build static libraries [default=>>AC_ENABLE_STATIC_DEFAULT], +changequote([, ])dnl +[p=${PACKAGE-default} +case "$enableval" in +yes) enable_static=yes ;; +no) enable_static=no ;; +*) + enable_static=no + # Look at the argument we got. We use all the common list separators. + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," + for pkg in $enableval; do + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$ac_save_ifs" + ;; +esac], +enable_static=AC_ENABLE_STATIC_DEFAULT)dnl +]) + +# AC_DISABLE_STATIC - set the default static flag to --disable-static +AC_DEFUN(AC_DISABLE_STATIC, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_STATIC(no)]) + + +# AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag +# Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)] +# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to +# `yes'. +AC_DEFUN(AC_ENABLE_FAST_INSTALL, [dnl +define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE(fast-install, +changequote(<<, >>)dnl +<< --enable-fast-install[=PKGS] optimize for fast installation [default=>>AC_ENABLE_FAST_INSTALL_DEFAULT], +changequote([, ])dnl +[p=${PACKAGE-default} +case "$enableval" in +yes) enable_fast_install=yes ;; +no) enable_fast_install=no ;; +*) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," + for pkg in $enableval; do + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$ac_save_ifs" + ;; +esac], +enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl +]) + +# AC_ENABLE_FAST_INSTALL - set the default to --disable-fast-install +AC_DEFUN(AC_DISABLE_FAST_INSTALL, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_FAST_INSTALL(no)]) + +# AC_PROG_LD - find the path to the GNU or non-GNU linker +AC_DEFUN(AC_PROG_LD, +[AC_ARG_WITH(gnu-ld, +[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]], +test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no) +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +ac_prog=ld +if test "$ac_cv_prog_gcc" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by GCC]) + ac_prog=`($CC -print-prog-name=ld) 2>&5` + case "$ac_prog" in + # Accept absolute paths. +changequote(,)dnl + [\\/]* | [A-Za-z]:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' +changequote([,])dnl + # Canonicalize the path of ld + ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(ac_cv_path_LD, +[if test -z "$LD"; then + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" + for ac_dir in $PATH; do + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + ac_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then + test "$with_gnu_ld" != no && break + else + test "$with_gnu_ld" != yes && break + fi + fi + done + IFS="$ac_save_ifs" +else + ac_cv_path_LD="$LD" # Let the user override the test with a path. +fi]) +LD="$ac_cv_path_LD" +if test -n "$LD"; then + AC_MSG_RESULT($LD) +else + AC_MSG_RESULT(no) +fi +test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) +AC_PROG_LD_GNU +]) + +AC_DEFUN(AC_PROG_LD_GNU, +[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld, +[# I'd rather use --version here, but apparently some GNU ld's only accept -v. +if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then + ac_cv_prog_gnu_ld=yes +else + ac_cv_prog_gnu_ld=no +fi]) +]) + +# AC_PROG_NM - find the path to a BSD-compatible name lister +AC_DEFUN(AC_PROG_NM, +[AC_MSG_CHECKING([for BSD-compatible nm]) +AC_CACHE_VAL(ac_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + ac_cv_path_NM="$NM" +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" + for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then + ac_cv_path_NM="$ac_dir/nm -B" + break + elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then + ac_cv_path_NM="$ac_dir/nm -p" + break + else + ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + fi + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm +fi]) +NM="$ac_cv_path_NM" +AC_MSG_RESULT([$NM]) +]) + +# AC_CHECK_LIBM - check for math library +AC_DEFUN(AC_CHECK_LIBM, +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case "$lt_target" in +*-*-beos* | *-*-cygwin*) + # These system don't have libm + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(m, main, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, main, LIBM="-lm") + ;; +esac +]) + +# AC_LIBLTDL_CONVENIENCE[(dir)] - sets LIBLTDL to the link flags for +# the libltdl convenience library, adds --enable-ltdl-convenience to +# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor +# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed +# to be `${top_builddir}/libltdl'. Make sure you start DIR with +# '${top_builddir}/' (note the single quotes!) if your package is not +# flat, and, if you're not using automake, define top_builddir as +# appropriate in the Makefiles. +AC_DEFUN(AC_LIBLTDL_CONVENIENCE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl + case "$enable_ltdl_convenience" in + no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;; + "") enable_ltdl_convenience=yes + ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;; + esac + LIBLTDL=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdlc.la + INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/libltdl']) +]) + +# AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for +# the libltdl installable library, and adds --enable-ltdl-install to +# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor +# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed +# to be `${top_builddir}/libltdl'. Make sure you start DIR with +# '${top_builddir}/' (note the single quotes!) if your package is not +# flat, and, if you're not using automake, define top_builddir as +# appropriate in the Makefiles. +# In the future, this macro may have to be called after AC_PROG_LIBTOOL. +AC_DEFUN(AC_LIBLTDL_INSTALLABLE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl + AC_CHECK_LIB(ltdl, main, + [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no], + [if test x"$enable_ltdl_install" = xno; then + AC_MSG_WARN([libltdl not installed, but installation disabled]) + else + enable_ltdl_install=yes + fi + ]) + if test x"$enable_ltdl_install" = x"yes"; then + ac_configure_args="$ac_configure_args --enable-ltdl-install" + LIBLTDL=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdl.la + INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/libltdl']) + else + ac_configure_args="$ac_configure_args --enable-ltdl-install=no" + LIBLTDL="-lltdl" + INCLTDL= + fi +]) + +dnl old names +AC_DEFUN(AM_PROG_LIBTOOL, [indir([AC_PROG_LIBTOOL])])dnl +AC_DEFUN(AM_ENABLE_SHARED, [indir([AC_ENABLE_SHARED], $@)])dnl +AC_DEFUN(AM_ENABLE_STATIC, [indir([AC_ENABLE_STATIC], $@)])dnl +AC_DEFUN(AM_DISABLE_SHARED, [indir([AC_DISABLE_SHARED], $@)])dnl +AC_DEFUN(AM_DISABLE_STATIC, [indir([AC_DISABLE_STATIC], $@)])dnl +AC_DEFUN(AM_PROG_LD, [indir([AC_PROG_LD])])dnl +AC_DEFUN(AM_PROG_NM, [indir([AC_PROG_NM])])dnl + +dnl This is just to silence aclocal about the macro not being used +ifelse([AC_DISABLE_FAST_INSTALL])dnl + +# Like AC_CONFIG_HEADER, but automatically create stamp file. + +AC_DEFUN(AM_CONFIG_HEADER, +[AC_PREREQ([2.12]) +AC_CONFIG_HEADER([$1]) +dnl When config.status generates a header, we must update the stamp-h file. +dnl This file resides in the same directory as the config header +dnl that is generated. We must strip everything past the first ":", +dnl and everything past the last "/". +AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl +ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>, +<<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>, +<<am_indx=1 +for am_file in <<$1>>; do + case " <<$>>CONFIG_HEADERS " in + *" <<$>>am_file "*<<)>> + echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx + ;; + esac + am_indx=`expr "<<$>>am_indx" + 1` +done<<>>dnl>>) +changequote([,]))]) + +# Check whether LC_MESSAGES is available in <locale.h>. +# Ulrich Drepper <drepper@cygnus.com>, 1995. +# +# This file file be copied and used freely without restrictions. It can +# be used in projects which are not available under the GNU Public License +# but which still want to provide support for the GNU gettext functionality. +# Please note that the actual code is *not* freely available. + +# serial 1 + +AC_DEFUN(AC_LC_MESSAGES, + [if test $ac_cv_header_locale_h = yes; then + AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES, + [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES], + ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)]) + if test $ac_cv_val_LC_MESSAGES = yes; then + AC_DEFINE(HAVE_LC_MESSAGES) + fi + fi]) + |