This is the mail archive of the
libstdc++@sourceware.cygnus.com
mailing list for the libstdc++ project.
Re: [patch] mkcshadow improvements
- To: "Benjamin Kosnik" <bkoz at cygnus dot com>
- Subject: Re: [patch] mkcshadow improvements
- From: "Anthony Williams" <anthony_w dot geo at yahoo dot com>
- Date: Tue, 16 May 2000 09:35:50 +0100
- Cc: <libstdc++ at sourceware dot cygnus dot com>,<ncm at zembu dot com>
- References: <Pine.LNX.4.10.10005151133390.20111-100000@decepticon.cygnus.com>
- Reply-To: "Anthony Williams" <anthony at anthonyw dot cjb dot net>
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
- - - ----- Original Message -----
From: Benjamin Kosnik <bkoz@cygnus.com>
>
> Anthony:
>
> Very interesting. Can I please move this to the libstdc++ list so
> that it gets archived? (Or can you cc the list if you respond to me
> please?)
CC'ed - I just didn't want to put a tarball in everyone's inbox.
> How did you generate these headers? And what version of solaris are
> you using?
I generated them manually for the ones with any content, using my
draft copy of the standard for the list of requirements. The ones
that just do namespace _C_Swamp{#include_next }, with the big GNU
copyright string were re-generated by Nathan's mkcshadow script (when
I had found it :), having previously been a cut-and-paste job.
Sparc-solaris-2.7
> Is there anyway you can give me a 'cvs diff -cp' of the include
> files, since there are so many files? I'm not quite sure how each
> individual header changed, and I'd like to be able to scope this
> via a diff.
I don't have CVS, but here's the output from "diff -r" against the
installed include directory (attached)
> Also, you and Nathan should work out the _C_swamp naming convention
> thing. Nathan, this name seems kind of silly, perhaps you could
> come up with something that is a bit more meaningful?
How about just _C_, seeing its purpose is to enclose the C headers
from the host environment, or is that reserved for something else?
>
> -benjamin
>
>
>
> On Mon, 15 May 2000, Anthony Williams wrote:
>
> > -----BEGIN PGP SIGNED MESSAGE-----
> > Hash: SHA1
> >
> > Benjamin,
> >
> > Attached is a tarball of the complete set of headers for my copy
> > of libstdc++, including all the standard C++ headers (iostream,
> > algorithm etc). This is because I ran against problems if they
> > weren't in the same directory (sub includes picked the wrong copy
> > of the shadowed headers)
> >
> > I currently cannot get the library to build, using these headers,
> > since some of the Solaris headers sub-include things like
> > stdio.h, inside extern "C" blocks, so the namespaces aren't at
> > global scope, as there aren't enough closing brackets to break
> > out of the top-level _C_Swamp namespace. ARGHHHH! Anyway, looking
> > at the headers, it appears that this only happens for C++ code,
> > due to a #ifdef _cplusplus, or somesuch, so I wonder if it would
> > break anything to #undef this (a bit naughty really, I know ;)
> > Alternatively, we could sub-include the same headers in the
> > shadow headers, so they are included in the correct scope, and
> > the include-guards will mask the second include. I haven't
> > checked how many times this occurs. Anyway, with this set of
> > headers, the only errors in the test suite occur where the test
> > suite assumes the symbol is at global scope, when it is now in
> > std::, or where it links against streambuf, since fpos_t is now
> > std::fpos_t, so the template names are different (hence the need
> > to rebuild the library, which currently isn't working), or where
> > there was already an error (21_strings, and a couple of others)
> >
> > Note that Nathan's mkcshadow program generates incorrect headers,
> > since the two _C_Swamp references don't match (one is _C_Swamp,
> > the other is _C_Swamp_ ), so I patched that first.
> >
> > Also required is a patch to the "new" header for gcc
> > ($PREFIX/lib/gcc-lib/sparc-solaris-2.7/2.96/include/new), so that
> > it uses std::size_t, which must be defined if not available, so
> > gcc will build. (diff below)
> >
> > Anthony
> >
> > diff ~awilliam/include/fixinc/new
> > $PREFIX/lib/gcc-lib/sparc-solaris-2.7/2.96/include/new
> > 15,18d14
> > < #ifndef _CPP_SIZE_T
> > < typedef ::size_t size_t;
> > < #endif
> > <
> > 32,33c28,29
> > < void *operator new (std::size_t) throw (std::bad_alloc);
> > < void *operator new[] (std::size_t) throw (std::bad_alloc);
> > - ---
> > > void *operator new (size_t) throw (std::bad_alloc);
> > > void *operator new[] (size_t) throw (std::bad_alloc);
> > 36,37c32,33
> > < void *operator new (std::size_t, const std::nothrow_t&)
> > throw(); < void *operator new[] (std::size_t, const
> > std::nothrow_t&) throw(); - ---
> > > void *operator new (size_t, const std::nothrow_t&) throw();
> > > void *operator new[] (size_t, const std::nothrow_t&) throw();
> > 42,43c38,39
> > < inline void *operator new(std::size_t, void *place) throw() {
> > return place; }
> > < inline void *operator new[](std::size_t, void *place) throw() {
> > return place; }
> > - ---
> > > inline void *operator new(size_t, void *place) throw() { return
> > > place; } inline void *operator new[](size_t, void *place)
> > > throw() { return place; }
> >
> > - ----- Original Message -----
> > From: Benjamin Kosnik <bkoz@cygnus.com>
> > To: <libstdc++@sourceware.cygnus.com>
> > Sent: 15 May 2000 07:30
> > Subject: Re: [patch] mkcshadow improvements
> >
> >
> > >
> > > Ok Nathan, I checked this in. I'm still interested in seeing
> > > the state of Anthony's work on solaris. Anthony, can you post
> > > what you have, even if it's a tarball?
> > >
> > > >Hmm, I can't agree. The "inclosure" script doesn't actually
> > >
> > > script == mk notation
> > >
> > > >make anything, it just generates a list of header names to
> > > >pipe into mkcshadow. In fact it probably could be integrated
> > > >into mkcshadow once we're confident that it's right. Maybe,
> > > >though, it would be better to save its output to a file in the
> > > >build directory, to make it easier to audit what it's up to.
> > >
> > > If it can be integrated, then do it and this issue will be
> > > moot. My preference is to save output to a file so that it's
> > > easier to see what all thse trickster scripts actually do.
> > >
> > > >Attached below is an improvement to mkcshadow, so it creates
> > > >cshadow/* in the build directory rather than the source
> > > >directory
> > >
> > > Yep. You shouldn't write into the source directory. This is
> > > easy to do in autoconf...
> > >
> > > > ../../../gcc/libstdc++-v3/inclosure \
> > > > -I ../../../v3/lib/gcc-lib/i686-pc-linux-gnu/2.96/include/
> > > > \
> > > > -I /usr/include \
> > > > -G machine/ansi.h \
> > > > | ../../../gcc/libstdc++-v3/mkcshadow
> > >
> > > Okay. Let me try to decipher what you've done:
> > >
> > > GCC_EXEC_PREFIX/include
> > > /usr/include
> > >
> > > but then what's the machine/ansi.h stuff, and how would this
> > > translate to solaris, for instance?
> > >
> > > >The appropriate "-I" arguments must be discovered by
> > > >configure, and the -G argument(s) depend on the target build
> > > >environment.
> > >
> > > Can you explain how configure is to discover them? At least
> > > what it should look for?
> > >
> > - -benjamin
> >
> > -----BEGIN PGP SIGNATURE-----
> > Version: PGPfreeware 6.5.1 for non-commercial use
> > <http://www.pgp.com>
> >
> > iQA/AwUBOR+7vpvw+P4cG5rVEQL58QCfcNb5hSCE9LMW+WpfNUQIn7bKC08AoOVE
> > 95JnyHYJUdb56SxpkMfzLvDJ
> > =DRyj
> > -----END PGP SIGNATURE-----
> >
> >
-----BEGIN PGP SIGNATURE-----
Version: PGPfreeware 6.5.1 for non-commercial use <http://www.pgp.com>
iQA/AwUBOSEIZZvw+P4cG5rVEQJZcgCfWkSQ2Geo/9mVYtyePktBAz6wXVwAnRWt
+CiMujHDEET4Bz8pZLJktE0f
=l2+T
-----END PGP SIGNATURE-----
Only in .: assert.h
Only in /work/egcs/include/g++-v3/: backward
Common subdirectories: ./bits and /work/egcs/include/g++-v3//bits
diff -r ./cassert /work/egcs/include/g++-v3//cassert
0a1
> // This one should not have include guards.
1a3
>
diff -r ./cctype /work/egcs/include/g++-v3//cctype
0a1
> #ifndef _CPP_CCTYPE
1a3
> #endif
diff -r ./cerrno /work/egcs/include/g++-v3//cerrno
0a1
> #ifndef _CPP_CERRNO
1a3
> #endif
diff -r ./cfloat /work/egcs/include/g++-v3//cfloat
0a1
> #ifndef _CPP_CFLOAT
1a3
> #endif
diff -r ./ciso646 /work/egcs/include/g++-v3//ciso646
0a1
> #ifndef _CPP_ISO646
1a3
> #endif
diff -r ./climits /work/egcs/include/g++-v3//climits
0a1
> #ifndef _CPP_CLIMITS
1a3
> #endif
diff -r ./clocale /work/egcs/include/g++-v3//clocale
0a1
> #ifndef _CPP_CLOCALE
1a3
> #endif
diff -r ./cmath /work/egcs/include/g++-v3//cmath
0a1
> #ifndef _CPP_CMATH
1a3
> #endif
diff -r ./csetjmp /work/egcs/include/g++-v3//csetjmp
0a1,2
>
> #ifndef _CPP_CSETJMP
1a4
> #endif
diff -r ./csignal /work/egcs/include/g++-v3//csignal
0a1,2
>
> #ifndef _CPP_CSIGNAL
1a4
> #endif
diff -r ./cstdarg /work/egcs/include/g++-v3//cstdarg
0a1,2
>
> #ifndef _CPP_CSTDARG
1a4
> #endif
diff -r ./cstddef /work/egcs/include/g++-v3//cstddef
0a1
> #ifndef _CPP_CSTDDEF
1a3
> #endif
diff -r ./cstdio /work/egcs/include/g++-v3//cstdio
0a1
> #ifndef _CPP_CSTDIO
1a3
> #endif
diff -r ./cstdlib /work/egcs/include/g++-v3//cstdlib
0a1
> #ifndef _CPP_CSTDLIB
1a3
> #endif
diff -r ./cstring /work/egcs/include/g++-v3//cstring
0a1
> #ifndef _CPP_CSTRING
1a3
> #endif
diff -r ./ctime /work/egcs/include/g++-v3//ctime
0a1
> #ifndef _CPP_CTIME
1a3
> #endif
Only in .: ctype.h
diff -r ./cwchar /work/egcs/include/g++-v3//cwchar
0a1
> #ifndef _CPP_CWCHAR
1a3
> #endif
diff -r ./cwctype /work/egcs/include/g++-v3//cwctype
0a1
> #ifndef _CPP_CWCTYPE
1a3
> #endif
Only in .: errno.h
Only in /work/egcs/include/g++-v3/: ext
Only in .: fcntl.h
Only in .: float.h
Only in .: floatingpoint.h
Only in .: iso646.h
Only in .: libintl.h
Only in /work/egcs/include/g++-v3/: libio.h
Only in .: limits.h
Only in .: locale.h
Only in .: math
Only in .: math.h
Only in .: pthread.h
Only in .: sched.h
Only in .: setjmp.h
Only in /work/egcs/include/g++-v3/: shadow
Only in .: signal.h
Only in .: stdarg.h
Only in .: stddef.h
Only in .: stdio.h
Only in .: stdio_impl.h
Only in .: stdio_tag.h
Only in .: stdlib.h
Only in .: string.h
Only in .: sys
Only in .: time.h
Only in .: v7
Only in .: varargs.h
Only in .: vm
Only in .: wchar.h
Only in .: wchar_impl.h
Only in .: wctype.h
diff -r ./bits/c++config.h /work/egcs/include/g++-v3//bits/c++config.h
66a67,638
> /* config.h. Generated automatically by configure. */
> /* config.h.in. Generated automatically from configure.in by autoheader. */
>
> /* Define if you have a working `mmap' system call. */
> #define _GLIBCPP_HAVE_MMAP 1
>
> // Include support for 'long long' and 'unsigned long long'.
> /* #undef _GLIBCPP_USE_LONG_LONG */
>
> // Define if the host has a type mbstate_t defined in
> // wchar.h, as required by 21.1.3.1. Some systems, namely
> // hppa-hp-hpux10.20 do not meet this requirement, and must be worked
> // around.
> /* #undef _GLIBCPP_NEED_MBSTATE_T */
>
> // Define if WCHAR_MIN and WCHAR_MAX are in the <cwchar_t>
> // header. Presently, this is needed so that solaris won't
> // instantitate numeric_limits<wchar_t>
> #define _GLIBCPP_HAS_WCHAR_MIN_MAX 1
>
> // Define if code specialized for wchar_t should be used.
> #define _GLIBCPP_USE_WCHAR_T 1
>
> // Define if the compiler/host combination has __builtin_sinf defined.
> #define _GLIBCPP_HAS_BUILTIN_SINF 1
>
> // Define if the compiler/host combination has __builtin_cosf defined.
> #define _GLIBCPP_HAS_BUILTIN_COSF 1
>
> // Define if the compiler/host combination has __builtin_fabsf defined.
> #define _GLIBCPP_HAS_BUILTIN_FABSF 1
>
> // Define if the compiler/host combination has __builtin_fabsf defined.
> #define _GLIBCPP_HAS_BUILTIN_SQRTF 1
>
> // Define if GCC support for __complex__ float is buggy.
> /* #undef _GLIBCPP_BUGGY_FLOAT_COMPLEX */
>
> // Define if GCC support for __complex__ is buggy.
> /* #undef _GLIBCPP_BUGGY_COMPLEX */
>
> // Define if LC_MESSAGES is available in <locale.h>.
> #define _GLIBCPP_HAVE_LC_MESSAGES 1
>
> // Define if <float.h> exists.
> #define _GLIBCPP_HAVE_FLOAT_H 1
>
> // Define if modf is present in <math.h>
> #define _GLIBCPP_HAVE_MODF 1
>
> /* Define if you have the _copysign function. */
> /* #undef _GLIBCPP_HAVE__COPYSIGN */
>
> /* Define if you have the _copysignl function. */
> /* #undef _GLIBCPP_HAVE__COPYSIGNL */
>
> /* Define if you have the _cosf function. */
> /* #undef _GLIBCPP_HAVE__COSF */
>
> /* Define if you have the _coshf function. */
> /* #undef _GLIBCPP_HAVE__COSHF */
>
> /* Define if you have the _fabsf function. */
> /* #undef _GLIBCPP_HAVE__FABSF */
>
> /* Define if you have the _finite function. */
> #define _GLIBCPP_HAVE__FINITE 1
>
> /* Define if you have the _finitef function. */
> /* #undef _GLIBCPP_HAVE__FINITEF */
>
> /* Define if you have the _fpclass function. */
> #define _GLIBCPP_HAVE__FPCLASS 1
>
> /* Define if you have the _isinf function. */
> /* #undef _GLIBCPP_HAVE__ISINF */
>
> /* Define if you have the _isinff function. */
> /* #undef _GLIBCPP_HAVE__ISINFF */
>
> /* Define if you have the _isinfl function. */
> /* #undef _GLIBCPP_HAVE__ISINFL */
>
> /* Define if you have the _isnan function. */
> #define _GLIBCPP_HAVE__ISNAN 1
>
> /* Define if you have the _isnanf function. */
> #define _GLIBCPP_HAVE__ISNANF 1
>
> /* Define if you have the _isnanl function. */
> /* #undef _GLIBCPP_HAVE__ISNANL */
>
> /* Define if you have the _log10f function. */
> /* #undef _GLIBCPP_HAVE__LOG10F */
>
> /* Define if you have the _logf function. */
> /* #undef _GLIBCPP_HAVE__LOGF */
>
> /* Define if you have the _modf function. */
> #define _GLIBCPP_HAVE__MODF 1
>
> /* Define if you have the _powf function. */
> /* #undef _GLIBCPP_HAVE__POWF */
>
> /* Define if you have the _qfinite function. */
> /* #undef _GLIBCPP_HAVE__QFINITE */
>
> /* Define if you have the _qfpclass function. */
> /* #undef _GLIBCPP_HAVE__QFPCLASS */
>
> /* Define if you have the _sincos function. */
> /* #undef _GLIBCPP_HAVE__SINCOS */
>
> /* Define if you have the _sincosf function. */
> /* #undef _GLIBCPP_HAVE__SINCOSF */
>
> /* Define if you have the _sincosl function. */
> /* #undef _GLIBCPP_HAVE__SINCOSL */
>
> /* Define if you have the _sinf function. */
> /* #undef _GLIBCPP_HAVE__SINF */
>
> /* Define if you have the _sinhf function. */
> /* #undef _GLIBCPP_HAVE__SINHF */
>
> /* Define if you have the _sqrtf function. */
> /* #undef _GLIBCPP_HAVE__SQRTF */
>
> /* Define if you have the _strtof function. */
> /* #undef _GLIBCPP_HAVE__STRTOF */
>
> /* Define if you have the _strtold function. */
> /* #undef _GLIBCPP_HAVE__STRTOLD */
>
> /* Define if you have the _tanf function. */
> /* #undef _GLIBCPP_HAVE__TANF */
>
> /* Define if you have the _tanhf function. */
> /* #undef _GLIBCPP_HAVE__TANHF */
>
> /* Define if you have the atan2f function. */
> /* #undef _GLIBCPP_HAVE_ATAN2F */
>
> /* Define if you have the c_log function. */
> /* #undef _GLIBCPP_HAVE_C_LOG */
>
> /* Define if you have the c_logf function. */
> /* #undef _GLIBCPP_HAVE_C_LOGF */
>
> /* Define if you have the c_logl function. */
> /* #undef _GLIBCPP_HAVE_C_LOGL */
>
> /* Define if you have the carg function. */
> /* #undef _GLIBCPP_HAVE_CARG */
>
> /* Define if you have the cargf function. */
> /* #undef _GLIBCPP_HAVE_CARGF */
>
> /* Define if you have the cargl function. */
> /* #undef _GLIBCPP_HAVE_CARGL */
>
> /* Define if you have the ccos function. */
> /* #undef _GLIBCPP_HAVE_CCOS */
>
> /* Define if you have the ccosf function. */
> /* #undef _GLIBCPP_HAVE_CCOSF */
>
> /* Define if you have the ccosh function. */
> /* #undef _GLIBCPP_HAVE_CCOSH */
>
> /* Define if you have the ccoshf function. */
> /* #undef _GLIBCPP_HAVE_CCOSHF */
>
> /* Define if you have the ccoshl function. */
> /* #undef _GLIBCPP_HAVE_CCOSHL */
>
> /* Define if you have the ccosl function. */
> /* #undef _GLIBCPP_HAVE_CCOSL */
>
> /* Define if you have the cexp function. */
> /* #undef _GLIBCPP_HAVE_CEXP */
>
> /* Define if you have the cexpf function. */
> /* #undef _GLIBCPP_HAVE_CEXPF */
>
> /* Define if you have the cexpl function. */
> /* #undef _GLIBCPP_HAVE_CEXPL */
>
> /* Define if you have the clog10 function. */
> /* #undef _GLIBCPP_HAVE_CLOG10 */
>
> /* Define if you have the clog10f function. */
> /* #undef _GLIBCPP_HAVE_CLOG10F */
>
> /* Define if you have the clog10l function. */
> /* #undef _GLIBCPP_HAVE_CLOG10L */
>
> /* Define if you have the copysign function. */
> #define _GLIBCPP_HAVE_COPYSIGN 1
>
> /* Define if you have the copysignf function. */
> /* #undef _GLIBCPP_HAVE_COPYSIGNF */
>
> /* Define if you have the copysignl function. */
> /* #undef _GLIBCPP_HAVE_COPYSIGNL */
>
> /* Define if you have the cosf function. */
> /* #undef _GLIBCPP_HAVE_COSF */
>
> /* Define if you have the coshf function. */
> /* #undef _GLIBCPP_HAVE_COSHF */
>
> /* Define if you have the cpow function. */
> /* #undef _GLIBCPP_HAVE_CPOW */
>
> /* Define if you have the cpowf function. */
> /* #undef _GLIBCPP_HAVE_CPOWF */
>
> /* Define if you have the cpowl function. */
> /* #undef _GLIBCPP_HAVE_CPOWL */
>
> /* Define if you have the csin function. */
> /* #undef _GLIBCPP_HAVE_CSIN */
>
> /* Define if you have the csinf function. */
> /* #undef _GLIBCPP_HAVE_CSINF */
>
> /* Define if you have the csinh function. */
> /* #undef _GLIBCPP_HAVE_CSINH */
>
> /* Define if you have the csinhf function. */
> /* #undef _GLIBCPP_HAVE_CSINHF */
>
> /* Define if you have the csinhl function. */
> /* #undef _GLIBCPP_HAVE_CSINHL */
>
> /* Define if you have the csinl function. */
> /* #undef _GLIBCPP_HAVE_CSINL */
>
> /* Define if you have the csqrt function. */
> /* #undef _GLIBCPP_HAVE_CSQRT */
>
> /* Define if you have the csqrtf function. */
> /* #undef _GLIBCPP_HAVE_CSQRTF */
>
> /* Define if you have the csqrtl function. */
> /* #undef _GLIBCPP_HAVE_CSQRTL */
>
> /* Define if you have the ctan function. */
> /* #undef _GLIBCPP_HAVE_CTAN */
>
> /* Define if you have the ctanf function. */
> /* #undef _GLIBCPP_HAVE_CTANF */
>
> /* Define if you have the ctanh function. */
> /* #undef _GLIBCPP_HAVE_CTANH */
>
> /* Define if you have the ctanhf function. */
> /* #undef _GLIBCPP_HAVE_CTANHF */
>
> /* Define if you have the ctanhl function. */
> /* #undef _GLIBCPP_HAVE_CTANHL */
>
> /* Define if you have the ctanl function. */
> /* #undef _GLIBCPP_HAVE_CTANL */
>
> /* Define if you have the expf function. */
> /* #undef _GLIBCPP_HAVE_EXPF */
>
> /* Define if you have the fabsf function. */
> /* #undef _GLIBCPP_HAVE_FABSF */
>
> /* Define if you have the finite function. */
> #define _GLIBCPP_HAVE_FINITE 1
>
> /* Define if you have the fpclass function. */
> #define _GLIBCPP_HAVE_FPCLASS 1
>
> /* Define if you have the fqfinite function. */
> /* #undef _GLIBCPP_HAVE_FQFINITE */
>
> /* Define if you have the getpagesize function. */
> #define _GLIBCPP_HAVE_GETPAGESIZE 1
>
> /* Define if you have the hypot function. */
> #define _GLIBCPP_HAVE_HYPOT 1
>
> /* Define if you have the hypotf function. */
> /* #undef _GLIBCPP_HAVE_HYPOTF */
>
> /* Define if you have the hypotl function. */
> /* #undef _GLIBCPP_HAVE_HYPOTL */
>
> /* Define if you have the isinf function. */
> /* #undef _GLIBCPP_HAVE_ISINF */
>
> /* Define if you have the isinff function. */
> /* #undef _GLIBCPP_HAVE_ISINFF */
>
> /* Define if you have the isinfl function. */
> /* #undef _GLIBCPP_HAVE_ISINFL */
>
> /* Define if you have the isnan function. */
> #define _GLIBCPP_HAVE_ISNAN 1
>
> /* Define if you have the isnanf function. */
> #define _GLIBCPP_HAVE_ISNANF 1
>
> /* Define if you have the isnanl function. */
> /* #undef _GLIBCPP_HAVE_ISNANL */
>
> /* Define if you have the log10f function. */
> /* #undef _GLIBCPP_HAVE_LOG10F */
>
> /* Define if you have the logf function. */
> /* #undef _GLIBCPP_HAVE_LOGF */
>
> /* Define if you have the modf function. */
> #define _GLIBCPP_HAVE_MODF 1
>
> /* Define if you have the nan function. */
> /* #undef _GLIBCPP_HAVE_NAN */
>
> /* Define if you have the powf function. */
> /* #undef _GLIBCPP_HAVE_POWF */
>
> /* Define if you have the qfpclass function. */
> /* #undef _GLIBCPP_HAVE_QFPCLASS */
>
> /* Define if you have the signbitl function. */
> /* #undef _GLIBCPP_HAVE_SIGNBITL */
>
> /* Define if you have the sincos function. */
> /* #undef _GLIBCPP_HAVE_SINCOS */
>
> /* Define if you have the sincosf function. */
> /* #undef _GLIBCPP_HAVE_SINCOSF */
>
> /* Define if you have the sincosl function. */
> /* #undef _GLIBCPP_HAVE_SINCOSL */
>
> /* Define if you have the sinf function. */
> /* #undef _GLIBCPP_HAVE_SINF */
>
> /* Define if you have the sinhf function. */
> /* #undef _GLIBCPP_HAVE_SINHF */
>
> /* Define if you have the sqrtf function. */
> /* #undef _GLIBCPP_HAVE_SQRTF */
>
> /* Define if you have the strtof function. */
> /* #undef _GLIBCPP_HAVE_STRTOF */
>
> /* Define if you have the strtold function. */
> /* #undef _GLIBCPP_HAVE_STRTOLD */
>
> /* Define if you have the tanf function. */
> /* #undef _GLIBCPP_HAVE_TANF */
>
> /* Define if you have the tanhf function. */
> /* #undef _GLIBCPP_HAVE_TANHF */
>
> /* Define if you have the wcslen function. */
> #define _GLIBCPP_HAVE_WCSLEN 1
>
> /* Define if you have the wmemchr function. */
> #define _GLIBCPP_HAVE_WMEMCHR 1
>
> /* Define if you have the wmemcmp function. */
> #define _GLIBCPP_HAVE_WMEMCMP 1
>
> /* Define if you have the wmemcpy function. */
> #define _GLIBCPP_HAVE_WMEMCPY 1
>
> /* Define if you have the wmemmove function. */
> #define _GLIBCPP_HAVE_WMEMMOVE 1
>
> /* Define if you have the wmemset function. */
> #define _GLIBCPP_HAVE_WMEMSET 1
>
> /* Define if you have the <complex.h> header file. */
> /* #undef _GLIBCPP_HAVE_COMPLEX_H */
>
> /* Define if you have the <endian.h> header file. */
> /* #undef _GLIBCPP_HAVE_ENDIAN_H */
>
> /* Define if you have the <float.h> header file. */
> #define _GLIBCPP_HAVE_FLOAT_H 1
>
> /* Define if you have the <fp.h> header file. */
> /* #undef _GLIBCPP_HAVE_FP_H */
>
> /* Define if you have the <ieeefp.h> header file. */
> #define _GLIBCPP_HAVE_IEEEFP_H 1
>
> /* Define if you have the <inttypes.h> header file. */
> #define _GLIBCPP_HAVE_INTTYPES_H 1
>
> /* Define if you have the <locale.h> header file. */
> #define _GLIBCPP_HAVE_LOCALE_H 1
>
> /* Define if you have the <machine/endian.h> header file. */
> /* #undef _GLIBCPP_HAVE_MACHINE_ENDIAN_H */
>
> /* Define if you have the <machine/param.h> header file. */
> /* #undef _GLIBCPP_HAVE_MACHINE_PARAM_H */
>
> /* Define if you have the <nan.h> header file. */
> #define _GLIBCPP_HAVE_NAN_H 1
>
> /* Define if you have the <sys/isa_defs.h> header file. */
> #define _GLIBCPP_HAVE_SYS_ISA_DEFS_H 1
>
> /* Define if you have the <sys/machine.h> header file. */
> /* #undef _GLIBCPP_HAVE_SYS_MACHINE_H */
>
> /* Define if you have the <unistd.h> header file. */
> #define _GLIBCPP_HAVE_UNISTD_H 1
>
> /* Name of package */
> #define _GLIBCPP_PACKAGE "libstdc++"
>
> /* Version number of package */
> #define _GLIBCPP_VERSION "2.90.8"
>
> //
> // Systems that have certain non-standard functions prefixed with an
> // underscore, we'll handle those here. Must come after config.h.in.
> //
>
> #if defined (_GLIBCPP_HAVE__ISNAN) && ! defined (_GLIBCPP_HAVE_ISNAN)
> # define _GLIBCPP_HAVE_ISNAN 1
> # define isnan _isnan
> #endif
>
> #if defined (_GLIBCPP_HAVE__ISNANF) && ! defined (_GLIBCPP_HAVE_ISNANF)
> # define _GLIBCPP_HAVE_ISNANF 1
> # define isnanf _isnanf
> #endif
>
> #if defined (_GLIBCPP_HAVE__ISNANL) && ! defined (_GLIBCPP_HAVE_ISNANL)
> # define _GLIBCPP_HAVE_ISNANL 1
> # define isnanl _isnanl
> #endif
>
> #if defined (_GLIBCPP_HAVE__ISINF) && ! defined (_GLIBCPP_HAVE_ISINF)
> # define _GLIBCPP_HAVE_ISINF 1
> # define isinf _isinf
> #endif
>
> #if defined (_GLIBCPP_HAVE__ISINFF) && ! defined (_GLIBCPP_HAVE_ISINFF)
> # define _GLIBCPP_HAVE_ISINFF 1
> # define isinff _isinff
> #endif
>
> #if defined (_GLIBCPP_HAVE__ISINFL) && ! defined (_GLIBCPP_HAVE_ISINFL)
> # define _GLIBCPP_HAVE_ISINFL 1
> # define isinfl _isinfl
> #endif
>
> #if defined (_GLIBCPP_HAVE__COPYSIGN) && ! defined (_GLIBCPP_HAVE_COPYSIGN)
> # define _GLIBCPP_HAVE_COPYSIGN 1
> # define copysign _copysign
> #endif
>
> #if defined (_GLIBCPP_HAVE__COPYSIGNL) && ! defined (_GLIBCPP_HAVE_COPYSIGNL)
> # define _GLIBCPP_HAVE_COPYSIGNL 1
> # define copysignl _copysignl
> #endif
>
> #if defined (_GLIBCPP_HAVE__COSF) && ! defined (_GLIBCPP_HAVE_COSF)
> # define _GLIBCPP_HAVE_COSF 1
> # define cosf _cosf
> #endif
>
> #if defined (_GLIBCPP_HAVE__COSHF) && ! defined (_GLIBCPP_HAVE_COSHF)
> # define _GLIBCPP_HAVE_COSHF 1
> # define coshf _coshf
> #endif
>
> #if defined (_GLIBCPP_HAVE__LOGF) && ! defined (_GLIBCPP_HAVE_LOGF)
> # define _GLIBCPP_HAVE_LOGF 1
> # define logf _logf
> #endif
>
> #if defined (_GLIBCPP_HAVE__LOG10F) && ! defined (_GLIBCPP_HAVE_LOG10F)
> # define _GLIBCPP_HAVE_LOG10F 1
> # define log10f _log10f
> #endif
>
> #if defined (_GLIBCPP_HAVE__POWF) && ! defined (_GLIBCPP_HAVE_POWF)
> # define _GLIBCPP_HAVE_POWF 1
> # define powf _powf
> #endif
>
> #if defined (_GLIBCPP_HAVE__SINF) && ! defined (_GLIBCPP_HAVE_SINF)
> # define _GLIBCPP_HAVE_SINF 1
> # define sinf _sinf
> #endif
>
> #if defined (_GLIBCPP_HAVE__SINHF) && ! defined (_GLIBCPP_HAVE_SINHF)
> # define _GLIBCPP_HAVE_SINHF 1
> # define sinhf _sinhf
> #endif
>
> #if defined (_GLIBCPP_HAVE__SQRTF) && ! defined (_GLIBCPP_HAVE_SQRTF)
> # define _GLIBCPP_HAVE_SQRTF 1
> # define sqrtf _sqrtf
> #endif
>
> #if defined (_GLIBCPP_HAVE__TANF) && ! defined (_GLIBCPP_HAVE_TANF)
> # define _GLIBCPP_HAVE_TANF 1
> # define tanf _tanf
> #endif
>
> #if defined (_GLIBCPP_HAVE__TANHF) && ! defined (_GLIBCPP_HAVE_TANHF)
> # define _GLIBCPP_HAVE_TANHF 1
> # define tanhf _tanhf
> #endif
>
> #if defined (_GLIBCPP_HAVE__STRTOF) && ! defined (_GLIBCPP_HAVE_STRTOF)
> # define _GLIBCPP_HAVE_STRTOF 1
> # define strtof _strtof
> #endif
>
> #if defined (_GLIBCPP_HAVE__STRTOLD) && ! defined (_GLIBCPP_HAVE_STRTOLD)
> # define _GLIBCPP_HAVE_STRTOLD 1
> # define strtold _strtold
> #endif
>
> #if defined (_GLIBCPP_HAVE__FABSF) && ! defined (_GLIBCPP_HAVE_FABSF)
> # define _GLIBCPP_HAVE_FABSF 1
> # define fabsf _fabsf
> #endif
>
> #if defined (_GLIBCPP_HAVE__SINCOS) && ! defined (_GLIBCPP_HAVE_SINCOS)
> # define _GLIBCPP_HAVE_SINCOS 1
> # define sincos _sincos
> #endif
>
> #if defined (_GLIBCPP_HAVE__SINCOSF) && ! defined (_GLIBCPP_HAVE_SINCOSF)
> # define _GLIBCPP_HAVE_SINCOSF 1
> # define sincosf _sincosf
> #endif
>
> #if defined (_GLIBCPP_HAVE__SINCOSL) && ! defined (_GLIBCPP_HAVE_SINCOSL)
> # define _GLIBCPP_HAVE_SINCOSL 1
> # define sincosl _sincosl
> #endif
>
> #if defined (_GLIBCPP_HAVE__FINITE) && ! defined (_GLIBCPP_HAVE_FINITE)
> # define _GLIBCPP_HAVE_FINITE 1
> # define finite _finite
> #endif
>
> #if defined (_GLIBCPP_HAVE__QFINITE) && ! defined (_GLIBCPP_HAVE_QFINITE)
> # define _GLIBCPP_HAVE_QFINITE 1
> # define qfinite _qfinite
> #endif
>
> #if defined (_GLIBCPP_HAVE__FPCLASS) && ! defined (_GLIBCPP_HAVE_FPCLASS)
> # define _GLIBCPP_HAVE_FPCLASS 1
> # define fpclass _fpclass
> #endif
>
> #if defined (_GLIBCPP_HAVE__QFPCLASS) && ! defined (_GLIBCPP_HAVE_QFPCLASS)
> # define _GLIBCPP_HAVE_QFPCLASS 1
> # define qfpclass _qfpclass
> #endif
>
>
> #endif // _CPP_CPPCONFIG_
Only in /work/egcs/include/g++-v3//bits: c++io.h
Only in /work/egcs/include/g++-v3//bits: c++threads.h
Only in /work/egcs/include/g++-v3//bits: c++threads.h~
diff -r ./bits/char_traits.h /work/egcs/include/g++-v3//bits/char_traits.h
179c179
< { return static_cast<const char_type*>(memchr(__s, __a, __n)); }
---
> { return static_cast<char*>(memchr(__s, __a, __n)); }
183c183
< { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
---
> { return static_cast<char*>(memmove(__s1, __s2, __n)); }
187c187
< { return static_cast<char_type *>(memcpy(__s1, __s2, __n)); }
---
> { return static_cast<char*>(memcpy(__s1, __s2, __n)); }
191c191
< { return static_cast<char_type*>(memset(__s, __a, __n)); }
---
> { return static_cast<char*>(memset(__s, __a, __n)); }
195c195
< { return static_cast<char_type>(__c); }
---
> { return static_cast<char>(__c); }
271c271
< { return static_cast<char_type*>(memmove(__s1, __s2,
---
> { return static_cast<wchar_t*>(memmove(__s1, __s2,
276c276
< { return static_cast<char_type*>(memcpy(__s1, __s2,
---
> { return static_cast<wchar_t*>(memcpy(__s1, __s2,
diff -r ./bits/generic_shadow.h /work/egcs/include/g++-v3//bits/generic_shadow.h
1,2c1
< // -*-C++-*-
< // <generic_shadow.h>
---
> // generic C header shadow file -*- C++ -*-
3a3,32
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
>
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
>
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
>
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> // This file is included by all the standard C <foo.h> headers
> // after defining _SHADOW_NAME.
>
6,8c35,37
< // get out of the "swamp"
< } // close extern "C"
< } // close namespace _C_Swamp::
---
> // get out of the "swamp"
> } // close extern "C"
> } // close namespace _C_Swamp::
11d39
<
14,18c42,46
< // dive back into the "swamp"
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
<
---
> // dive back into the "swamp"
> namespace _C_Swamp {
> extern "C" {
> # define _IN_C_SWAMP_
>
20c48
<
---
>
21a50,52
>
> // expose global C names, including non-standard ones, but shadow
> // some names and types with the std:: C++ version.
23,26c54,55
< // expose global C names, including non-standard ones, but shadow
< // some names and types with the std:: C++ version.
< using namespace ::_C_Swamp::_C_Shadow;
<
---
> using namespace ::_C_Swamp::_C_Shadow;
>
27a57
>
diff -r ./bits/std_cassert.h /work/egcs/include/g++-v3//bits/std_cassert.h
1,5c1
< // -*-C++-*-
< /* Allow this file to be included multiple times
< with different settings of NDEBUG. */
< #undef assert
< #undef __assert
---
> // -*- C++ -*- forwarding header.
7,9c3,9
< #ifdef NDEBUG
< #define assert(ignore) ((void) 0)
< #else
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
11c11,14
< #ifndef __GNUC__
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
13,14c16,19
< #define assert(expression) \
< ((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__)))
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
16,18c21,28
< #define __assert(expression, file, lineno) \
< (printf ("%s:%u: failed assertion\n", file, lineno), \
< abort (), 0)
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
20c30,32
< #else
---
> //
> // ISO C++ 14882: 19.2 Assertions
> //
22c34
< #if defined(__STDC__) || defined (__cplusplus)
---
> // Note: This is not a conforming implementation.
24,42c36
< /* Defined in libgcc.a */
< #ifdef __cplusplus
< namespace _C_Swamp
< {
< extern "C" {
< extern void __eprintf (const char *, const char *, unsigned, const char *)
< __attribute__ ((noreturn));
< }
< }
< #define __assert(expression, file, line) \
< (_C_Swamp::__eprintf ("%s:%u: failed assertion `%s'\n", \
< file, line, expression), 0)
< #else
< extern void __eprintf (const char *, const char *, unsigned, const char *)
< __attribute__ ((noreturn));
< #define __assert(expression, file, line) \
< (__eprintf ("%s:%u: failed assertion `%s'\n", \
< file, line, expression), 0)
< #endif
---
> // No include guards on this header...
44,60c38
< #define assert(expression) \
< ((void) ((expression) ? 0 : __assert (#expression, __FILE__, __LINE__)))
<
< #else /* no __STDC__ and not C++; i.e. -traditional. */
<
< extern void __eprintf () __attribute__ ((noreturn)); /* Defined in libgcc.a */
<
< #define assert(expression) \
< ((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__)))
<
< #define __assert(expression, file, lineno) \
< (__eprintf ("%s:%u: failed assertion `%s'\n", \
< file, lineno, "expression"), 0)
<
< #endif /* no __STDC__ and not C++; i.e. -traditional. */
< #endif /* no __GNU__; i.e., /bin/cc. */
< #endif
---
> # include_next <assert.h>
diff -r ./bits/std_cctype.h /work/egcs/include/g++-v3//bits/std_cctype.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CCTYPE_
< #define _CPP_INCLUDE_CCTYPE_
---
> // -*- C++ -*- forwarding header.
5,15c3,39
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <ctype.h>
< }
< namespace _C_Shadow { } // placeholder
< #ifdef isupper
< inline int _CPP_isupper(int c)
< {
< return isupper(c);
< }
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
>
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
>
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
>
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: <ccytpe>
> //
>
> #ifndef _CPP_CCTYPE
> #define _CPP_CCTYPE 1
>
> // This keeps isanum, et al from being propagated as macros.
> #if __linux__
> #define __NO_CTYPE 1
17,21c41,61
< #ifdef isdigit
< inline int _CPP_isdigit(int c)
< {
< return isdigit(c);
< }
---
>
> # include_next <ctype.h>
>
> // Sequester the C non-inline implementations in the _C_Swamp::
> // namespace, and provide C++ inlines for them in the std:: namespace
> // where they belong.
>
> namespace std
> {
> // NB: If not using namespaces, can't have any of these definitions,
> // as they will duplicate what's in the global namespace.
>
> #ifdef toupper
> inline int
> _S_toupper_helper(int __c) { return toupper(__c); }
> # undef toupper
> inline int
> toupper(int __c) { return _S_toupper_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> toupper(int __c) { return ::toupper(__c); }
23,27c63,72
< #ifdef isalpha
< inline int _CPP_isalpha(int c)
< {
< return isalpha(c);
< }
---
>
> #ifdef tolower
> inline int
> _S_tolower_helper(int __c) { return tolower(__c); }
> # undef tolower
> inline int
> tolower(int __c) { return _S_tolower_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> tolower(int __c) { return ::tolower(__c); }
29,46c74
< #ifdef islower
< inline int _CPP_islower(int c)
< {
< return islower(c);
< }
< #endif
< #ifdef isxdigit
< inline int _CPP_isxdigit(int c)
< {
< return isxdigit(c);
< }
< #endif
< #ifdef isalnum
< inline int _CPP_isalnum(int c)
< {
< return isalnum(c);
< }
< #endif
---
>
48,51c76,83
< inline int _CPP_isspace(int c)
< {
< return isspace(c);
< }
---
> inline int
> _S_isspace_helper(int __c) { return isspace(__c); }
> # undef isspace
> inline int
> isspace(int __c) { return _S_isspace_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isspace(int __c) { return ::isspace(__c); }
53,57c85,94
< #ifdef ispunct
< inline int _CPP_ispunct(int c)
< {
< return ispunct(c);
< }
---
>
> #ifdef isprint
> inline int
> _S_isprint_helper(int __c) { return isprint(__c); }
> # undef isprint
> inline int
> isprint(int __c) { return _S_isprint_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isprint(int __c) { return ::isprint(__c); }
59,64c96
< #ifdef isgraph
< inline int _CPP_isgraph(int c)
< {
< return isgraph(c);
< }
< #endif
---
>
66,69c98,105
< inline int _CPP_iscntrl(int c)
< {
< return iscntrl(c);
< }
---
> inline int
> _S_iscntrl_helper(int __c) { return iscntrl(__c); }
> # undef iscntrl
> inline int
> iscntrl(int __c) { return _S_iscntrl_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> iscntrl(int __c) { return ::iscntrl(__c); }
71,90d106
< #ifdef isprint
< inline int _CPP_isprint(int c)
< {
< return isprint(c);
< }
< #endif
< #ifdef toupper
< inline int _CPP_toupper(int c)
< {
< return toupper(c);
< }
< #endif
< #ifdef tolower
< inline int _CPP_tolower(int c)
< {
< return tolower(c);
< }
< #endif
<
< } // close namespace ::_C_Swamp::
92,93d107
< namespace std {
<
95,101c109,116
< #undef isupper
< inline int isupper(int c)
< {
< return ::_C_Swamp::_CPP_isupper(c);
< }
< #else
< using ::_C_Swamp::isupper;
---
> inline int
> _S_isupper_helper(int __c) { return isupper(__c); }
> # undef isupper
> inline int
> isupper(int __c) { return _S_isupper_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isupper(int __c) { return ::isupper(__c); }
103,110c118,127
< #ifdef isdigit
< #undef isdigit
< inline int isdigit(int c)
< {
< return ::_C_Swamp::_CPP_isdigit(c);
< }
< #else
< using ::_C_Swamp::isdigit;
---
>
> #ifdef islower
> inline int
> _S_islower_helper(int __c) { return islower(__c); }
> # undef islower
> inline int
> islower(int __c) { return _S_islower_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> islower(int __c) { return ::islower(__c); }
111a129
>
113,119c131,138
< #undef isalpha
< inline int isalpha(int c)
< {
< return ::_C_Swamp::_CPP_isalpha(c);
< }
< #else
< using ::_C_Swamp::isalpha;
---
> inline int
> _S_isalpha_helper(int __c) { return isalpha(__c); }
> # undef isalpha
> inline int
> isalpha(int __c) { return _S_isalpha_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isalpha(int __c) { return ::isalpha(__c); }
121,128c140,149
< #ifdef islower
< #undef islower
< inline int islower(int c)
< {
< return ::_C_Swamp::_CPP_islower(c);
< }
< #else
< using ::_C_Swamp::islower;
---
>
> #ifdef isdigit
> inline int
> _S_isdigit_helper(int __c) { return isdigit(__c); }
> # undef isdigit
> inline int
> isdigit(int __c) { return _S_isdigit_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isdigit(int __c) { return ::isdigit(__c); }
129a151,162
>
> #ifdef ispunct
> inline int
> _S_ispunct_helper(int __c) { return ispunct(__c); }
> # undef ispunct
> inline int
> ispunct(int __c) { return _S_ispunct_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> ispunct(int __c) { return ::ispunct(__c); }
> #endif
>
131,137c164,171
< #undef isxdigit
< inline int isxdigit(int c)
< {
< return ::_C_Swamp::_CPP_isxdigit(c);
< }
< #else
< using ::_C_Swamp::isxdigit;
---
> inline int
> _S_isxdigit_helper(int __c) { return isxdigit(__c); }
> # undef isxdigit
> inline int
> isxdigit(int __c) { return _S_isxdigit_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isxdigit(int __c) { return ::isxdigit(__c); }
138a173
>
140,146c175,182
< #undef isalnum
< inline int isalnum(int c)
< {
< return ::_C_Swamp::_CPP_isalnum(c);
< }
< #else
< using ::_C_Swamp::isalnum;
---
> inline int
> _S_isalnum_helper(int __c) { return isalnum(__c); }
> # undef isalnum
> inline int
> isalnum(int __c) { return _S_isalnum_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isalnum(int __c) { return ::isalnum(__c); }
148,165c184
< #ifdef isspace
< #undef isspace
< inline int isspace(int c)
< {
< return ::_C_Swamp::_CPP_isspace(c);
< }
< #else
< using ::_C_Swamp::isspace;
< #endif
< #ifdef ispunct
< #undef ispunct
< inline int ispunct(int c)
< {
< return ::_C_Swamp::_CPP_ispunct(c);
< }
< #else
< using ::_C_Swamp::ispunct;
< #endif
---
>
167,173c186,193
< #undef isgraph
< inline int isgraph(int c)
< {
< return ::_C_Swamp::_CPP_isgraph(c);
< }
< #else
< using ::_C_Swamp::isgraph;
---
> inline int
> _S_isgraph_helper(int __c) { return isgraph(__c); }
> # undef isgraph
> inline int
> isgraph(int __c) { return _S_isgraph_helper(__c); }
> #elif _GLIBCPP_USE_NAMESPACES
> inline int
> isgraph(int __c) { return ::isgraph(__c); }
175,210d194
< #ifdef iscntrl
< #undef iscntrl
< inline int iscntrl(int c)
< {
< return ::_C_Swamp::_CPP_iscntrl(c);
< }
< #else
< using ::_C_Swamp::iscntrl;
< #endif
< #ifdef isprint
< #undef isprint
< inline int isprint(int c)
< {
< return ::_C_Swamp::_CPP_isprint(c);
< }
< #else
< using ::_C_Swamp::isprint;
< #endif
< #ifdef tolower
< #undef tolower
< inline int tolower(int c)
< {
< return ::_C_Swamp::_CPP_tolower(c);
< }
< #else
< using ::_C_Swamp::tolower;
< #endif
< #ifdef toupper
< #undef toupper
< inline int toupper(int c)
< {
< return ::_C_Swamp::_CPP_toupper(c);
< }
< #else
< using ::_C_Swamp::toupper;
< #endif
212c196
< } // close namespace std::
---
> } // namespace std
214c198
< #undef _IN_C_SWAMP_
---
> #endif // _CPP_CCTYPE
216c200,210
< #endif
---
>
>
>
>
>
>
>
>
>
>
>
diff -r ./bits/std_cerrno.h /work/egcs/include/g++-v3//bits/std_cerrno.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CERRNO_
< #define _CPP_INCLUDE_CERRNO_
---
> // The -*- C++ -*- error number header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <errno.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,17c11,14
< // capture errno in safe scope
< inline int _CPP_errno()
< {
< return errno;
< }
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
19,26c16,19
< namespace std {
< #ifdef errno
< #undef errno
< #endif
< // errno MUST be a macro
< #define errno (::_C_Swamp::_CPP_errno())
<
< } // close namespace std::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
28c21,28
< #undef _IN_C_SWAMP_
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
29a30,38
> //
> // ISO C++ 14882: 19.3 Error numbers
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CERRNO
> #define _CPP_CERRNO 1
> # include_next <errno.h>
diff -r ./bits/std_cfloat.h /work/egcs/include/g++-v3//bits/std_cfloat.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CFLOAT_
< #define _CPP_INCLUDE_CFLOAT_
---
> // -*- C++ -*- forwarding header.
5,11c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <float.h>
< }
< namespace _C_Shadow { } // placeholder
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
13,15c11,14
< namespace std {
<
< } // close namespace std::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
17c16,19
< #undef _IN_C_SWAMP_
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
18a21,45
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: 18.2.2 Implementation properties: C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CFLOAT
> #define _CPP_CFLOAT 1
> # include_next <float.h>
>
> #if 0
> # ifdef __GLIBC__
> // For GNU libc we must also include this one:
> # include <fenv.h>
> # endif
> #endif
diff -r ./bits/std_ciso646.h /work/egcs/include/g++-v3//bits/std_ciso646.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CISO646_
< #define _CPP_INCLUDE_CISO646_
---
> // ciso646 -*- C++ -*-
5,11c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <iso646.h>
< }
< namespace _C_Shadow { } // placeholder
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12a11,36
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
>
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
>
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: <ciso646>
> //
>
> #ifndef _CPP_ISO646
> #define _CPP_ISO646 1
>
14,15d37
<
< } // close namespace std::
17c39,41
< #undef _IN_C_SWAMP_
---
> // 2.11 Keywords
> // alternative representations
> // and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq
18a43,54
> #ifndef __cplusplus
> #define and &&
> #define and_eq &=
> #define bitand &
> #define bitor |
> #define compl ~
> #define not !
> #define not_eq !=
> #define or ||
> #define or_eq |=
> #define xor ^
> #define xor_eq ^=
19a56,71
>
> #if 0
> template<typename _T1, typename _T2>
> inline bool
> operator and(const _T1& __lhs, const _T2& __rhs)
> { return (static_cast<bool>(__lhs) && static_cast<bool>(__rhs)); }
>
> template<typename _T1, typename _T2>
> inline bool
> operator or(const _T1& __lhs, const _T2& __rhs)
> { return (static_cast<bool>(__lhs) || static_cast<bool>(__rhs)); }
> #endif
>
> } // namespace std
>
> #endif // _CPP_ISO646
diff -r ./bits/std_climits.h /work/egcs/include/g++-v3//bits/std_climits.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CLIMITS_
< #define _CPP_INCLUDE_CLIMITS_
---
> // -*- C++ -*- forwarding header.
5,11c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <limits.h>
< }
< namespace _C_Shadow { } // placeholder
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
13,15c11,14
< namespace std {
<
< } // close namespace std::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
17c16,19
< #undef _IN_C_SWAMP_
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
18a21,38
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: 18.2.2 Implementation properties: C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CLIMITS
> #define _CPP_CLIMITS 1
> # include_next <limits.h>
diff -r ./bits/std_clocale.h /work/egcs/include/g++-v3//bits/std_clocale.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CLOCALE_
< #define _CPP_INCLUDE_CLOCALE_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <locale.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,16c11,14
< //types
< #ifdef lconv
< typedef lconv _CPP_lconv;
< #endif
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
18,31c16,19
< namespace std {
< #ifdef lconv
< #undef lconv
< struct lconv:
< ::_C_Swamp::_CPP_lconv
< {
< };
< #else
< struct lconv:
< ::_C_Swamp::lconv
< {
< };
< #endif
< } // close namespace std::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
33,49c21,28
< // functions
< namespace _C_Swamp
< {
< #ifdef localeconv
< inline lconv *_CPP_localeconv()
< {
< return localeconv();
< }
< #endif
< #ifdef setlocale
< inline char*_CPP_setlocale(int category,const char*locale)
< {
< return setlocale(category,locale);
< }
< #endif
<
< }
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
51,74c30,32
< namespace std
< {
< #ifdef localeconv
< #undef localeconv
< inline std::lconv *localeconv()
< {
< return reinterpret_cast<std::lconv *>(::_C_Swamp::_CPP_localeconv());
< }
< #else
< inline std::lconv *localeconv()
< {
< return reinterpret_cast<std::lconv *>(::_C_Swamp::localeconv());
< }
< #endif
< #ifdef setlocale
< #undef setlocale
< inline char*setlocale(int category,const char*locale)
< {
< return ::_C_Swamp::_CPP_setlocale(category,locale);
< }
< #else
< using ::_C_Swamp::setlocale;
< #endif
< }
---
> //
> // ISO C++ 14882: 18.2.2 Implementation properties: C library
> //
75a34
> // Note: this is not a conforming implementation.
77,78c36,38
< #undef _IN_C_SWAMP_
<
---
> #ifndef _CPP_CLOCALE
> #define _CPP_CLOCALE 1
> # include_next <locale.h>
79a40
>
diff -r ./bits/std_cmath.h /work/egcs/include/g++-v3//bits/std_cmath.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CMATH_
< #define _CPP_INCLUDE_CMATH_
---
> // -*- C++ -*- C math library.
5,144c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <math.h>
< }
< namespace _C_Shadow { } // placeholder
< #ifdef modf
< inline double _CPP_modf(double x,double *p)
< {
< return modf(x,p);
< }
< #endif
< #ifdef fabs
< inline double _CPP_fabs(double x)
< {
< return fabs(x);
< }
< #endif
< #ifdef ceil
< inline double _CPP_ceil(double x)
< {
< return ceil(x);
< }
< #endif
< #ifdef acos
< inline double _CPP_acos(double x)
< {
< return acos(x);
< }
< #endif
< #ifdef asin
< inline double _CPP_asin(double x)
< {
< return asin(x);
< }
< #endif
< #ifdef atan
< inline double _CPP_atan(double x)
< {
< return atan(x);
< }
< #endif
< #ifdef atan2
< inline double _CPP_atan2(double x)
< {
< return atan2(x);
< }
< #endif
< #ifdef pow
< inline double _CPP_pow(double x,double y)
< {
< return pow(x,y);
< }
< #endif
< #ifdef sin
< inline double _CPP_sin(double x)
< {
< return sin(x);
< }
< #endif
< #ifdef sinh
< inline double _CPP_sinh(double x)
< {
< return sinh(x);
< }
< #endif
< #ifdef cos
< inline double _CPP_cos(double x)
< {
< return cos(x);
< }
< #endif
< #ifdef cosh
< inline double _CPP_cosh(double x)
< {
< return cosh(x);
< }
< #endif
< #ifdef tan
< inline double _CPP_tan(double x)
< {
< return tan(x);
< }
< #endif
< #ifdef tanh
< inline double _CPP_tanh(double x)
< {
< return tanh(x);
< }
< #endif
< #ifdef exp
< inline double _CPP_exp(double x)
< {
< return exp(x);
< }
< #endif
< #ifdef floor
< inline double _CPP_floor(double x)
< {
< return floor(x);
< }
< #endif
< #ifdef fmod
< inline double _CPP_fmod(double x,double y)
< {
< return fmod(x,y);
< }
< #endif
< #ifdef frexp
< inline double _CPP_frexp(double num,int *exp)
< {
< return frexp(num,exp);
< }
< #endif
< #ifdef ldexp
< inline double _CPP_ldexp(double x,int exp)
< {
< return ldexp(x,exp);
< }
< #endif
< #ifdef log
< inline double _CPP_log(double x)
< {
< return log(x);
< }
< #endif
< #ifdef log10
< inline double _CPP_log10(double x)
< {
< return log10(x);
< }
< #endif
< #ifdef sqrt
< inline double _CPP_sqrt(double x)
< {
< return sqrt(x);
< }
< #endif
<
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
145a11,42
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
>
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
>
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: 26.5 C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CMATH
> #define _CPP_CMATH 1
> # include_next <math.h>
> # include_next <stdlib.h>
>
> #include <bits/c++config.h>
>
148,345c45,46
< #ifdef modf
< #undef modf
< inline double modf(double x,double *p)
< {
< return ::_C_Swamp::_CPP_modf(x,p);
< }
< #else
< using ::_C_Swamp::modf;
< #endif
< #ifdef pow
< #undef pow
< inline double pow(double x,double y)
< {
< return ::_C_Swamp::_CPP_pow(x,y);
< }
< #else
< using ::_C_Swamp::pow;
< #endif
< #ifdef fabs
< #undef fabs
< inline double fabs(double x)
< {
< return ::_C_Swamp::_CPP_fabs(x);
< }
< #else
< using ::_C_Swamp::fabs;
< #endif
< #ifdef ceil
< #undef ceil
< inline double ceil(double x)
< {
< return ::_C_Swamp::_CPP_ceil(x);
< }
< #else
< using ::_C_Swamp::ceil;
< #endif
< #ifdef acos
< #undef acos
< inline double acos(double x)
< {
< return ::_C_Swamp::_CPP_acos(x);
< }
< #else
< using ::_C_Swamp::acos;
< #endif
< #ifdef asin
< #undef asin
< inline double asin(double x)
< {
< return ::_C_Swamp::_CPP_asin(x);
< }
< #else
< using ::_C_Swamp::asin;
< #endif
< #ifdef atan
< #undef atan
< inline double atan(double x)
< {
< return ::_C_Swamp::_CPP_atan(x);
< }
< #else
< using ::_C_Swamp::atan;
< #endif
< #ifdef atan2
< #undef atan2
< inline double atan2(double x)
< {
< return ::_C_Swamp::_CPP_atan2(x);
< }
< #else
< using ::_C_Swamp::atan2;
< #endif
< #ifdef sin
< #undef sin
< inline double sin(double x)
< {
< return ::_C_Swamp::_CPP_sin(x);
< }
< #else
< using ::_C_Swamp::sin;
< #endif
< #ifdef sinh
< #undef sinh
< inline double sinh(double x)
< {
< return ::_C_Swamp::_CPP_sinh(x);
< }
< #else
< using ::_C_Swamp::sinh;
< #endif
< #ifdef cos
< #undef cos
< inline double cos(double x)
< {
< return ::_C_Swamp::_CPP_cos(x);
< }
< #else
< using ::_C_Swamp::cos;
< #endif
< #ifdef cosh
< #undef cosh
< inline double cosh(double x)
< {
< return ::_C_Swamp::_CPP_cosh(x);
< }
< #else
< using ::_C_Swamp::cosh;
< #endif
< #ifdef tan
< #undef tan
< inline double tan(double x)
< {
< return ::_C_Swamp::_CPP_tan(x);
< }
< #else
< using ::_C_Swamp::tan;
< #endif
< #ifdef tanh
< #undef tanh
< inline double tanh(double x)
< {
< return ::_C_Swamp::_CPP_tanh(x);
< }
< #else
< using ::_C_Swamp::tanh;
< #endif
< #ifdef exp
< #undef exp
< inline double exp(double x)
< {
< return ::_C_Swamp::_CPP_exp(x);
< }
< #else
< using ::_C_Swamp::exp;
< #endif
< #ifdef floor
< #undef floor
< inline double floor(double x)
< {
< return ::_C_Swamp::_CPP_floor(x);
< }
< #else
< using ::_C_Swamp::floor;
< #endif
< #ifdef fmod
< #undef fmod
< inline double fmod(double x,double y)
< {
< return ::_C_Swamp::_CPP_fmod(x,y);
< }
< #else
< using ::_C_Swamp::fmod;
< #endif
< #ifdef frexp
< #undef frexp
< inline double frexp(double num,int *exp)
< {
< return ::_C_Swamp::_CPP_frexp(num,exp);
< }
< #else
< using ::_C_Swamp::frexp;
< #endif
< #ifdef ldexp
< #undef ldexp
< inline double ldexp(double x,int exp)
< {
< return ::_C_Swamp::_CPP_ldexp(x,exp);
< }
< #else
< using ::_C_Swamp::ldexp;
< #endif
< #ifdef log
< #undef log
< inline double log(double x)
< {
< return ::_C_Swamp::_CPP_log(x);
< }
< #else
< using ::_C_Swamp::log;
< #endif
< #ifdef log10
< #undef log10
< inline double log10(double x)
< {
< return ::_C_Swamp::_CPP_log10(x);
< }
< #else
< using ::_C_Swamp::log10;
< #endif
< #ifdef sqrt
< #undef sqrt
< inline double sqrt(double x)
< {
< return ::_C_Swamp::_CPP_sqrt(x);
< }
< #else
< using ::_C_Swamp::sqrt;
< #endif
---
> inline long
> abs(long __l) { return ::labs(__l); }
347c48,49
< // now define overloads for types that don't match the C library
---
> inline ldiv_t
> div(long __a, long __b) { return ::ldiv(__a, __b); }
348a51
> // double
350c53
< abs(double __x) { return fabs(__x); }
---
> abs(double __x) { return ::fabs(__x); }
352c55,58
< #if _GLIBCPP_HAVE_ABSF
---
> double
> pow(double, int);
>
> // float
354,355c60,61
< abs(float __x) { return ::_C_Swamp::absf(__x); }
< #else
---
> ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
>
357,358c63
< abs(float __x) { return fabs(static_cast<double>(__x)); }
< #endif
---
> floor(float __x) { return ::floor(static_cast<double>(__x)); }
361,362c66,67
< pow(float __x, float __y)
< { return pow(static_cast<double>(__x), static_cast<double>(__y)); }
---
> fmod(float __x, float __y)
> { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
364,365c69,71
< double
< pow(double, int);
---
> inline float
> frexp(float __x, int* __p)
> { return ::frexp(static_cast<double>(__x), __p); }
366a73,80
> inline float
> ldexp(float __x, int __i)
> { return ::ldexp(static_cast<double>(__x), __i); }
>
> inline float
> pow(float __x, float __y)
> { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
>
370,372c84
< long double
< pow(long double, int);
<
---
> #if _GLIBCPP_HAVE_ABSF
374c86,90
< ceil(float __x) { return ceil(static_cast<double>(__x)); }
---
> abs(float __x) { return ::absf(__x); }
> #else
> inline float
> abs(float __x) { return ::fabs(static_cast<double>(__x)); }
> #endif
378c94
< acos(float __x) { return ::_C_Swamp::acosf(__x); }
---
> acos(float __x) { return ::acosf(__x); }
381c97
< acos(float __x) { return acos(static_cast<double>(__x)); }
---
> acos(float __x) { return ::acos(static_cast<double>(__x)); }
386c102
< asin(float __x) { return ::_C_Swamp::asinf(__x); }
---
> asin(float __x) { return ::asinf(__x); }
389c105
< asin(float __x) { return asin(static_cast<double>(__x)); }
---
> asin(float __x) { return ::asin(static_cast<double>(__x)); }
394c110
< atan(float __x) { return ::_C_Swamp::atanf(__x); }
---
> atan(float __x) { return ::atanf(__x); }
397c113
< atan(float __x) { return atan(static_cast<double>(__x)); }
---
> atan(float __x) { return ::atan(static_cast<double>(__x)); }
402c118
< atan2(float __x, float __y) { return ::_C_Swamp::atan2f(__x, __y); }
---
> atan2(float __x, float __y) { return ::atan2f(__x, __y); }
406c122
< { return atan2(static_cast<double>(__x), static_cast<double>(__y)); }
---
> { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }
409c125
< #if GLIBCPP_HAS_BUILTIN_SINF
---
> #if _GLIBCPP_HAVE_TANF
411,414c127
< sin(float __x) { return __builtin_sinf(__x); }
< #elif _GLIBCPP_HAVE_SINF
< inline float
< sin(float __x) { return ::_C_Swamp::sinf(__x); }
---
> tan(float __x) { return ::tanf(__x); }
417c130
< sin(float __x) { return sin(static_cast<double>(__x)); }
---
> tan(float __x) { return ::tan(static_cast<double>(__x)); }
420c133
< #if GLIBCPP_HAS_BUILTIN_COSF
---
> #if _GLIBCPP_HAVE_SINHF
422,425c135
< cos(float __x) { return __builtin_cosf(__x); }
< #elif _GLIBCPP_HAVE_COSF
< inline float
< cos(float __x) { return ::_C_Swamp::cosf(__x); }
---
> sinh(float __x) { return ::sinhf(__x); }
428c138
< cos(float __x) { return cos(static_cast<double>(__x)); }
---
> sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
431c141
< #if GLIBCPP_HAS_BUILTIN_FABSF
---
> #if _GLIBCPP_HAVE_TANHF
433,436c143
< fabs(float __x) { return __builtin_fabsf(__x); }
< #elif _GLIBCPP_HAVE_FABSF
< inline float
< fabs(float __x) { return ::_C_Swamp::fabsf(__x); }
---
> tanh(float __x) { return ::tanhf(__x); }
439c146
< fabs(float __x) { return fabs(static_cast<double>(__x)); }
---
> tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
442c149
< #if _GLIBCPP_HAVE_MODFF
---
> #if _GLIBCPP_HAVE_COSHF
444c151
< modf(float __x, float* __p) { return ::_C_Swamp::modff(__x, __p); }
---
> cosh(float __x) { return ::coshf(__x); }
447,453c154
< modf(float __x, float* __p)
< {
< double __tmp;
< double __res = modf(static_cast<double>(__x), &__tmp);
< *__p = static_cast<float> (__tmp);
< return __res;
< }
---
> cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
455,456c156,157
<
< #if _GLIBCPP_HAVE_TANF
---
>
> #if _GLIBCPP_HAVE_EXPF
458c159
< tan(float __x) { return ::_C_Swamp::tanf(__x); }
---
> exp(float __x) { return ::expf(__x); }
461c162
< tan(float __x) { return tan(static_cast<double>(__x)); }
---
> exp(float __x) { return ::exp(static_cast<double>(__x)); }
464c165
< #if _GLIBCPP_HAVE_SINHF
---
> #if _GLIBCPP_HAVE_LOGF
466c167
< sinh(float __x) { return ::_C_Swamp::sinhf(__x); }
---
> log(float __x) { return ::logf(__x); }
469c170
< sinh(float __x) { return sinh(static_cast<double>(__x)); }
---
> log(float __x) { return ::log(static_cast<double>(__x)); }
472c173
< #if _GLIBCPP_HAVE_TANHF
---
> #if _GLIBCPP_HAVE_LOG10F
474c175
< tanh(float __x) { return ::_C_Swamp::tanhf(__x); }
---
> log10(float __x) { return ::log10f(__x); }
477c178
< tanh(float __x) { return tanh(static_cast<double>(__x)); }
---
> log10(float __x) { return ::log10(static_cast<double>(__x)); }
480c181
< #if _GLIBCPP_HAVE_COSHF
---
> #if _GLIBCPP_HAVE_MODFF
482c183
< cosh(float __x) { return ::_C_Swamp::coshf(__x); }
---
> modf(float __x, float* __p) { return ::modff(__x, __p); }
485c186,192
< cosh(float __x) { return cosh(static_cast<double>(__x)); }
---
> modf(float __x, float* __p)
> {
> double __tmp;
> double __res = ::modf(static_cast<double>(__x), &__tmp);
> *__p = static_cast<float> (__tmp);
> return __res;
> }
487,488c194,195
<
< #if _GLIBCPP_HAVE_EXPF
---
>
> #if GLIBCPP_HAS_BUILTIN_SINF
490c197,200
< exp(float __x) { return ::_C_Swamp::expf(__x); }
---
> sin(float __x) { return __builtin_sinf(__x); }
> #elif _GLIBCPP_HAVE_SINF
> inline float
> sin(float __x) { return ::sinf(__x); }
493c203
< exp(float __x) { return exp(static_cast<double>(__x)); }
---
> sin(float __x) { return ::sin(static_cast<double>(__x)); }
495a206
> #if GLIBCPP_HAS_BUILTIN_COSF
497,498c208,209
< floor(float __x) { return floor(static_cast<double>(__x)); }
<
---
> cos(float __x) { return __builtin_cosf(__x); }
> #elif _GLIBCPP_HAVE_COSF
500,513c211
< fmod(float __x, float __y)
< { return fmod(static_cast<double>(__x), static_cast<double>(__y)); }
<
< inline float
< frexp(float __x, int* __p)
< { return frexp(static_cast<double>(__x), __p); }
<
< inline float
< ldexp(float __x, int __i)
< { return ldexp(static_cast<double>(__x), __i); }
<
< #if _GLIBCPP_HAVE_LOGF
< inline float
< log(float __x) { return ::_C_Swamp::logf(__x); }
---
> cos(float __x) { return ::cosf(__x); }
516c214
< log(float __x) { return log(static_cast<double>(__x)); }
---
> cos(float __x) { return ::cos(static_cast<double>(__x)); }
519c217
< #if _GLIBCPP_HAVE_LOG10F
---
> #if GLIBCPP_HAS_BUILTIN_FABSF
521c219,222
< log10(float __x) { return ::_C_Swamp::log10f(__x); }
---
> fabs(float __x) { return __builtin_fabsf(__x); }
> #elif _GLIBCPP_HAVE_FABSF
> inline float
> fabs(float __x) { return ::fabsf(__x); }
524c225
< log10(float __x) { return log10(static_cast<double>(__x)); }
---
> fabs(float __x) { return ::fabs(static_cast<double>(__x)); }
532c233
< sqrt(float __x) { return ::_C_Swamp::sqrtf(__x); }
---
> sqrt(float __x) { return ::sqrtf(__x); }
535c236
< sqrt(float __x) { return sqrt(static_cast<double>(__x)); }
---
> sqrt(float __x) { return ::fabs(static_cast<double>(__x)); }
537a239,241
> // XXX long double
> long double
> pow(long double, int);
539c243
< } // close namespace std
---
> } // std
541c245
< #undef _IN_C_SWAMP_
---
> #endif // _CPP_CMATH
543c247
< #endif
---
>
diff -r ./bits/std_csetjmp.h /work/egcs/include/g++-v3//bits/std_csetjmp.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSETJMP_
< #define _CPP_INCLUDE_CSETJMP_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <setjmp.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,16c11,14
< // types
< #ifdef jmp_buf
< typedef jmp_buf _CPP_jmp_buf;
< #endif
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
18,25c16,19
< namespace std {
< #ifdef jmp_buf
< #undef jmp_buf
< typedef ::_C_Swamp::_CPP_jmp_buf jmp_buf;
< #else
< typedef ::_C_Swamp::jmp_buf jmp_buf;
< #endif
< } // close namespace std::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
27,35c21,28
< // functions
< namespace _C_Swamp
< {
< #ifdef longjmp
< inline void _CPP_longjmp(jmp_buf env,int val)
< {
< return longjmp(env,val);
< }
< #endif
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
37,43c30,32
< // capture setjmp in correct scope
< inline int _CPP_setjmp(jmp_buf env)
< {
< return setjmp(env);
< }
<
< }
---
> //
> // ISO C++ 14882: 20.4.6 C library
> //
45,61c34
< namespace std
< {
< #ifdef longjmp
< #undef longjmp
< inline void longjmp(std::jmp_buf env,int val)
< {
< ::_C_Swamp::_CPP_longjmp(env,val);
< }
< #else
< using ::_C_Swamp::longjmp;
< #endif
< // ensure setjmp is a macro
< #ifdef setjmp
< #undef setjmp
< #endif
< #define setjmp(env) (::_C_Swamp::_CPP_setjmp(env))
< }
---
> // Note: this is not a conforming implementation.
63,65c36,38
<
< #undef _IN_C_SWAMP_
<
---
> #ifndef _CPP_CSETJMP
> #define _CPP_CSETJMP 1
> # include_next <setjmp.h>
diff -r ./bits/std_csignal.h /work/egcs/include/g++-v3//bits/std_csignal.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSIGNAL_
< #define _CPP_INCLUDE_CSIGNAL_
---
> // -*- C++ -*- forwarding header.
5,27c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <signal.h>
< }
< namespace _C_Shadow { } // placeholder
< #ifdef sig_atomic_t
< typedef sig_atomic_t _CPP_sig_atomic_t;
< #endif
< #ifdef raise
< inline int _CPP_raise(int sig)
< {
< return raise(sig);
< }
< #endif
< #ifdef signal
< inline void (*_CPP_signal (int sig,void (*disp)(int)))(int)
< {
< return signal(sig,disp);
< }
< #endif
<
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
29,54c11,14
< namespace std {
< #ifdef sig_atomic_t
< #undef sig_atomic_t
< typedef ::_C_Swamp::_CPP_sig_atomic_t sig_atomic_t;
< #else
< typedef ::_C_Swamp::sig_atomic_t sig_atomic_t;
< #endif
< #ifdef raise
< #undef raise
< inline int raise(int sig)
< {
< return ::_C_Swamp::_CPP_raise(sig);
< }
< #else
< using ::_C_Swamp::raise;
< #endif
< #ifdef signal
< #undef signal
< inline void (*signal (int sig,void (*disp)(int)))(int)
< {
< return ::_C_Swamp::_CPP_signal(sig,disp);
< }
< #else
< using ::_C_Swamp::signal;
< #endif
< } // close namespace std::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
56c16,19
< #undef _IN_C_SWAMP_
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
57a21,38
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: 20.4.6 C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CSIGNAL
> #define _CPP_CSIGNAL 1
> # include_next <signal.h>
diff -r ./bits/std_cstdarg.h /work/egcs/include/g++-v3//bits/std_cstdarg.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSTDARG_
< #define _CPP_INCLUDE_CSTDARG_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <stdarg.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,16c11,14
< // types
< #ifdef va_list
< typedef va_list _CPP_va_list;
< #endif
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
18,26c16,19
< namespace std {
< #ifdef va_list
< #undef va_list
< typedef ::_C_Swamp::_CPP_va_list va_list;
< #else
< typedef ::_C_Swamp::va_list va_list;
< #endif
<
< } // close namespace std::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
28c21,28
< #undef _IN_C_SWAMP_
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
29a30,38
> //
> // ISO C++ 14882: 20.4.6 C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CSTDARG
> #define _CPP_CSTDARG 1
> # include_next <stdarg.h>
diff -r ./bits/std_cstddef.h /work/egcs/include/g++-v3//bits/std_cstddef.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSTDDEF_
< #define _CPP_INCLUDE_CSTDDEF_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <stddef.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,20c11,14
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
< #ifdef ptrdiff_t
< typedef ptrdiff_t _CPP_ptrdiff_t;
< #endif
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
22c16,19
< namespace std {
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
24,39c21,28
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
< #endif
< #endif
< #ifdef ptrdiff_t
< #undef ptrdiff_t
< typedef ::_C_Swamp::_CPP_ptrdiff_t ptrdiff_t;
< #else
< typedef ::_C_Swamp::ptrdiff_t ptrdiff_t;
< #endif
< } // close namespace std::
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
41c30,32
< #undef _IN_C_SWAMP_
---
> //
> // ISO C++ 14882: 18.1 Types
> //
42a34,38
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CSTDDEF
> #define _CPP_CSTDDEF 1
> # include_next <stddef.h>
diff -r ./bits/std_cstdio.h /work/egcs/include/g++-v3//bits/std_cstdio.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSTDIO_
< #define _CPP_INCLUDE_CSTDIO_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <stdio.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,34c11,14
< // types first
< #ifndef _CPP_FILE_DEFINED
< #ifdef FILE
< typedef FILE _CPP_FILE;
< #else
< typedef FILE _CPP_FILE;
< #endif
< #endif
< #ifdef fpos_t
< typedef fpos_t _CPP_fpos_t;
< #endif
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
< #ifdef va_list
< typedef va_list _CPP_va_list;
< #else
< // stdio shouldn't really define va_list, but we need it for vprintf etc.
< // On Solaris, it equates to void *
< typedef void *_CPP_va_list;
< #endif
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
36,50c16,19
< // capture standard stream macros
< inline FILE *_CPP_stdin()
< {
< return stdin;
< }
< inline FILE *_CPP_stdout()
< {
< return stdout;
< }
< inline FILE *_CPP_stderr()
< {
< return stderr;
< }
<
< } // close namespace ::_C_Swamp::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
52,88c21,28
< namespace std
< {
< // the following assumes that the FILE structure is actually defined in full
< // in the C headers
< // (since all functions use FILE * it could just be an opaque structure
< // declared with
< // struct FILE;
< // )
< #ifndef _CPP_FILE_DEFINED
< #ifdef FILE
< #undef FILE
< #endif
< struct FILE:
< ::_C_Swamp::_CPP_FILE
< {
< };
< #define _CPP_FILE_DEFINED
< #endif
< #ifdef fpos_t
< #undef fpos_t
< typedef ::_C_Swamp::_CPP_fpos_t fpos_t;
< #else
< typedef ::_C_Swamp::fpos_t fpos_t;
< #endif
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
< #endif
< #endif
< #ifdef va_list
< #undef va_list
< #endif
< typedef ::_C_Swamp::_CPP_va_list va_list;
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
90,103c30,32
< // define new macros for standard streams
< #ifdef stdin
< #undef stdin
< #endif
< #ifdef stdout
< #undef stdout
< #endif
< #ifdef stderr
< #undef stderr
< #endif
< #define stdin (reinterpret_cast<std::FILE*>(::_C_Swamp::_CPP_stdin()))
< #define stdout (reinterpret_cast<std::FILE*>(::_C_Swamp::_CPP_stdout()))
< #define stderr (reinterpret_cast<std::FILE*>(::_C_Swamp::_CPP_stderr()))
< }
---
> //
> // ISO C++ 14882: 27.8.2 C Library files
> //
105,319c34
< //functions next
< namespace _C_Swamp
< {
< #ifdef clearerr
< inline void _CPP_clearerr(FILE *f)
< {
< return clearerr(f);
< }
< #endif
< #ifdef fclose
< inline int _CPP_fclose(FILE *f)
< {
< return fclose(f);
< }
< #endif
< #ifdef ferror
< inline int _CPP_ferror(FILE *f)
< {
< return ferror(f);
< }
< #endif
< #ifdef feof
< inline int _CPP_feof(FILE *f)
< {
< return feof(f);
< }
< #endif
< #ifdef fflush
< inline int _CPP_fflush(FILE *f)
< {
< return fflush(f);
< }
< #endif
< #ifdef fgetc
< inline int _CPP_fgetc(FILE *f)
< {
< return fgetc(f);
< }
< #endif
< #ifdef fgetpos
< inline int _CPP_fgetpos(FILE *f,fpos_t *pos)
< {
< return fgetpos(f,pos);
< }
< #endif
< #ifdef fgets
< inline char *_CPP_fgets(char *s,int n,FILE *f)
< {
< return fgets(s,n,f);
< }
< #endif
< #ifdef fopen
< inline FILE *_CPP_fopen(const char *name,const char *mode)
< {
< return fopen(name,mode);
< }
< #endif
< #ifdef fputc
< inline int _CPP_fputc(int c,FILE *f)
< {
< return fputc(c,f);
< }
< #endif
< #ifdef fputs
< inline int _CPP_fputs(const char *c,FILE *f)
< {
< return fputs(c,f);
< }
< #endif
< #ifdef fread
< inline size_t _CPP_fread(void *p,size_t s,size_t n,FILE *f)
< {
< return fread(p,s,n,f);
< }
< #endif
< #ifdef freopen
< inline FILE *_CPP_freopen(const char*name,const char *mode,FILE *f)
< {
< return freopen(name,mode,f);
< }
< #endif
< #ifdef fseek
< inline int _CPP_fseek(FILE *f,long offset,int whence)
< {
< return fseek(f,offset,whence);
< }
< #endif
< #ifdef fsetpos
< inline int _CPP_fsetpos(FILE *f,const fpos_t *p)
< {
< return fsetpos(f,p);
< }
< #endif
< #ifdef ftell
< inline long _CPP_ftell(FILE *f)
< {
< return ftell(f);
< }
< #endif
< #ifdef fwrite
< inline size_t _CPP_fwrite(const void *p,size_t s,size_t n,FILE *f)
< {
< return fwrite(p,s,n,f);
< }
< #endif
< #ifdef getc
< inline int _CPP_getc(FILE *f)
< {
< return getc(f);
< }
< #endif
< #ifdef getchar
< inline int _CPP_getchar()
< {
< return getchar();
< }
< #endif
< #ifdef gets
< inline char*_CPP_gets(char *s)
< {
< return gets(s);
< }
< #endif
< #ifdef perror
< inline void _CPP_perror(const char *s)
< {
< perror(s);
< }
< #endif
< #ifdef putc
< inline int _CPP_putc(int c,FILE *f)
< {
< return putc(c,f);
< }
< #endif
< #ifdef putchar
< inline int _CPP_putchar(int c)
< {
< return putchar(c);
< }
< #endif
< #ifdef puts
< inline int _CPP_puts(const char*s)
< {
< return puts(s);
< }
< #endif
< #ifdef remove
< inline int _CPP_remove(const char*path)
< {
< return remove(path);
< }
< #endif
< #ifdef rename
< inline int _CPP_rename(const char*old,const char*new)
< {
< return rename(old,new);
< }
< #endif
< #ifdef rewind
< inline void _CPP_rewind(FILE *s)
< {
< rewind(s);
< }
< #endif
< #ifdef setbuf
< inline void _CPP_setbuf(FILE *s,char *buf)
< {
< setbuf(s,buf);
< }
< #endif
< #ifdef setvbuf
< inline int _CPP_setvbuf(FILE *s,char *buf,int type,size_t size)
< {
< return setvbuf(s,buf,type,size);
< }
< #endif
< #ifdef ungetc
< inline int _CPP_ungetc(int c,FILE *f)
< {
< return ungetc(c,f);
< }
< #endif
< #ifdef tmpfile
< inline FILE *_CPP_tmpfile()
< {
< return tmpfile();
< }
< #endif
< #ifdef tmpnam
< inline char*_CPP_tmpnam(char *s)
< {
< return tmpnam(s);
< }
< #endif
< #ifdef vprintf
< inline int _CPP_vprintf(const char*f,va_list ap)
< {
< return vprintf(f,ap);
< }
< #endif
< #ifdef vfprintf
< inline int _CPP_vfprintf(FILE *f,const char*f,va_list ap)
< {
< return vfprintf(f,ap);
< }
< #endif
< #ifdef vsprintf
< inline int _CPP_vsprintf(char *s,const char*f,va_list ap)
< {
< return vsprintf(s,f,ap);
< }
< #endif
<
< }
---
> // Note: this is not a conforming implementation.
320a36,38
> #ifndef _CPP_CSTDIO
> #define _CPP_CSTDIO 1
> # include_next <stdio.h>
322,477c40,41
< namespace std {
< #ifdef clearerr
< #undef clearerr
< inline void clearerr(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_clearerr(f);
< }
< #else
< inline void clearerr(std::FILE *f)
< {
< return ::_C_Swamp::clearerr(f);
< }
< #endif
< #ifdef fclose
< #undef fclose
< inline int fclose(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fclose(f);
< }
< #else
< inline int fclose(std::FILE *f)
< {
< return ::_C_Swamp::fclose(f);
< }
< #endif
< #ifdef feof
< #undef feof
< inline int feof(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_feof(f);
< }
< #else
< inline int feof(std::FILE *f)
< {
< return ::_C_Swamp::feof(f);
< }
< #endif
< #ifdef ferror
< #undef ferror
< inline int ferror(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_ferror(f);
< }
< #else
< inline int ferror(std::FILE *f)
< {
< return ::_C_Swamp::ferror(f);
< }
< #endif
< #ifdef fflush
< #undef fflush
< inline int fflush(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fflush(f);
< }
< #else
< inline int fflush(std::FILE *f)
< {
< return ::_C_Swamp::fflush(f);
< }
< #endif
< #ifdef fgetc
< #undef fgetc
< inline int fgetc(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fgetc(f);
< }
< #else
< inline int fgetc(std::FILE *f)
< {
< return ::_C_Swamp::fgetc(f);
< }
< #endif
< #ifdef fgetpos
< #undef fgetpos
< inline int fgetpos(std::FILE *f,std::fpos_t *pos)
< {
< return ::_C_Swamp::_CPP_fgetpos(f,pos);
< }
< #else
< inline int fgetpos(std::FILE *f,std::fpos_t *pos)
< {
< return ::_C_Swamp::fgetpos(f,pos);
< }
< #endif
< #ifdef fgets
< #undef fgets
< inline char *fgets(char *s,int n,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fgets(s,n,f);
< }
< #else
< inline char *fgets(char *s,int n,std::FILE *f)
< {
< return ::_C_Swamp::fgets(s,n,f);
< }
< #endif
< #ifdef fopen
< #undef fopen
< inline std::FILE *fopen(const char *name,const char*mode)
< {
< return reinterpret_cast<std::FILE *>(::_C_Swamp::_CPP_fopen(name,mode));
< }
< #else
< inline std::FILE *fopen(const char *name,const char*mode)
< {
< return reinterpret_cast<std::FILE *>(::_C_Swamp::fopen(name,mode));
< }
< #endif
< #ifdef fputc
< #undef fputc
< inline int fputc(int c,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fputc(c,f);
< }
< #else
< inline int fputc(int c,std::FILE *f)
< {
< return ::_C_Swamp::fputc(c,f);
< }
< #endif
< #ifdef fputs
< #undef fputs
< inline int fputs(const char *c,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fputs(c,f);
< }
< #else
< inline int fputs(const char *c,std::FILE *f)
< {
< return ::_C_Swamp::fputs(c,f);
< }
< #endif
< #ifdef fread
< #undef fread
< inline std::size_t fread(void *p,std::size_t s,std::size_t n,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fread(p,s,n,f);
< }
< #else
< inline std::size_t fread(void *p,std::size_t s,std::size_t n,std::FILE *f)
< {
< return ::_C_Swamp::fread(p,s,n,f);
< }
< #endif
< #ifdef freopen
< #undef freopen
< inline std::FILE *freopen(const char*name,const char*mode,std::FILE *f)
< {
< return reinterpret_cast<std::FILE*>(::_C_Swamp::_CPP_freopen(name,mode,f));
< }
< #else
< inline std::FILE *freopen(const char*name,const char*mode,std::FILE *f)
< {
< return reinterpret_cast<std::FILE*>(::_C_Swamp::freopen(name,mode,f));
< }
---
> #ifndef SEEK_CUR
> #define SEEK_CUR 1
479,489c43,45
< #ifdef fseek
< #undef fseek
< inline int fseek(std::FILE *f,long offset,int whence)
< {
< return ::_C_Swamp::_CPP_fseek(f,offset,whence);
< }
< #else
< inline int fseek(std::FILE *f,long offset,int whence)
< {
< return ::_C_Swamp::fseek(f,offset,whence);
< }
---
>
> #ifndef SEEK_END
> #define SEEK_END 2
491,525c47,49
< #ifdef fsetpos
< #undef fsetpos
< inline int fsetpos(std::FILE *f,const std::fpos_t *p)
< {
< return ::_C_Swamp::_CPP_fsetpos(f,p);
< }
< #else
< inline int fsetpos(std::FILE *f,const std::fpos_t *p)
< {
< return ::_C_Swamp::fsetpos(f,p);
< }
< #endif
< #ifdef ftell
< #undef ftell
< inline long ftell(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_ftell(f);
< }
< #else
< inline long ftell(std::FILE *f)
< {
< return ::_C_Swamp::ftell(f);
< }
< #endif
< #ifdef fwrite
< #undef fwrite
< inline std::size_t fwrite(const void *p,std::size_t s,std::size_t n,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_fwrite(p,s,n,f);
< }
< #else
< inline std::size_t fwrite(const void *p,std::size_t s,std::size_t n,std::FILE *f)
< {
< return ::_C_Swamp::fwrite(p,s,n,f);
< }
---
>
> #ifndef SEEK_SET
> #define SEEK_SET 4
527,537c51
< #ifdef getc
< #undef getc
< inline int getc(std::FILE *f)
< {
< return ::_C_Swamp::_CPP_getc(f);
< }
< #else
< inline int getc(std::FILE *f)
< {
< return ::_C_Swamp::getc(f);
< }
---
>
539,722d52
< #ifdef getchar
< #undef getchar
< inline int getchar()
< {
< return ::_C_Swamp::_CPP_getchar();
< }
< #else
< using ::_C_Swamp::getchar();
< #endif
< #ifdef gets
< #undef gets
< inline char *gets(char*s)
< {
< return ::_C_Swamp::_CPP_gets(s);
< }
< #else
< using ::_C_Swamp::gets;
< #endif
< #ifdef perror
< #undef perror
< inline void perror(const char*s)
< {
< ::_C_Swamp::_CPP_perror(s);
< }
< #else
< using ::_C_Swamp::perror;
< #endif
< #ifdef putc
< #undef putc
< inline int putc(int c,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_putc(c,f);
< }
< #else
< inline int putc(int c,std::FILE *f)
< {
< return ::_C_Swamp::putc(c,f);
< }
< #endif
< #ifdef putchar
< #undef putchar
< inline int putchar(int c)
< {
< return ::_C_Swamp::_CPP_putchar(c);
< }
< #else
< using ::_C_Swamp::putchar;
< #endif
< #ifdef puts
< #undef puts
< inline int puts(const char *s)
< {
< return ::_C_Swamp::_CPP_puts(s);
< }
< #else
< using ::_C_Swamp::puts;
< #endif
< #ifdef remove
< #undef remove
< inline int remove(const char *path)
< {
< return ::_C_Swamp::_CPP_remove(path);
< }
< #else
< using ::_C_Swamp::remove;
< #endif
< #ifdef rename
< #undef rename
< inline int rename(const char *old,const char*new)
< {
< return ::_C_Swamp::_CPP_rename(old,new);
< }
< #else
< using ::_C_Swamp::rename;
< #endif
< #ifdef rewind
< #undef rewind
< inline void rewind(std::FILE *f)
< {
< ::_C_Swamp::_CPP_rewind(f);
< }
< #else
< inline void rewind(std::FILE *f)
< {
< ::_C_Swamp::rewind(f);
< }
< #endif
< #ifdef setbuf
< #undef setbuf
< inline void setbuf(std::FILE *f,char *buf)
< {
< ::_C_Swamp::_CPP_setbuf(f,buf);
< }
< #else
< inline void setbuf(std::FILE *f,char *buf)
< {
< ::_C_Swamp::setbuf(f,buf);
< }
< #endif
< #ifdef setvbuf
< #undef setvbuf
< inline void setvbuf(std::FILE *f,char *buf,int type,std::size_t size)
< {
< ::_C_Swamp::_CPP_setvbuf(f,buf,type,size);
< }
< #else
< inline void setvbuf(std::FILE *f,char *buf,int type,std::size_t size)
< {
< ::_C_Swamp::setvbuf(f,buf,type,size);
< }
< #endif
< #ifdef ungetc
< #undef ungetc
< inline int ungetc(int c,std::FILE *f)
< {
< return ::_C_Swamp::_CPP_ungetc(c,f);
< }
< #else
< inline int ungetc(int c,std::FILE *f)
< {
< return ::_C_Swamp::ungetc(c,f);
< }
< #endif
< #ifdef tmpfile
< #undef tmpfile
< inline std::FILE *tmpfile()
< {
< return reinterpret_cast<std::FILE *>(::_C_Swamp::_CPP_tmpfile());
< }
< #else
< inline std::FILE *tmpfile()
< {
< return reinterpret_cast<std::FILE *>(::_C_Swamp::tmpfile());
< }
< #endif
< #ifdef tmpnam
< #undef tmpnam
< inline char *tmpnam(char *s)
< {
< return ::_C_Swamp::_CPP_tmpnam(s);
< }
< #else
< using ::_C_Swamp::tmpnam;
< #endif
< #ifdef vprintf
< #undef vprintf
< inline int vprintf(const char*f,std::va_list ap)
< {
< return ::_C_Swamp::_CPP_vprintf(f,ap);
< }
< #else
< using ::_C_Swamp::vprintf;
< #endif
< #ifdef vfprintf
< #undef vfprintf
< inline int vfprintf(std::FILE *s,const char*f,std::va_list ap)
< {
< return ::_C_Swamp::_CPP_vfprintf(s,f,ap);
< }
< #else
< inline int vfprintf(std::FILE *s,const char*f,std::va_list ap)
< {
< return ::_C_Swamp::vfprintf(s,f,ap);
< }
< #endif
< #ifdef vsprintf
< #undef vsprintf
< inline int vsprintf(char *s,const char*f,std::va_list ap)
< {
< return ::_C_Swamp::_CPP_vsprintf(s,f,ap);
< }
< #else
< using ::_C_Swamp::vsprintf;
< #endif
< // we have no choice but to use the printf functions as-is
< // since they take a variable argument list
< using ::_C_Swamp::fscanf;
< using ::_C_Swamp::scanf;
< using ::_C_Swamp::sscanf;
< using ::_C_Swamp::printf;
< using ::_C_Swamp::sprintf;
< using ::_C_Swamp::fprintf;
<
< } // close namespace std::
724d53
< #undef _IN_C_SWAMP_
726c55,60
< #endif
---
>
>
>
>
>
>
diff -r ./bits/std_cstdlib.h /work/egcs/include/g++-v3//bits/std_cstdlib.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSTDLIB_
< #define _CPP_INCLUDE_CSTDLIB_
---
> // -*- C++ -*- forwarding header.
5,23c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <stdlib.h>
< }
< namespace _C_Shadow { } // placeholder
< // types first
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
< #ifdef div_t
< typedef div_t _CPP_div_t;
< #endif
< #ifdef ldiv_t
< typedef ldiv_t _CPP_ldiv_t;
< #endif
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
25,61c11,14
< namespace std
< {
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
< #endif
< #endif
< #ifdef div_t
< #undef div_t
< struct div_t:
< ::_C_Swamp::_CPP_div_t
< {
< };
< #else
< struct div_t:
< ::_C_Swamp::div_t
< {
< };
< #endif
< #ifdef ldiv_t
< #undef ldiv_t
< struct ldiv_t:
< ::_C_Swamp::_CPP_ldiv_t
< {
< };
< #else
< struct ldiv_t:
< ::_C_Swamp::ldiv_t
< {
< };
< #endif
<
< }
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
63,231c16,19
< // then functions
< namespace _C_Swamp
< {
< #ifdef atoi
< inline int _CPP_atoi(const char *c)
< {
< return atoi(c);
< }
< #endif
< #ifdef atof
< inline double _CPP_atof(const char *c)
< {
< return atof(c);
< }
< #endif
< #ifdef atol
< inline long _CPP_atol(const char *c)
< {
< return atol(c);
< }
< #endif
< #ifdef bsearch
< inline void *_CPP_bsearch(const void *key, const void *base, size_t nel,
< size_t size, int (*compar)(const void *,const void *))
< {
< return bsearch(key,base,nel,size,compar);
< }
< #endif
< #ifdef free
< inline void _CPP_free(void *p)
< {
< free(p);
< }
< #endif
< #ifdef malloc
< inline void *_CPP_malloc(size_t s)
< {
< return malloc(s);
< }
< #endif
< #ifdef calloc
< inline void *_CPP_calloc(size_t n,size_t s)
< {
< return calloc(n,s);
< }
< #endif
< #ifdef abs
< inline int _CPP_abs(int x)
< {
< return abs(x);
< }
< #endif
< #ifdef labs
< inline long _CPP_labs(long x)
< {
< return labs(x);
< }
< #endif
< #ifdef abort
< inline void _CPP_abort(void)
< {
< abort();
< }
< #endif
< #ifdef exit
< inline void _CPP_exit(int status)
< {
< exit(status);
< }
< #endif
< #ifdef atexit
< inline int _CPP_atexit(void (*func)(void))
< {
< return atexit(func);
< }
< #endif
< #ifdef div
< inline div_t _CPP_div(int num,int denom)
< {
< return div(num,denom);
< }
< #endif
< #ifdef ldiv
< inline ldiv_t _CPP_ldiv(int num,int denom)
< {
< return ldiv(num,denom);
< }
< #endif
< #ifdef getenv
< inline char *_CPP_getenv(const char*name)
< {
< return getenv(name);
< }
< #endif
< #ifdef mblen
< inline int _CPP_mblen(const char *s,size_t n)
< {
< return mblen(s,n);
< }
< #endif
< #ifdef qsort
< inline void _CPP_qsort(void *base, size_t nel, size_t width, int
< (*compar)(const void *, const void *))
< {
< return qsort(base,nel,width,compar);
< }
< #endif
< #ifdef rand
< inline int _CPP_rand()
< {
< return rand();
< }
< #endif
< #ifdef realloc
< inline void *_CPP_realloc(void *p,size_t size)
< {
< return realloc(p,size);
< }
< #endif
< #ifdef srand
< inline void _CPP_srand(unsigned seed)
< {
< srand(seed);
< }
< #endif
< #ifdef mbstowcs
< inline size_t _CPP_mbstowcs(wchar_t *dst, const char **src, size_t len)
< {
< return mbstowcs(dst,src,len);
< }
< #endif
< #ifdef mbtowc
< inline int _CPP_mbtowc(wchar_t *dst, const char *src, size_t len)
< {
< return mbtowc(dst,src,len);
< }
< #endif
< #ifdef strtod
< inline double _CPP_strtod(const char *s,char **ep)
< {
< return strtod(s,ep);
< }
< #endif
< #ifdef strtol
< inline double _CPP_strtol(const char *s,char **ep,int base)
< {
< return strtol(s,ep,base);
< }
< #endif
< #ifdef strtoul
< inline double _CPP_strtoul(const char *s,char **ep,int base)
< {
< return strtoul(s,ep,base);
< }
< #endif
< #ifdef system
< inline int _CPP_system(const char *s)
< {
< system(s);
< }
< #endif
< #ifdef wctomb
< inline int _CPP_wctomb(char *s,wchar_t c)
< {
< return wctomb(s,c);
< }
< #endif
<
< }
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
233,241c21,41
< namespace std {
< #ifdef atoi
< #undef atoi
< inline int atoi(const char *c)
< {
< return _CPP_atoi(c);
< }
< #else
< using ::_C_Swamp::atoi;
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: 20.4.6 C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CSTDLIB
> #define _CPP_CSTDLIB 1
>
> // This keeps isanum, et al from being propagated as macros.
> #if __linux__
> #define __USE_ISOC9X 1
243,488d42
< #ifdef atof
< #undef atof
< inline double atof(const char *c)
< {
< return _CPP_atof(c);
< }
< #else
< using ::_C_Swamp::atof;
< #endif
< #ifdef atol
< #undef atol
< inline long atol(const char *c)
< {
< return _CPP_atol(c);
< }
< #else
< using ::_C_Swamp::atol;
< #endif
< #ifdef bsearch
< #undef bsearch
< inline void *bsearch(const void *key, const void *base, std::size_t nel,
< std::size_t size, int (*compar)(const void *,const void *))
< {
< return ::_C_Swamp::_CPP_bsearch(key,base,nel,size,compar);
< }
< #else
< using ::_C_Swamp::bsearch;
< #endif
< #ifdef free
< #undef free
< inline void free(void *p)
< {
< _CPP_free(c);
< }
< #else
< using ::_C_Swamp::free;
< #endif
< #ifdef malloc
< #undef malloc
< inline void *malloc(std::size_t s)
< {
< return _CPP_malloc(s);
< }
< #else
< using ::_C_Swamp::malloc;
< #endif
< #ifdef calloc
< #undef calloc
< inline void *calloc(std::size_t n,std::size_t s)
< {
< return _CPP_calloc(n,s);
< }
< #else
< using ::_C_Swamp::calloc;
< #endif
< #ifdef abs
< #undef abs
< inline int abs(int x)
< {
< return ::_C_Swamp::_CPP_abs(x);
< }
< #else
< using ::_C_Swamp::abs;
< #endif
< #ifdef labs
< #undef labs
< inline long labs(long x)
< {
< return ::_C_Swamp::_CPP_labs(x);
< }
< #else
< using ::_C_Swamp::labs;
< #endif
< #ifdef abort
< #undef abort
< inline void abort(void)
< {
< ::_C_Swamp::_CPP_abort();
< }
< #else
< using ::_C_Swamp::abort;
< #endif
< #ifdef exit
< #undef exit
< inline void exit(int status)
< {
< ::_C_Swamp::_CPP_exit(status);
< }
< #else
< using ::_C_Swamp::exit;
< #endif
< #ifdef atexit
< #undef atexit
< inline int atexit(void (*func)(void))
< {
< return ::_C_Swamp::_CPP_atexit(func);
< }
< #else
< using ::_C_Swamp::atexit;
< #endif
< #ifdef div
< #undef div
< inline std::div_t div(int num,int denom)
< {
< ::_C_Swamp::div_t tmp=::_C_Swamp::_CPP_div(num,denom);
< return *(reinterpret_cast<std::div_t*>(&tmp));
< }
< #else
< inline std::div_t div(int num,int denom)
< {
< ::_C_Swamp::div_t tmp=::_C_Swamp::div(num,denom);
< return *(reinterpret_cast<std::div_t*>(&tmp));
< }
< #endif
< #ifdef ldiv
< #undef ldiv
< inline std::ldiv_t ldiv(int num,int denom)
< {
< ::_C_Swamp::ldiv_t tmp=::_C_Swamp::_CPP_ldiv(num,denom);
< return *(reinterpret_cast<std::ldiv_t*>(&tmp));
< }
< #else
< inline std::ldiv_t ldiv(int num,int denom)
< {
< ::_C_Swamp::ldiv_t tmp=::_C_Swamp::ldiv(num,denom);
< return *(reinterpret_cast<std::ldiv_t*>(&tmp));
< }
< #endif
< #ifdef getenv
< #undef getenv
< inline char *getenv(const char*name)
< {
< return ::_C_Swamp::_CPP_getenv(name);
< }
< #else
< using ::_C_Swamp::getenv;
< #endif
< #ifdef mblen
< #undef mblen
< inline int mblen(const char*s,std::size_t n)
< {
< return ::_C_Swamp::_CPP_mblen(s,n);
< }
< #else
< using ::_C_Swamp::mblen;
< #endif
< #ifdef qsort
< #undef qsort
< inline void qsort(void *base, std::size_t nel, std::size_t width, int
< (*compar)(const void *, const void *))
< {
< return ::_C_Swamp::_CPP_qsort(base,nel,width,compar);
< }
< #else
< using ::_C_Swamp::qsort;
< #endif
< #ifdef rand
< #undef rand
< inline int rand()
< {
< return ::_C_Swamp::_CPP_rand();
< }
< #else
< using ::_C_Swamp::rand;
< #endif
< #ifdef realloc
< #undef realloc
< inline void *realloc(void *p,std::size_t size)
< {
< return ::_C_Swamp::_CPP_realloc(p,size);
< }
< #else
< using ::_C_Swamp::realloc;
< #endif
< #ifdef srand
< #undef srand
< inline void srand(unsigned seed)
< {
< ::_C_Swamp::_CPP_srand(seed);
< }
< #else
< using ::_C_Swamp::srand;
< #endif
< #ifdef mbstowcs
< #undef mbstowcs
< inline std::size_t mbstowcs(wchar_t *dst, const char **src, std::size_t len)
< {
< return ::_C_Swamp::_CPP_mbstowcs(dst,src,len);
< }
< #else
< using ::_C_Swamp::mbstowcs;
< #endif
< #ifdef mbtowc
< #undef mbtowc
< inline int mbtowc(wchar_t *dst, const char *src, std::size_t len)
< {
< return ::_C_Swamp::_CPP_mbtowc(dst,src,len);
< }
< #else
< using ::_C_Swamp::mbtowc;
< #endif
< #ifdef strtod
< #undef strtod
< inline double strtod(const char*s,char **ep)
< {
< return ::_C_Swamp::_CPP_strtod(s,ep);
< }
< #else
< using ::_C_Swamp::strtod;
< #endif
< #ifdef strtol
< #undef strtol
< inline long strtol(const char*s,char **ep,int base)
< {
< return ::_C_Swamp::_CPP_strtol(s,ep,base);
< }
< #else
< using ::_C_Swamp::strtol;
< #endif
< #ifdef strtoul
< #undef strtoul
< inline unsigned long strtoul(const char*s,char **ep,int base)
< {
< return ::_C_Swamp::_CPP_strtoul(s,ep,base);
< }
< #else
< using ::_C_Swamp::strtoul;
< #endif
< #ifdef system
< #undef system
< inline int system(const char*s)
< {
< return ::_C_Swamp::_CPP_system(s);
< }
< #else
< using ::_C_Swamp::system;
< #endif
< #ifdef wctomb
< #undef wctomb
< inline int wctomb(char *s,wchar_t c)
< {
< return ::_C_Swamp::_CPP_wctomb;
< }
< #else
< using ::_C_Swamp::wctomb;
< #endif
490,492c44
< // now define overloads for types that don't match the C library
< inline long
< abs(long __l) { return labs(__l); }
---
> # include_next <stdlib.h>
494,495c46
< inline std::ldiv_t
< div(long __a, long __b) { return ldiv(__a, __b); }
---
> #endif // _CPP_CSTDLIB
497d47
< } // close namespace std::
499d48
< #undef _IN_C_SWAMP_
501c50,53
< #endif
---
>
>
>
>
diff -r ./bits/std_cstring.h /work/egcs/include/g++-v3//bits/std_cstring.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CSTRING_
< #define _CPP_INCLUDE_CSTRING_
---
> // -*- C++ -*- forwarding header.
5,28c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <string.h>
< }
< namespace _C_Shadow { } // placeholder
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
< }
< namespace std
< {
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
< #endif
< #endif
< }
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
30,185c11,14
< namespace _C_Swamp
< {
< #ifdef memchr
< inline const void* _CPP_memchr(const void* s, int c, std::size_t n)
< {
< return memchr(const_cast<void*>(s),c,n);
< }
< inline void* _CPP_memchr(void* s, int c, std::size_t n)
< {
< return memchr(s,c,n);
< }
< #endif
< #ifdef memmove
< inline void *_CPP_memmove( void *dest, const void *src, std::size_t count )
< {
< return memmove(dest,src,count);
< }
< #endif
< #ifdef memcpy
< inline void *_CPP_memcpy( void *dest, const void *src, std::size_t count )
< {
< return memcpy(dest,src,count);
< }
< #endif
< #ifdef memcmp
< inline int _CPP_memcmp(const void*s1,const void*s2,std::size_t n)
< {
< return memcmp(s1,s2,n);
< }
< #endif
< #ifdef memset
< inline void *_CPP_memset(void*s1,int c,std::size_t n)
< {
< return memset(s1,c,n);
< }
< #endif
< #ifdef strlen
< inline std::size_t _CPP_strlen(const char*s)
< {
< return strlen(s);
< }
< #endif
< #ifdef strncmp
< inline int _CPP_strncmp(const char*s1,const char*s2,std::size_t n)
< {
< return strncmp(s1,s2,n);
< }
< #endif
< #ifdef strcmp
< inline int _CPP_strcmp(const char*s1,const char*s2)
< {
< return strcmp(s1,s2);
< }
< #endif
< #ifdef strcat
< inline char *_CPP_strcat(char*s1,const char*s2)
< {
< return strcat(s1,s2);
< }
< #endif
< #ifdef strchr
< inline const char* _CPP_strchr(const char* s, int c)
< {
< return strchr(s,c);
< }
< inline char* _CPP_strchr(char* s, int c)
< {
< return strchr(s,c);
< }
< #endif
< #ifdef strcoll
< inline int _CPP_strcoll(const char*s1,const char*s2)
< {
< return strcoll(s1,s2);
< }
< #endif
< #ifdef strcpy
< inline char *_CPP_strcpy( char *dest, const char *src)
< {
< return strcpy(dest,src);
< }
< #endif
< #ifdef strcspn
< inline size_t _CPP_strcspn(const char*s1,const char*s2)
< {
< return strcspn(s1,s2);
< }
< #endif
< #ifdef strerror
< inline char*_CPP_strerror(int errnum)
< {
< return strerror(errnum);
< }
< #endif
< #ifdef strncat
< inline char *_CPP_strncat(char*s1,const char*s2,size_t n)
< {
< return strncat(s1,s2,n);
< }
< #endif
< #ifdef strncpy
< inline char *_CPP_strncpy( char *dest, const char *src, std::size_t count )
< {
< return strncpy(dest,src,count);
< }
< #endif
< #ifdef strpbrk
< inline const char* _CPP_strpbrk(const char* s, const char *s2)
< {
< return strpbrk(s,s2);
< }
< inline char* _CPP_strpbrk(char* s, const char *s2)
< {
< return strpbrk(s,s2);
< }
< #endif
< #ifdef strrchr
< inline const char* _CPP_strrchr(const char* s, int c)
< {
< return strrchr(s,c);
< }
< inline char* _CPP_strrchr(char* s, int c)
< {
< return strrchr(s,c);
< }
< #endif
< #ifdef strspn
< inline size_t _CPP_strspn(const char *s1,const char*s2)
< {
< return strspn(s1,s2);
< }
< #endif
< #ifdef strstr
< inline const char* _CPP_strstr(const char* s, const char *s2)
< {
< return strstr(s,s2);
< }
< inline char* _CPP_strstr(char* s, const char *s2)
< {
< return strstr(s,s2);
< }
< #endif
< #ifdef strtok
< inline char *_CPP_strtok(char *s1,const char*s2)
< {
< return strtok(s1,s2);
< }
< #endif
< #ifdef strxfrm
< inline size_t _CPP_strxfrm(char *s1,const char *s2,size_t n)
< {
< return strxfrm(s1,s2,n);
< }
< #endif
<
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
187,442c16,19
< namespace std {
<
< #ifdef memchr
< #undef memchr
< inline const void* memchr(const void* s, int c, std::size_t n)
< {
< return ::_C_Swamp::_CPP_memchr(s,c,n);
< }
< inline void* memchr(void* s, int c, std::size_t n)
< {
< return ::_C_Swamp::_CPP_memchr(s,c,n);
< }
< #else
< inline const void* memchr(const void* s, int c, std::size_t n)
< {
< return ::_C_Swamp::memchr(const_cast<void*>(s),c,n);
< }
< inline void* memchr(void* s, int c, std::size_t n)
< {
< return ::_C_Swamp::memchr(s,c,n);
< }
< #endif
< #ifdef memmove
< #undef memmove
< inline void *memmove( void *dest, const void *src, std::size_t count )
< {
< return ::_C_Swamp::_CPP_memmove(dest,src,count);
< }
< #else
< using ::_C_Swamp::memmove;
< #endif
< #ifdef memcpy
< #undef memcpy
< inline void *memcpy( void *dest, const void *src, std::size_t count )
< {
< return ::_C_Swamp::_CPP_memcpy(dest,src,count);
< }
< #else
< using ::_C_Swamp::memcpy;
< #endif
< #ifdef memcmp
< #undef memcmp
< inline int memcmp(const void*s1,const void*s2,std::size_t n)
< {
< return ::_C_Swamp::_CPP_memcmp(s1,s2,n);
< }
< #else
< using ::_C_Swamp::memcmp;
< #endif
< #ifdef memset
< #undef memset
< inline void *memset(void*s1,int c,std::size_t n)
< {
< return ::_C_Swamp::_CPP_memset(s1,c,n);
< }
< #else
< using ::_C_Swamp::memset;
< #endif
< #ifdef strlen
< #undef strlen
< inline std::size_t strlen(const char*s)
< {
< return ::_C_Swamp::_CPP_strlen(s);
< }
< #else
< using ::_C_Swamp::strlen;
< #endif
< #ifdef strncmp
< #undef strncmp
< inline int strncmp(const char*s1,const char*s2,std::size_t n)
< {
< return ::_C_Swamp::_CPP_strncmp(s1,s2,n);
< }
< #else
< using ::_C_Swamp::strncmp;
< #endif
< #ifdef strcmp
< #undef strcmp
< inline int strcmp(const char*s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strcmp(s1,s2);
< }
< #else
< using ::_C_Swamp::strcmp;
< #endif
< #ifdef strcat
< #undef strcat
< inline char *strcat(char*s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strcat(s1,s2);
< }
< #else
< using ::_C_Swamp::strcat;
< #endif
< #ifdef strchr
< #undef strchr
< inline const char* strchr(const char* s, int c)
< {
< return ::_C_Swamp::_CPP_strchr(s,c);
< }
< inline char* strchr(char* s, int c)
< {
< return ::_C_Swamp::_CPP_strchr(s,c);
< }
< #else
< inline const char* strchr(const char* s, int c)
< {
< return ::_C_Swamp::strchr(s,c);
< }
< inline char* strchr(char* s, int c)
< {
< return ::_C_Swamp::strchr(s,c);
< }
< #endif
< #ifdef strcoll
< #undef strcoll
< inline int strcoll(const char*s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strcoll(s1,s2);
< }
< #else
< using ::_C_Swamp::strcoll;
< #endif
< #ifdef strcpy
< #undef strcpy
< inline char *strcpy(char *dest,const char*src)
< {
< return ::_C_Swamp::_CPP_strcpy(dest,src);
< }
< #else
< using ::_C_Swamp::strcpy;
< #endif
< #ifdef strcspn
< #undef strcspn
< inline std::size_t strcspn(const char*s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strcspn(s1,s2);
< }
< #else
< using ::_C_Swamp::strcspn;
< #endif
< #ifdef strerror
< #undef strerror
< inline char*strerror(int errnum)
< {
< return ::_C_Swamp::_CPP_strerror(errnum);
< }
< #else
< using ::_C_Swamp::strerror;
< #endif
< #ifdef strncat
< #undef strncat
< inline char *strncat(char*s1,const char*s2,std::size_t n)
< {
< return ::_C_Swamp::_CPP_strncat(s1,s2,n);
< }
< #else
< using ::_C_Swamp::strncat;
< #endif
< #ifdef strncpy
< #undef strncpy
< inline char *strncpy( char *dest, const char *src, std::size_t count )
< {
< return ::_C_Swamp::_CPP_strncpy(dest,src,count);
< }
< #else
< using ::_C_Swamp::strncpy;
< #endif
< #ifdef strpbrk
< #undef strpbrk
< inline const char* strpbrk(const char* s, const char *s2)
< {
< return ::_C_Swamp::_CPP_strpbrk(s,s2);
< }
< inline char* strpbrk(char* s, const char *s2)
< {
< return ::_C_Swamp::_CPP_strpbrk(s,s2);
< }
< #else
< inline const char* strpbrk(const char* s, const char *s2)
< {
< return ::_C_Swamp::strpbrk(s,s2);
< }
< inline char* strpbrk(char* s, const char *s2)
< {
< return ::_C_Swamp::strpbrk(s,s2);
< }
< #endif
< #ifdef strrchr
< #undef strrchr
< inline const char* strrchr(const char* s, int c)
< {
< return ::_C_Swamp::_CPP_strrchr(s,c);
< }
< inline char* strrchr(char* s, int c)
< {
< return ::_C_Swamp::_CPP_strrchr(s,c);
< }
< #else
< inline const char* strrchr(const char* s, int c)
< {
< return ::_C_Swamp::strrchr(s,c);
< }
< inline char* strrchr(char* s, int c)
< {
< return ::_C_Swamp::strrchr(s,c);
< }
< #endif
< #ifdef strspn
< #undef strspn
< inline std::size_t strspn(const char*s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strspn(s1,s2);
< }
< #else
< using ::_C_Swamp::strspn;
< #endif
< #ifdef strstr
< #undef strstr
< inline const char* strstr(const char* s, const char *s2)
< {
< return ::_C_Swamp::_CPP_strstr(s,s2);
< }
< inline char* strstr(char* s, const char *s2)
< {
< return ::_C_Swamp::_CPP_strstr(s,s2);
< }
< #else
< inline const char* strstr(const char* s, const char *s2)
< {
< return ::_C_Swamp::strstr(s,s2);
< }
< inline char* strstr(char* s, const char *s2)
< {
< return ::_C_Swamp::strstr(s,s2);
< }
< #endif
< #ifdef strtok
< #undef strtok
< inline char *strtok(char *s1,const char*s2)
< {
< return ::_C_Swamp::_CPP_strtok(s1,s2);
< }
< #else
< using ::_C_Swamp::strtok;
< #endif
< #ifdef strxfrm
< #undef strxfrm
< inline std::size_t strxfrm(char *s1,const char*s2,std::size_t n)
< {
< return ::_C_Swamp::_CPP_strxfrm(s1,s2,n);
< }
< #else
< using ::_C_Swamp::strxfrm;
< #endif
< } // close namespace std::
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
444c21,28
< #undef _IN_C_SWAMP_
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
445a30,42
> //
> // ISO C++ 14882: 20.4.6 C library
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CSTRING
> #define _CPP_CSTRING 1
> # if defined __GLIBC__ && __GLIBC__ >= 2
> // We must not see the optimized string functions GNU libc defines.
> # define __NO_STRING_INLINES
> # endif
> # include_next <string.h>
diff -r ./bits/std_ctime.h /work/egcs/include/g++-v3//bits/std_ctime.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CTIME_
< #define _CPP_INCLUDE_CTIME_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <time.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12,27c11,14
< // types first
< #ifdef tm
< typedef tm _CPP_tm;
< #endif
< #ifdef clock_t
< typedef clock_t _CPP_clock_t;
< #endif
< #ifdef time_t
< typedef time_t _CPP_time_t;
< #endif
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
< } // close namespace ::_C_Swamp::
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
29c16,19
< namespace std {
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
31,64c21,28
< #ifdef tm
< #undef tm
< struct tm:
< ::_C_Swamp::_CPP_tm
< {
< };
< #else
< struct tm:
< ::_C_Swamp::tm
< {
< };
< #endif
< #ifdef clock_t
< #undef clock_t
< typedef ::_C_Swamp::_CPP_clock_t clock_t ;
< #else
< typedef ::_C_Swamp::clock_t clock_t;
< #endif
< #ifdef time_t
< #undef time_t
< typedef ::_C_Swamp::_CPP_time_t time_t;
< #else
< typedef ::_C_Swamp::time_t time_t;
< #endif
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
< #endif
< #endif
< } // close namespace std::
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
66,124c30,32
< // functions
< namespace _C_Swamp
< {
< #ifdef asctime
< inline char *_CPP_asctime(const ::_C_Swamp::tm *_tm)
< {
< return asctime(_tm);
< }
< #endif
< #ifdef clock
< inline clock_t _CPP_clock(void)
< {
< return clock();
< }
< #endif
< #ifdef ctime
< inline char *_CPP_ctime(const time_t *clock)
< {
< return ctime(clock);
< }
< #endif
< #ifdef difftime
< inline double _CPP_difftime(time_t time1, time_t time0)
< {
< return difftime(time1,time0);
< }
< #endif
< #ifdef gmtime
< inline tm *_CPP_gmtime(const time_t *clock)
< {
< return gmtime(clock);
< }
< #endif
< #ifdef localtime
< inline tm *_CPP_localtime(const time_t *clock)
< {
< return localtime(clock);
< }
< #endif
< #ifdef mktime
< inline time_t _CPP_mktime(tm *p)
< {
< return mktime(p);
< }
< #endif
< #ifdef strftime
< inline size_t _CPP_strftime(char *s,size_t ms,const char *fmt,const tm*tp)
< {
< return strftime(s,ms,fmt,tp);
< }
< #endif
< #ifdef time
< inline time_t _CPP_time(time_t *tloc)
< {
< return time(tloc);
< }
< #endif
<
< }
---
> //
> // ISO C++ 14882: 20.5 Date and time
> //
126,224c34
< namespace std
< {
< #ifdef asctime
< #undef asctime
< inline char *asctime(const std::tm *_tm)
< {
< return ::_C_Swamp::_CPP_asctime(_tm);
< }
< #else
< inline char *asctime(const std::tm *_tm)
< {
< return ::_C_Swamp::asctime(_tm);
< }
< #endif
< #ifdef clock
< #undef clock
< inline std::clock_t clock(void)
< {
< return ::_C_Swamp::_CPP_clock();
< }
< #else
< using ::_C_Swamp::clock;
< #endif
< #ifdef ctime
< #undef ctime
< inline char *ctime(const std::time_t *clock)
< {
< return ::_C_Swamp::_CPP_ctime(clock);
< }
< #else
< using ::_C_Swamp::ctime;
< #endif
< #ifdef difftime
< #undef difftime
< inline double difftime(time_t time1, time_t time0)
< {
< return ::_C_Swamp::_CPP_difftime(time1,time0);
< }
< #else
< using ::_C_Swamp::difftime;
< #endif
< #ifdef gmtime
< #undef gmtime
< inline std::tm *gmtime(const std::time_t *clock)
< {
< return reinterpret_cast<std::tm*>(::_C_Swamp::_CPP_gmtime(clock));
< }
< #else
< inline std::tm *gmtime(const std::time_t *clock)
< {
< return reinterpret_cast<std::tm*>(::_C_Swamp::gmtime(clock));
< }
< #endif
< #ifdef localtime
< #undef localtime
< inline std::tm *localtime(const std::time_t *clock)
< {
< return reinterpret_cast<std::tm*>(::_C_Swamp::_CPP_localtime(clock));
< }
< #else
< inline std::tm *localtime(const std::time_t *clock)
< {
< return reinterpret_cast<std::tm*>(::_C_Swamp::localtime(clock));
< }
< #endif
< #ifdef mktime
< #undef mktime
< inline std::time_t mktime(std::tm *p)
< {
< return ::_C_Swamp::_CPP_mktime(p);
< }
< #else
< inline std::time_t mktime(std::tm *p)
< {
< return ::_C_Swamp::mktime(p);
< }
< #endif
< #ifdef strftime
< #undef strftime
< inline std::size_t strftime(char *s,std::size_t ms,const char *fmt,const std::tm*tp)
< {
< return ::_C_Swamp::_CPP_strftime(s,ms,fmt,tp);
< }
< #else
< inline std::size_t strftime(char *s,std::size_t ms,const char *fmt,const std::tm*tp)
< {
< return ::_C_Swamp::strftime(s,ms,fmt,tp);
< }
< #endif
< #ifdef time
< #undef time
< inline std::time_t time(std::time_t *tloc)
< {
< return ::_C_Swamp::_CPP_time(tloc);
< }
< #else
< using ::_C_Swamp::time;
< #endif
< }
---
> // Note: this is not a conforming implementation.
226,228c36,38
<
< #undef _IN_C_SWAMP_
<
---
> #ifndef _CPP_CTIME
> #define _CPP_CTIME 1
> # include_next <time.h>
diff -r ./bits/std_cwchar.h /work/egcs/include/g++-v3//bits/std_cwchar.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CWCHAR_
< #define _CPP_INCLUDE_CWCHAR_
---
> // -*- C++ -*- forwarding header.
5,10c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <wchar.h>
< }
< namespace _C_Shadow { } // placeholder
---
> // Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
12c11,14
< // types first
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
14,29c16,19
< #ifndef _CPP___FILE
< #ifdef __FILE
< typedef __FILE _CPP___FILE;
< #endif
< #endif
< #ifdef mbstate_t
< typedef mbstate_t _CPP_mbstate_t;
< #endif
< #ifdef wint_t
< typedef wint_t _CPP_wint_t;
< #endif
< #ifndef _CPP_SIZE_T
< #ifdef size_t
< typedef size_t _CPP_size_t;
< #endif
< #endif
---
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
31c21,28
< } // close namespace ::_C_Swamp::
---
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
33,53c30,49
< namespace std {
<
< // the following assumes that the __FILE structure is actually defined in full
< // in the C headers
< // (since all functions use __FILE * it could just be an opaque structure
< // declared with
< // struct __FILE;
< // )
< #ifndef _CPP___FILE
< #define _CPP___FILE
< #ifdef __FILE
< #undef __FILE
< struct __FILE:
< ::_C_Swamp::_CPP___FILE
< {
< };
< #else
< struct __FILE:
< ::_C_Swamp::__FILE
< {
< };
---
> //
> // ISO C++ 14882: ???
> //
>
> // Note: this is not a conforming implementation.
>
> #ifndef _CPP_CWCHAR
> #define _CPP_CWCHAR 1
>
> #include <bits/c++config.h>
> #ifdef _GLIBCPP_USE_WCHAR_T
> # include_next <wchar.h>
> #endif
>
> extern "C" {
>
> #ifdef _GLIBCPP_USE_WCHAR_T
>
> #ifndef _GLIBCPP_HAVE_WMEMCMP
> int wmemcmp(const wchar_t* __s1, const wchar_t* __s2, size_t __n);
54a51,53
>
> #ifndef _GLIBCPP_HAVE_WCSLEN
> size_t wcslen(const wchar_t* __s);
56,66c55,57
< #ifdef mbstate_t
< #undef mbstate_t
< typedef ::_C_Swamp::_CPP_mbstate_t mbstate_t;
< #else
< typedef ::_C_Swamp::mbstate_t mbstate_t;
< #endif
< #ifdef wint_t
< #undef wint_t
< typedef ::_C_Swamp::_CPP_wint_t wint_t;
< #else
< typedef ::_C_Swamp::wint_t wint_t;
---
>
> #ifndef _GLIBCPP_HAVE_WMEMCHR
> wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n);
68,74c59,61
< #ifndef _CPP_SIZE_T
< #define _CPP_SIZE_T
< #ifdef size_t
< #undef size_t
< typedef ::_C_Swamp::_CPP_size_t size_t;
< #else
< typedef ::_C_Swamp::size_t size_t;
---
>
> #ifndef _GLIBCPP_HAVE_WMEMMOVE
> wchar_t* wmemmove(wchar_t* __s1, const wchar_t* __s2, size_t __n);
75a63,65
>
> #ifndef _GLIBCPP_HAVE_WMEMCPY
> wchar_t* wmemcpy(wchar_t* __s1, const wchar_t* __s2, size_t __n);
77,78d66
<
< } // close namespace std::
80,93c68,69
< // then functions
< namespace _C_Swamp
< {
< #ifdef btowc
< inline wint_t _CPP_btowc(int c)
< {
< return btowc(c);
< }
< #endif
< #ifdef mbrlen
< inline size_t _CPP_mbrlen(const char*s,size_t n,mbstate_t *ps)
< {
< return mbrlen(s,n,ps);
< }
---
> #ifndef _GLIBCPP_HAVE_WMEMSET
> wchar_t* wmemset(wchar_t* __s, wchar_t __c, size_t __n);
95,105c71,83
< #ifdef mbrtowc
< inline size_t _CPP_mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
< {
< return mbrtowc(pwc,s,n,ps);
< }
< #endif
< #ifdef mbsinit
< inline int _CPP_mbsinit(const mbstate_t *ps)
< {
< return mbsinit(ps);
< }
---
>
> #endif //_GLIBCPP_USE_WCHAR_T
>
> // NB: mbstate_t should be defined in <cwchar>, as per
> // 21.2 p5
> // If not, autoconf will
> // detect this with some configure time magic and define
> // _GLIBCPP_NEED_MBSTATE_T (see config.h in the build directory.)
> #ifdef _GLIBCPP_NEED_MBSTATE_T
> typedef struct
> {
> int __fill[6];
> } mbstate_t;
107,167d84
< #ifdef mbsrtowcs
< inline size_t _CPP_mbsrtowcs(wchar_t *dst, const char **src, size_t len,
< mbstate_t *ps)
< {
< return mbsrtowcs(dst,src,len,ps);
< }
< #endif
< #ifdef fgetwc
< inline wint_t _CPP_fgetwc(__FILE *f)
< {
< return fgetwc(f);
< }
< #endif
< #ifdef fgetws
< inline wchar_t *_CPP_fgetws(wchar_t *s,int n,__FILE *f)
< {
< return fgetws(s,n,f);
< }
< #endif
< #ifdef fputwc
< inline wint_t _CPP_fputwc(wint_t c,__FILE *f)
< {
< return fputwc(c,f);
< }
< #endif
< #ifdef fputws
< inline int _CPP_fputws(const wchar_t *c,__FILE *f)
< {
< return fputws(c,f);
< }
< #endif
< #ifdef fwide
< inline int _CPP_fwide(__FILE *f,int c)
< {
< return fwide(f,c);
< }
< #endif
< #ifdef putwc
< inline wint_t _CPP_putwc(wint_t c,__FILE *f)
< {
< return putwc(c,f);
< }
< #endif
< #ifdef putwchar
< inline wint_t _CPP_putwchar(wint_t c)
< {
< return putwchar(c);
< }
< #endif
< #ifdef ungetwc
< inline wint_t _CPP_ungetwc(wint_t c,__FILE *f)
< {
< return ungetwc(c,f);
< }
< #endif
< #ifdef wcrtomb
< inline size_t _CPP_wcrtomb(char *s,wchar_t c,mbstate_t *mb)
< {
< return wcrtomb(s,c,mb);
< }
< #endif
170,295d86
< namespace std
< {
< #ifdef btowc
< #undef btowc
< inline std::wint_t btowc(int c)
< {
< return ::_C_Swamp::_CPP_btowc(c);
< }
< #else
< using ::_C_Swamp::btowc;
< #endif
< #ifdef mbrlen
< #undef mbrlen
< inline std::size_t mbrlen(const char*s,std::size_t n,std::mbstate_t *ps)
< {
< return ::_C_Swamp::_CPP_mbrlen(s,n,ps);
< }
< #else
< using ::_C_Swamp::mbrlen;
< #endif
< #ifdef mbrtowc
< #undef mbrtowc
< inline std::size_t mbrtowc(wchar_t *pwc, const char *s, std::size_t n, std::mbstate_t *ps)
< {
< return ::_C_Swamp::_CPP_mbrtowc(pwc,s,n,ps);
< }
< #else
< using ::_C_Swamp::mbrtowc;
< #endif
< #ifdef mbsinit
< #undef mbsinit
< inline int mbsinit(const mbstate_t *ps)
< {
< return ::_C_Swamp::_CPP_mbsinit(ps);
< }
< #else
< using ::_C_Swamp::mbsinit;
< #endif
< #ifdef mbsrtowcs
< #undef mbsrtowcs
< inline std::size_t mbsrtowcs(wchar_t *dst, const char **src, std::size_t len,
< std::mbstate_t *ps)
< {
< return ::_C_Swamp::_CPP_mbsrtowcs(dst,src,len,ps);
< }
< #else
< using ::_C_Swamp::mbsrtowcs;
< #endif
< #ifdef fgetwc
< #undef fgetwc
< inline std::wint_t fgetwc(std::__FILE *f)
< {
< return ::_C_Swamp::_CPP_fgetwc(f);
< }
< #else
< inline std::wint_t fgetwc(std::__FILE *f)
< {
< return ::_C_Swamp::fgetwc(f);
< }
< #endif
< #ifdef fputwc
< #undef fputwc
< inline std::wint_t fputwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::_CPP_fputwc(c,f);
< }
< #else
< inline std::wint_t fputwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::fputwc(c,f);
< }
< #endif
< #ifdef fwide
< #undef fwide
< inline int fwide(std::__FILE *f,int c)
< {
< return ::_C_Swamp::_CPP_fwide(f,c);
< }
< #else
< inline int fwide(std::__FILE *f,int c)
< {
< return ::_C_Swamp::fwide(f,c);
< }
< #endif
< #ifdef putwc
< #undef putwc
< inline std::wint_t putwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::_CPP_putwc(c,f);
< }
< #else
< inline std::wint_t putwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::putwc(c,f);
< }
< #endif
< #ifdef putwchar
< #undef putwchar
< inline std::wint_t putwchar(std::wint_t c)
< {
< return ::_C_Swamp::_CPP_putwchar(c);
< }
< #else
< using ::_C_Swamp::putwchar;
< #endif
< #ifdef ungetwc
< #undef ungetwc
< inline std::wint_t ungetwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::_CPP_ungetwc(c,f);
< }
< #else
< inline std::wint_t ungetwc(std::wint_t c,std::__FILE *f)
< {
< return ::_C_Swamp::ungetwc(c,f);
< }
< #endif
< #ifdef wcrtomb
< #undef wcrtomb
< inline std::size_t wcrtomb(char *s,wchar_t c,std::mbstate_t *mb)
< {
< return ::_C_Swamp::_CPP_wcrtomb(s,c,mb);
< }
< #else
< using ::_C_Swamp::wcrtomb;
< #endif
297,302c88
< // variable argument functions have to be passed as-is
< using ::_C_Swamp::fwprintf;
< using ::_C_Swamp::fwscanf;
< using ::_C_Swamp::swprintf;
< using ::_C_Swamp::swscanf;
< }
---
> #endif // _CPP_CWCHAR
305d90
< #undef _IN_C_SWAMP_
307c92,108
< #endif
---
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
diff -r ./bits/std_cwctype.h /work/egcs/include/g++-v3//bits/std_cwctype.h
1,3c1
< // -*-C++-*-
< #ifndef _CPP_INCLUDE_CWCTYPE_
< #define _CPP_INCLUDE_CWCTYPE_
---
> // -*- C++ -*- forwarding header.
5,17c3,9
< namespace _C_Swamp {
< extern "C" {
< # define _IN_C_SWAMP_
< #include_next <wctype.h>
< }
< namespace _C_Shadow { } // placeholder
< #ifdef wint_t
< typedef wint_t _CPP_wint_t;
< #endif
< #ifdef wctrans_t
< typedef wctrans_t _CPP_wctrans_t;
< #endif
< } // close namespace ::_C_Swamp::
---
> // Copyright (C) 1997-1999 Free Software Foundation, Inc.
> //
> // This file is part of the GNU ISO C++ Library. This library is free
> // software; you can redistribute it and/or modify it under the
> // terms of the GNU General Public License as published by the
> // Free Software Foundation; either version 2, or (at your option)
> // any later version.
19,24c11,39
< namespace std {
< #ifdef wint_t
< #undef wint_t
< typedef ::_C_Swamp::_CPP_wint_t wint_t;
< #else
< typedef ::_C_Swamp::wint_t wint_t;
---
> // This library is distributed in the hope that it will be useful,
> // but WITHOUT ANY WARRANTY; without even the implied warranty of
> // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> // GNU General Public License for more details.
>
> // You should have received a copy of the GNU General Public License along
> // with this library; see the file COPYING. If not, write to the Free
> // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
> // USA.
>
> // As a special exception, you may use this file as part of a free software
> // library without restriction. Specifically, if other files instantiate
> // templates or use macros or inline functions from this file, or you compile
> // this file and link it with other files to produce an executable, this
> // file does not by itself cause the resulting executable to be covered by
> // the GNU General Public License. This exception does not however
> // invalidate any other reasons why the executable file might be covered by
> // the GNU General Public License.
>
> //
> // ISO C++ 14882: <cwctype>
> //
>
> #ifndef _CPP_CWCTYPE
> #define _CPP_CWCTYPE 1
>
> // This keeps isanum, et al from being propagated as macros.
> #if __linux__
> #define __NO_WCTYPE 1
26,33d40
< #ifdef wctrans_t
< #undef wctrans_t
< typedef ::_C_Swamp::_CPP_wctrans_t wctrans_t;
< #else
< typedef ::_C_Swamp::wctrans_t wctrans_t;
< #endif
<
< } // close namespace std::
35,36c42,48
< // functions
< namespace _C_Swamp
---
> # include_next <wctype.h>
>
> // Sequester the C non-inline implementations in the _C_Swamp::
> // namespace, and provide C++ inlines for them in the std:: namespace
> // where they belong.
>
> namespace std
38,42c50,56
< #ifdef iswupper
< inline wint_t _CPP_isupper(wint_t c)
< {
< return iswupper(c);
< }
---
>
> #ifdef towupper
> inline wint_t
> _S_towupper_helper(wint_t __wc) { return towupper(__wc); }
> # undef towupper
> inline wint_t
> towupper(wint_t __wc) { return _S_towupper_helper(__wc); }
44,48c58,64
< #ifdef iswdigit
< inline wint_t _CPP_isdigit(wint_t c)
< {
< return iswdigit(c);
< }
---
>
> #ifdef towlower
> inline wint_t
> _S_towlower_helper(wint_t __wc) { return towlower(__wc); }
> # undef towlower
> inline wint_t
> towlower(wint_t __wc) { return _S_towlower_helper(__wc); }
50,73c66
< #ifdef iswalpha
< inline wint_t _CPP_isalpha(wint_t c)
< {
< return iswalpha(c);
< }
< #endif
< #ifdef iswlower
< inline wint_t _CPP_islower(wint_t c)
< {
< return iswlower(c);
< }
< #endif
< #ifdef iswxdigit
< inline wint_t _CPP_isxdigit(wint_t c)
< {
< return iswxdigit(c);
< }
< #endif
< #ifdef iswalnum
< inline wint_t _CPP_isalnum(wint_t c)
< {
< return iswalnum(c);
< }
< #endif
---
>
75,78c68,72
< inline wint_t _CPP_isspace(wint_t c)
< {
< return iswspace(c);
< }
---
> inline int
> _S_iswspace_helper(wint_t __wc) { return iswspace(__wc); }
> # undef iswspace
> inline int
> iswspace(wint_t __wc) { return _S_iswspace_helper(__wc); }
80,84c74,80
< #ifdef iswpunct
< inline wint_t _CPP_ispunct(wint_t c)
< {
< return iswpunct(c);
< }
---
>
> #ifdef iswprint
> inline int
> _S_iswprint_helper(wint_t __wc) { return iswprint(__wc); }
> # undef iswprint
> inline int
> iswprint(wint_t __wc) { return _S_iswprint_helper(__wc); }
86,91c82
< #ifdef iswgraph
< inline wint_t _CPP_isgraph(wint_t c)
< {
< return iswgraph(c);
< }
< #endif
---
>
93,96c84,88
< inline wint_t _CPP_iscntrl(wint_t c)
< {
< return iswcntrl(c);
< }
---
> inline int
> _S_iswcntrl_helper(wint_t __wc) { return iswcntrl(__wc); }
> # undef iswcntrl
> inline int
> iswcntrl(wint_t __wc) { return _S_iswcntrl_helper(__wc); }
98,123d89
< #ifdef iswprint
< inline wint_t _CPP_isprint(wint_t c)
< {
< return iswprwint_t(c);
< }
< #endif
< #ifdef towupper
< inline wint_t _CPP_toupper(wint_t c)
< {
< return towupper(c);
< }
< #endif
< #ifdef towlower
< inline wint_t _CPP_tolower(wint_t c)
< {
< return towlower(c);
< }
< #endif
< #ifdef towctrans
< inline wint_t _CPP_towctrans(wint_t wc,wctrans_t desc)
< {
< return towctrans(wc,desc);
< }
< #endif
<
< } // close namespace ::_C_Swamp::
125,126d90
< namespace std {
<
128,134c92,96
< #undef iswupper
< inline wint_t iswupper(wint_t c)
< {
< return ::_C_Swamp::_CPP_isupper(c);
< }
< #else
< using ::_C_Swamp::iswupper;
---
> inline int
> _S_iswupper_helper(wint_t __wc) { return iswupper(__wc); }
> # undef iswupper
> inline int
> iswupper(wint_t __wc) { return _S_iswupper_helper(__wc); }
136,143c98,104
< #ifdef iswdigit
< #undef iswdigit
< inline wint_t iswdigit(wint_t c)
< {
< return ::_C_Swamp::_CPP_isdigit(c);
< }
< #else
< using ::_C_Swamp::iswdigit;
---
>
> #ifdef iswlower
> inline int
> _S_iswlower_helper(wint_t __wc) { return iswlower(__wc); }
> # undef iswlower
> inline int
> iswlower(wint_t __wc) { return _S_iswlower_helper(__wc); }
144a106
>
146,152c108,112
< #undef iswalpha
< inline wint_t iswalpha(wint_t c)
< {
< return ::_C_Swamp::_CPP_isalpha(c);
< }
< #else
< using ::_C_Swamp::iswalpha;
---
> inline int
> _S_iswalpha_helper(wint_t __wc) { return iswalpha(__wc); }
> # undef iswalpha
> inline int
> iswalpha(wint_t __wc) { return _S_iswalpha_helper(__wc); }
154,161c114,120
< #ifdef iswlower
< #undef iswlower
< inline wint_t iswlower(wint_t c)
< {
< return ::_C_Swamp::_CPP_islower(c);
< }
< #else
< using ::_C_Swamp::iswlower;
---
>
> #ifdef iswdigit
> inline int
> _S_iswdigit_helper(wint_t __wc) { return iswdigit(__wc); }
> # undef iswdigit
> inline int
> iswdigit(wint_t __wc) { return _S_iswdigit_helper(__wc); }
162a122,130
>
> #ifdef iswpunct
> inline int
> _S_iswpunct_helper(wint_t __wc) { return iswpunct(__wc); }
> # undef iswpunct
> inline int
> iswpunct(wint_t __wc) { return _S_iswpunct_helper(__wc); }
> #endif
>
164,170c132,136
< #undef iswxdigit
< inline wint_t iswxdigit(wint_t c)
< {
< return ::_C_Swamp::_CPP_isxdigit(c);
< }
< #else
< using ::_C_Swamp::iswxdigit;
---
> inline int
> _S_iswxdigit_helper (wint_t __wc) { return iswxdigit(__wc); }
> # undef iswxdigit
> inline int
> iswxdigit(wint_t __wc) { return _S_iswxdigit_helper(__wc); }
171a138
>
173,179c140,144
< #undef iswalnum
< inline wint_t iswalnum(wint_t c)
< {
< return ::_C_Swamp::_CPP_isalnum(c);
< }
< #else
< using ::_C_Swamp::iswalnum;
---
> inline int
> _S_iswalnum_helper(wint_t __wc) { return iswalnum(__wc); }
> # undef iswalnum
> inline int
> iswalnum(wint_t __wc) { return _S_iswalnum_helper(__wc); }
181,198c146
< #ifdef iswspace
< #undef iswspace
< inline wint_t iswspace(wint_t c)
< {
< return ::_C_Swamp::_CPP_isspace(c);
< }
< #else
< using ::_C_Swamp::iswspace;
< #endif
< #ifdef iswpunct
< #undef iswpunct
< inline wint_t iswpunct(wint_t c)
< {
< return ::_C_Swamp::_CPP_ispunct(c);
< }
< #else
< using ::_C_Swamp::iswpunct;
< #endif
---
>
200,206c148,152
< #undef iswgraph
< inline wint_t iswgraph(wint_t c)
< {
< return ::_C_Swamp::_CPP_isgraph(c);
< }
< #else
< using ::_C_Swamp::iswgraph;
---
> inline int
> _S_iswgraph_helper(wint_t __wc) { return iswgraph(__wc); }
> # undef iswgraph
> inline int
> iswgraph(wint_t __wc) { return _S_iswgraph_helper(__wc); }
208,253d153
< #ifdef iswcntrl
< #undef iswcntrl
< inline wint_t iswcntrl(wint_t c)
< {
< return ::_C_Swamp::_CPP_iscntrl(c);
< }
< #else
< using ::_C_Swamp::iswcntrl;
< #endif
< #ifdef iswprint
< #undef iswprint
< inline wint_t iswprint(wint_t c)
< {
< return ::_C_Swamp::_CPP_isprint(c);
< }
< #else
< using ::_C_Swamp::iswprint;
< #endif
< #ifdef towlower
< #undef towlower
< inline wint_t towlower(wint_t c)
< {
< return ::_C_Swamp::_CPP_tolower(c);
< }
< #else
< using ::_C_Swamp::towlower;
< #endif
< #ifdef towupper
< #undef towupper
< inline wint_t towupper(wint_t c)
< {
< return ::_C_Swamp::_CPP_toupper(c);
< }
< #else
< using ::_C_Swamp::towupper;
< #endif
< #ifdef towctrans
< #undef towctrans
< inline std::wint_t towctrans(std::wint_t wc,std::wctrans_t desc)
< {
< return ::_C_Swamp::_CPP_towctrans(wc,desc);
< }
< #else
< using ::_C_Swamp::towctrans;
< #endif
< }
254a155
> } // namespace std
256c157
< #undef _IN_C_SWAMP_
---
> #endif // _CPP_CWCTYPE
258c159,164
< #endif
---
>
>
>
>
>
>