AC_MSG_NOTICE([OS config directory is $os_include_dir])
])
-
-dnl
-dnl Initialize basic configure bits.
-dnl
-dnl Substs:
-dnl multi_basedir
-dnl
-AC_DEFUN([GLIBCXX_TOPREL_CONFIGURE], [
- # Sets up multi_basedir, which is srcdir/.. plus the usual
- # "multi_source_toprel_bottom_adjust" lunacy as needed.
- AM_ENABLE_MULTILIB(, ..)
-
- # The generated code is exactly the same, except that automake's looks in
- # ".. $srcdir/.." and autoconf's looks in multi_basedir. Apparently other
- # things are triggered on the presence of the two ...AUX_DIR[S], but I don't
- # know what they are or what the other differences might be (and they keep
- # changing anyhow).
- #
- # Looking in multi_basedir seems smarter, so actually execute that branch.
- if false; then
- # this is for automake
- AC_CONFIG_AUX_DIR(..)
- else
- # this is for autoconf
- AC_CONFIG_AUX_DIRS(${multi_basedir})
- fi
-
- dnl XXX Turn this on.
- dnl AC_LANG_CPLUSPLUS
-])
-
-
dnl
dnl Initialize the rest of the library configury. At this point we have
dnl variables like $host.
dnl
dnl Sets:
-dnl gcc_version (x.y.z format)
dnl SUBDIRS
dnl Substs:
dnl glibcxx_builddir (absolute path)
AC_SUBST(CFLAGS)
AC_SUBST(CXXFLAGS)
- # For directory versioning (e.g., headers) and other variables.
- AC_MSG_CHECKING([for GCC version number])
- gcc_version=`$CXX -dumpversion`
- AC_MSG_RESULT($gcc_version)
-
# Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
# available). Uncomment the next line to force a particular method.
AC_PROG_LN_S
## (Right now, this only matters for enable_wchar_t, but nothing prevents
## other macros from doing the same. This should be automated.) -pme
need_libmath=no
- enable_wchar_t=no
- #enable_libstdcxx_debug=no
- #enable_libstdcxx_pch=no
- #enable_cheaders=c
- #c_compatibility=no
- #enable_abi_check=no
- #enable_symvers=no
- #enable_hosted_libstdcxx=yes
# Find platform-specific directories containing configuration info.
# Also possibly modify flags used elsewhere, as needed by the platform.
])
-m4_include([linkage.m4])
-m4_include([../config/no-executables.m4])
-
-
dnl
dnl Tests for newer compiler features, or features that are present in newer
dnl compiler versions but not older compiler versions still in use, should
dnl
-dnl Check to see if this target can enable the wchar_t parts.
-dnl If --disable-c-mbchar was given, no wchar_t stuff is enabled. (This
-dnl must have been previously checked.) By default, wide characters are
-dnl disabled.
+dnl Check to see if this target can enable the iconv specializations.
+dnl If --disable-c-mbchar was given, no wchar_t specialization is enabled.
+dnl (This must have been previously checked, along with the rest of C99
+dnl support.) By default, iconv support is disabled.
dnl
dnl Defines:
-dnl HAVE_MBSTATE_T if mbstate_t is not in wchar.h
-dnl _GLIBCXX_USE_WCHAR_T if all the bits are found.
+dnl _GLIBCXX_USE_ICONV if all the bits are found.
+dnl Substs:
+dnl LIBICONV to a -l string containing the iconv library, if needed.
dnl
-AC_DEFUN([GLIBCXX_CHECK_WCHAR_T_SUPPORT], [
- # Test wchar.h for mbstate_t, which is needed for char_traits and
- # others even if wchar_t support is not on.
- AC_MSG_CHECKING([for mbstate_t])
- AC_TRY_COMPILE([#include <wchar.h>],
- [mbstate_t teststate;],
- have_mbstate_t=yes, have_mbstate_t=no)
- AC_MSG_RESULT($have_mbstate_t)
- if test x"$have_mbstate_t" = xyes; then
- AC_DEFINE(HAVE_MBSTATE_T)
- fi
-
- # Sanity check for existence of ISO C99 headers for extended encoding.
- AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
- AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+AC_DEFUN([GLIBCXX_CHECK_ICONV_SUPPORT], [
+ enable_iconv=no
# Only continue checking if the ISO C99 headers exist and support is on.
- if test x"$ac_has_wchar_h" = xyes &&
- test x"$ac_has_wctype_h" = xyes &&
- test x"$enable_c_mbchar" != xno; then
-
- # Test wchar.h for WCHAR_MIN, WCHAR_MAX, which is needed before
- # 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)
-
- # Test wchar.h for WEOF, which is what we use to determine whether
- # to specialize for char_traits<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)
-
- # Tests for wide character functions used in char_traits<wchar_t>.
- ac_wfuncs=yes
- AC_CHECK_FUNCS([wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset],
- [],[ac_wfuncs=no])
-
- # Checks for names injected into std:: by the c_std headers.
- AC_CHECK_FUNCS([btowc wctob fgetwc fgetws fputwc fputws fwide \
- fwprintf fwscanf swprintf swscanf vfwprintf vswprintf \
- vwprintf wprintf wscanf getwc getwchar mbsinit mbrlen mbrtowc \
- mbsrtowcs wcsrtombs putwc putwchar ungetwc wcrtomb wcstod wcstol \
- wcstoul wcscpy wcsncpy wcscat wcsncat wcscmp wcscoll wcsncmp wcsxfrm \
- wcscspn wcsspn wcstok wcsftime wcschr wcspbrk wcsrchr wcsstr],
- [],[ac_wfuncs=no])
-
- # Checks for wide character functions that are not required
- # for basic wchar_t support. Don't disable support if they are missing.
- # Injection of these is wrapped with guard macros.
- AC_CHECK_FUNCS([vfwscanf vswscanf vwscanf wcstof iswblank],[],[])
-
- AC_MSG_CHECKING([for ISO C99 wchar_t support])
- if test x"$has_weof" = xyes &&
- test x"$has_wchar_minmax" = xyes &&
- test x"$ac_wfuncs" = xyes;
- then
- ac_isoC99_wchar_t=yes
- else
- ac_isoC99_wchar_t=no
- fi
- AC_MSG_RESULT($ac_isoC99_wchar_t)
+ if test x"$enable_wchar_t" = xyes; then
# Use iconv for wchar_t to char conversions. As such, check for
# X/Open Portability Guide, version 2 features (XPG2).
AC_CHECK_HEADER(langinfo.h, ac_has_langinfo_h=yes, ac_has_langinfo_h=no)
# Check for existence of libiconv.a providing XPG2 wchar_t support.
- AC_CHECK_LIB(iconv, iconv, libiconv="-liconv")
+ AC_CHECK_LIB(iconv, iconv, LIBICONV="-liconv")
ac_save_LIBS="$LIBS"
- LIBS="$LIBS $libiconv"
+ LIBS="$LIBS $LIBICONV"
+ AC_SUBST(LIBICONV)
AC_CHECK_FUNCS([iconv_open iconv_close iconv nl_langinfo],
[ac_XPG2funcs=yes], [ac_XPG2funcs=no])
LIBS="$ac_save_LIBS"
- AC_MSG_CHECKING([for XPG2 wchar_t support])
if test x"$ac_has_iconv_h" = xyes &&
test x"$ac_has_langinfo_h" = xyes &&
test x"$ac_XPG2funcs" = xyes;
then
- ac_XPG2_wchar_t=yes
- else
- ac_XPG2_wchar_t=no
- fi
- AC_MSG_RESULT($ac_XPG2_wchar_t)
-
- # At the moment, only enable wchar_t specializations if all the
- # above support is present.
- if test x"$ac_isoC99_wchar_t" = xyes &&
- test x"$ac_XPG2_wchar_t" = xyes;
- then
- AC_DEFINE(_GLIBCXX_USE_WCHAR_T)
- enable_wchar_t=yes
+ AC_DEFINE([_GLIBCXX_USE_ICONV],1,
+ [Define if iconv and related functions exist and are usable.])
+ enable_iconv=yes
fi
fi
- AC_MSG_CHECKING([for enabled wchar_t specializations])
- AC_MSG_RESULT($enable_wchar_t)
+ AC_MSG_CHECKING([for enabled iconv specializations])
+ AC_MSG_RESULT($enable_iconv)
])
dnl Used only in testsuite_hooks.h. Called from GLIBCXX_CONFIGURE_TESTSUITE.
dnl
dnl Defines:
-dnl _GLIBCXX_MEM_LIMITS if we can set artificial limits on memory
-dnl various HAVE_MEMLIMIT_* for individual limit names
+dnl _GLIBCXX_RES_LIMITS if we can set artificial resource limits
+dnl various HAVE_LIMIT_* for individual limit names
dnl
AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
AC_TRY_COMPILE(
],
[ int f = RLIMIT_$1 ; ],
[glibcxx_mresult=1], [glibcxx_mresult=0])
- AC_DEFINE_UNQUOTED(HAVE_MEMLIMIT_$1, $glibcxx_mresult,
+ AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
[Only used in build directory testsuite_hooks.h.])
])
GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
+ GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
# Check for rlimit, setrlimit.
AC_CACHE_VAL(ac_setrlimit, [
])
fi
- AC_MSG_CHECKING([for testsuite memory limit support])
+ AC_MSG_CHECKING([for testsuite resource limits support])
if test $setrlimit_have_headers = yes && test $ac_setrlimit = yes; then
- ac_mem_limits=yes
- AC_DEFINE(_GLIBCXX_MEM_LIMITS)
+ ac_res_limits=yes
+ AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
+ [Define if using setrlimit to set resource limits during
+ "make check"])
else
- ac_mem_limits=no
+ ac_res_limits=no
fi
- AC_MSG_RESULT($ac_mem_limits)
+ AC_MSG_RESULT($ac_res_limits)
])
[glibcxx_cv_S_IFREG=no])
])
if test $glibcxx_cv_S_ISREG = yes; then
- AC_DEFINE(HAVE_S_ISREG)
+ AC_DEFINE(HAVE_S_ISREG, 1,
+ [Define if S_IFREG is available in <sys/stat.h>.])
elif test $glibcxx_cv_S_IFREG = yes; then
- AC_DEFINE(HAVE_S_IFREG)
+ AC_DEFINE(HAVE_S_IFREG, 1,
+ [Define if S_IFREG is available in <sys/stat.h>.])
fi
])
[glibcxx_cv_POLL=no])
])
if test $glibcxx_cv_POLL = yes; then
- AC_DEFINE(HAVE_POLL)
+ AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
fi
])
[glibcxx_cv_WRITEV=no])
])
if test $glibcxx_cv_WRITEV = yes; then
- AC_DEFINE(HAVE_WRITEV)
+ AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
fi
])
[glibcxx_cv_INT64_T=no])
])
if test $glibcxx_cv_INT64_T = yes; then
- AC_DEFINE(HAVE_INT64_T)
+ AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
fi
])
AC_TRY_LINK(
[#include <unistd.h>
#include <stdio.h>
+ #include <sys/stat.h>
],
[FILE* fp;
fopen64("t", "w");
fseeko64(fp, 0, SEEK_CUR);
ftello64(fp);
- lseek64(1, 0, SEEK_CUR);],
+ lseek64(1, 0, SEEK_CUR);
+ struct stat64 buf;
+ fstat64(1, &buf);],
[glibcxx_cv_LFS=yes],
[glibcxx_cv_LFS=no])
])
if test $glibcxx_cv_LFS = yes; then
- AC_DEFINE(_GLIBCXX_USE_LFS)
+ AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
fi
CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
dnl
+dnl Check for whether a fully dynamic basic_string implementation should
+dnl be turned on, that does not put empty objects in per-process static
+dnl memory (mostly useful together with shared memory allocators, see PR
+dnl libstdc++/16612 for details).
+dnl
+dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING
+dnl --disable-fully-dynamic-string leaves _GLIBCXX_FULLY_DYNAMIC_STRING undefined
+dnl + Usage: GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
+dnl Where DEFAULT is either `yes' or `no'.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
+ GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
+ if test $enable_fully_dynamic_string = yes; then
+ AC_DEFINE(_GLIBCXX_FULLY_DYNAMIC_STRING, 1,
+ [Define if a fully dynamic basic_string is wanted.])
+ fi
+])
+
+
+dnl
dnl Does any necessary configuration of the testsuite directory. Generates
dnl the testsuite_hooks.h header.
dnl
dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
dnl
dnl Sets:
-dnl enable_abi_check / GLIBCXX_TEST_ABI
+dnl enable_abi_check
+dnl GLIBCXX_TEST_WCHAR_T
+dnl GLIBCXX_TEST_THREAD
dnl Substs:
dnl baseline_dir
dnl
AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
- if $GLIBCXX_IS_NATIVE && test $is_hosted = yes; then
- # Do checks for memory limit functions.
+ if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
+ test $enable_symvers != no; then
+ # Do checks for resource limit functions.
GLIBCXX_CHECK_SETRLIMIT
# Look for setenv, so that extended locale tests can be performed.
# CXX_FOR_BUILD.
enable_abi_check=no
fi
-
+
# Export file names for ABI checking.
baseline_dir="$glibcxx_srcdir/config/abi/${abi_baseline_pair}\$(MULTISUBDIR)"
AC_SUBST(baseline_dir)
-
- GLIBCXX_CONDITIONAL(GLIBCXX_TEST_WCHAR_T, test $enable_wchar_t = yes)
- GLIBCXX_CONDITIONAL(GLIBCXX_TEST_ABI, test $enable_abi_check = yes)
])
OPTIMIZE_CXXFLAGS=
AC_SUBST(OPTIMIZE_CXXFLAGS)
- WARN_FLAGS='-Wall -W -Wwrite-strings -Wcast-qual'
+ WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual'
AC_SUBST(WARN_FLAGS)
])
# Default case for install directory for include files.
if test $version_specific_libs = no && test $gxx_include_dir = no; then
- gxx_include_dir='${prefix}'/include/c++/${gcc_version}
+ gxx_include_dir='${prefix}/include/c++/${gcc_version}'
fi
# Version-specific runtime libs processing.
# is selected. FIXME: these variables are misnamed, there are
# no executables installed in _toolexecdir or _toolexeclibdir.
if test x"$gxx_include_dir" = x"no"; then
- gxx_include_dir='${libdir}/gcc/${host_alias}/'$gcc_version/include/c++
+ gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
fi
glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
- glibcxx_toolexeclibdir='${toolexecdir}/'$gcc_version'$(MULTISUBDIR)'
+ glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
fi
# Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
AC_DEFUN([GLIBCXX_ENABLE_C99], [
GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
+ # Test wchar.h for mbstate_t, which is needed for char_traits and fpos
+ # even if C99 support is turned off.
+ AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
+ AC_MSG_CHECKING([for mbstate_t])
+ AC_TRY_COMPILE([#include <wchar.h>],
+ [mbstate_t teststate;],
+ have_mbstate_t=yes, have_mbstate_t=no)
+ AC_MSG_RESULT($have_mbstate_t)
+ if test x"$have_mbstate_t" = xyes; then
+ AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
+ fi
+
+ if test x"$enable_c99" = x"yes"; then
+
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
# Check for the existence of <math.h> functions used if C99 is enabled.
- ac_c99_math=yes;
AC_MSG_CHECKING([for ISO C99 support in <math.h>])
- AC_TRY_COMPILE([#include <math.h>],[fpclassify(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isfinite(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isinf(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isnan(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isnormal(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[signbit(0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isgreater(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],
- [isgreaterequal(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[isless(0.0,0.0);],, [ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],[islessequal(0.0,0.0);],,[ac_c99_math=no])
- AC_TRY_COMPILE([#include <math.h>],
- [islessgreater(0.0,0.0);],, [ac_c99_math=no])
+ AC_CACHE_VAL(ac_c99_math, [
AC_TRY_COMPILE([#include <math.h>],
- [isunordered(0.0,0.0);],, [ac_c99_math=no])
+ [fpclassify(0.0);
+ isfinite(0.0);
+ isinf(0.0);
+ isnan(0.0);
+ isnormal(0.0);
+ signbit(0.0);
+ isgreater(0.0,0.0);
+ isgreaterequal(0.0,0.0);
+ isless(0.0,0.0);
+ islessequal(0.0,0.0);
+ islessgreater(0.0,0.0);
+ islessgreater(0.0,0.0);
+ isunordered(0.0,0.0);
+ ],[ac_c99_math=yes], [ac_c99_math=no])
+ ])
AC_MSG_RESULT($ac_c99_math)
-
if test x"$ac_c99_math" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_MATH)
+ AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
+ [Define if C99 functions or macros in <math.h> should be imported
+ in <cmath> in namespace std.])
+ fi
+
+ # Check for the existence of <complex.h> complex math functions.
+ # This is necessary even though libstdc++ uses the builtin versions
+ # of these functions, because if the builtin cannot be used, a reference
+ # to the library function is emitted.
+ AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
+ ac_c99_complex=no;
+ if test x"$ac_has_complex_h" = x"yes"; then
+ AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
+ AC_TRY_COMPILE([#include <complex.h>],
+ [typedef __complex__ float float_type; float_type tmpf;
+ cabsf(tmpf);
+ cargf(tmpf);
+ ccosf(tmpf);
+ ccoshf(tmpf);
+ cexpf(tmpf);
+ clogf(tmpf);
+ csinf(tmpf);
+ csinhf(tmpf);
+ csqrtf(tmpf);
+ ctanf(tmpf);
+ ctanhf(tmpf);
+ cpowf(tmpf, tmpf);
+ typedef __complex__ double double_type; double_type tmpd;
+ cabs(tmpd);
+ carg(tmpd);
+ ccos(tmpd);
+ ccosh(tmpd);
+ cexp(tmpd);
+ clog(tmpd);
+ csin(tmpd);
+ csinh(tmpd);
+ csqrt(tmpd);
+ ctan(tmpd);
+ ctanh(tmpd);
+ cpow(tmpd, tmpd);
+ typedef __complex__ long double ld_type; ld_type tmpld;
+ cabsl(tmpld);
+ cargl(tmpld);
+ ccosl(tmpld);
+ ccoshl(tmpld);
+ cexpl(tmpld);
+ clogl(tmpld);
+ csinl(tmpld);
+ csinhl(tmpld);
+ csqrtl(tmpld);
+ ctanl(tmpld);
+ ctanhl(tmpld);
+ cpowl(tmpld, tmpld);
+ ],[ac_c99_complex=yes], [ac_c99_complex=no])
+ fi
+ AC_MSG_RESULT($ac_c99_complex)
+ if test x"$ac_c99_complex" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
+ [Define if C99 functions in <complex.h> should be used in
+ <complex>. Using compiler builtins for these functions requires
+ corresponding C99 library functions to be present.])
fi
# Check for the existence in <stdio.h> of vscanf, et. al.
- ac_c99_stdio=yes;
AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
- AC_TRY_COMPILE([#include <stdio.h>],
- [snprintf("12", 0, "%i");],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vfscanf(stderr, "%i", args);}],
- [],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vscanf("%i", args);}],
- [],, [ac_c99_stdio=no])
- AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
- void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vsnprintf(fmt, 0, "%i", args);}],
- [],, [ac_c99_stdio=no])
+ AC_CACHE_VAL(ac_c99_stdio, [
AC_TRY_COMPILE([#include <stdio.h>
- #include <stdarg.h>
+ #include <stdarg.h>
void foo(char* fmt, ...)
- {va_list args; va_start(args, fmt);
- vsscanf(fmt, "%i", args);}],
- [],, [ac_c99_stdio=no])
+ {
+ va_list args; va_start(args, fmt);
+ vfscanf(stderr, "%i", args);
+ vscanf("%i", args);
+ vsnprintf(fmt, 0, "%i", args);
+ vsscanf(fmt, "%i", args);
+ }],
+ [snprintf("12", 0, "%i");],
+ [ac_c99_stdio=yes], [ac_c99_stdio=no])
+ ])
AC_MSG_RESULT($ac_c99_stdio)
# Check for the existence in <stdlib.h> of lldiv_t, et. al.
- ac_c99_stdlib=yes;
- AC_MSG_CHECKING([for lldiv_t declaration])
- AC_CACHE_VAL(ac_c99_lldiv_t, [
- AC_TRY_COMPILE([#include <stdlib.h>],
- [ lldiv_t mydivt;],
- [ac_c99_lldiv_t=yes], [ac_c99_lldiv_t=no])
- ])
- AC_MSG_RESULT($ac_c99_lldiv_t)
-
AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
+ AC_CACHE_VAL(ac_c99_stdlib, [
AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtof("gnu", &tmp);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtold("gnu", &tmp);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [llabs(10);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [lldiv(10,1);],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [atoll("10");],, [ac_c99_stdlib=no])
- AC_TRY_COMPILE([#include <stdlib.h>], [_Exit(0);],, [ac_c99_stdlib=no])
- if test x"$ac_c99_lldiv_t" = x"no"; then
- ac_c99_stdlib=no;
- fi;
+ [char* tmp;
+ strtof("gnu", &tmp);
+ strtold("gnu", &tmp);
+ strtoll("gnu", &tmp, 10);
+ strtoull("gnu", &tmp, 10);
+ llabs(10);
+ lldiv(10,1);
+ atoll("10");
+ _Exit(0);
+ lldiv_t mydivt;],[ac_c99_stdlib=yes], [ac_c99_stdlib=no])
+ ])
AC_MSG_RESULT($ac_c99_stdlib)
- # Check for the existence of <wchar.h> functions used if C99 is enabled.
- # XXX the wchar.h checks should be rolled into the general C99 bits.
- ac_c99_wchar=yes;
- AC_MSG_CHECKING([for additional ISO C99 support in <wchar.h>])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstold(L"10.0", NULL);],, [ac_c99_wchar=no])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstoll(L"10", NULL, 10);],, [ac_c99_wchar=no])
- AC_TRY_COMPILE([#include <wchar.h>],
- [wcstoull(L"10", NULL, 10);],, [ac_c99_wchar=no])
- AC_MSG_RESULT($ac_c99_wchar)
+ # Check for the existence in <wchar.h> of wcstoull, WEOF, etc.
+ AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
+ ac_c99_wchar=no;
+ if test x"$ac_has_wchar_h" = xyes &&
+ test x"$ac_has_wctype_h" = xyes; then
+ AC_TRY_COMPILE([#include <wchar.h>
+ #include <stddef.h>
+ wint_t i;
+ long l = WEOF;
+ long j = WCHAR_MIN;
+ long k = WCHAR_MAX;
+ namespace test
+ {
+ using ::btowc;
+ using ::fgetwc;
+ using ::fgetws;
+ using ::fputwc;
+ using ::fputws;
+ using ::fwide;
+ using ::fwprintf;
+ using ::fwscanf;
+ using ::getwc;
+ using ::getwchar;
+ using ::mbrlen;
+ using ::mbrtowc;
+ using ::mbsinit;
+ using ::mbsrtowcs;
+ using ::putwc;
+ using ::putwchar;
+ using ::swprintf;
+ using ::swscanf;
+ using ::ungetwc;
+ using ::vfwprintf;
+ using ::vswprintf;
+ using ::vwprintf;
+ using ::wcrtomb;
+ using ::wcscat;
+ using ::wcschr;
+ using ::wcscmp;
+ using ::wcscoll;
+ using ::wcscpy;
+ using ::wcscspn;
+ using ::wcsftime;
+ using ::wcslen;
+ using ::wcsncat;
+ using ::wcsncmp;
+ using ::wcsncpy;
+ using ::wcspbrk;
+ using ::wcsrchr;
+ using ::wcsrtombs;
+ using ::wcsspn;
+ using ::wcsstr;
+ using ::wcstod;
+ using ::wcstok;
+ using ::wcstol;
+ using ::wcstold;
+ using ::wcstoll;
+ using ::wcstoul;
+ using ::wcstoull;
+ using ::wcsxfrm;
+ using ::wctob;
+ using ::wmemchr;
+ using ::wmemcmp;
+ using ::wmemcpy;
+ using ::wmemmove;
+ using ::wmemset;
+ using ::wprintf;
+ using ::wscanf;
+ }
+ ],[],[ac_c99_wchar=yes], [ac_c99_wchar=no])
+
+ # Checks for wide character functions that may not be present.
+ # Injection of these is wrapped with guard macros.
+ # NB: only put functions here, instead of immediately above, if
+ # absolutely necessary.
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vfwscanf; } ], [],
+ [AC_DEFINE(HAVE_VFWSCANF,1,
+ [Defined if vfwscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vswscanf; } ], [],
+ [AC_DEFINE(HAVE_VSWSCANF,1,
+ [Defined if vswscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::vwscanf; } ], [],
+ [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
+
+ AC_TRY_COMPILE([#include <wchar.h>
+ namespace test { using ::wcstof; } ], [],
+ [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
+
+ AC_TRY_COMPILE([#include <wctype.h>],
+ [ wint_t t; int i = iswblank(t);],
+ [AC_DEFINE(HAVE_ISWBLANK,1,
+ [Defined if iswblank exists.])],[])
+
+ AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
+ AC_MSG_RESULT($ac_c99_wchar)
+ fi
- AC_MSG_CHECKING([for enabled ISO C99 support])
+ # Option parsed, now set things appropriately.
if test x"$ac_c99_math" = x"no" ||
+ test x"$ac_c99_complex" = x"no" ||
test x"$ac_c99_stdio" = x"no" ||
test x"$ac_c99_stdlib" = x"no" ||
test x"$ac_c99_wchar" = x"no"; then
enable_c99=no;
- fi;
- AC_MSG_RESULT($enable_c99)
-
- if test x"$ac_99_math" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99_MATH)
- fi
-
- # Option parsed, now set things appropriately
- if test x"$enable_c99" = x"yes"; then
- AC_DEFINE(_GLIBCXX_USE_C99)
+ else
+ AC_DEFINE(_GLIBCXX_USE_C99, 1,
+ [Define if C99 functions or macros from <wchar.h>, <math.h>,
+ <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
fi
AC_LANG_RESTORE
+ fi
+
+ AC_MSG_CHECKING([for fully enabled ISO C99 support])
+ AC_MSG_RESULT($enable_c99)
])
# Probe for locale support if no specific model is specified.
# Default to "generic".
if test $enable_clocale_flag = auto; then
- case x${target_os} in
- xlinux* | xgnu* | xkfreebsd*-gnu | xknetbsd*-gnu)
+ case ${target_os} in
+ linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
AC_EGREP_CPP([_GLIBCXX_ok], [
#include <features.h>
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
], enable_clocale_flag=gnu, enable_clocale_flag=generic)
# Test for bugs early in glibc-2.2.x series
- if test x$enable_clocale_flag = xgnu; then
+ if test $enable_clocale_flag = gnu; then
AC_TRY_RUN([
#define _GNU_SOURCE 1
#include <locale.h>
# ... at some point put __strxfrm_l tests in as well.
;;
+ darwin* | freebsd*)
+ enable_clocale_flag=darwin
+ ;;
*)
enable_clocale_flag=generic
;;
CLOCALE_H=config/locale/generic/c_locale.h
CLOCALE_CC=config/locale/generic/c_locale.cc
- CCODECVT_H=config/locale/generic/codecvt_specializations.h
CCODECVT_CC=config/locale/generic/codecvt_members.cc
CCOLLATE_CC=config/locale/generic/collate_members.cc
CCTYPE_CC=config/locale/generic/ctype_members.cc
CTIME_CC=config/locale/generic/time_members.cc
CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
;;
+ darwin)
+ AC_MSG_RESULT(darwin or freebsd)
+
+ CLOCALE_H=config/locale/generic/c_locale.h
+ CLOCALE_CC=config/locale/generic/c_locale.cc
+ CCODECVT_CC=config/locale/generic/codecvt_members.cc
+ CCOLLATE_CC=config/locale/generic/collate_members.cc
+ CCTYPE_CC=config/locale/darwin/ctype_members.cc
+ CMESSAGES_H=config/locale/generic/messages_members.h
+ CMESSAGES_CC=config/locale/generic/messages_members.cc
+ CMONEY_CC=config/locale/generic/monetary_members.cc
+ CNUMERIC_CC=config/locale/generic/numeric_members.cc
+ CTIME_H=config/locale/generic/time_members.h
+ CTIME_CC=config/locale/generic/time_members.cc
+ CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
+ ;;
+
gnu)
AC_MSG_RESULT(gnu)
CLOCALE_H=config/locale/gnu/c_locale.h
CLOCALE_CC=config/locale/gnu/c_locale.cc
- CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
CCODECVT_CC=config/locale/gnu/codecvt_members.cc
CCOLLATE_CC=config/locale/gnu/collate_members.cc
CCTYPE_CC=config/locale/gnu/ctype_members.cc
CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
- CCODECVT_H=config/locale/ieee_1003.1-2001/codecvt_specializations.h
CCODECVT_CC=config/locale/generic/codecvt_members.cc
CCOLLATE_CC=config/locale/generic/collate_members.cc
CCTYPE_CC=config/locale/generic/ctype_members.cc
AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
fi
if test $USE_NLS = yes; then
- AC_DEFINE(_GLIBCXX_USE_NLS)
+ AC_DEFINE(_GLIBCXX_USE_NLS, 1,
+ [Define if NLS translations are to be used.])
fi
AC_SUBST(USE_NLS)
AC_SUBST(CLOCALE_H)
- AC_SUBST(CCODECVT_H)
AC_SUBST(CMESSAGES_H)
AC_SUBST(CCODECVT_CC)
AC_SUBST(CCOLLATE_CC)
dnl Default is new.
dnl
AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
- AC_MSG_CHECKING([for std::allocator base class to use])
+ AC_MSG_CHECKING([for std::allocator base class])
GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
[use KIND for target std::allocator base],
- [permit new|malloc|mt|bitmap|yes|no|auto])
+ [permit new|malloc|mt|bitmap|pool|yes|no|auto])
+
# If they didn't use this option switch, or if they specified --enable
# with no specific model, we'll have to look for one. If they
# specified --disable (???), do likewise.
- if test $enable_libstdcxx_allocator = no || test $enable_libstdcxx_allocator = yes; then
+ if test $enable_libstdcxx_allocator = no ||
+ test $enable_libstdcxx_allocator = yes;
+ then
enable_libstdcxx_allocator=auto
fi
- # Either a known package, or "auto"
+ # Either a known package, or "auto". Auto implies the default choice
+ # for a particular platform.
enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
# Probe for host-specific support if no specific model is specified.
# Default to "new".
if test $enable_libstdcxx_allocator_flag = auto; then
case ${target_os} in
- freebsd*)
- enable_libstdcxx_allocator_flag=mt
- ;;
- hpux11*)
- enable_libstdcxx_allocator_flag=mt
- ;;
- irix6*)
- enable_libstdcxx_allocator_flag=mt
- ;;
linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
enable_libstdcxx_allocator_flag=mt
;;
- solaris*)
- enable_libstdcxx_allocator_flag=mt
- ;;
*)
enable_libstdcxx_allocator_flag=new
;;
ALLOCATOR_H=config/allocator/new_allocator_base.h
ALLOCATOR_NAME=__gnu_cxx::new_allocator
;;
+ pool)
+ ALLOCATOR_H=config/allocator/pool_allocator_base.h
+ ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
+ ;;
esac
AC_SUBST(ALLOCATOR_H)
AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
if test $enable_concept_checks = yes; then
- AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS)
+ AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
+ [Define to use concept checking code from the boost libraries.])
fi
])
dnl
-dnl Check for wide character support. Has the same effect as the option
-dnl in gcc's configure, but in a form that autoconf can mess with.
-dnl
-dnl --enable-c-mbchar requests all the wchar_t stuff.
-dnl --disable-c-mbchar doesn't.
-dnl + Usage: GLIBCXX_ENABLE_C_MBCHAR[(DEFAULT)]
-dnl Where DEFAULT is either `yes' or `no'.
-dnl
-AC_DEFUN([GLIBCXX_ENABLE_C_MBCHAR], [
- GLIBCXX_ENABLE(c-mbchar,$1,,[enable multibyte (wide) characters])
- # Option parsed, now other scripts can test enable_c_mbchar for yes/no.
-])
-
-
-dnl
dnl Check to see if debugging libraries are to be built.
dnl
dnl --enable-libstdcxx-debug
AC_ARG_ENABLE([hosted-libstdcxx],
AC_HELP_STRING([--disable-hosted-libstdcxx],
[only build freestanding C++ runtime support]),,
- [enable_hosted_libstdcxx=yes])
+ [case "$host" in
+ arm*-*-symbianelf*)
+ enable_hosted_libstdcxx=no
+ ;;
+ *)
+ enable_hosted_libstdcxx=yes
+ ;;
+ esac])
if test "$enable_hosted_libstdcxx" = no; then
AC_MSG_NOTICE([Only freestanding libraries will be built])
is_hosted=no
dnl
-dnl Check for template specializations for the 'long long' type extension.
+dnl Check for template specializations for the 'long long' type.
dnl The result determines only whether 'long long' I/O is enabled; things
dnl like numeric_limits<> specializations are always available.
dnl
dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
dnl + Usage: GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
dnl Where DEFAULT is either `yes' or `no'.
-dnl + If 'long long' stuff is not available, ignores DEFAULT and sets `no'.
dnl
AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
- GLIBCXX_ENABLE(long-long,$1,,[enables I/O support for 'long long'])
-
- AC_LANG_SAVE
- AC_LANG_CPLUSPLUS
-
- AC_MSG_CHECKING([for enabled long long I/O support])
- # iostreams require strtoll, strtoull to compile
- AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtoll("gnu", &tmp, 10);],,[enable_long_long=no])
- AC_TRY_COMPILE([#include <stdlib.h>],
- [char* tmp; strtoull("gnu", &tmp, 10);],,[enable_long_long=no])
-
- # Option parsed, now set things appropriately
+ GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
if test $enable_long_long = yes; then
- AC_DEFINE(_GLIBCXX_USE_LONG_LONG)
+ AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
+ [Define if code specialized for long long should be used.])
fi
- AC_MSG_RESULT($enable_long_long)
+ AC_MSG_CHECKING([for enabled long long specializations])
+ AC_MSG_RESULT([$enable_long_long])
+])
- AC_LANG_RESTORE
+
+dnl
+dnl Check for template specializations for the 'wchar_t' type.
+dnl
+dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
+dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
+dnl + Usage: GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
+dnl Where DEFAULT is either `yes' or `no'.
+dnl
+dnl Necessary support (probed along with C99 support) must also be present.
+dnl
+AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
+ GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
+ if test x"$ac_c99_wchar" = x"yes" && test x"$enable_wchar_t" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
+ [Define if code specialized for wchar_t should be used.])
+ fi
+ AC_MSG_CHECKING([for enabled wchar_t specializations])
+ AC_MSG_RESULT([$enable_wchar_t])
])
enable_sjlj_exceptions=yes
elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
enable_sjlj_exceptions=no
+ elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
+ enable_sjlj_exceptions=no
fi
fi
CXXFLAGS="$old_CXXFLAGS"
CFLAGS=' -lgcc_s'
AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
CFLAGS="$ac_save_CFLAGS"
+ if test $glibcxx_shared_libgcc = no; then
+ cat > conftest.c <<EOF
+int main (void) { return 0; }
+EOF
+changequote(,)dnl
+ glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
+ -shared -shared-libgcc -o conftest.so \
+ conftest.c -v 2>&1 >/dev/null \
+ | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
+changequote([,])dnl
+ rm -f conftest.c conftest.so
+ if test x${glibcxx_libgcc_s_suffix+set} = xset; then
+ CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
+ AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
+ CFLAGS="$ac_save_CFLAGS"
+ fi
+ fi
AC_MSG_RESULT($glibcxx_shared_libgcc)
fi
# For GNU ld, we need at least this version. The format is described in
# GLIBCXX_CHECK_LINKER_FEATURES above.
glibcxx_min_gnu_ld_version=21400
-# XXXXXXXXXXX glibcxx_gnu_ld_version=21390
# Check to see if unspecified "yes" value can win, given results above.
# Change "yes" into either "no" or a style name.
AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
if test $glibcxx_gnu_ld_version -ge 21200 ; then
# Globbing fix is present, proper block support is not.
- dnl AC_MSG_WARN([=== Dude, you are soooo close. Maybe we can fake it.])
- dnl enable_symvers=???
AC_MSG_WARN([=== Symbol versioning will be disabled.])
enable_symvers=no
else
;;
gnu)
SYMVER_MAP=config/linker-map.gnu
- AC_DEFINE(_GLIBCXX_SYMVER)
+ AC_DEFINE(_GLIBCXX_SYMVER, 1,
+ [Define to use symbol versioning in the shared library.])
;;
esac
+# In addition, need this to deal with std::size_t mangling in
+# src/compatibility.cc. In a perfect world, could use
+# typeid(std::size_t).name()[0] to do direct substitution.
+AC_MSG_CHECKING([for size_t as unsigned int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
+ [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_size_t_is_i" = yes; then
+ AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
+fi
+AC_MSG_RESULT([$glibcxx_size_t_is_i])
+
+AC_MSG_CHECKING([for ptrdiff_t as int])
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS="-Werror"
+AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
+ [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
+CFLAGS=$ac_save_CFLAGS
+if test "$glibcxx_ptrdiff_t_is_i" = yes; then
+ AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
+fi
+AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
+
AC_SUBST(SYMVER_MAP)
AC_SUBST(port_specific_symbol_files)
GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_VERSIONED_SHLIB, test $enable_symvers != no)
AC_MSG_RESULT([$target_thread_file])
if test $target_thread_file != single; then
- AC_DEFINE(HAVE_GTHR_DEFAULT)
+ AC_DEFINE(HAVE_GTHR_DEFAULT, 1,
+ [Define if gthr-default.h exists
+ (meaning that threading support is enabled).])
fi
glibcxx_thread_h=gthr-$target_thread_file.h
+
+ dnl Check for __GTHREADS define.
+ gthread_file=${toplevel_srcdir}/gcc/${glibcxx_thread_h}
+ if grep __GTHREADS $gthread_file >/dev/null 2>&1 ; then
+ enable_thread=yes
+ else
+ enable_thread=no
+ fi
+
AC_SUBST(glibcxx_thread_h)
])
[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)
+ AC_DEFINE(HAVE_LC_MESSAGES, 1,
+ [Define if LC_MESSAGES is available in <locale.h>.])
fi
])
])
-sinclude([../libtool.m4])
-dnl The lines below arrange for aclocal not to bring an installed
-dnl libtool.m4 into aclocal.m4, while still arranging for automake to
-dnl add a definition of LIBTOOL to Makefile.in.
-ifelse(,,,[AC_SUBST(LIBTOOL)
-AC_DEFUN([AM_PROG_LIBTOOL])
-AC_DEFUN([AC_LIBTOOL_DLOPEN])
-AC_DEFUN([AC_PROG_LD])
-])
-
dnl vim:et:ts=2:sw=2
OSDN Git Service
