libstdc++-v3: New directory.

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

	* libstdc++-v3: New directory.

From-SVN: r33317

libstdc++-v3/Makefile.am

+## Makefile for the toplevel directory of the GNU C++ Standard library.
+##
+## Copyright (C) 1997,1998, 1999, 2000 Free Software Foundation, Inc.
+##
+## This file is part of the libstdc++ version 3 distribution.
+## Process this file with automake to produce Makefile.in.
+
+## 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.
+
+AUTOMAKE_OPTIONS = 1.3 cygnus
+MAINT_CHARSET = latin1
+
+# This helps subvert libstdcxx_interface, as calculated by devo/config.if
+# Needed so that g++ can find the correct include subdir automatically.
+INTERFACE = v3
+gxx_include_dir=$(includedir)/g++
+
+SUBDIRS = math libio src
+
+check:  $(top_builddir)/mkcheck
+	$(top_builddir)/mkcheck 0 $(top_builddir) $(top_srcdir)
+
+check-install: $(top_builddir)/mkcheck
+	$(top_builddir)/mkcheck 1 $(top_builddir) $(top_srcdir) $(prefix)
+
+#all-local:  stamp-rebuild
+
+# This has already been sanity-checked by configure to a certain extent
+#stamp-rebuild:  $(top_builddir)/config.status
+#	if test "$(GCC_OBJDIR)" != "no"; then \
+#	(cd "$(GCC_OBJDIR)/gcc" && \
+#	 if test -f libgcc2.ready ; then \
+#	   rm -f libgcc2.ready libgcc.a libgcc2.a ; \
+#	   $(MAKE) libgcc2.a TARGET_LIBGCC2_CFLAGS='@NAMESPACES@' ; \
+#	   $(MAKE) libgcc.a ; \
+#	 else \
+#	   echo '** There does not appear to be a previously-built' ; \
+#	   echo '** library here.  Please see' ; \
+#	   echo '** <http://sourceware.cygnus.com/libstdc++/install.html>' ; \
+#	   echo '** In particular, the "Building and Installing' ; \
+#	   echo '** the library (without GCC sources)" section.' ; \
+#	   exit 1 ; \
+#	 fi \
+#	) \
+#	fi
+#	touch stamp-rebuild
+
+# Multilib support.
+MAKEOVERRIDES=
+
+# Multilib variables.
+MULTISRCTOP =
+MULTIBUILDTOP =
+MULTIDIRS =
+MULTISUBDIR =
+MULTIDO = true
+MULTICLEAN = true
+
+# Multilib Makefile bits.
+.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \
+	maintainer-clean-multi
+
+all-am: all-multi
+install-am: install-multi
+mostlyclean-am: mostlyclean-multi
+clean-am: clean-multi
+distclean-am: distclean-multi
+maintainer-clean-am: maintainer-clean-multi
+
+all-multi:
+	$(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do
+install-multi:
+	$(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do
+mostlyclean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean
+clean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean
+distclean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean
+maintainer-clean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean
+
+# Work around what appears to be a GNU make bug handling MAKEFLAGS
+# values defined in terms of make variables, as is the case for CC and
+# friends when we are called from the top level Makefile.
+AM_MAKEFLAGS = \
+	"AR_FLAGS=$(AR_FLAGS)" \
+	"CC_FOR_BUILD=$(CC_FOR_BUILD)" \
+	"CC_FOR_TARGET=$(CC_FOR_TARGET)" \
+	"CFLAGS=$(CFLAGS)" \
+	"CXXFLAGS=$(CXXFLAGS)" \
+	"CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
+	"CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
+	"INSTALL=$(INSTALL)" \
+	"INSTALL_DATA=$(INSTALL_DATA)" \
+	"INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
+	"INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
+	"LDFLAGS=$(LDFLAGS)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
+	"MAKE=$(MAKE)" \
+	"MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
+	"PICFLAG=$(PICFLAG)" \
+	"PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \
+	"SHELL=$(SHELL)" \
+	"EXPECT=$(EXPECT)" \
+	"RUNTEST=$(RUNTEST)" \
+	"RUNTESTFLAGS=$(RUNTESTFLAGS)" \
+	"exec_prefix=$(exec_prefix)" \
+	"infodir=$(infodir)" \
+	"libdir=$(libdir)" \
+	"includedir=$(includedir)" \
+	"prefix=$(prefix)" \
+	"tooldir=$(tooldir)" \
+	"AR=$(AR)" \
+	"AS=$(AS)" \
+	"CC=$(CC)" \
+	"CXX=$(CXX)" \
+	"LD=$(LD)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"PICFLAG=$(PICFLAG)" \
+	"RANLIB=$(RANLIB)" \
+	"NM=$(NM)" \
+	"NM_FOR_BUILD=$(NM_FOR_BUILD)" \
+	"NM_FOR_TARGET=$(NM_FOR_TARGET)" \
+	"DESTDIR=$(DESTDIR)"
+
+
+
+
+
+
+

libstdc++-v3/README

+file: isolib/README
+
+New users may wish to point their web browsers to the file index.html
+in the 'docs' subdirectory.  It contains brief building instructions
+and notes on how to configure the library in interesting ways.
+
+
+Instructions for configuring and building this snapshot appear
+in install.html.
+
+This directory contains the files needed to create [a still broken
+subset of] an ISO Standard C++ Library.
+
+It has subdirectories:
+
+  bits
+     Files included by standard headers and by other files in
+     the bits directory.  Includes a set of files bits/std_xxxx.h
+     that implement the standard headers <xxxx>.
+
+  std
+     Files meant to be found by #include <name> directives in
+     standard-conforming user programs.  These headers are not
+     referred to by other headers, because such dependencies
+     confuse Make (leading it to delete them, all too often).
+     Installations may substitute symbolic links in place of
+     these files.
+
+  ext
+     Headers that define extensions to the standard library.  No
+     standard header refers to any of them.
+
+  backward
+     Headers provided for backward compatibility, such as <iostream.h>.
+     They are not used in this library.
+
+  src
+     Files that are used in constructing the library, but are not
+     installed.
+
+  testsuites/17_* to 27_*
+     Test programs are here, and may be used to begin to exercise the 
+     library.  Support for "make check" and "make check-install" is
+     complete, and runs through all the subdirectories here when this
+     command is issued from the build directory. Please note that
+     "make check" calls the script mkcheck, which requires bash, and which
+     may need the paths to bash adjusted to work properly, as /bin/bash is
+     assumed.
+
+  shadow
+     Headers intended to shadow standard C headers provided by an
+     underlying OS or C library, and other headers depended on directly
+     by C++ headers (e.g. unistd.h).  These are meant to wrap the names
+     defined there into the _CSwamp namespace.
+     [NB: this is still experimental, and is not currently used.]
+
+  cshadow
+     The contents of this directory are constructed by scripts which 
+     examine the underlying C headers to discover other headers they
+     depend on.  These headers are wrappers for them.
+     [NB: this is still experimental, and is not currently used.]
+
+Other subdirectories contain variant versions of certain files
+that are meant to be copied or linked by the configure script.
+Currently these are:
+
+  amm1 generic glibc math
+
+Files needed only to construct the library, but not installed,
+are in src/.  Files to be copied as part of an installation are
+all found in the subdirectories mentioned above.  (A configure
+script may link files from another directory into one of these.)
+
+In a normal installation the bits/ directory is copied
+under the std/ directory, and arranged to be searched only
+when an include directive specifies a filename of "bits/..."
+or <bits/...>.  When building the library, we use
+
+  -Istd -I. -Iconfig/* -Iconfig/cpu/*
+
+to get the same effect.
+
+Note that glibc also has a bits/ subdirectory.  We will either
+need to be careful not to collide with names in its bits/
+directory; or rename bits to (e.g.) cppbits/.
+
+To install libstdc++ you need GNU make.  The makefiles do not work with
+any other make.
+
+In files throughout the system, lines marked with an "XXX" indicate
+a bug or incompletely-implemented feature.  Lines marked "XXX MT"
+indicate a place that may require attention for multi-thread safety.
+(Warning: places that need an atomic read are not so marked yet.)
+

libstdc++-v3/acconfig.h

+// acconfig.h symbols and macros for libstdc++ v3 -*- C++ -*-
+
+// If using the namespace std, you need this. Eventually this should
+// not be an option. In the meantime, and as things like std_ctype.h
+// need to be hacked out, give people the option. If this is set to 1,
+// CXXFLAGS should include -fhonor-std. If this is undefined, CXXFLAGS
+// should include -fno-honor-std.
+#undef _GLIBCPP_USE_NAMESPACES
+
+// 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>
+#undef _GLIBCPP_HAS_WCHAR_MIN_MAX
+
+// Define if code specialized for wchar_t should be used.
+#undef _GLIBCPP_USE_WCHAR_T
+
+// Define if the compiler/host combination has __builtin_sinf defined.
+#undef _GLIBCPP_HAS_BUILTIN_SINF
+
+// Define if the compiler/host combination has __builtin_cosf defined.
+#undef _GLIBCPP_HAS_BUILTIN_COSF
+
+// Define if the compiler/host combination has __builtin_fabsf defined.
+#undef _GLIBCPP_HAS_BUILTIN_FABSF
+
+// Define if the compiler/host combination has __builtin_fabsf defined.
+#undef _GLIBCPP_HAS_BUILTIN_SQRTF
+
+// 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>.
+#undef HAVE_LC_MESSAGES
+
+// Define if <float.h> exists.
+#undef HAVE_FLOAT_H
+
+// Define if modf is present in <math.h>
+#undef HAVE_MODF
+
+// @BOTTOM@
+//
+// Systems that have certain non-standard functions prefixed with an
+// underscore, we'll handle those here. Must come after config.h.in.
+//
+
+#if defined (HAVE__ISNAN) && ! defined (HAVE_ISNAN)
+# define HAVE_ISNAN 1
+# define isnan _isnan
+#endif
+
+#if defined (HAVE__ISNANF) && ! defined (HAVE_ISNANF)
+# define HAVE_ISNANF 1
+# define isnanf _isnanf
+#endif
+
+#if defined (HAVE__ISNANL) && ! defined (HAVE_ISNANL)
+# define HAVE_ISNANL 1
+# define isnanl _isnanl
+#endif
+
+#if defined (HAVE__ISINF) && ! defined (HAVE_ISINF)
+# define HAVE_ISINF 1
+# define isinf _isinf
+#endif
+
+#if defined (HAVE__ISINFF) && ! defined (HAVE_ISINFF)
+# define HAVE_ISINFF 1
+# define isinff _isinff
+#endif
+
+#if defined (HAVE__ISINFL) && ! defined (HAVE_ISINFL)
+# define HAVE_ISINFL 1
+# define isinfl _isinfl
+#endif
+
+#if defined (HAVE__COPYSIGN) && ! defined (HAVE_COPYSIGN)
+# define HAVE_COPYSIGN 1
+# define copysign _copysign
+#endif
+
+#if defined (HAVE__COPYSIGNL) && ! defined (HAVE_COPYSIGNL)
+# define HAVE_COPYSIGNL 1
+# define copysignl _copysignl
+#endif
+
+#if defined (HAVE__COSF) && ! defined (HAVE_COSF)
+# define HAVE_COSF 1
+# define cosf _cosf
+#endif
+
+#if defined (HAVE__COSHF) && ! defined (HAVE_COSHF)
+# define HAVE_COSHF 1
+# define coshf _coshf
+#endif
+
+#if defined (HAVE__LOGF) && ! defined (HAVE_LOGF)
+# define HAVE_LOGF 1
+# define logf _logf
+#endif
+
+#if defined (HAVE__LOG10F) && ! defined (HAVE_LOG10F)
+# define HAVE_LOG10F 1
+# define log10f _log10f
+#endif
+
+#if defined (HAVE__POWF) && ! defined (HAVE_POWF)
+# define HAVE_POWF 1
+# define powf _powf
+#endif
+
+#if defined (HAVE__SINF) && ! defined (HAVE_SINF)
+# define HAVE_SINF 1
+# define sinf _sinf
+#endif
+
+#if defined (HAVE__SINHF) && ! defined (HAVE_SINHF)
+# define HAVE_SINHF 1
+# define sinhf _sinhf
+#endif
+
+#if defined (HAVE__SQRTF) && ! defined (HAVE_SQRTF)
+# define HAVE_SQRTF 1
+# define sqrtf _sqrtf
+#endif
+
+#if defined (HAVE__TANF) && ! defined (HAVE_TANF)
+# define HAVE_TANF 1
+# define tanf _tanf
+#endif
+
+#if defined (HAVE__TANHF) && ! defined (HAVE_TANHF)
+# define HAVE_TANHF 1
+# define tanhf _tanhf
+#endif
+
+#if defined (HAVE__STRTOF) && ! defined (HAVE_STRTOF)
+# define HAVE_STRTOF 1
+# define strtof _strtof
+#endif
+
+#if defined (HAVE__STRTOLD) && ! defined (HAVE_STRTOLD)
+# define HAVE_STRTOLD 1
+# define strtold _strtold
+#endif
+
+#if defined (HAVE__FABSF) && ! defined (HAVE_FABSF)
+# define HAVE_FABSF 1
+# define fabsf _fabsf
+#endif
+
+#if defined (HAVE__SINCOS) && ! defined (HAVE_SINCOS)
+# define HAVE_SINCOS 1
+# define sincos _sincos
+#endif
+
+#if defined (HAVE__SINCOSF) && ! defined (HAVE_SINCOSF)
+# define HAVE_SINCOSF 1
+# define sincosf _sincosf
+#endif
+
+#if defined (HAVE__SINCOSL) && ! defined (HAVE_SINCOSL)
+# define HAVE_SINCOSL 1
+# define sincosl _sincosl
+#endif
+
+#if defined (HAVE__FINITE) && ! defined (HAVE_FINITE)
+# define HAVE_FINITE 1
+# define finite _finite
+#endif
+
+#if defined (HAVE__QFINITE) && ! defined (HAVE_QFINITE)
+# define HAVE_QFINITE 1
+# define qfinite _qfinite
+#endif
+
+#if defined (HAVE__FPCLASS) && ! defined (HAVE_FPCLASS)
+# define HAVE_FPCLASS 1
+# define fpclass _fpclass
+#endif
+
+#if defined (HAVE__QFPCLASS) && ! defined (HAVE_QFPCLASS)
+# define HAVE_QFPCLASS 1
+# define qfpclass _qfpclass
+#endif
+

libstdc++-v3/backward/algo.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_ALGO_H
+#define _CPP_BACKWARD_ALGO_H 1
+
+#include "algobase.h"
+#include "tempbuf.h"
+#include <bits/stl_algo.h>
+#include <bits/stl_numeric.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from <stl_algo.h>
+using __STD::for_each; 
+using __STD::find; 
+using __STD::find_if; 
+using __STD::adjacent_find; 
+using __STD::count; 
+using __STD::count_if; 
+using __STD::search; 
+using __STD::search_n; 
+using __STD::swap_ranges; 
+using __STD::transform; 
+using __STD::replace; 
+using __STD::replace_if; 
+using __STD::replace_copy; 
+using __STD::replace_copy_if; 
+using __STD::generate; 
+using __STD::generate_n; 
+using __STD::remove; 
+using __STD::remove_if; 
+using __STD::remove_copy; 
+using __STD::remove_copy_if; 
+using __STD::unique; 
+using __STD::unique_copy; 
+using __STD::reverse; 
+using __STD::reverse_copy; 
+using __STD::rotate; 
+using __STD::rotate_copy; 
+using __STD::random_shuffle; 
+using __STD::random_sample; 
+using __STD::random_sample_n; 
+using __STD::partition; 
+using __STD::stable_partition; 
+using __STD::sort; 
+using __STD::stable_sort; 
+using __STD::partial_sort; 
+using __STD::partial_sort_copy; 
+using __STD::nth_element; 
+using __STD::lower_bound; 
+using __STD::upper_bound; 
+using __STD::equal_range; 
+using __STD::binary_search; 
+using __STD::merge; 
+using __STD::inplace_merge; 
+using __STD::includes; 
+using __STD::set_union; 
+using __STD::set_intersection; 
+using __STD::set_difference; 
+using __STD::set_symmetric_difference; 
+using __STD::min_element; 
+using __STD::max_element; 
+using __STD::next_permutation; 
+using __STD::prev_permutation; 
+using __STD::find_first_of; 
+using __STD::find_end; 
+using __STD::is_sorted; 
+using __STD::is_heap; 
+
+// Names from stl_heap.h
+using __STD::push_heap;
+using __STD::pop_heap;
+using __STD::make_heap;
+using __STD::sort_heap;
+
+// Names from stl_numeric.h
+using __STD::accumulate; 
+using __STD::inner_product; 
+using __STD::partial_sum; 
+using __STD::adjacent_difference; 
+using __STD::power; 
+using __STD::iota; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_ALGO_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/algobase.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_ALGOBASE_H
+#define _CPP_BACKWARD_ALGOBASE_H 1
+
+#ifndef _CPP_BACKWARD_PAIR_H
+#include "pair.h"
+#endif
+#ifndef _CPP_BACKWARD_ITERATOR_H
+#include "iterator.h"
+#endif
+#ifndef _CPP_BITS_STL__ALGOBASE_H
+#include <bits/stl_algobase.h>
+#endif
+#ifndef _CPP_BITS_STL_UNINITIALIZED_H
+#include <bits/stl_uninitialized.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_algobase.h
+using __STD::iter_swap; 
+using __STD::swap; 
+using __STD::min; 
+using __STD::max; 
+using __STD::copy; 
+using __STD::copy_backward; 
+using __STD::copy_n; 
+using __STD::fill; 
+using __STD::fill_n; 
+using __STD::mismatch; 
+using __STD::equal; 
+using __STD::lexicographical_compare; 
+using __STD::lexicographical_compare_3way; 
+
+// Names from stl_uninitialized.h
+using __STD::uninitialized_copy;
+using __STD::uninitialized_copy_n;
+using __STD::uninitialized_fill;
+using __STD::uninitialized_fill_n;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_ALGOBASE_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/alloc.h

+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_ALLOC_H
+#define _CPP_BACKWARD_ALLOC_H 1
+
+#ifndef _CPP_BITS_STL_CONFIG_H
+#include <bits/stl_config.h>
+#endif
+#ifndef _CPP_BITS_STL_ALLOC_H
+#include <bits/stl_alloc.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::__malloc_alloc_template; 
+using __STD::malloc_alloc; 
+using __STD::simple_alloc; 
+using __STD::debug_alloc; 
+using __STD::__default_alloc_template; 
+using __STD::alloc; 
+using __STD::single_client_alloc; 
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+using __STD::__malloc_alloc_oom_handler; 
+#endif /* __STL_STATIC_TEMPLATE_MEMBER_BUG */
+#ifdef __STL_USE_STD_ALLOCATORS 
+using __STD::allocator;
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_ALLOC_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/bvector.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_BVECTOR_H
+#define _CPP_BACKWARD_BVECTOR_H 1
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+#include "vector.h"
+#else
+#include "algobase.h"
+#include "alloc.h"
+#endif 
+
+#include <bits/stl_bvector.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::bit_vector;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_BVECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
+

libstdc++-v3/backward/defalloc.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+// Inclusion of this file is DEPRECATED.  This is the original HP
+// default allocator.  It is provided only for backward compatibility.
+// This file WILL BE REMOVED in a future release.
+//
+// DO NOT USE THIS FILE unless you have an old container implementation
+// that requires an allocator with the HP-style interface.  
+//
+// Standard-conforming allocators have a very different interface.  The
+// standard default allocator is declared in the header <memory>.
+
+#ifndef _CPP_BACKWARD_DEFALLOC_H
+#define _CPP_BACKWARD_DEFALLOC_H 1
+
+#include "new.h"
+#include <stddef.h>
+#include <stdlib.h>
+#include <limits.h> 
+#include "iostream.h" 
+#include "algobase.h"
+
+
+template <class _Tp>
+inline _Tp* allocate(ptrdiff_t __size, _Tp*) {
+    set_new_handler(0);
+    _Tp* __tmp = (_Tp*)(::operator new((size_t)(__size * sizeof(_Tp))));
+    if (__tmp == 0) {
+	cerr << "out of memory" << endl; 
+	exit(1);
+    }
+    return __tmp;
+}
+
+
+template <class _Tp>
+inline void deallocate(_Tp* __buffer) {
+    ::operator delete(__buffer);
+}
+
+template <class _Tp>
+class allocator {
+public:
+    typedef _Tp value_type;
+    typedef _Tp* pointer;
+    typedef const _Tp* const_pointer;
+    typedef _Tp& reference;
+    typedef const _Tp& const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    pointer allocate(size_type __n) { 
+	return ::allocate((difference_type)__n, (pointer)0);
+    }
+    void deallocate(pointer __p) { ::deallocate(__p); }
+    pointer address(reference __x) { return (pointer)&__x; }
+    const_pointer const_address(const_reference __x) { 
+	return (const_pointer)&__x; 
+    }
+    size_type init_page_size() { 
+	return max(size_type(1), size_type(4096/sizeof(_Tp))); 
+    }
+    size_type max_size() const { 
+	return max(size_type(1), size_type(UINT_MAX/sizeof(_Tp))); 
+    }
+};
+
+class allocator<void> {
+public:
+    typedef void* pointer;
+};
+
+
+
+#endif /* _CPP_BACKWARD_DEFALLOC_H */

libstdc++-v3/backward/deque.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_DEQUE_H
+#define _CPP_BACKWARD_DEQUE_H 1
+
+#include "algobase.h"
+#include "alloc.h"
+#include <bits/std_deque.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::deque;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/function.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_FUNCTION_H
+#define _CPP_BACKWARD_FUNCTION_H 1
+
+#ifndef _CPP_BITS_STL_CONFIG_H
+#include <bits/stl_config.h>
+#endif
+#ifndef _CPP_BITS_STL_RELOPS
+#include <bits/stl_relops.h>
+#endif
+#include <stddef.h>
+#ifndef _CPP_BITS_STL_FUNCTION_H
+#include <bits/stl_function.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACE_FOR_RELOPS
+
+// Names from stl_relops.h
+using __STD_RELOPS::operator!=;
+using __STD_RELOPS::operator>;
+using __STD_RELOPS::operator<=;
+using __STD_RELOPS::operator>=;
+
+#endif /* __STL_USE_NAMESPACE_FOR_RELOPS */
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_function.h
+using __STD::unary_function; 
+using __STD::binary_function; 
+using __STD::plus; 
+using __STD::minus; 
+using __STD::multiplies; 
+using __STD::divides; 
+using __STD::identity_element; 
+using __STD::modulus; 
+using __STD::negate; 
+using __STD::equal_to; 
+using __STD::not_equal_to; 
+using __STD::greater; 
+using __STD::less; 
+using __STD::greater_equal; 
+using __STD::less_equal; 
+using __STD::logical_and; 
+using __STD::logical_or; 
+using __STD::logical_not; 
+using __STD::unary_negate; 
+using __STD::binary_negate; 
+using __STD::not1; 
+using __STD::not2; 
+using __STD::binder1st; 
+using __STD::binder2nd; 
+using __STD::bind1st; 
+using __STD::bind2nd; 
+using __STD::unary_compose; 
+using __STD::binary_compose; 
+using __STD::compose1; 
+using __STD::compose2; 
+using __STD::pointer_to_unary_function; 
+using __STD::pointer_to_binary_function; 
+using __STD::ptr_fun; 
+using __STD::identity; 
+using __STD::select1st; 
+using __STD::select2nd; 
+using __STD::project1st; 
+using __STD::project2nd; 
+using __STD::constant_void_fun; 
+using __STD::constant_unary_fun; 
+using __STD::constant_binary_fun; 
+using __STD::constant0; 
+using __STD::constant1; 
+using __STD::constant2; 
+using __STD::subtractive_rng; 
+using __STD::mem_fun_t; 
+using __STD::const_mem_fun_t; 
+using __STD::mem_fun_ref_t; 
+using __STD::const_mem_fun_ref_t; 
+using __STD::mem_fun1_t; 
+using __STD::const_mem_fun1_t; 
+using __STD::mem_fun1_ref_t; 
+using __STD::const_mem_fun1_ref_t; 
+using __STD::mem_fun; 
+using __STD::mem_fun_ref; 
+using __STD::mem_fun1; 
+using __STD::mem_fun1_ref; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_FUNCTION_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/hash_map.h

+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef _CPP_BACKWARD_HASH_MAP_H
+#define _CPP_BACKWARD_HASH_MAP_H 1
+
+#ifndef _CPP_BITS_STL_HASHTABLE_H
+#include <bits/stl_hashtable.h>
+#endif 
+
+#include "algobase.h"
+#include <bits/stl_hash_map.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+using __STD::hash_map;
+using __STD::hash_multimap;
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* _CPP_BACKWARD_HASH_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/hash_set.h

+/*
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef _CPP_BACKWARD_HASH_SET_H
+#define _CPP_BACKWARD_HASH_SET_H 1
+
+#ifndef _CPP_BITS_STL_HASHTABLE_H
+#include <bits/stl_hashtable.h>
+#endif 
+
+#include "algobase.h"
+#include <bits/stl_hash_set.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+using __STD::hash_set;
+using __STD::hash_multiset;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_HASH_SET_H */

libstdc++-v3/backward/hashtable.h

+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _CPP_BACKWARD_HASHTABLE_H
+#define _CPP_BACKWARD_HASHTABLE_H 1
+
+#include <bits/stl_hashtable.h>
+#include "algo.h"
+#include "alloc.h"
+#include "vector.h"
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::hash;
+using __STD::hashtable;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/heap.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_HEAP_H
+#define _CPP_BACKWARD_HEAP_H 1
+
+#include <bits/stl_config.h>
+#include <bits/stl_heap.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::push_heap;
+using __STD::pop_heap;
+using __STD::make_heap;
+using __STD::sort_heap;
+
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* _CPP_BACKWARD_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/iostream.h

+
+// 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.
+
+#ifndef _CPP_BACKWARD_IOSTREAM_H
+#define _CPP_BACKWARD_IOSTREAM_H 1
+
+#include <bits/std_iostream.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::iostream;
+using __STD::ostream;
+using __STD::istream;
+using __STD::ios;
+using __STD::streambuf;
+
+using __STD::cout;
+using __STD::cin;
+using __STD::cerr;
+using __STD::clog;
+using __STD::wcout;
+using __STD::wcin;
+using __STD::wcerr;
+using __STD::wclog;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_IOSTREAM_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/iterator.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_ITERATOR_H
+#define _CPP_BACKWARD_ITERATOR_H 1
+
+#ifndef _CPP_BACKWARD_FUNCTION_H
+#include "function.h"
+#endif
+#include <stddef.h>
+#include "iostream.h"
+#ifndef _CPP_BITS_STL_ITERATOR_H
+#include <bits/stl_iterator.h>
+#endif
+#ifndef _CPP_BITS_TYPE_TRAITS_H
+#include <bits/type_traits.h>
+#endif
+#ifndef _CPP_BITS_STL_CONSTRUCT_H
+#include <bits/stl_construct.h>
+#endif
+#ifndef _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H
+#include <bits/stl_raw_storage_iter.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+// Names from stl_iterator.h
+
+using __STD::input_iterator_tag;
+using __STD::output_iterator_tag;
+using __STD::forward_iterator_tag;
+using __STD::bidirectional_iterator_tag;
+using __STD::random_access_iterator_tag;
+
+#if 0
+using __STD::iterator;
+#endif
+using __STD::input_iterator;
+using __STD::output_iterator;
+using __STD::forward_iterator;
+using __STD::bidirectional_iterator;
+using __STD::random_access_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+using __STD::iterator_traits;
+#endif
+
+using __STD::iterator_category;
+using __STD::distance_type;
+using __STD::value_type;
+
+using __STD::distance; 
+using __STD::advance; 
+
+using __STD::insert_iterator;
+using __STD::front_insert_iterator;
+using __STD::back_insert_iterator;
+using __STD::inserter;
+using __STD::front_inserter;
+using __STD::back_inserter;
+
+using __STD::reverse_iterator;
+using __STD::reverse_bidirectional_iterator;
+
+using __STD::istream_iterator;
+using __STD::ostream_iterator;
+
+// Names from stl_construct.h
+using __STD::construct;
+using __STD::destroy;
+
+// Names from stl_raw_storage_iter.h
+using __STD::raw_storage_iterator;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/list.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_LIST_H
+#define _CPP_BACKWARD_LIST_H 1
+
+#include <bits/stl_algobase.h>
+#include "alloc.h"
+#include <bits/std_list.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::list;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/map.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_MAP_H
+#define _CPP_BACKWARD_MAP_H 1
+
+#include "tree.h"
+#include <bits/stl_map.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::map;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/multimap.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_MULTIMAP_H
+#define _CPP_BACKWARD_MULTIMAP_H 1
+
+#include "tree.h"
+#include <bits/stl_multimap.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::multimap;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_MULTIMAP_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/multiset.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_MULTISET_H
+#define _CPP_BACKWARD_MULTISET_H 1
+
+#include "tree.h"
+#include <bits/stl_multiset.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::multiset;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_MULTISET_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/new.h

+
+// 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.
+
+#ifndef _CPP_BACKWARD_NEW_H
+#define _CPP_BACKWARD_NEW_H 1
+
+#include <bits/std_new.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::bad_alloc;
+using __STD::nothrow_t;
+using __STD::nothrow;
+using __STD::new_handler;
+using __STD::set_new_handler;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_NEW_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/pair.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_PAIR_H
+#define _CPP_BACKWARD_PAIR_H 1
+
+#ifndef _CPP_BITS_STL_CONFIG_H
+#include <bits/stl_config.h>
+#endif
+#ifndef _CPP_BITS_STL_RELOPS_H
+#include <bits/stl_relops.h>
+#endif
+#ifndef _CPP_BITS_STL_PAIR_H
+#include <bits/stl_pair.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::pair;
+using __STD::make_pair;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_PAIR_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/rope.h

+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_ROPE_H
+#define _CPP_BACKWARD_ROPE_H 1
+
+#include "hashtable.h"   
+#include <bits/stl_rope.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::char_producer; 
+using __STD::sequence_buffer; 
+using __STD::rope; 
+using __STD::crope; 
+using __STD::wrope; 
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_ROPE_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/set.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_SET_H
+#define _CPP_BACKWARD_SET_H 1
+
+#include "tree.h"
+#include <bits/stl_set.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::set;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/slist.h

+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef _CPP_BACKWARD_SLIST_H
+#define _CPP_BACKWARD_SLIST_H 1
+
+#include <ext/slist>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::slist;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/stack.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_STACK_H
+#define _CPP_BACKWARD_STACK_H 1
+
+#include "vector.h"
+#include "deque.h"
+#include "heap.h"
+#include <bits/stl_stack.h>
+#include <bits/stl_queue.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::stack;
+using __STD::queue;
+using __STD::priority_queue;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_STACK_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/tempbuf.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_TEMPBUF_H
+#define _CPP_BACKWARD_TEMPBUF_H 1
+
+#ifndef _CPP_BACKWARD_PAIR_H
+#include "pair.h"
+#endif
+#include <iterator.h>
+#include <limits.h>
+#include <stddef.h> 
+#include <stdlib.h> 
+#ifndef _CPP_BITS_TYPE_TRAITS_H
+#include <bits/type_traits.h>  
+#endif
+#ifndef _CPP_BITS_STL_CONSTRUCT_H
+#include <bits/stl_construct.h>
+#endif
+#ifndef _CPP_BITS_STL_UNINITIALIZED_H
+#include <bits/stl_uninitialized.h>
+#endif
+#ifndef _CPP_BITS_STL_TEMPBUF_H
+#include <bits/stl_tempbuf.h>
+#endif
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::get_temporary_buffer;
+using __STD::return_temporary_buffer;
+using __STD::_Temporary_buffer;
+
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_TEMPBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/tree.h

+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ */
+
+#ifndef _CPP_BACKWARD_TREE_H
+#define _CPP_BACKWARD_TREE_H 1
+
+#ifndef _CPP_BITS_STL_TREE_H
+#include <bits/stl_tree.h>
+#endif
+#include "algobase.h" 
+#include "alloc.h"
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::rb_tree;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_TREE_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/backward/vector.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_BACKWARD_VECTOR_H
+#define _CPP_BACKWARD_VECTOR_H 1
+
+#include "algobase.h"
+#include "alloc.h"  
+#include <bits/stl_vector.h>
+
+#ifdef __STL_USE_NAMESPACES
+using __STD::vector;
+#endif /* __STL_USE_NAMESPACES */
+
+#endif /* _CPP_BACKWARD_VECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/bits/basic_file.h

+// Wrapper of C-language FILE struct -*- C++ -*-
+
+// Copyright (C) 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: 27.8  File-based streams
+//
+
+#ifndef _CPP_BASIC_FILE
+#define _CPP_BASIC_FILE		1
+
+#include <bits/c++config.h>
+#include <bits/std_ios.h>
+
+namespace std {
+  
+  // Some of these member functions are based on libio/filebuf.cc.
+  // Also note that the order and number of virtual functions has to precisely
+  // match the order and number in the _IO_jump_t struct defined in libioP.h.
+#if _GLIBCPP_BASIC_FILE_INHERITANCE
+  class __basic_file: public __c_file_type
+#else
+  class __basic_file
+#endif
+  {
+#if _GLIBCPP_BASIC_FILE_ENCAPSULATION
+    int _M_fileno;
+    __c_file_type* _M_cfile;
+#endif
+
+  public:
+    __basic_file(__c_lock* __lock = 0);
+
+    // Eqivalent to the normal fopen function.
+    __basic_file* 
+    open(const char* __name, ios_base::openmode __mode, int __prot = 0664);
+
+    // Used for opening the standard streams, cin, cout, cerr, clog,
+    // and their wide-stream equivalents. Instead of calling open, it
+    // just sets __c_file_type->_fileno and the respective _flags bits, and
+    // returns.
+    __basic_file*
+    sys_open(int __fd, ios_base::openmode __mode);
+
+    __basic_file* 
+    close(); 
+
+    bool 
+    is_open();
+
+    // Needed by ios_base::sync_with_stdio.
+    int get_fileno(void);
+
+    // NB: Must match FILE specific jump table starting here--this
+    // means all virtual functions starting with the dtor must match,
+    // slot by slot. For glibc-based dystems, this means the _IO_FILE
+    // as the FILE struct and _IO_jump_t as the jump table.
+    virtual 
+    ~__basic_file(); // Takes the place of __finish.
+
+    virtual int 
+    overflow(int __c = EOF);
+
+    virtual int 
+    underflow();
+
+    virtual int 
+    uflow();
+
+    virtual int 
+    pbackfail(int __c);
+
+    // A complex "write" function that sets all of __c_file_type's
+    // ponters and associated data members correctly and manages it's
+    // relation to the external byte sequence.
+    virtual streamsize 
+    xsputn(const char* __s, streamsize __n);
+
+    // A complex "read" function that sets all of __c_file_type's
+    // ponters and associated data members correctly and manages it's
+    // relation to the external byte sequence.
+    virtual streamsize 
+    xsgetn(char* __s, streamsize __n);
+
+    // A complex "seekoff" function that sets all of __c_file_type's
+    // ponters and associated data members correctly and manages it's
+    // relation to the external byte sequence.
+    virtual __c_streampos 
+    seekoff(streamoff __off, ios_base::seekdir __way,
+	    ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+    // A complex "seekpos" function that sets all of __c_file_type's
+    // pointers and associated data members correctly and manages it's
+    // relation to the external byte sequence.
+    virtual __c_streampos 
+    seekpos(__c_streampos __pos, 
+	    ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+    virtual streambuf* 
+    setbuf(char* __b, int __len);
+
+    virtual int 
+    sync();
+
+    virtual int 
+    doallocate();
+
+    // A simple read function for the external byte sequence, that
+    // does no mucking around with or setting of the pointers or flags
+    // in __c_file_type.
+    virtual streamsize 
+    sys_read(char* __s, streamsize __n);
+
+    // A simple write function for the external byte sequence, that
+    // does no mucking around with or setting of the pointers or flags
+    // in __c_file_type.
+    virtual streamsize 
+    sys_write(const char* __s, streamsize __n);
+
+    // A simple seek function for the external byte sequence, that
+    // does no mucking around with or setting of the pointers or flags
+    // in __c_file_type.
+    virtual __c_streampos 
+    sys_seek(__c_streampos __off, ios_base::seekdir __way);
+
+    virtual int 
+    sys_close();
+
+    virtual int 
+    sys_stat(void* __v);
+
+    virtual int 
+    showmanyc();
+
+    virtual void 
+    imbue(void* __v);
+    };
+
+} // namespace std
+
+#endif	/* _CPP_BASIC_FILE */
+
+
+
+
+
+
+
+

libstdc++-v3/bits/basic_ios.h

+// Iostreams base classes -*- 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.
+
+#ifndef _CPP_BITS_BASICIOS_H
+#define _CPP_BITS_BASICIOS_H 1
+
+#include <bits/sbuf_iter.h>
+
+namespace std {
+
+  // 27.4.5  Template class basic_ios
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+
+      // Types:
+      typedef _CharT 				char_type;
+      typedef typename _Traits::int_type 	int_type;
+      typedef typename _Traits::pos_type 	pos_type;
+      typedef typename _Traits::off_type 	off_type;
+      typedef _Traits 				traits_type;
+
+      // Non-standard Types:
+      typedef ctype<_CharT>           		__ctype_type;
+      // From ostream
+      typedef ostreambuf_iterator<_CharT>		__ostreambuf_iter;
+      typedef num_put<_CharT, __ostreambuf_iter>        __numput_type;
+      typedef istreambuf_iterator<_CharT>		__istreambuf_iter;
+      typedef num_get<_CharT, __istreambuf_iter>        __numget_type;
+      
+      // Data members:
+    private:
+      basic_ostream<_CharT, _Traits>* 	_M_tie;
+      char_type 			_M_fill;
+      iostate 				_M_exception;
+
+    protected:
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+      iostate 				_M_streambuf_state;
+
+      // Cached use_facet<ctype>, which is based on the current locale info.
+      const __ctype_type*		_M_fctype_ios;      
+      // From ostream.
+      const __numput_type* 		_M_fnumput;
+      // From istream.
+      const __numget_type* 		_M_fnumget;
+
+    public:
+
+      inline const __ctype_type*	
+      _M_get_fctype_ios(void)
+      { return _M_fctype_ios; }
+
+      inline const __numget_type* 
+      _M_get_fnumget(void)
+      { return _M_fnumget; }
+
+      inline const __numput_type* 
+      _M_get_fnumput(void)
+      { return _M_fnumput; }
+
+      operator void*() const 
+      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
+
+      inline bool 
+      operator!() const 
+      { return this->fail(); }
+
+      inline iostate 
+      rdstate() const 
+      { return _M_streambuf_state; }
+
+      inline void 
+      clear(iostate __state = goodbit)
+      { 
+	if (this->rdbuf())
+	  _M_streambuf_state = __state;
+	else
+	  _M_streambuf_state = __state | badbit;
+	if ((this->rdstate() & this->exceptions()))
+	  throw failure("basic_ios::clear(iostate) caused exception");
+      }
+
+      inline void 
+      setstate(iostate __state) 
+      { this->clear(this->rdstate() | __state); }
+
+      inline bool 
+      good() const 
+      { return this->rdstate() == 0; }
+
+      inline bool 
+      eof() const 
+      { return (this->rdstate() & eofbit) != 0; }
+
+      inline bool 
+      fail() const 
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+      inline bool 
+      bad() const 
+      { return (this->rdstate() & badbit) != 0; }
+
+      inline iostate 
+      exceptions() const 
+      { return _M_exception; }
+
+      inline void 
+      exceptions(iostate __except) 
+      { 
+	_M_exception = __except; 
+	this->clear(_M_streambuf_state); 
+      }
+
+      // Constructor/destructor:
+      explicit 
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base() 
+      { this->init(__sb); }
+
+      virtual 
+      ~basic_ios() { }
+      
+      // Members:
+      inline basic_ostream<_CharT, _Traits>*
+      tie() const      
+      { return _M_tie; }
+
+      inline basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+	basic_ostream<_CharT, _Traits>* __old = _M_tie;
+	_M_tie = __tiestr;
+	return __old;
+      }
+
+      inline basic_streambuf<_CharT, _Traits>*
+      rdbuf() const    
+      { return _M_streambuf; }
+
+      basic_streambuf<_CharT, _Traits>* 
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+      inline char_type 
+      fill() const 
+      { return _M_fill; }
+
+      inline char_type 
+      fill(char_type __ch)
+      {
+	char_type __old = _M_fill;
+	_M_fill = __ch;
+	return __old;
+      }
+
+      // Locales:
+      locale 
+      imbue(const locale& __loc);
+
+      char 
+      narrow(char_type __c, char __dfault) const;
+
+      char_type 
+      widen(char __c) const;
+     
+    protected:
+      // 27.4.5.1  basic_ios constructors
+      basic_ios() : ios_base() 
+      { }
+
+      void 
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+    };
+  
+} // namespace std
+
+#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
+# define export
+//#include <bits/basic_ios.tcc>
+#endif
+
+#endif /* _CPP_BITS_BASICIOS_H */
+
+
+
+
+

libstdc++-v3/bits/basic_ios.tcc

+// basic_ios locale and locale-related member functions -*- C++ -*-
+
+// Copyright (C) 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.
+
+#ifndef _CPP_BITS_BASICIOS_TCC
+#define _CPP_BITS_BASICIOS_TCC 1
+
+namespace std {
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>* 
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+      // Per 27.1.1.1, do not call imbue, yet must trash all caches
+      // associated with imbue()
+
+      // Alloc any new word array first, so if it fails we have "rollback".
+      _Words* __words = (__rhs._M_word_limit <= _S_local_words) ?
+	_M_word_array : new _Words[__rhs._M_word_limit];
+
+      // XXX This is the only reason _Callback_list was defined
+      // inline. The suspicion is that this increased compilation
+      // times dramatically for functions that use this member
+      // function (inserters_extractors, ios_manip_fmtflags). FIX ME,
+      // clean this stuff up. Callbacks are broken right now, anyway.
+
+      // Bump refs before doing callbacks, for safety.
+      _Callback_list* __cb = __rhs._M_callbacks;
+      if (__cb) 
+	__cb->_M_add_reference();
+      _M_call_callbacks(erase_event);
+      if (_M_words != _M_word_array) 
+	delete [] _M_words;
+      _M_dispose_callbacks();
+
+      _M_callbacks = __cb;  // NB: Don't want any added during above.
+      for (int __i = 0; __i < __rhs._M_word_limit; ++__i)
+	__words[__i] = __rhs._M_words[__i];
+      if (_M_words != _M_word_array) 
+	delete [] _M_words;
+      _M_words = __words;
+      _M_word_limit = __rhs._M_word_limit;
+
+      this->flags(__rhs.flags());
+      this->width(__rhs.width());
+      this->precision(__rhs.precision());
+      this->tie(__rhs.tie());
+      this->fill(__rhs.fill());
+      // The next is required to be the last assignment.
+      this->exceptions(__rhs.exceptions());
+      
+      _M_call_callbacks(copyfmt_event);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    char
+    basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
+    { return _M_fctype_ios->narrow(__c, __dfault); }
+
+  template<typename _CharT, typename _Traits>
+    _CharT
+    basic_ios<_CharT, _Traits>::widen(char __c) const
+    { return _M_fctype_ios->widen(__c); }
+
+  // Locales:
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_fctype_ios = &use_facet<__ctype_type>(__loc);
+      _M_fnumput = &use_facet<__numput_type>(__loc); 
+      _M_fnumget = &use_facet<__numget_type>(__loc); 
+      if (this->rdbuf() != 0)
+	this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      // NB: This may be called more than once on the same object.
+      ios_base::_M_init();
+      locale __loc = this->getloc();
+      _M_fctype_ios = &use_facet<__ctype_type>(__loc);
+      // Should be filled in by ostream and istream, respectively.
+      _M_fnumput = &use_facet<__numput_type>(__loc); 
+      _M_fnumget = &use_facet<__numget_type>(__loc); 
+      _M_tie = 0;
+      _M_fill = this->widen(' ');
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      iostate __state = __sb ? goodbit : badbit;
+      _M_streambuf_state = __state;
+    }
+
+} // namespace std
+
+#endif /* _CPP_BITS_BASICIOS_TCC */
+
+
+
+
+

libstdc++-v3/bits/c++config.h

+// Predefined symbols and macros -*- C++ -*-
+
+// 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.
+
+// 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.
+
+#ifndef _CPP_CPPCONFIG
+#define _CPP_CPPCONFIG 1
+
+// The current version of the C++ library in compressed ISO date format.
+#define __GLIBCPP__ 20000324
+
+// This flag controls the error handling in string, and perhaps other
+// bits as time goes on: check out bits/basic_string.h for more
+// info. It also helps alleviate the circular dependency between
+// string and exception.
+# define _GLIBCPP_USE_EXCEPTIONS 1 
+
+// This is necessary until Egcs supports separate template
+// compilation.  
+#define _GLIBCPP_NO_TEMPLATE_EXPORT 1
+
+// This is a hack around not having either pre-compiled headers or
+// export compilation. If defined, the io, string, and valarray
+// headers will include all the necessary bits. If not defined, the
+// implementation optimizes the headers for the most commonly-used
+// types. For the io library, this means that larger, out-of-line
+// member functions are only declared, and definitions are not parsed
+// by the compiler, but instead instantiated into the library binary.
+//#define _GLIBCPP_FULLY_COMPLIANT_HEADERS 1
+
+// To enable older, ARM-style iostreams and other anachronisms use this.
+//#define _GLIBCPP_DEPRICATED 1
+
+// Use corrected code from the committee library group's issues list.
+# define _GLIBCPP_RESOLVE_LIB_DEFECTS 1
+
+
+
+
+
+
+

libstdc++-v3/bits/char_traits.h

+// Character Traits for use by standard string and iostream
+
+// 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: 21  Strings library
+//
+
+#ifndef _CPP_BITS_CHAR_TRAITS_H
+#define _CPP_BITS_CHAR_TRAITS_H 1
+
+#include <bits/std_cwchar.h> 	// For mbstate_t.
+#include <bits/std_cstring.h> 	// For memmove, memset, memchr
+#include <bits/fpos.h> 		// For streamoff, streamsize
+
+namespace std {
+
+  // Same as iosfwd
+#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
+  // Can't have self-recursive types for streampos. 
+  // 21.1.3.1 char_traits sets size_type to streampos
+  // 27.4.1 
+  // And here, where streampos is typedefed to fpos<traits::state_type>
+    typedef fpos<mbstate_t> 	streampos;
+#  ifdef _GLIBCPP_USE_WCHAR_T
+    typedef fpos<mbstate_t> 	wstreampos;
+#  endif
+#endif
+
+  // 21.1.2 Basis for explicit _Traits specialization 
+  // NB: That for any given actual character type this definition is
+  // probably wrong.
+
+  template<class _CharT>
+    struct char_traits
+    {
+      typedef _CharT 		char_type;
+      // Unsigned as wint_t in unsigned.
+      typedef unsigned long  	int_type;
+      typedef streampos 	pos_type;
+      typedef streamoff 	off_type;
+      typedef mbstate_t 	state_type;
+      
+      static void 
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool 
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool 
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int 
+      compare(const char_type* __s1, const char_type* __s2, int_type __n)
+      { 
+	for (int_type __i = 0; __i < __n; ++__i)
+	  if (!eq(__s1[__i],__s2[__i]))
+	    return lt(__s1[__i],__s2[__i]) ? -1 : 1;
+	return 0; 
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { 
+	const char_type* __p = __s; 
+	while (*__p) ++__p; 
+	return (__p - __s); 
+      }
+
+      static const char_type* 
+      find(const char_type* __s, int __n, const char_type& __a)
+      { 
+	for (const char_type* __p = __s; __p < __s+__n; ++__p)
+	  if (*__p == __a) return __p;
+	return 0;
+      }
+
+      static char_type* 
+      move(char_type* __s1, const char_type* __s2, int_type __n)
+      { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
+
+      static char_type* 
+      copy(char_type* __s1, const char_type* __s2, int_type __n)
+      { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
+
+      static char_type* 
+      assign(char_type* __s, int_type __n, char_type __a)
+      { 
+	for (char_type* __p = __s; __p - __s < __n; ++__p) 
+	  assign(*__p, __a);
+        return __s; 
+      }
+
+      static char_type 
+      to_char_type(const int_type& __c)
+      { return char_type(__c); }
+
+      static int_type 
+      to_int_type(const char_type& __c) { return int_type(__c); }
+
+      static bool 
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static state_type 
+      get_state (pos_type __pos) { return __pos.state(); }
+
+      static int_type 
+      eof() { return static_cast<int_type>(-1); }
+
+      static int_type 
+      eos() { return int_type(); }
+
+      static int_type 
+      not_eof(const int_type& __c)
+      { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
+    };
+
+  // 21.1.4  char_traits specializations
+  template<>
+    struct char_traits<char>
+    {
+      typedef char 		char_type;
+      typedef unsigned int 	int_type;
+      typedef streampos 	pos_type;
+      typedef streamoff 	off_type;
+      typedef mbstate_t 	state_type;
+
+      static void 
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool 
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool 
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int 
+      compare(const char_type* __s1, const char_type* __s2, int_type __n)
+      { return memcmp(__s1, __s2, __n); }
+
+      static size_t
+      length(const char_type* __s)
+      { return strlen(__s); }
+
+      static const char_type* 
+      find(const char_type* __s, int __n, const char_type& __a)
+      { return static_cast<char*>(memchr(__s, __a, __n)); }
+
+      static char_type* 
+      move(char_type* __s1, const char_type* __s2, int_type __n)
+      { return static_cast<char*>(memmove(__s1, __s2, __n)); }
+
+      static char_type* 
+      copy(char_type* __s1, const char_type* __s2, int_type __n)
+      {  return static_cast<char*>(memcpy(__s1, __s2, __n)); }
+
+      static char_type* 
+      assign(char_type* __s, int_type __n, char_type __a)
+      { return static_cast<char*>(memset(__s, __a, __n)); }
+
+      static char_type 
+      to_char_type(const int_type& __c)
+      { return static_cast<char>(__c); }
+
+      //  To keep both the byte 0xff and the eof symbol 0xffffffff
+      //  from ending up as 0xffffffff.
+      static int_type 
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+
+      static bool 
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static state_type 
+      get_state(pos_type __pos) { return __pos.state(); }
+
+      static int_type 
+      eof() { return static_cast<int_type>(EOF); }
+
+      static int_type 
+      eos() { return '\0'; }
+
+      static int_type 
+      not_eof(const int_type& __c)
+      { return (__c == eof()) ? 0 : __c; }
+  };
+
+
+#ifdef _GLIBCPP_USE_WCHAR_T
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t 		char_type;
+      typedef wint_t 		int_type;
+      typedef wstreamoff 	off_type;
+      typedef wstreampos 	pos_type;
+      typedef mbstate_t 	state_type;
+      
+      static void 
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+      static bool 
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+      static bool 
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int 
+      compare(const char_type* __s1, const char_type* __s2, int_type __n)
+      { 
+	for (int_type __i = 0; __i < __n; ++__i)
+	  if (!eq(__s1[__i], __s2[__i]))
+	    return lt(__s1[__i], __s2[__i]) ? -1 : 1;
+	return 0; 
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { 
+	const char_type* __p = __s; 
+	while (*__p) 
+	  ++__p; 
+	return (__p - __s); 
+      }
+
+      static const char_type* 
+      find (const char_type* __s, int __n, const char_type& __a)
+      { 
+	for (const char_type* __p = __s; __p < __s+__n; ++__p)
+	  if (*__p == __a) 
+	    return __p;
+	return 0;
+      }
+
+      static char_type* 
+      move(char_type* __s1, const char_type* __s2, int_type __n)
+      { return static_cast<wchar_t*>(memmove(__s1, __s2, 
+					     __n * sizeof(wchar_t))); }
+
+      static char_type* 
+      copy(char_type* __s1, const char_type* __s2, int_type __n)
+      { return static_cast<wchar_t*>(memcpy(__s1, __s2, 
+					    __n * sizeof(wchar_t))); }
+
+      static char_type* 
+      assign(char_type* __s, int_type __n, char_type __a)
+      { 
+	for (char_type* __p = __s; __p < __s + __n; ++__p) 
+	  assign(*__p, __a);
+        return __s; 
+      }
+
+      static char_type 
+      to_char_type(const int_type& __c) { return char_type(__c); }
+
+      static int_type 
+      to_int_type(const char_type& __c) { return int_type(__c); }
+
+      static bool 
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static state_type 
+      get_state(pos_type __pos) { return __pos.state(); }
+
+      static int_type 
+      eof() { return static_cast<int_type>(WEOF); }
+
+      static int_type 
+      eos() { return int_type(); }
+
+      static int_type 
+      not_eof(const int_type& __c)
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+#endif //_GLIBCPP_USE_WCHAR_T
+
+  template<typename _CharT, typename _Traits>
+    struct _Char_traits_match
+    {
+      _CharT _M_c;
+      _Char_traits_match(_CharT const& __c) : _M_c(__c) { }
+
+      bool 
+      operator()(_CharT const& __a) { return _Traits::eq(_M_c,__a); }
+    };
+
+} // namespace std
+
+
+#endif /* _CPP_BITS_CHAR_TRAITS_H */
+
+

libstdc++-v3/bits/cpp_type_traits.h

+// The  -*- C++ -*- type traits classes for internal use in libstdc++
+
+// Copyright (C) 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.
+
+// 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.
+
+// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
+
+#ifndef _CPP_BITS_CPP_TYPE_TRAITS_H
+#define _CPP_BITS_CPP_TYPE_TRAITS_H 1
+
+//
+// This file provides some compile-time information about various types.
+// These informations were designed, on purpose, to be constant-expressions
+// and not types as found in <stl/bits/type_traits.h>.  In particular, they
+// can be used in control structures and the optimizer hopefully will do
+// the obvious thing.
+//
+// Why integral expressions, and not functions nor types?
+// Firstly, these compile-time information entities are used as
+// template-arguments so function return values won't work.  We
+// need compile-time entities.  We're left with types and constant
+// integral expressions.
+// Secondly, from the point of view of ease of use type-based compile-time
+// information is -not- *that* convenient.  On has to write lots of
+// overloaded functions and to hope that the compiler will select the right
+// one. As a net effect, the overall structure isn't very clear at first
+// glance.
+// Thirdly, partial ordering and overload resolution (of template functions)
+// is very costly in terms of compiler-resource.  It is a Good Thing to
+// keep these resource consumption as least as possible.
+//
+// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
+//
+
+namespace std {
+
+  template<typename _Tp>
+  struct __is_void
+  {
+    enum
+    {
+      _M_type = 0
+    };
+  };
+
+  template<>
+  struct __is_void<void>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  //
+  // Integer types
+  //
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum
+      {
+	_M_type = 0
+      };
+    };
+
+  // Thirteen specializations (yes there are eleven standard integer
+  // types; 'long long' and 'unsigned long long' are supported as
+  // extensions)
+  template<>
+    struct __is_integer<bool>
+    {
+      enum
+      {
+	_M_type = 1
+      };
+    };
+  
+  template<>
+    struct __is_integer<char>
+    {
+      enum
+      {
+	_M_type = 1
+      };
+    };
+
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum
+      {
+	_M_type = 1
+      };
+    };
+  
+  template<>
+  struct __is_integer<unsigned char>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+# ifdef _GLIBCPP_USE_WCHAR_T
+  template<>
+  struct __is_integer<wchar_t>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+# endif
+  
+  template<>
+  struct __is_integer<short>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<unsigned short>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<int>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<unsigned int>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<long>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<unsigned long>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+# ifdef _GLIBCPP_USE_LONG_LONG
+  template<>
+  struct __is_integer<long long>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_integer<unsigned long long>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+# endif
+
+  //
+  // Floating point types
+  //
+  template<typename _Tp>
+  struct __is_floating
+  {
+    enum
+    {
+      _M_type = 0
+    };
+  };
+
+  // three specializations (float, double and 'long double')
+  template<>
+  struct __is_floating<float>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_floating<double>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  template<>
+  struct __is_floating<long double>
+  {
+    enum
+    {
+      _M_type = 1
+    };
+  };
+
+  //
+  // An arithmetic type is an integer type or a floating point type
+  //
+  template<typename _Tp>
+  struct __is_arithmetic
+  {
+    enum
+    {
+      _M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
+    };
+  };
+
+  //
+  // A fundamental type is `void' or and arithmetic type
+  //
+  template<typename _Tp>
+  struct __is_fundamental
+  {
+    enum
+    {
+      _M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
+    };
+  };
+
+  //
+  // For the immediate use, the following is a good approximation
+  //
+  template<typename _Tp>
+  struct __is_pod
+  {
+    enum
+    {
+      _M_type = __is_fundamental<_Tp>::_M_type
+    };
+  };
+
+} // namespace std
+
+
+#endif //_CPP_BITS_CPP_TYPE_TRAITS_H
+
+
+
+
+
+
+

libstdc++-v3/bits/exception_support.h

+// Methods and support infrastructure for exceptions -*- C++ -*-
+
+// Copyright (C) 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.
+
+// 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: 15 Exception handling
+//
+
+// This file declares functions whose only purpose is to throw an
+// exception. They help break a circularity between <string> and
+// <stdexcept>. See src/stdexcept.cc, where these functions are
+// defined.
+
+// XXX: These functions serve a similar purpose to those in
+// stl/bits/stl_range_errors.h . Eventually the two approaches should
+// be merged. 
+
+#ifndef _CPP_EXCEPTION_SUPPORT_H
+#define _CPP_EXCEPTION_SUPPORT_H	1
+
+namespace std {
+
+#if _GLIBCPP_USE_EXCEPTIONS
+  // Internal functions for string implementation.
+  extern void __out_of_range(const char *__str);
+  extern void __length_error(const char *__str);
+  
+# define __OUTOFRANGE(__cond) \
+  do { if (__cond) __out_of_range(#__cond); } while (0)
+# define __LENGTHERROR(__cond) \
+  do { if (__cond) __length_error(#__cond); } while (0)
+#else
+# include <bits/std_cassert.h>
+# define __OUTOFRANGE(__cond) assert(!(__cond))
+# define __LENGTHERROR(__cond) assert(!(__cond))
+#endif
+
+} // namespace std
+
+#endif	/* _CPP_EXCEPTION_SUPPORT_H */
+
+
+
+
+
+
+
+
+
+
+
+
+
+

libstdc++-v3/bits/fpos.h

+// File position object and stream types
+
+// 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: 27 Input/output library
+//
+
+#ifndef _CPP_BITS_FPOS_H
+#define _CPP_BITS_FPOS_H 1
+
+// Need this here as well as in std_ios because fpos is used in
+// char_traits, and char_traits is used by string, which may or may
+// not have included the std_ios file.
+#include <bits/c++io.h>
+
+namespace std {
+
+  // 27.4.1  Types
+
+  // 27.4.3  Template class fpos
+  template<typename _StateT>
+    class fpos
+    {
+    public:
+
+      // Types:
+      typedef _StateT __state_type;
+
+      __state_type
+      state() const  { return _M_st; }
+
+      void 
+      state(__state_type __st)  { _M_st = __st; }
+
+      // NB: The standard defines only the implicit copy ctor and the
+      // previous two members.  The rest is a "conforming extension".
+      fpos(): _M_st(__state_type()), _M_pos(streamoff()) { }
+
+      fpos(streamoff __pos, __state_type __st)
+      : _M_st(__st), _M_pos(__pos) { }
+
+      fpos(streamoff __pos)
+      : _M_st(), _M_pos(__pos) { }
+
+      operator streamoff() const { return _M_pos; }
+
+      fpos& 
+      operator+=(streamoff __off) { _M_pos += __off; return *this; }
+
+      fpos& 
+      operator-=(streamoff __off) { _M_pos -= __off; return *this; }
+
+      bool  
+      operator==(const fpos& __pos2) const { return _M_pos == __pos2._M_pos; }
+
+      bool  
+      operator!=(const fpos& __pos2) const { return _M_pos != __pos2._M_pos; }
+      
+      streamoff 
+      _M_position() const { return _M_pos; }
+
+      void
+      _M_position(streamoff __pos)  { _M_pos = __pos; }
+
+    private:
+      __state_type _M_st;
+      streamoff _M_pos;
+    };
+
+  template<typename _State>
+    inline fpos<_State> 
+    operator+(const fpos<_State>& __pos, streamoff __off)
+    { 
+      fpos<_State> t(__pos); 
+      return t += __off; 
+    }
+
+  template<typename _State>
+    inline fpos<_State>
+    operator-(const fpos<_State>& __pos, streamoff __off)
+    { 
+      fpos<_State> t(__pos); 
+      return t -= __off; 
+    }
+
+  template<typename _State>
+    inline streamoff 
+    operator-(const fpos<_State>& __pos1, const fpos<_State>& __pos2)
+    { return __pos1._M_position() - __pos2._M_position(); }
+
+}  // namespace std
+
+#endif /* _CPP_BITS_FPOS_H */
+
+

libstdc++-v3/bits/generic_shadow.h

+// generic C header shadow file -*- 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.
+
+// This file is included by all the standard C <foo.h> headers
+// after defining _SHADOW_NAME.
+
+#ifdef _IN_C_SWAMP_  /* sub-included by a C header */
+
+      // get out of the "swamp"
+    } // close extern "C"
+  }   // close namespace _C_Swamp::
+
+# undef _IN_C_SWAMP_
+# include _SHADOW_NAME
+
+  // dive back into the "swamp"
+  namespace _C_Swamp {
+    extern "C" {
+#     define _IN_C_SWAMP_
+  
+#else /* not _IN_C_SWAMP_:  directly included by user program */
+  
+# include _SHADOW_NAME
+  
+  // 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;
+  
+#endif /* _IN_C_SWAMP_ */
+    

libstdc++-v3/bits/gslice.h

+// The template and inlines for the -*- C++ -*- gslice class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_GSLICE_H
+#define _CPP_BITS_GSLICE_H
+
+namespace std {
+    
+    class gslice
+    {
+    public:
+        gslice ();
+        gslice (size_t, const valarray<size_t>&, const valarray<size_t>&);
+        // XXX: the IS says the copy-ctor and copy-assignment operators are
+        //      synthetized by the compiler but they are just unsuitable
+        //      for a ref-counted semantic
+        gslice(const gslice&);
+        ~gslice();
+
+        // XXX: See the note above.
+        gslice& operator= (const gslice&);
+        
+        size_t           start () const;
+        valarray<size_t> size () const;
+        valarray<size_t> stride () const;
+        
+    private:
+        struct _Indexer {
+            size_t _M_count;
+            size_t _M_start;
+            valarray<size_t> _M_size;
+            valarray<size_t> _M_stride;
+            valarray<size_t> _M_index;
+            _Indexer(size_t, const valarray<size_t>&,
+                     const valarray<size_t>&);
+            void _M_increment_use() { ++_M_count; }
+            size_t _M_decrement_use() { return --_M_count; }
+        };
+
+        _Indexer* _M_index;
+        
+        template<typename _Tp> friend class valarray;
+    };
+    
+    inline size_t
+    gslice::start () const
+    { return _M_index ? _M_index->_M_start : 0; }
+    
+    inline valarray<size_t>
+    gslice::size () const
+    { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
+    
+    inline valarray<size_t>
+    gslice::stride () const
+    { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
+    
+    inline gslice::gslice () : _M_index(0) {}
+
+    inline
+    gslice::gslice(size_t __o, const valarray<size_t>& __l,
+                   const valarray<size_t>& __s)
+            : _M_index(new gslice::_Indexer(__o, __l, __s)) {}
+
+    inline
+    gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
+    { if (_M_index) _M_index->_M_increment_use(); }
+    
+    inline
+    gslice::~gslice()
+    { if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
+
+    inline gslice&
+    gslice::operator= (const gslice& __g)
+    {
+        if (__g._M_index) __g._M_index->_M_increment_use();
+        if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index;
+        _M_index = __g._M_index;
+        return *this;
+    }
+            
+    
+} // std::
+
+
+#endif /* _CPP_BITS_GSLICE_H */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/gslice_array.h

+// The template and inlines for the -*- C++ -*- gslice_array class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_GSLICE_ARRAY
+#define _CPP_BITS_GSLICE_ARRAY 1
+
+namespace std {
+
+    template<typename _Tp> class gslice_array
+    {
+    public:
+        typedef _Tp value_type;
+
+        void operator=  (const valarray<_Tp>&) const;
+        void operator*= (const valarray<_Tp>&) const;
+        void operator/= (const valarray<_Tp>&) const;
+        void operator%= (const valarray<_Tp>&) const;
+        void operator+= (const valarray<_Tp>&) const;
+        void operator-= (const valarray<_Tp>&) const;
+        void operator^= (const valarray<_Tp>&) const;
+        void operator&= (const valarray<_Tp>&) const;
+        void operator|= (const valarray<_Tp>&) const;
+        void operator<<=(const valarray<_Tp>&) const;
+        void operator>>=(const valarray<_Tp>&) const;
+        void operator=(const _Tp&);
+
+        template<class _Dom>
+        void operator= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator*= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator/= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator%= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator+= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator-= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator^= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator&= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator|= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator<<= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator>>= (const _Expr<_Dom,_Tp>&) const;
+        
+    private:
+        _Array<_Tp>    _M_array;
+        const valarray<size_t>& _M_index;
+        
+        friend class valarray<_Tp>;
+        
+        gslice_array (_Array<_Tp>, const valarray<size_t>&);
+
+        // this constructor needs to be implemented.
+        gslice_array (const gslice_array&);
+
+        // not implemented
+        gslice_array();
+        gslice_array& operator= (const gslice_array&);
+    };
+
+    template<typename _Tp>
+    inline
+    gslice_array<_Tp>::gslice_array (_Array<_Tp> __a,
+                                     const valarray<size_t>& __i)
+            : _M_array (__a), _M_index (__i) {}
+
+
+    template<typename _Tp>
+    inline
+    gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a)
+            : _M_array (__a._M_array), _M_index (__a._M_index) {}
+
+    
+    template<typename _Tp>
+    inline void
+    gslice_array<_Tp>::operator= (const _Tp& __t) 
+    { 
+        __valarray_fill (_M_array, _Array<size_t>(_M_index),
+                         _M_index.size(), __t); 
+    }
+
+    template<typename _Tp>
+    inline void
+    gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
+    {
+        __valarray_copy (_Array<_Tp> (__v), __v.size (),
+                         _M_array, _Array<size_t>(_M_index));
+    }
+
+    template<typename _Tp>
+    template<class E>
+    inline void
+    gslice_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
+    {
+        __valarray_copy (__e, _M_index.size(), _M_array,
+                         _Array<size_t>(_M_index));
+    }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(op, name)				\
+template<typename _Tp>							\
+inline void								\
+gslice_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const	\
+{									\
+    _Array_augmented_##name (_M_array, _Array<size_t>(_M_index),	\
+                              _Array<_Tp> (__v), __v.size ());		\
+}									\
+									\
+template<typename _Tp> template<class E>        			\
+inline void 								\
+gslice_array<_Tp>::operator##op##= (const _Expr<E, _Tp>& __e) const	\
+{									\
+    _Array_augmented_##name (_M_array, _Array<size_t>(_M_index), __e,	\
+                              _M_index.size());				\
+}
+
+_DEFINE_VALARRAY_OPERATOR(*, multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, divides)    
+_DEFINE_VALARRAY_OPERATOR(%, modulus)
+_DEFINE_VALARRAY_OPERATOR(+, plus)    
+_DEFINE_VALARRAY_OPERATOR(-, minus)
+_DEFINE_VALARRAY_OPERATOR(^, xor)
+_DEFINE_VALARRAY_OPERATOR(&, and)
+_DEFINE_VALARRAY_OPERATOR(|, or)
+_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+} // std::
+
+#endif /* _CPP_BITS_GSLICE_ARRAY */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/indirect_array.h

+// The template and inlines for the -*- C++ -*- indirect_array class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_INDIRECT_ARRAY_H
+#define _CPP_BITS_INDIRECT_ARRAY_H
+
+namespace std {
+
+    template <class _Tp> class indirect_array
+    {
+    public:
+        typedef _Tp value_type;
+    
+        void operator=  (const valarray<_Tp>&) const;
+        void operator*= (const valarray<_Tp>&) const;
+        void operator/= (const valarray<_Tp>&) const;
+        void operator%= (const valarray<_Tp>&) const; 
+        void operator+= (const valarray<_Tp>&) const;
+        void operator-= (const valarray<_Tp>&) const;  
+        void operator^= (const valarray<_Tp>&) const;
+        void operator&= (const valarray<_Tp>&) const;
+        void operator|= (const valarray<_Tp>&) const;
+        void operator<<= (const valarray<_Tp>&) const;
+        void operator>>= (const valarray<_Tp>&) const; 
+        void operator= (const _Tp&);
+        //    ~indirect_array();
+
+        template<class _Dom>
+        void operator=  (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator*= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator/= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator%= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator+= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator-= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator^= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator&= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator|= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator<<= (const _Expr<_Dom, _Tp>&) const;
+        template<class _Dom>
+        void operator>>= (const _Expr<_Dom, _Tp>&) const; 
+
+    private:
+    indirect_array (const indirect_array&);
+    indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
+
+    friend class valarray<_Tp>;
+    friend class gslice_array<_Tp>;
+
+    const size_t 	 _M_sz;
+    const _Array<size_t> _M_index;
+    const _Array<_Tp> 	 _M_array;
+
+        // not implemented
+        indirect_array ();
+        indirect_array& operator= (const indirect_array&);
+    };
+
+    template<typename _Tp>
+    inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
+            : _M_sz (__a._M_sz), _M_index (__a._M_index),
+              _M_array (__a._M_array) {}
+    
+    template<typename _Tp>
+    inline
+    indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s, 
+                                         _Array<size_t> __i)
+            : _M_sz (__s), _M_index (__i), _M_array (__a) {}
+    
+    // template<typename _Tp>
+    // inline indirect_array<_Tp>::~indirect_array() {}
+
+    template<typename _Tp>
+    inline void
+    indirect_array<_Tp>::operator= (const _Tp& __t)
+    { __valarray_fill(_M_array, _M_index, _M_sz, __t); }
+
+    template<typename _Tp>
+    inline void
+    indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
+    { __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
+
+    template<typename _Tp>
+    template<class _Dom>
+    inline void
+    indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
+    { __valarray_copy (__e, _M_sz, _M_array, _M_index); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(op, name)				\
+template<typename _Tp>							\
+inline void								\
+indirect_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const	\
+{									\
+  _Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
+}									\
+									\
+template<typename _Tp> template<class _Dom>				\
+inline void								\
+indirect_array<_Tp>::operator##op##= (const _Expr<_Dom,_Tp>& __e) const \
+{									\
+  _Array_augmented_##name (_M_array, _M_index, __e, _M_sz);		\
+}
+
+_DEFINE_VALARRAY_OPERATOR(*, multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, divides)
+_DEFINE_VALARRAY_OPERATOR(%, modulus)
+_DEFINE_VALARRAY_OPERATOR(+, plus)
+_DEFINE_VALARRAY_OPERATOR(-, minus)
+_DEFINE_VALARRAY_OPERATOR(^, xor)
+_DEFINE_VALARRAY_OPERATOR(&, and)
+_DEFINE_VALARRAY_OPERATOR(|, or)
+_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+} // std::
+
+#endif /* _CPP_BITS_INDIRECT_ARRAY_H */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/mask_array.h

+// The template and inlines for the -*- C++ -*- mask_array class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_MASK_ARRAY_H
+#define _CPP_BITS_MASK_ARRAY_H 1
+
+namespace std {
+
+    template <class _Tp> class mask_array
+    { 
+    public:
+        typedef _Tp value_type;
+    
+        void operator=  (const valarray<_Tp>&) const;
+        void operator*= (const valarray<_Tp>&) const;
+        void operator/= (const valarray<_Tp>&) const;
+        void operator%= (const valarray<_Tp>&) const;
+        void operator+= (const valarray<_Tp>&) const; 
+        void operator-= (const valarray<_Tp>&) const;
+        void operator^= (const valarray<_Tp>&) const;  
+        void operator&= (const valarray<_Tp>&) const;
+        void operator|= (const valarray<_Tp>&) const;
+        void operator<<=(const valarray<_Tp>&) const;  
+        void operator>>=(const valarray<_Tp>&) const; 
+        void operator= (const _Tp&);
+    
+        //        ~mask_array ();
+        
+        template<class _Dom>
+        void operator=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator*= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator/= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator%= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator+= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator-= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator^= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator&= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator|= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator<<=(const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator>>=(const _Expr<_Dom,_Tp>&) const; 
+
+    private:
+        mask_array (_Array<_Tp>, size_t, _Array<bool>);
+        friend class valarray<_Tp>;
+        
+        const size_t       _M_sz;
+        const _Array<bool> _M_mask;
+        const _Array<_Tp>   _M_array;
+        
+        mask_array (const mask_array&);
+        
+        // not implemented
+        mask_array ();
+        mask_array& operator= (const mask_array&);
+    };
+
+
+    template<typename _Tp>
+    inline mask_array<_Tp>::mask_array (const mask_array<_Tp>& a)
+            : _M_sz (a._M_sz), _M_mask (a._M_mask), _M_array (a._M_array) {}
+
+    template<typename _Tp>
+    inline 
+    mask_array<_Tp>::mask_array (_Array<_Tp> __a, size_t __s, _Array<bool> __m)
+            : _M_sz (__s), _M_mask (__m), _M_array (__a) {}
+    
+    //    template<typename _Tp>
+    //    inline mask_array<_Tp>::~mask_array () {}
+    
+    template<typename _Tp>
+    inline void
+    mask_array<_Tp>::operator= (const _Tp& __t)
+    { __valarray_fill (_M_array, _M_sz, _M_mask, __t); }
+    
+    template<typename _Tp>
+    inline void
+    mask_array<_Tp>::operator= (const valarray<_Tp>& __v) const
+    { __valarray_copy (_Array<_Tp> (__v), __v.size (), _M_array, _M_mask); }
+
+    template<typename _Tp>
+    template<class E>
+    inline void
+    mask_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
+    { __valarray_copy (__e, __e.size (), _M_array, _M_mask); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(op, name)				\
+template<typename _Tp>							\
+inline void								\
+mask_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const	\
+{									\
+  _Array_augmented_##name (_M_array, _M_mask, 				\
+                           _Array<_Tp> (__v), __v.size ());		\
+}									\
+									\
+template<typename _Tp> template<class E>				\
+inline void								\
+mask_array<_Tp>::operator##op##= (const _Expr<E, _Tp>& __e) const	\
+{									\
+  _Array_augmented_##name (_M_array, _M_mask, __e, __e.size ());	\
+}
+
+_DEFINE_VALARRAY_OPERATOR(*, multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, divides)
+_DEFINE_VALARRAY_OPERATOR(%, modulus)
+_DEFINE_VALARRAY_OPERATOR(+, plus)
+_DEFINE_VALARRAY_OPERATOR(-, minus)
+_DEFINE_VALARRAY_OPERATOR(^, xor)
+_DEFINE_VALARRAY_OPERATOR(&, and)
+_DEFINE_VALARRAY_OPERATOR(|, or)
+_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR    
+    
+} // std::
+
+#endif /* _CPP_BITS_MASK_ARRAY_H */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/sbuf_iter.h

+// Streambuf iterators
+
+// 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.
+
+// XXX Should specialize copy, find algorithms for streambuf iterators.
+
+#ifndef _CPP_BITS_SBUF_ITER_H
+#define _CPP_BITS_SBUF_ITER_H 1
+
+namespace std
+{
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+#if 0      // XXX this is standard:
+    : public iterator<output_iterator_tag,_CharT,void,void,void>
+#else
+    : public output_iterator
+#endif
+    {
+    public:
+
+      // Types:
+      typedef _CharT                       	 char_type;
+      typedef _Traits                          traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits>   ostream_type;
+      
+      inline 
+      ostreambuf_iterator(ostream_type& __s) throw ()
+      : _M_sbuf(__s.rdbuf()), _M_failed(false) { }
+      
+      ostreambuf_iterator(streambuf_type* __s) throw ()
+      : _M_sbuf(__s), _M_failed(false) { }
+
+      ostreambuf_iterator& 
+      operator=(_CharT __c);
+
+      ostreambuf_iterator& 
+      operator*() throw()
+      { return *this; }
+
+      ostreambuf_iterator& 
+      operator++(int) throw()
+      { return *this; }
+
+      ostreambuf_iterator& 
+      operator++() throw()
+      { return *this; }
+
+      bool 
+      failed() const throw()
+      { return _M_failed; }
+
+    private:
+      streambuf_type* 	_M_sbuf;
+      bool 		_M_failed;
+
+#if 0
+      template<>
+        friend char const*
+        copy(char const* __first, char const* __last,
+             ostreambuf_iterator<char,char_traits<char> > __to);
+      template<>
+        friend wchar_t const*
+        copy(wchar_t const* __first, wchar_t const* __last,
+             ostreambuf_iterator<wchar_t,char_traits<wchar_t> > __to);
+#endif
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline ostreambuf_iterator<_CharT, _Traits>&
+    ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c)
+    {
+      if (!_M_failed &&
+          _Traits::eq_int_type(_M_sbuf->sputc(__c),_Traits::eof()))
+      _M_failed = true;
+      return *this;
+    }
+
+
+#if 0
+  // Optimized specializations of standard algorithms
+  // These are specialized only for standard types
+  // (with no unbound arguments) to avoid creating
+  // overload problems with user specializations.
+
+  template<>
+    char const*
+    copy(char const* __first, char const* __last,
+	 ostreambuf_iterator<char,char_traits<char> > __to)
+    {
+      if (!__to._M_failed)
+	__to._M_sbuf->sputn(__first, __last-__first);
+      return __last;
+    }
+
+  template<>
+    wchar_t const*
+    copy(wchar_t const* __first, wchar_t const* __last,
+	 ostreambuf_iterator<whar_t,char_traits<wchar_t> > __to)
+    {
+      if (!__to._M_failed)
+	__to._M_sbuf->sputn(__first, __last-__first);
+      return __last;
+    }
+#endif
+
+  // 24.5.3 Template class istreambuf_iterator
+  template<class _CharT, class _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+    		      _CharT*, _CharT&>
+    {
+    public:
+
+      // Types:
+      typedef _CharT                         		char_type;
+      typedef _Traits                        		traits_type;
+      typedef typename _Traits::int_type     		int_type;
+      typedef basic_streambuf<_CharT, _Traits> 		streambuf_type;
+      typedef basic_istream<_CharT, _Traits>         	istream_type;
+      // Non-standard Types:
+      typedef istreambuf_iterator<_CharT, _Traits>	__istreambufiter_type;
+
+      istreambuf_iterator() throw() 
+      : _M_istreambuf(NULL), _M_c(-2) { }
+      
+      istreambuf_iterator(istream_type& __s) throw()
+      : _M_istreambuf(__s.rdbuf()), _M_c(-2) { }
+
+      istreambuf_iterator(streambuf_type* __s) throw()
+      : _M_istreambuf(__s), _M_c(-2) { }
+       
+      // NB: This should really have an int_type return
+      // value, so "end of stream" postion can be checked without
+      // hacking.
+      char_type 
+      operator*() const
+      { 
+	// The result of operator*() on an end of stream is undefined.
+	char_type __retval;
+	if (_M_istreambuf && _M_c != static_cast<int_type>(-2))
+	  __retval = _M_c;
+	else if (_M_istreambuf)
+	  __retval = traits_type::to_char_type(_M_istreambuf->sgetc()); 
+	else
+	  __retval = static_cast<char_type>(traits_type::eof());
+	return __retval;
+      }
+	
+      __istreambufiter_type& 
+      operator++()
+      { 
+	if (_M_istreambuf)
+	  _M_istreambuf->sbumpc();
+	_M_c = -2;
+	return *this; 
+      }
+
+#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
+      // 14882 says return a proxy object. It should be a const
+      // proxy object, but since this class is not mandated, it
+      // should allow this signature:
+      const __istreambufiter_type
+      operator++(int)
+      {
+	if (_M_istreambuf)
+	  _M_c = _M_istreambuf->sbumpc();
+	return *this; 
+      }
+#endif
+
+      bool 
+      equal(const __istreambufiter_type& __b)
+      { 
+	int_type __eof = traits_type::eof();
+	bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
+	bool __beof = !__b._M_istreambuf 
+	  	      || __b._M_istreambuf->sgetc() == __eof;
+	return (__thiseof && __beof || (!__thiseof && !__beof));
+      }
+
+#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
+      // 110 istreambuf_iterator::equal not const
+      // NB: there is also number 111 pending on this function.
+      bool 
+      equal(const __istreambufiter_type& __b) const
+      {
+	int_type __eof = traits_type::eof();
+	bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
+	bool __beof = !__b._M_istreambuf 
+	  	      || __b._M_istreambuf->sgetc() == __eof;
+	return (__thiseof && __beof || (!__thiseof && !__beof));
+      }
+#endif
+
+    private:
+      // 24.5.3 istreambuf_iterator 
+      // p 1 
+      // If the end of stream is reached (streambuf_type::sgetc()
+      // returns traits_type::eof()), the iterator becomes equal to
+      // the "end of stream" iterator value.
+      // NB: This implementation assumes the "end of stream" value
+      // is EOF, or -1.
+      streambuf_type* 		_M_istreambuf;  
+      int_type 			_M_c;
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline bool 
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+	       const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+
+  template<typename _CharT, typename _Traits>
+    inline bool 
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+	       const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+
+} // std::
+
+#endif /* _CPP_BITS_SBUF_ITER_H */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

libstdc++-v3/bits/slice.h

+// The template and inlines for the -*- C++ -*- slice class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_SLICE_H
+#define _CPP_BITS_SLICE_H
+
+namespace std {
+
+class slice
+{
+public:
+    slice ();
+    slice (size_t, size_t, size_t);
+
+    size_t start () const;
+    size_t size () const;
+    size_t stride () const;
+
+private:
+    size_t _M_off;                      // offset
+    size_t _M_sz;			// size
+    size_t _M_st;			// stride unit
+};
+
+inline slice::slice () {}
+
+inline slice::slice (size_t __o, size_t __d, size_t __s)
+        : _M_off (__o), _M_sz (__d), _M_st (__s) {}
+
+inline size_t
+slice::start () const
+  { return _M_off; }
+
+inline size_t
+slice::size () const
+  { return _M_sz; }
+
+inline size_t
+slice::stride () const
+  { return _M_st; }
+
+} // std::
+
+
+#endif /* _CPP_BITS_SLICE_H */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/slice_array.h

+// The template and inlines for the -*- C++ -*- slice_array class.
+
+// 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.
+
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+#ifndef _CPP_BITS_SLICE_ARRAY_H
+#define _CPP_BITS_SLICE_ARRAY_H 1
+
+namespace std {
+    
+    template<typename _Tp>
+    class slice_array
+    {
+    public:
+        typedef _Tp value_type;
+        
+        void operator=   (const valarray<_Tp>&) const;
+        void operator*=  (const valarray<_Tp>&) const;
+        void operator/=  (const valarray<_Tp>&) const;
+        void operator%=  (const valarray<_Tp>&) const;
+        void operator+=  (const valarray<_Tp>&) const;
+        void operator-=  (const valarray<_Tp>&) const;
+        void operator^=  (const valarray<_Tp>&) const;
+        void operator&=  (const valarray<_Tp>&) const;
+        void operator|=  (const valarray<_Tp>&) const;
+        void operator<<= (const valarray<_Tp>&) const;
+        void operator>>= (const valarray<_Tp>&) const;
+        void operator= (const _Tp &);
+        //        ~slice_array ();
+        
+        template<class _Dom>
+        void operator=   (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator*=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator/=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator%=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator+=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator-=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator^=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator&=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator|=  (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator<<= (const _Expr<_Dom,_Tp>&) const;
+        template<class _Dom>
+        void operator>>= (const _Expr<_Dom,_Tp>&) const;
+        
+    private:
+        friend class valarray<_Tp>;
+        slice_array(_Array<_Tp>, const slice&);
+        
+        const size_t     _M_sz;
+        const size_t     _M_stride;
+        const _Array<_Tp> _M_array;
+        
+        // this constructor is implemented since we need to return a value.
+        slice_array (const slice_array&);
+
+        // not implemented
+        slice_array ();
+        slice_array& operator= (const slice_array&);
+    };
+
+    template<typename _Tp>
+    inline slice_array<_Tp>::slice_array (_Array<_Tp> __a, const slice& __s)
+            : _M_sz (__s.size ()), _M_stride (__s.stride ()),
+              _M_array (__a.begin () + __s.start ()) {}
+
+    
+    template<typename _Tp>
+    inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
+            : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
+    
+    //    template<typename _Tp>
+    //    inline slice_array<_Tp>::~slice_array () {}
+
+    template<typename _Tp>
+    inline void
+    slice_array<_Tp>::operator= (const _Tp& __t) 
+    { __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
+    
+    template<typename _Tp>
+    inline void
+    slice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
+    { __valarray_copy (_Array<_Tp> (__v), _M_array, _M_sz, _M_stride); }
+    
+    template<typename _Tp>
+    template<class _Dom>
+    inline void
+    slice_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
+    { __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
+
+#undef _DEFINE_VALARRAY_OPERATOR
+#define _DEFINE_VALARRAY_OPERATOR(op, name)				\
+template<typename _Tp>							\
+inline void								\
+slice_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const	\
+{									\
+  _Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_Tp> (__v));\
+}									\
+									\
+template<typename _Tp> template<class _Dom>				\
+inline void								\
+slice_array<_Tp>::operator##op##= (const _Expr<_Dom,_Tp>& __e) const	\
+{									\
+    _Array_augmented_##name (_M_array, _M_stride, __e, _M_sz);		\
+}
+        
+
+_DEFINE_VALARRAY_OPERATOR(*, multiplies)
+_DEFINE_VALARRAY_OPERATOR(/, divides)
+_DEFINE_VALARRAY_OPERATOR(%, modulus)
+_DEFINE_VALARRAY_OPERATOR(+, plus)
+_DEFINE_VALARRAY_OPERATOR(-, minus)
+_DEFINE_VALARRAY_OPERATOR(^, xor)
+_DEFINE_VALARRAY_OPERATOR(&, and)
+_DEFINE_VALARRAY_OPERATOR(|, or)
+_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
+_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
+
+#undef _DEFINE_VALARRAY_OPERATOR
+
+} // std::
+
+#endif /* _CPP_BITS_SLICE_ARRAY_H */
+
+// Local Variables:
+// mode:c++
+// End:

libstdc++-v3/bits/sstream.tcc

+// String based streams -*- 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: 27.7  String-based streams
+//
+
+#ifndef _CPP_BITS_SSTREAM_TCC
+#define _CPP_BITS_SSTREAM_TCC	1
+
+#include <bits/std_sstream.h>
+
+namespace std {
+
+  template <class _CharT, class _Traits, class _Alloc>
+    basic_stringbuf<_CharT, _Traits, _Alloc>::int_type 
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __retval = traits_type::eof();
+      bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur; 
+      
+      // Try to put back __c into input sequence in one of three ways.
+      // Order these tests done in is unspecified by the standard.
+      if (!__testeof && __testpos 
+	  && traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
+	{
+	  --_M_in_cur;
+	  __retval = __c;
+	}
+      else if (!__testeof && __testpos)
+	{
+	  --_M_in_cur;
+	  *_M_in_cur = traits_type::to_char_type(__c);
+	  __retval = __c;
+	}
+      else if (__testeof && __testpos)
+	{
+	  --_M_in_cur;
+	  __retval = traits_type::not_eof(__c);
+	}
+      return __retval;
+    }
+  
+  template <class _CharT, class _Traits, class _Alloc>
+    basic_stringbuf<_CharT, _Traits, _Alloc>::int_type 
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      int_type __retval = traits_type::eof();
+      bool __testeof = traits_type::eq_int_type(__c, __retval);
+      bool __testwrite = _M_out_cur < _M_buf + _M_buf_size;
+      bool __testout = _M_mode & ios_base::out;
+
+      // Try to append __c into output sequence in one of two ways.
+      // Order these tests done in is unspecified by the standard.
+      if (__testout)
+	{
+	  if (!__testeof)
+	    {
+	      // NB: Start ostringstream buffers at 1024 bytes. This
+	      // is an experimental value (pronounced "arbitrary" in
+	      // some of the hipper english-speaking countries), and
+	      // can be changed to suite particular needs.
+	      __size_type __len = max(_M_buf_size, static_cast<int_type>(512));
+	      __len *= 2;
+
+	      if (__testwrite)
+		__retval = this->sputc(__c);
+	      else if (__len <= _M_string.max_size())
+		{
+		  // Force-allocate, re-sync.
+		  _M_string = this->str();
+		  _M_string.reserve(__len);
+		  _M_buf_size = static_cast<int_type>(__len);
+		  _M_really_sync(_M_in_cur - _M_in_beg, 
+				 _M_out_cur - _M_out_beg);
+		  *_M_out_cur = traits_type::to_char_type(__c);
+		  _M_buf_bump(1);
+		  __retval = __c;
+		}
+	    }
+	  else
+	    __retval = traits_type::not_eof(__c);
+	}
+      return __retval;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __retval =  pos_type(off_type(-1)); 
+      bool __testin = __mode & ios_base::in && _M_mode & ios_base::in;
+      bool __testout = __mode & ios_base::out && _M_mode & ios_base::out;
+      bool __testboth = __testin && __testout && __way != ios_base::cur;
+      
+      if (_M_buf_size && ((__testin != __testout) || __testboth))
+	{
+	  char_type* __beg = _M_buf;
+	  char_type* __curi = NULL;
+	  char_type* __curo = NULL;
+	  char_type* __endi = NULL;
+	  char_type* __endo = NULL;
+
+	  if (__testin)
+	    {
+	      __curi = this->gptr();
+	      __endi = this->egptr();
+	    }
+	  if (__testout)
+	    {
+	      __curo = this->pptr();
+	      __endo = this->epptr();
+	    }
+
+	  off_type __newoffi = 0;
+	  off_type __newoffo = 0;
+	  if (__way == ios_base::cur)
+	    {
+	      __newoffi = __curi - __beg;
+	      __newoffo = __curo - __beg;
+	    }
+	  else if (__way == ios_base::end)
+	    {
+	      __newoffi = __endi - __beg;
+	      __newoffo = __endo - __beg;
+	    }
+
+	  if (__testin
+	      && __newoffi + __off >= 0 && __endi - __beg >= __newoffi + __off)
+	    {
+	      _M_in_cur = __beg + __newoffi + __off;
+	      __retval = pos_type(__newoffi);
+	    }
+	  if (__testout
+	      && __newoffo + __off >= 0 && __endo - __beg >= __newoffo + __off)
+	    {
+	      _M_buf_bump(__newoffo + __off - (_M_out_cur - __beg));
+	      __retval = pos_type(__newoffo);
+	    }
+	}
+      return __retval;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __retval =  pos_type(off_type(-1)); 
+      off_type __pos = __sp._M_position();
+      char_type* __beg = NULL;
+      char_type* __end = NULL;
+      bool __testin = __mode & ios_base::in && _M_mode & ios_base::in;
+      bool __testout = __mode & ios_base::out && _M_mode & ios_base::out;
+      
+      if (__testin)
+	{
+	  __beg = this->eback();
+	  __end = this->egptr();
+	}
+      if (__testout)
+	{
+	  __beg = this->pbase();
+	  __end = _M_buf + _M_buf_size;
+	}
+ 
+      if (0 <= __pos && __pos <= __end - __beg)
+	{
+	  // Need to set both of these if applicable
+	  if (__testin)
+	    _M_in_cur = _M_in_beg + __pos;
+	  if (__testout)
+	    _M_buf_bump((__pos) - (_M_out_cur - __beg));
+	  __retval = pos_type(off_type(__pos));
+	}
+      
+      return __retval;
+    }
+
+} // namespace std
+
+#endif	/* _CPP_BITS_SSTREAM_TCC */
+
+
+
+
+
+
+
+
+

libstdc++-v3/bits/std_algorithm.h

+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _CPP_ALGORITHM
+#define _CPP_ALGORITHM 1
+
+#include <bits/stl_algobase.h>
+#include <bits/stl_construct.h>
+#include <bits/stl_uninitialized.h>
+#include <bits/stl_tempbuf.h>
+#include <bits/stl_algo.h>
+
+#endif /* _CPP_ALGORITHM */
+
+// Local Variables:
+// mode:C++
+// End:

libstdc++-v3/bits/std_cassert.h

+// -*- C++ -*- forwarding header.
+
+// 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: 19.2  Assertions
+//
+
+// Note: This is not a conforming implementation.
+
+// No include guards on this header...
+
+# include_next <assert.h>

libstdc++-v3/bits/std_cctype.h

+// -*- C++ -*- forwarding header.
+
+// 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
+#endif
+
+# 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); }
+#endif
+
+#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); }
+#endif
+
+#ifdef isspace
+  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); }
+#endif
+
+#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); }
+#endif
+
+#ifdef iscntrl
+  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); }
+#endif
+
+#ifdef 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); }
+#endif
+
+#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); }
+#endif
+
+#ifdef 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); }
+#endif
+
+#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); }
+#endif
+
+#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
+
+#ifdef 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); }
+#endif
+
+#ifdef 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); }
+#endif
+
+#ifdef 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); }
+#endif
+
+} // namespace std
+
+#endif // _CPP_CCTYPE
+
+
+
+
+
+
+
+
+
+
+
+