2000-04-21 Benjamin Kosnik <bkoz@redhat.com>

	* libstdc++-v3: New directory.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@33317 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 881 insertions, 0 deletions

diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4
new file mode 100644
index 00000000000..8b9a4547390
--- /dev/null
+++ b/libstdc++-v3/acinclude.m4
@@ -0,0 +1,881 @@
+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
+])
+
+
+
+
+
+
+
+
+
+
+
+