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 ], [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 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 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 -- solaris 2.6 and 2.7 if test $ctype_default = "yes"; then AC_MSG_CHECKING([for solaris 2.6 or 2.7 ]) 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") 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 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 ], [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_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([ 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 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 ])