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, and if so, if any version- dnl specific precautions need to be taken. In particular, test for dnl newer compiler features, or features that are present in newer dnl compiler version but not older compiler versions should be placed dnl here. dnl dnl Define FMTFLAGS='-fdiagnostics-show-location=once' if possible dnl Define WERROR='-Werror' if possible; g++'s that lack the new inlining dnl code or the new system_header pragma will die. Other options dealing dnl with warnings, errors, and compiler complaints may be folded into dnl the WERROR variable. dnl dnl GLIBCPP_CHECK_COMPILER_VERSION AC_DEFUN(GLIBCPP_CHECK_COMPILER_VERSION, [ # All these tests are for C++; save the language and the compiler flags. # The CXXFLAGS thing is suspicious, but based on similar bits # found in GLIBCPP_CONFIGURE. AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_test_CXXFLAGS="${CXXFLAGS+set}" ac_save_CXXFLAGS="$CXXFLAGS" WERROR='-Werror' # Sanity check that g++ is capable of dealing with v-3. AC_MSG_CHECKING([for g++ that will successfully 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) # Check for pragma system_header. AC_MSG_CHECKING([for g++ that supports pragma system_header]) CXXFLAGS='-Wunknown-pragmas -Werror' AC_TRY_COMPILE([#pragma system_header], [int foo; ], [ac_newpragma=yes], [ac_newpragma=no]) if test "$ac_test_CXXFLAGS" = set; then CXXFLAGS="$ac_save_CXXFLAGS" else # this is the suspicious part CXXFLAGS='' fi if test "$ac_newpragma" = "no"; then WERROR="$WERROR -Wno-unknown-pragmas" fi AC_MSG_RESULT($ac_newpragma) # Check for more sophisticated diagnostic control. AC_MSG_CHECKING([for g++ that supports -fdiagnostics-show-location=once]) CXXFLAGS='-fdiagnostics-show-location=once' AC_TRY_COMPILE(, [int foo; ], [ac_gabydiags=yes], [ac_gabydiags=no]) if test "$ac_test_CXXFLAGS" = set; then CXXFLAGS="$ac_save_CXXFLAGS" else # this is the suspicious part CXXFLAGS='' fi if test "$ac_gabydiags" = "yes"; then FMTFLAGS='-fdiagnostics-show-location=once' fi AC_MSG_RESULT($ac_gabydiags) AC_LANG_RESTORE AC_SUBST(WERROR) AC_SUBST(FMTFLAGS) ]) 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 ], [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 ], [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 ], [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 ], [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 Check to see what architecture we are compiling for. If it's dnl supported, use special hand-crafted routines to provide thread dnl primitives. Also, if architecture-specific flags are required for dnl compilation, add them here. dnl dnl Depending on what is found, select configure/cpu/*/bits/atomicity.h dnl If not found, select configure/cpu/generic/bits/atomicity.h dnl dnl GLIBCPP_CHECK_CPU AC_DEFUN(GLIBCPP_CHECK_CPU, [ AC_MSG_CHECKING([for cpu primitives directory]) CPUFLAGS= case "$target_cpu" in alpha*) cpu_include_dir="config/cpu/alpha" ;; arm*) cpu_include_dir="config/cpu/arm" ;; i386) cpu_include_dir="config/cpu/i386" ;; i486 | i586 | i686 | i786) cpu_include_dir="config/cpu/i486" ;; powerpc | rs6000) cpu_include_dir="config/cpu/powerpc" CPUFLAGS='-mcpu=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) AC_SUBST(CPUFLAGS) ]) 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 functionality -- gnu-linux AC_MSG_CHECKING([ for gnu-linux ]) AC_TRY_COMPILE([#include ], [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 functionality -- FreeBSD 4.0 if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for freebsd 4.0 ]) AC_TRY_COMPILE([#include ], [int foo (int a) { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \ + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}], \ ctype_bsd=yes, ctype_bsd=no) AC_MSG_RESULT($ctype_bsd) if test $ctype_bsd = "yes"; then ctype_include_dir="config/bsd" ctype_default=no fi fi dnl Test for functionality -- FreeBSD 3.4 if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for freebsd 3.4 ]) AC_TRY_COMPILE([#include ], [int foo (int a) { return _S + _R + _C + _U + _L + _A \ + _D + _P + _X + _G + __istype (a, 0);}], \ ctype_freebsd34=yes, ctype_freebsd34=no) AC_MSG_RESULT($ctype_freebsd34) if test $ctype_freebsd34 = "yes"; then ctype_include_dir="config/bsd" ctype_default=no fi fi dnl Test for functionality -- solaris 2.6 and 2.7 if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for solaris 2.[6,7,8] ]) AC_TRY_COMPILE([#include ], [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 ], [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,8]") ctype_default=no fi fi fi dnl Test for functionality -- solaris 2.5.1 if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for solaris 2.5.1 ]) AC_TRY_COMPILE([#include ], [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 functionality -- aix if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for aix ]) AC_TRY_COMPILE([#include ], [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 functionality -- newlib if test $ctype_default = "yes"; then AC_MSG_CHECKING([ for newlib ]) AC_TRY_COMPILE([#include ], [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 long double functions. USE_LONG_DOUBLE=no AC_CHECK_FUNC(copysignl, 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 ], [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 AC_MSG_CHECKING([for WCHAR_MIN and WCHAR_MAX]) AC_TRY_COMPILE([#include ], [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 #include ], [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_SUBST(libinst_wstring_la) AC_MSG_CHECKING([for wide character support]) if test $has_weof = "yes" && test $has_wchar_minmax = "yes"; then libinst_wstring_la="libinst-wstring.la" AC_DEFINE(_GLIBCPP_USE_WCHAR_T) AC_MSG_RESULT(ok) else libinst_wstring_la="" AC_MSG_RESULT("not specializing for wchar_t") fi ],[ AC_MSG_WARN([ 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 <. 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 special debugging mode; not for production use. 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='-O0 -ggdb' ;; no) DEBUGFLAGS='-g' ;; esac AC_SUBST(DEBUGFLAGS) ]) dnl dnl Check for "unusual" flags to pass to the compiler while building. dnl dnl GLIBCPP_ENABLE_CXX_FLAGS dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing dnl experimental flags such as -fhonor-std, -fsquangle, -Dfloat=char, etc. dnl Somehow this same set of flags must be passed when [re]building dnl libgcc. dnl --disable-cxx-flags passes nothing. dnl + See http://sourceware.cygnus.com/ml/libstdc++/2000-q2/msg00131.html dnl http://sourceware.cygnus.com/ml/libstdc++/2000-q2/msg00284.html dnl http://sourceware.cygnus.com/ml/libstdc++/2000-q1/msg00035.html dnl + Usage: GLIBCPP_ENABLE_CXX_FLAGS(default flags) dnl If "default flags" is an empty string (or "none"), the effect is dnl the same as --disable or --enable=no. AC_DEFUN(GLIBCPP_ENABLE_CXX_FLAGS, [dnl define([GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], ifelse($1,,, $1))dnl AC_ARG_ENABLE(cxx-flags, changequote(<<, >>)dnl << --enable-cxx-flags=FLAGS pass compiler FLAGS when building library; [default=>>GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT], changequote([, ])dnl [case "x$enableval" in xyes) AC_MSG_ERROR([--enable-cxx-flags needs compiler flags as arguments]) ;; xno|x) enable_cxx_flags='' ;; *) enable_cxx_flags="$enableval" ;; esac], enable_cxx_flags='GLIBCPP_ENABLE_CXX_FLAGS_DEFAULT')dnl dnl Thinko on my part during design. This kludge is the workaround. if test "$enable_cxx_flags" = "none"; then enable_cxx_flags=''; fi dnl Run through flags (either default or command-line) and set anything dnl extra (e.g., #defines) that must accompany particular g++ options. if test -n "$enable_cxx_flags"; then for f in $enable_cxx_flags; do case "$f" in -fhonor-std) ;; -*) ;; *) # and we're trying to pass /what/ exactly? AC_MSG_ERROR([compiler flags start with a -]) ;; esac done fi EXTRA_CXX_FLAGS="$enable_cxx_flags" AC_SUBST(EXTRA_CXX_FLAGS) ]) 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 which I/O library to use: libio, or something specific. 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) # see if the _G_config.h header needs to be built. # NB: This replaces the _G_CONFIG_H machinery in libio-v2 AC_CHECK_HEADER(_G_config.h, has_gconf_h=yes, has_gconf_h=no) AM_CONDITIONAL(GLIBCPP_NEED_LIBIO_CONFIG_H, test "$has_gconf_h" = no) ;; 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 which threading library to use. 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 template specializations for the 'long long' type extension. 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 + If 'long long' stuff is not available, ignores DEFAULT and sets `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 # must do check_func outside the local msg_checking/msg_result AC_CHECK_FUNC(strtoll,,ac_ll=no) AC_MSG_CHECKING([for enabled long long]) 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 if test x"$ac_ll" = xno; then enable_long_long=no; fi; unset ac_ll AC_MSG_RESULT($enable_long_long) dnl Option parsed, now set things appropriately case "$enable_long_long" in yes) AC_DEFINE(_GLIBCPP_USE_LONG_LONG) ;; esac ]) dnl dnl Check for whether or not to do shadowed C headers. dnl dnl GLIBCPP_ENABLE_SHADOW dnl --enable-cshadow-headers [does stuff]. dnl --disable-cshadow-headers [does not do stuff]. dnl + This will eventually need to be on by default. dnl + Usage: GLIBCPP_ENABLE_SHADOW[(DEFAULT)] dnl Where DEFAULT is either `yes' or `no'. If ommitted, it dnl defaults to `no'. AC_DEFUN(GLIBCPP_ENABLE_SHADOW, [dnl define([GLIBCPP_ENABLE_SHADOW_DEFAULT], ifelse($1, yes, yes, no))dnl AC_MSG_CHECKING([for enabled cshadow headers]) AC_ARG_ENABLE(cshadow-headers, changequote(<<, >>)dnl << --enable-cshadow-headers construct "shadowed" C header files for g++ [default=>>GLIBCPP_ENABLE_SHADOW_DEFAULT], changequote([, ])dnl [case "$enableval" in yes) enable_cshadow_headers=yes ;; no) enable_cshadow_headers=no ;; *) AC_MSG_ERROR([Unknown argument to enable/disable shadowed C headers]) ;; esac], enable_cshadow_headers=GLIBCPP_ENABLE_SHADOW_DEFAULT)dnl AC_MSG_RESULT($enable_cshadow_headers) dnl Option parsed, now set things appropriately case "$enable_cshadow_headers" in yes) CSHADOWFLAGS="-D_ISOC9X_SOURCE" CSHADOW_INCLUDES=" -I$srcdir/shadow -I$blddir/cshadow" ;; no) CSHADOWFLAGS="" CSHADOW_INCLUDES="" ;; esac AC_SUBST(CSHADOWFLAGS) AC_SUBST(CSHADOW_INCLUDES) AM_CONDITIONAL(GLIBCPP_USE_CSHADOW, test "$enable_cshadow_headers" = yes) ]) # Check whether LC_MESSAGES is available in . # Ulrich Drepper , 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 ], [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]) # Check for functions in math library. # Ulrich Drepper , 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 , 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 ])