diff options
Diffstat (limited to 'contrib/libstdc++/include')
70 files changed, 13800 insertions, 9051 deletions
diff --git a/contrib/libstdc++/include/Makefile.am b/contrib/libstdc++/include/Makefile.am index 5c87bb3b45b1..906468d590ef 100644 --- a/contrib/libstdc++/include/Makefile.am +++ b/contrib/libstdc++/include/Makefile.am @@ -1,6 +1,6 @@ ## Makefile for the include subdirectory of the GNU C++ Standard library. ## -## Copyright (C) 2001, 2002 Free Software Foundation, Inc. +## Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. ## ## This file is part of the libstdc++ version 3 distribution. ## Process this file with automake to produce Makefile.in. @@ -31,6 +31,75 @@ CXX = @glibcpp_CXX@ glibcpp_srcdir=@glibcpp_srcdir@ glibcpp_builddir=@glibcpp_builddir@ +GLIBCPP_INCLUDES = @GLIBCPP_INCLUDES@ +LIBSUPCXX_INCLUDES = @LIBSUPCXX_INCLUDES@ +INCLUDES = -nostdinc++ $(GLIBCPP_INCLUDES) $(LIBSUPCXX_INCLUDES) + +# Standard C++ includes. +std_srcdir = ${glibcpp_srcdir}/include/std +std_builddir = . +std_headers = \ + ${std_srcdir}/std_algorithm.h \ + ${std_srcdir}/std_bitset.h \ + ${std_srcdir}/std_complex.h \ + ${std_srcdir}/std_deque.h \ + ${std_srcdir}/std_fstream.h \ + ${std_srcdir}/std_functional.h \ + ${std_srcdir}/std_iomanip.h \ + ${std_srcdir}/std_ios.h \ + ${std_srcdir}/std_iosfwd.h \ + ${std_srcdir}/std_iostream.h \ + ${std_srcdir}/std_istream.h \ + ${std_srcdir}/std_iterator.h \ + ${std_srcdir}/std_limits.h \ + ${std_srcdir}/std_list.h \ + ${std_srcdir}/std_locale.h \ + ${std_srcdir}/std_map.h \ + ${std_srcdir}/std_memory.h \ + ${std_srcdir}/std_numeric.h \ + ${std_srcdir}/std_ostream.h \ + ${std_srcdir}/std_queue.h \ + ${std_srcdir}/std_set.h \ + ${std_srcdir}/std_sstream.h \ + ${std_srcdir}/std_stack.h \ + ${std_srcdir}/std_stdexcept.h \ + ${std_srcdir}/std_streambuf.h \ + ${std_srcdir}/std_string.h \ + ${std_srcdir}/std_utility.h \ + ${std_srcdir}/std_valarray.h \ + ${std_srcdir}/std_vector.h +# Renamed at build time. +std_headers_rename = \ + algorithm \ + bitset \ + complex \ + deque \ + fstream \ + functional \ + iomanip \ + ios \ + iosfwd \ + iostream \ + istream \ + iterator \ + limits \ + list \ + locale \ + map \ + memory \ + numeric \ + ostream \ + queue \ + set \ + sstream \ + stack \ + stdexcept \ + streambuf \ + string \ + utility \ + valarray \ + vector + bits_srcdir = ${glibcpp_srcdir}/include/bits bits_builddir = ./bits bits_headers = \ @@ -43,15 +112,17 @@ bits_headers = \ ${bits_srcdir}/codecvt.h \ ${bits_srcdir}/concept_check.h \ ${bits_srcdir}/cpp_type_traits.h \ + ${bits_srcdir}/deque.tcc \ ${bits_srcdir}/fpos.h \ ${bits_srcdir}/fstream.tcc \ ${bits_srcdir}/functexcept.h \ - ${bits_srcdir}/generic_shadow.h \ ${bits_srcdir}/gslice.h \ ${bits_srcdir}/gslice_array.h \ ${bits_srcdir}/indirect_array.h \ ${bits_srcdir}/ios_base.h \ ${bits_srcdir}/istream.tcc \ + ${bits_srcdir}/list.tcc \ + ${bits_srcdir}/locale_classes.h \ ${bits_srcdir}/locale_facets.h \ ${bits_srcdir}/locale_facets.tcc \ ${bits_srcdir}/localefwd.h \ @@ -60,7 +131,6 @@ bits_headers = \ ${bits_srcdir}/pthread_allocimpl.h \ ${bits_srcdir}/stream_iterator.h \ ${bits_srcdir}/streambuf_iterator.h \ - ${bits_srcdir}/slice.h \ ${bits_srcdir}/slice_array.h \ ${bits_srcdir}/sstream.tcc \ ${bits_srcdir}/stl_algo.h \ @@ -96,7 +166,8 @@ bits_headers = \ ${bits_srcdir}/type_traits.h \ ${bits_srcdir}/valarray_array.h \ ${bits_srcdir}/valarray_array.tcc \ - ${bits_srcdir}/valarray_meta.h + ${bits_srcdir}/valarray_meta.h \ + ${bits_srcdir}/vector.tcc backward_srcdir = ${glibcpp_srcdir}/include/backward backward_builddir = ./backward @@ -135,7 +206,6 @@ backward_headers = \ ${backward_srcdir}/tree.h \ ${backward_srcdir}/vector.h \ ${backward_srcdir}/fstream.h \ - ${backward_srcdir}/strstream.h \ ${backward_srcdir}/strstream \ ${backward_srcdir}/backward_warning.h @@ -239,71 +309,6 @@ else c_compatibility_headers_extra = endif - -std_srcdir = ${glibcpp_srcdir}/include/std -std_builddir = . -std_headers = \ - ${std_srcdir}/std_algorithm.h \ - ${std_srcdir}/std_bitset.h \ - ${std_srcdir}/std_complex.h \ - ${std_srcdir}/std_deque.h \ - ${std_srcdir}/std_fstream.h \ - ${std_srcdir}/std_functional.h \ - ${std_srcdir}/std_iomanip.h \ - ${std_srcdir}/std_ios.h \ - ${std_srcdir}/std_iosfwd.h \ - ${std_srcdir}/std_iostream.h \ - ${std_srcdir}/std_istream.h \ - ${std_srcdir}/std_iterator.h \ - ${std_srcdir}/std_limits.h \ - ${std_srcdir}/std_list.h \ - ${std_srcdir}/std_locale.h \ - ${std_srcdir}/std_map.h \ - ${std_srcdir}/std_memory.h \ - ${std_srcdir}/std_numeric.h \ - ${std_srcdir}/std_ostream.h \ - ${std_srcdir}/std_queue.h \ - ${std_srcdir}/std_set.h \ - ${std_srcdir}/std_sstream.h \ - ${std_srcdir}/std_stack.h \ - ${std_srcdir}/std_stdexcept.h \ - ${std_srcdir}/std_streambuf.h \ - ${std_srcdir}/std_string.h \ - ${std_srcdir}/std_utility.h \ - ${std_srcdir}/std_valarray.h \ - ${std_srcdir}/std_vector.h -# Renamed at build time. -std_headers_rename = \ - algorithm \ - bitset \ - complex \ - deque \ - fstream \ - functional \ - iomanip \ - ios \ - iosfwd \ - iostream \ - istream \ - iterator \ - limits \ - list \ - locale \ - map \ - memory \ - numeric \ - ostream \ - queue \ - set \ - sstream \ - stack \ - stdexcept \ - streambuf \ - string \ - utility \ - valarray \ - vector - target_srcdir = ${glibcpp_srcdir}/@OS_INC_SRCDIR@ target_builddir = ./${target_alias}/bits target_headers = \ @@ -311,8 +316,12 @@ target_headers = \ ${target_srcdir}/ctype_inline.h \ ${target_srcdir}/ctype_noninline.h \ ${target_srcdir}/os_defines.h \ - ${glibcpp_srcdir}/@ATOMICITY_INC_SRCDIR@/atomicity.h \ - ${glibcpp_srcdir}/@CPU_LIMITS_INC_SRCDIR@/cpu_limits.h + ${glibcpp_srcdir}/@ATOMICITY_INC_SRCDIR@/atomicity.h + +# Non-installed target_header files. +target_headers_noinst = \ + ${glibcpp_srcdir}/@CLOCALE_INTERNAL_H@ + # These target_headers_extra files are all built with ad hoc naming rules. target_headers_extra = \ ${target_builddir}/basic_file.h \ @@ -333,9 +342,7 @@ thread_target_headers = \ # CLEANFILES and all-local are kept up-to-date. allstamps = \ stamp-std stamp-bits stamp-c_base stamp-c_compatibility \ - stamp-backward stamp-ext \ - ${target_builddir}/stamp-target - + stamp-backward stamp-ext stamp-target # Here are the rules for building the headers all-local: ${target_builddir}/c++config.h ${thread_target_headers} ${allstamps} @@ -352,6 +359,12 @@ stamp-std: ${std_headers} done) ;\ echo `date` > stamp-std +stamp-std-precompile: stamp-std + for h in ${std_headers_rename}; do \ + $(CXX) -Winvalid-pch -x c++-header $(INCLUDES) $${h}; \ + done; \ + echo `date` > stamp-std-precompile + stamp-bits: ${bits_headers} @if [ ! -d "${bits_builddir}" ]; then \ mkdir -p ${bits_builddir} ;\ @@ -402,17 +415,19 @@ stamp-${target_alias}: fi # Target includes static. -${target_builddir}/stamp-target: ${target_headers} stamp-${target_alias} - @cd ${target_builddir} ;\ - if [ ! -f stamp-target ]; then \ +# XXX Missing dependency info for {target_headers_extra} +stamp-target: ${target_headers} ${target_headers_noinst} stamp-${target_alias} + @if [ ! -f stamp-target ]; then \ + (cd ${target_builddir} ;\ @LN_S@ ${target_headers} . || true ;\ @LN_S@ ${glibcpp_srcdir}/@BASIC_FILE_H@ basic_file.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CSTDIO_H@ c++io.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CLOCALE_H@ c++locale.h || true ;\ + @LN_S@ ${glibcpp_srcdir}/@CLOCALE_INTERNAL_H@ . || true ;\ @LN_S@ ${glibcpp_srcdir}/@CMESSAGES_H@ messages_members.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CTIME_H@ time_members.h || true ;\ - @LN_S@ ${glibcpp_srcdir}/@CCODECVT_H@ codecvt_specializations.h || true ;\ - echo `date` > stamp-target; \ + @LN_S@ ${glibcpp_srcdir}/@CCODECVT_H@ codecvt_specializations.h || true);\ + echo `date` > stamp-target ; \ fi # Target includes dynamic. @@ -495,7 +510,7 @@ install-data-local: $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${target_builddir}; done # By adding these files here, automake will remove them for 'make clean' -#CLEANFILES = ${allstamps} +CLEANFILES = *.pch stamp-std-precompile # Stop implicit '.o' make rules from ever stomping on extensionless # headers, in the improbable case where some foolish, crack-addled diff --git a/contrib/libstdc++/include/Makefile.in b/contrib/libstdc++/include/Makefile.in index 37a06d4199e7..cc7e3a5031cb 100644 --- a/contrib/libstdc++/include/Makefile.in +++ b/contrib/libstdc++/include/Makefile.in @@ -1,4 +1,4 @@ -# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am +# Makefile.in generated automatically by automake 1.4-p6 from Makefile.am # Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation @@ -67,15 +67,24 @@ AR = @AR@ AS = @AS@ ATOMICITY_INC_SRCDIR = @ATOMICITY_INC_SRCDIR@ AWK = @AWK@ +BASIC_FILE_CC = @BASIC_FILE_CC@ BASIC_FILE_H = @BASIC_FILE_H@ CC = @CC@ CCODECVT_C = @CCODECVT_C@ +CCODECVT_CC = @CCODECVT_CC@ CCODECVT_H = @CCODECVT_H@ +CCOLLATE_CC = @CCOLLATE_CC@ +CCTYPE_CC = @CCTYPE_CC@ +CLOCALE_CC = @CLOCALE_CC@ CLOCALE_H = @CLOCALE_H@ +CLOCALE_INTERNAL_H = @CLOCALE_INTERNAL_H@ +CMESSAGES_CC = @CMESSAGES_CC@ CMESSAGES_H = @CMESSAGES_H@ +CMONEY_CC = @CMONEY_CC@ +CNUMERIC_CC = @CNUMERIC_CC@ CPP = @CPP@ -CPU_LIMITS_INC_SRCDIR = @CPU_LIMITS_INC_SRCDIR@ CSTDIO_H = @CSTDIO_H@ +CTIME_CC = @CTIME_CC@ CTIME_H = @CTIME_H@ CXXCPP = @CXXCPP@ C_INCLUDE_DIR = @C_INCLUDE_DIR@ @@ -85,12 +94,10 @@ EXEEXT = @EXEEXT@ EXTRA_CXX_FLAGS = @EXTRA_CXX_FLAGS@ GCJ = @GCJ@ GCJFLAGS = @GCJFLAGS@ -GLIBCPP_INCLUDES = @GLIBCPP_INCLUDES@ GLIBCPP_IS_CROSS_COMPILING = @GLIBCPP_IS_CROSS_COMPILING@ LIBIO_INCLUDES = @LIBIO_INCLUDES@ LIBMATHOBJS = @LIBMATHOBJS@ LIBMATH_INCLUDES = @LIBMATH_INCLUDES@ -LIBSUPCXX_INCLUDES = @LIBSUPCXX_INCLUDES@ LIBSUPCXX_PICFLAGS = @LIBSUPCXX_PICFLAGS@ LIBTOOL = @LIBTOOL@ LIBUNWIND_FLAG = @LIBUNWIND_FLAG@ @@ -107,6 +114,7 @@ RANLIB = @RANLIB@ SECTION_FLAGS = @SECTION_FLAGS@ SECTION_LDFLAGS = @SECTION_LDFLAGS@ STRIP = @STRIP@ +SYMVER_MAP = @SYMVER_MAP@ TOPLEVEL_INCLUDES = @TOPLEVEL_INCLUDES@ USE_NLS = @USE_NLS@ VERSION = @VERSION@ @@ -139,6 +147,77 @@ CXX = @glibcpp_CXX@ glibcpp_srcdir = @glibcpp_srcdir@ glibcpp_builddir = @glibcpp_builddir@ +GLIBCPP_INCLUDES = @GLIBCPP_INCLUDES@ +LIBSUPCXX_INCLUDES = @LIBSUPCXX_INCLUDES@ +INCLUDES = -nostdinc++ $(GLIBCPP_INCLUDES) $(LIBSUPCXX_INCLUDES) + +# Standard C++ includes. +std_srcdir = ${glibcpp_srcdir}/include/std +std_builddir = . +std_headers = \ + ${std_srcdir}/std_algorithm.h \ + ${std_srcdir}/std_bitset.h \ + ${std_srcdir}/std_complex.h \ + ${std_srcdir}/std_deque.h \ + ${std_srcdir}/std_fstream.h \ + ${std_srcdir}/std_functional.h \ + ${std_srcdir}/std_iomanip.h \ + ${std_srcdir}/std_ios.h \ + ${std_srcdir}/std_iosfwd.h \ + ${std_srcdir}/std_iostream.h \ + ${std_srcdir}/std_istream.h \ + ${std_srcdir}/std_iterator.h \ + ${std_srcdir}/std_limits.h \ + ${std_srcdir}/std_list.h \ + ${std_srcdir}/std_locale.h \ + ${std_srcdir}/std_map.h \ + ${std_srcdir}/std_memory.h \ + ${std_srcdir}/std_numeric.h \ + ${std_srcdir}/std_ostream.h \ + ${std_srcdir}/std_queue.h \ + ${std_srcdir}/std_set.h \ + ${std_srcdir}/std_sstream.h \ + ${std_srcdir}/std_stack.h \ + ${std_srcdir}/std_stdexcept.h \ + ${std_srcdir}/std_streambuf.h \ + ${std_srcdir}/std_string.h \ + ${std_srcdir}/std_utility.h \ + ${std_srcdir}/std_valarray.h \ + ${std_srcdir}/std_vector.h + +# Renamed at build time. +std_headers_rename = \ + algorithm \ + bitset \ + complex \ + deque \ + fstream \ + functional \ + iomanip \ + ios \ + iosfwd \ + iostream \ + istream \ + iterator \ + limits \ + list \ + locale \ + map \ + memory \ + numeric \ + ostream \ + queue \ + set \ + sstream \ + stack \ + stdexcept \ + streambuf \ + string \ + utility \ + valarray \ + vector + + bits_srcdir = ${glibcpp_srcdir}/include/bits bits_builddir = ./bits bits_headers = \ @@ -151,15 +230,17 @@ bits_headers = \ ${bits_srcdir}/codecvt.h \ ${bits_srcdir}/concept_check.h \ ${bits_srcdir}/cpp_type_traits.h \ + ${bits_srcdir}/deque.tcc \ ${bits_srcdir}/fpos.h \ ${bits_srcdir}/fstream.tcc \ ${bits_srcdir}/functexcept.h \ - ${bits_srcdir}/generic_shadow.h \ ${bits_srcdir}/gslice.h \ ${bits_srcdir}/gslice_array.h \ ${bits_srcdir}/indirect_array.h \ ${bits_srcdir}/ios_base.h \ ${bits_srcdir}/istream.tcc \ + ${bits_srcdir}/list.tcc \ + ${bits_srcdir}/locale_classes.h \ ${bits_srcdir}/locale_facets.h \ ${bits_srcdir}/locale_facets.tcc \ ${bits_srcdir}/localefwd.h \ @@ -168,7 +249,6 @@ bits_headers = \ ${bits_srcdir}/pthread_allocimpl.h \ ${bits_srcdir}/stream_iterator.h \ ${bits_srcdir}/streambuf_iterator.h \ - ${bits_srcdir}/slice.h \ ${bits_srcdir}/slice_array.h \ ${bits_srcdir}/sstream.tcc \ ${bits_srcdir}/stl_algo.h \ @@ -204,7 +284,8 @@ bits_headers = \ ${bits_srcdir}/type_traits.h \ ${bits_srcdir}/valarray_array.h \ ${bits_srcdir}/valarray_array.tcc \ - ${bits_srcdir}/valarray_meta.h + ${bits_srcdir}/valarray_meta.h \ + ${bits_srcdir}/vector.tcc backward_srcdir = ${glibcpp_srcdir}/include/backward @@ -244,7 +325,6 @@ backward_headers = \ ${backward_srcdir}/tree.h \ ${backward_srcdir}/vector.h \ ${backward_srcdir}/fstream.h \ - ${backward_srcdir}/strstream.h \ ${backward_srcdir}/strstream \ ${backward_srcdir}/backward_warning.h @@ -342,72 +422,6 @@ c_compatibility_headers = \ @GLIBCPP_C_HEADERS_COMPATIBILITY_TRUE@c_compatibility_headers_extra = @GLIBCPP_C_HEADERS_COMPATIBILITY_TRUE@${c_compatibility_headers} @GLIBCPP_C_HEADERS_COMPATIBILITY_FALSE@c_compatibility_headers_extra = -std_srcdir = ${glibcpp_srcdir}/include/std -std_builddir = . -std_headers = \ - ${std_srcdir}/std_algorithm.h \ - ${std_srcdir}/std_bitset.h \ - ${std_srcdir}/std_complex.h \ - ${std_srcdir}/std_deque.h \ - ${std_srcdir}/std_fstream.h \ - ${std_srcdir}/std_functional.h \ - ${std_srcdir}/std_iomanip.h \ - ${std_srcdir}/std_ios.h \ - ${std_srcdir}/std_iosfwd.h \ - ${std_srcdir}/std_iostream.h \ - ${std_srcdir}/std_istream.h \ - ${std_srcdir}/std_iterator.h \ - ${std_srcdir}/std_limits.h \ - ${std_srcdir}/std_list.h \ - ${std_srcdir}/std_locale.h \ - ${std_srcdir}/std_map.h \ - ${std_srcdir}/std_memory.h \ - ${std_srcdir}/std_numeric.h \ - ${std_srcdir}/std_ostream.h \ - ${std_srcdir}/std_queue.h \ - ${std_srcdir}/std_set.h \ - ${std_srcdir}/std_sstream.h \ - ${std_srcdir}/std_stack.h \ - ${std_srcdir}/std_stdexcept.h \ - ${std_srcdir}/std_streambuf.h \ - ${std_srcdir}/std_string.h \ - ${std_srcdir}/std_utility.h \ - ${std_srcdir}/std_valarray.h \ - ${std_srcdir}/std_vector.h - -# Renamed at build time. -std_headers_rename = \ - algorithm \ - bitset \ - complex \ - deque \ - fstream \ - functional \ - iomanip \ - ios \ - iosfwd \ - iostream \ - istream \ - iterator \ - limits \ - list \ - locale \ - map \ - memory \ - numeric \ - ostream \ - queue \ - set \ - sstream \ - stack \ - stdexcept \ - streambuf \ - string \ - utility \ - valarray \ - vector - - target_srcdir = ${glibcpp_srcdir}/@OS_INC_SRCDIR@ target_builddir = ./${target_alias}/bits target_headers = \ @@ -415,8 +429,13 @@ target_headers = \ ${target_srcdir}/ctype_inline.h \ ${target_srcdir}/ctype_noninline.h \ ${target_srcdir}/os_defines.h \ - ${glibcpp_srcdir}/@ATOMICITY_INC_SRCDIR@/atomicity.h \ - ${glibcpp_srcdir}/@CPU_LIMITS_INC_SRCDIR@/cpu_limits.h + ${glibcpp_srcdir}/@ATOMICITY_INC_SRCDIR@/atomicity.h + + +# Non-installed target_header files. +target_headers_noinst = \ + ${glibcpp_srcdir}/@CLOCALE_INTERNAL_H@ + # These target_headers_extra files are all built with ad hoc naming rules. target_headers_extra = \ @@ -440,8 +459,7 @@ thread_target_headers = \ # CLEANFILES and all-local are kept up-to-date. allstamps = \ stamp-std stamp-bits stamp-c_base stamp-c_compatibility \ - stamp-backward stamp-ext \ - ${target_builddir}/stamp-target + stamp-backward stamp-ext stamp-target # Target includes for threads @@ -457,6 +475,9 @@ uppercase = [ABCDEFGHIJKLMNOPQRSTUVWXYZ_] # target_headers_extra are taken out of the build tree staging area; # the rest are taken from the original source tree. gxx_include_dir = @gxx_include_dir@ + +# By adding these files here, automake will remove them for 'make clean' +CLEANFILES = *.pch stamp-std-precompile CONFIG_HEADER = ../config.h CONFIG_CLEAN_FILES = DIST_COMMON = Makefile.am Makefile.in @@ -525,6 +546,7 @@ installdirs: mostlyclean-generic: clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) distclean-generic: -rm -f Makefile $(CONFIG_CLEAN_FILES) @@ -574,6 +596,12 @@ stamp-std: ${std_headers} done) ;\ echo `date` > stamp-std +stamp-std-precompile: stamp-std + for h in ${std_headers_rename}; do \ + $(CXX) -Winvalid-pch -x c++-header $(INCLUDES) $${h}; \ + done; \ + echo `date` > stamp-std-precompile + stamp-bits: ${bits_headers} @if [ ! -d "${bits_builddir}" ]; then \ mkdir -p ${bits_builddir} ;\ @@ -624,17 +652,19 @@ stamp-${target_alias}: fi # Target includes static. -${target_builddir}/stamp-target: ${target_headers} stamp-${target_alias} - @cd ${target_builddir} ;\ - if [ ! -f stamp-target ]; then \ +# XXX Missing dependency info for {target_headers_extra} +stamp-target: ${target_headers} ${target_headers_noinst} stamp-${target_alias} + @if [ ! -f stamp-target ]; then \ + (cd ${target_builddir} ;\ @LN_S@ ${target_headers} . || true ;\ @LN_S@ ${glibcpp_srcdir}/@BASIC_FILE_H@ basic_file.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CSTDIO_H@ c++io.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CLOCALE_H@ c++locale.h || true ;\ + @LN_S@ ${glibcpp_srcdir}/@CLOCALE_INTERNAL_H@ . || true ;\ @LN_S@ ${glibcpp_srcdir}/@CMESSAGES_H@ messages_members.h || true ;\ @LN_S@ ${glibcpp_srcdir}/@CTIME_H@ time_members.h || true ;\ - @LN_S@ ${glibcpp_srcdir}/@CCODECVT_H@ codecvt_specializations.h || true ;\ - echo `date` > stamp-target; \ + @LN_S@ ${glibcpp_srcdir}/@CCODECVT_H@ codecvt_specializations.h || true);\ + echo `date` > stamp-target ; \ fi # Target includes dynamic. @@ -702,9 +732,6 @@ install-data-local: ${thread_target_headers}; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${target_builddir}; done -# By adding these files here, automake will remove them for 'make clean' -#CLEANFILES = ${allstamps} - # Stop implicit '.o' make rules from ever stomping on extensionless # headers, in the improbable case where some foolish, crack-addled # developer tries to create them via make in the include build diff --git a/contrib/libstdc++/include/bits/basic_ios.h b/contrib/libstdc++/include/bits/basic_ios.h index 13ad0f82e990..fe5e36a4fd7f 100644 --- a/contrib/libstdc++/include/bits/basic_ios.h +++ b/contrib/libstdc++/include/bits/basic_ios.h @@ -1,6 +1,7 @@ // Iostreams base classes -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003 +// 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 @@ -38,120 +39,291 @@ #pragma GCC system_header #include <bits/streambuf_iterator.h> +#include <bits/localefwd.h> +#include <bits/locale_classes.h> #include <bits/locale_facets.h> namespace std { // 27.4.5 Template class basic_ios + /** + * @brief Virtual base class for all stream classes. + * + * Most of the member functions called dispatched on stream objects + * (e.g., @c std::cout.foo(bar);) are consolidated in this class. + */ 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; - typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter; - typedef num_put<_CharT, __ostreambuf_iter> __numput_type; - typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter; - typedef num_get<_CharT, __istreambuf_iter> __numget_type; + //@{ + /** + * These are standard types. They permit a standardized way of + * referring to names of (or names dependant on) the template + * parameters, which are specific to the implementation. + */ + 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; + //@} + + //@{ + /** + * @if maint + * These are non-standard types. + * @endif + */ + typedef ctype<_CharT> __ctype_type; + typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter; + typedef num_put<_CharT, __ostreambuf_iter> __numput_type; + typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter; + typedef num_get<_CharT, __istreambuf_iter> __numget_type; + //@} + + friend void ios_base::Init::_S_ios_create(bool); // Data members: protected: - basic_ostream<_CharT, _Traits>* _M_tie; - mutable char_type _M_fill; - mutable bool _M_fill_init; - basic_streambuf<_CharT, _Traits>* _M_streambuf; + basic_ostream<_CharT, _Traits>* _M_tie; + mutable char_type _M_fill; + mutable bool _M_fill_init; + basic_streambuf<_CharT, _Traits>* _M_streambuf; // Cached use_facet<ctype>, which is based on the current locale info. - const __ctype_type* _M_fctype; + const __ctype_type* _M_fctype; // From ostream. - const __numput_type* _M_fnumput; + const __numput_type* _M_fnumput; // From istream. - const __numget_type* _M_fnumget; + const __numget_type* _M_fnumget; public: + //@{ + /** + * @brief The quick-and-easy status check. + * + * This allows you to write constructs such as + * "if (!a_stream) ..." and "while (a_stream) ..." + */ operator void*() const { return this->fail() ? 0 : const_cast<basic_ios*>(this); } bool operator!() const { return this->fail(); } - + //@} + + /** + * @brief Returns the error state of the stream buffer. + * @return A bit pattern (well, isn't everything?) + * + * See std::ios_base::iostate for the possible bit values. Most + * users will call one of the interpreting wrappers, e.g., good(). + */ iostate rdstate() const { return _M_streambuf_state; } + /** + * @brief [Re]sets the error state. + * @param state The new state flag(s) to set. + * + * See std::ios_base::iostate for the possible bit values. Most + * users will not need to pass an argument. + */ void clear(iostate __state = goodbit); + /** + * @brief Sets additional flags in the error state. + * @param state The additional state flag(s) to set. + * + * See std::ios_base::iostate for the possible bit values. + */ void setstate(iostate __state) { this->clear(this->rdstate() | __state); } + /** + * @brief Fast error checking. + * @return True if no error flags are set. + * + * A wrapper around rdstate. + */ bool good() const { return this->rdstate() == 0; } + /** + * @brief Fast error checking. + * @return True if the eofbit is set. + * + * Note that other iostate flags may also be set. + */ bool eof() const { return (this->rdstate() & eofbit) != 0; } + /** + * @brief Fast error checking. + * @return True if either the badbit or the failbit is set. + * + * Checking the badbit in fail() is historical practice. + * Note that other iostate flags may also be set. + */ bool fail() const { return (this->rdstate() & (badbit | failbit)) != 0; } + /** + * @brief Fast error checking. + * @return True if the badbit is set. + * + * Note that other iostate flags may also be set. + */ bool bad() const { return (this->rdstate() & badbit) != 0; } + /** + * @brief Throwing exceptions on errors. + * @return The current exceptions mask. + * + * This changes nothing in the stream. See the one-argument version + * of exceptions(iostate) for the meaning of the return value. + */ iostate exceptions() const { return _M_exception; } + /** + * @brief Throwing exceptions on errors. + * @param except The new exceptions mask. + * + * By default, error flags are set silently. You can set an + * exceptions mask for each stream; if a bit in the mask becomes set + * in the error flags, then an exception of type + * std::ios_base::failure is thrown. + * + * If the error flage is already set when the exceptions mask is + * added, the exception is immediately thrown. Try running the + * following under GCC 3.1 or later: + * @code + * #include <iostream> + * #include <fstream> + * #include <exception> + * + * int main() + * { + * std::set_terminate (__gnu_cxx::__verbose_terminate_handler); + * + * std::ifstream f ("/etc/motd"); + * + * std::cerr << "Setting badbit\n"; + * f.setstate (std::ios_base::badbit); + * + * std::cerr << "Setting exception mask\n"; + * f.exceptions (std::ios_base::badbit); + * } + * @endcode + */ void exceptions(iostate __except) { - _M_exception = __except; - this->clear(_M_streambuf_state); + _M_exception = __except; + this->clear(_M_streambuf_state); } // Constructor/destructor: + /** + * @brief Constructor performs initialization. + * + * The parameter is passed by derived streams. + */ explicit basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base() { this->init(__sb); } + /** + * @brief Empty. + * + * The destructor does nothing. More specifically, it does not + * destroy the streambuf held by rdbuf(). + */ virtual ~basic_ios() { } // Members: + /** + * @brief Fetches the current @e tied stream. + * @return A pointer to the tied stream, or NULL if the stream is + * not tied. + * + * A stream may be @e tied (or synchronized) to a second output + * stream. When this stream performs any I/O, the tied stream is + * first flushed. For example, @c std::cin is tied to @c std::cout. + */ basic_ostream<_CharT, _Traits>* tie() const { return _M_tie; } + /** + * @brief Ties this stream to an output stream. + * @param tiestr The output stream. + * @return The previously tied output stream, or NULL if the stream + * was not tied. + * + * This sets up a new tie; see tie() for more. + */ basic_ostream<_CharT, _Traits>* tie(basic_ostream<_CharT, _Traits>* __tiestr) { - basic_ostream<_CharT, _Traits>* __old = _M_tie; - _M_tie = __tiestr; - return __old; + basic_ostream<_CharT, _Traits>* __old = _M_tie; + _M_tie = __tiestr; + return __old; } + /** + * @brief Accessing the underlying buffer. + * @return The current stream buffer. + * + * This does not change the state of the stream. + */ basic_streambuf<_CharT, _Traits>* rdbuf() const { return _M_streambuf; } + /** + * @brief Changing the underlying buffer. + * @param sb The new stream buffer. + * @return The previous stream buffer. + * + * Associates a new buffer with the current stream, and clears the + * error state. + * + * Due to historical accidents which the LWG refuses to correct, the + * I/O library suffers from a design error: this function is hidden + * in derived classes by overrides of the zero-argument @c rdbuf(), + * which is non-virtual for hysterical raisins. As a result, you + * must use explicit qualifications to access this function via any + * derived class. + */ basic_streambuf<_CharT, _Traits>* rdbuf(basic_streambuf<_CharT, _Traits>* __sb); + /** + * @doctodo + */ basic_ios& copyfmt(const basic_ios& __rhs); + /** + * @brief Retreives the "empty" character. + * @return The current fill character. + * + * It defaults to a space (' ') in the current locale. + */ char_type fill() const { @@ -163,6 +335,15 @@ namespace std return _M_fill; } + /** + * @brief Sets a new "empty" character. + * @param ch The new character. + * @return The previous fill character. + * + * The fill character is used to fill out space when P+ characters + * have been requested (e.g., via setw), Q characters are actually + * used, and Q<P. It defaults to a space (' ') in the current locale. + */ char_type fill(char_type __ch) { @@ -172,20 +353,77 @@ namespace std } // Locales: + /** + * @brief Moves to a new locale. + * @param loc The new locale. + * @return The previous locale. + * + * Calls @c ios_base::imbue(loc), and if a stream buffer is associated + * with this stream, calls that buffer's @c pubimbue(loc). + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html + */ locale imbue(const locale& __loc); + /** + * @brief Squeezes characters. + * @param c The character to narrow. + * @param dfault The character to narrow. + * @return The narrowed character. + * + * Maps a character of @c char_type to a character of @c char, + * if possible. + * + * Returns the result of + * @code + * std::use_facet< ctype<char_type> >(getloc()).narrow(c,dfault) + * @endcode + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html + */ char narrow(char_type __c, char __dfault) const; + /** + * @brief Widens characters. + * @param c The character to widen. + * @return The widened character. + * + * Maps a character of @c char to a character of @c char_type. + * + * Returns the result of + * @code + * std::use_facet< ctype<char_type> >(getloc()).widen(c) + * @endcode + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html + */ char_type widen(char __c) const; protected: // 27.4.5.1 basic_ios constructors + /** + * @brief Empty. + * + * The default constructor does nothing and is not normally + * accessible to users. + */ basic_ios() : ios_base() { } + /** + * @brief All setup is performed here. + * + * This is called from the public constructor. It is not virtual and + * cannot be redefined. The second argument, __cache, is used + * to initialize the standard streams without allocating + * memory. + */ void init(basic_streambuf<_CharT, _Traits>* __sb); @@ -198,7 +436,18 @@ namespace std } void + _M_cache_locale(const locale& __loc); + +#if 1 + // XXX GLIBCXX_ABI Deprecated, compatibility only. + void _M_cache_facets(const locale& __loc); +#endif + + // Internal state setter that won't throw, only set the state bits. + // Used to guarantee we don't throw when setting badbit. + void + _M_setstate(iostate __state) { _M_streambuf_state |= __state; } }; } // namespace std diff --git a/contrib/libstdc++/include/bits/basic_ios.tcc b/contrib/libstdc++/include/bits/basic_ios.tcc index 7ee8015e29f6..1c9cd3b7256a 100644 --- a/contrib/libstdc++/include/bits/basic_ios.tcc +++ b/contrib/libstdc++/include/bits/basic_ios.tcc @@ -1,6 +1,6 @@ // basic_ios locale and locale-related member functions -*- C++ -*- -// Copyright (C) 1999, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 1999, 2001, 2002, 2003 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 @@ -95,10 +95,17 @@ namespace std this->precision(__rhs.precision()); this->tie(__rhs.tie()); this->fill(__rhs.fill()); + _M_ios_locale = __rhs.getloc(); + + // This removes the link to __rhs locale cache + _M_call_callbacks(copyfmt_event); + + _M_cache_locale(_M_ios_locale); + + // The next is required to be the last assignment. this->exceptions(__rhs.exceptions()); - _M_call_callbacks(copyfmt_event); return *this; } @@ -129,7 +136,7 @@ namespace std { locale __old(this->getloc()); ios_base::imbue(__loc); - _M_cache_facets(__loc); + _M_cache_locale(__loc); if (this->rdbuf() != 0) this->rdbuf()->pubimbue(__loc); return __old; @@ -141,7 +148,7 @@ namespace std { // NB: This may be called more than once on the same object. ios_base::_M_init(); - _M_cache_facets(_M_ios_locale); + _M_cache_locale(_M_ios_locale); _M_tie = 0; // NB: The 27.4.4.1 Postconditions Table specifies requirements @@ -166,31 +173,47 @@ namespace std template<typename _CharT, typename _Traits> void - basic_ios<_CharT, _Traits>::_M_cache_facets(const locale& __loc) + basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) { - if (has_facet<__ctype_type>(__loc)) + if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) _M_fctype = &use_facet<__ctype_type>(__loc); else _M_fctype = 0; - // Should be filled in by ostream and istream, respectively. - if (has_facet<__numput_type>(__loc)) + if (__builtin_expect(has_facet<__numput_type>(__loc), true)) _M_fnumput = &use_facet<__numput_type>(__loc); else _M_fnumput = 0; - if (has_facet<__numget_type>(__loc)) - _M_fnumget = &use_facet<__numget_type>(__loc); + if (__builtin_expect(has_facet<__numget_type>(__loc), true)) + _M_fnumget = &use_facet<__numget_type>(__loc); else _M_fnumget = 0; } +#if 1 + // XXX GLIBCXX_ABI Deprecated, compatibility only. + template<typename _CharT, typename _Traits> + void + basic_ios<_CharT, _Traits>::_M_cache_facets(const locale& __loc) + { + if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) + _M_fctype = &use_facet<__ctype_type>(__loc); + if (__builtin_expect(has_facet<__numput_type>(__loc), true)) + _M_fnumput = &use_facet<__numput_type>(__loc); + if (__builtin_expect(has_facet<__numget_type>(__loc), true)) + _M_fnumget = &use_facet<__numget_type>(__loc); + } +#endif + // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_ios<char>; #ifdef _GLIBCPP_USE_WCHAR_T extern template class basic_ios<wchar_t>; #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/basic_string.h b/contrib/libstdc++/include/bits/basic_string.h index a9c02ce37089..e92009dc9d7b 100644 --- a/contrib/libstdc++/include/bits/basic_string.h +++ b/contrib/libstdc++/include/bits/basic_string.h @@ -38,7 +38,7 @@ */ #ifndef _CPP_BITS_STRING_H -#define _CPP_BITS_STRING_H 1 +#define _CPP_BITS_STRING_H 1 #pragma GCC system_header @@ -46,44 +46,64 @@ namespace std { - // Documentation? What's that? - // Nathan Myers <ncm@cantrip.org>. - // - // A string looks like this: - // - // [_Rep] - // _M_length - // [basic_string<char_type>] _M_capacity - // _M_dataplus _M_state - // _M_p ----------------> unnamed array of char_type - - // Where the _M_p points to the first character in the string, and - // you cast it to a pointer-to-_Rep and subtract 1 to get a - // pointer to the header. - - // This approach has the enormous advantage that a string object - // requires only one allocation. All the ugliness is confined - // within a single pair of inline functions, which each compile to - // a single "add" instruction: _Rep::_M_data(), and - // string::_M_rep(); and the allocation function which gets a - // block of raw bytes and with room enough and constructs a _Rep - // object at the front. - - // The reason you want _M_data pointing to the character array and - // not the _Rep is so that the debugger can see the string - // contents. (Probably we should add a non-inline member to get - // the _Rep for the debugger to use, so users can check the actual - // string length.) - - // Note that the _Rep object is a POD so that you can have a - // static "empty string" _Rep object already "constructed" before - // static constructors have run. The reference-count encoding is - // chosen so that a 0 indicates one reference, so you never try to - // destroy the empty-string _Rep object. - - // All but the last paragraph is considered pretty conventional - // for a C++ string implementation. - + /** + * @class basic_string basic_string.h <string> + * @brief Managing sequences of characters and character-like objects. + * + * @ingroup Containers + * @ingroup Sequences + * + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and a + * <a href="tables.html#67">sequence</a>. Of the + * <a href="tables.html#68">optional sequence requirements</a>, only + * @c push_back, @c at, and array access are supported. + * + * @doctodo + * + * + * @if maint + * Documentation? What's that? + * Nathan Myers <ncm@cantrip.org>. + * + * A string looks like this: + * + * @code + * [_Rep] + * _M_length + * [basic_string<char_type>] _M_capacity + * _M_dataplus _M_state + * _M_p ----------------> unnamed array of char_type + * @endcode + * + * Where the _M_p points to the first character in the string, and + * you cast it to a pointer-to-_Rep and subtract 1 to get a + * pointer to the header. + * + * This approach has the enormous advantage that a string object + * requires only one allocation. All the ugliness is confined + * within a single pair of inline functions, which each compile to + * a single "add" instruction: _Rep::_M_data(), and + * string::_M_rep(); and the allocation function which gets a + * block of raw bytes and with room enough and constructs a _Rep + * object at the front. + * + * The reason you want _M_data pointing to the character array and + * not the _Rep is so that the debugger can see the string + * contents. (Probably we should add a non-inline member to get + * the _Rep for the debugger to use, so users can check the actual + * string length.) + * + * Note that the _Rep object is a POD so that you can have a + * static "empty string" _Rep object already "constructed" before + * static constructors have run. The reference-count encoding is + * chosen so that a 0 indicates one reference, so you never try to + * destroy the empty-string _Rep object. + * + * All but the last paragraph is considered pretty conventional + * for a C++ string implementation. + * @endif + */ // 21.3 Template class basic_string template<typename _CharT, typename _Traits, typename _Alloc> class basic_string @@ -102,9 +122,9 @@ namespace std typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator; typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> const_iterator; - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; - + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; + private: // _Rep: string representation // Invariants: @@ -125,7 +145,7 @@ namespace std // Types: typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc; - // (Public) Data members: + // (Public) Data members: // The maximum number of individual char_type elements of an // individual string is determined by _S_max_size. This is the @@ -133,10 +153,10 @@ namespace std // is the maximum number of bytes the allocator can allocate.) // If one was to divvy up the theoretical largest size string, // with a terminating character and m _CharT elements, it'd - // look like this: + // look like this: // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT) // Solving for m: - // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 + // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 // In addition, this implementation quarters this ammount. static const size_type _S_max_size; static const _CharT _S_terminal; @@ -144,7 +164,7 @@ namespace std size_type _M_length; size_type _M_capacity; _Atomic_word _M_references; - + bool _M_is_leaked() const { return _M_references < 0; } @@ -154,50 +174,50 @@ namespace std { return _M_references > 0; } void - _M_set_leaked() + _M_set_leaked() { _M_references = -1; } void - _M_set_sharable() + _M_set_sharable() { _M_references = 0; } - _CharT* + _CharT* _M_refdata() throw() { return reinterpret_cast<_CharT*>(this + 1); } - _CharT& + _CharT& operator[](size_t __s) throw() { return _M_refdata() [__s]; } - _CharT* + _CharT* _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) - { - return (!_M_is_leaked() && __alloc1 == __alloc2) - ? _M_refcopy() : _M_clone(__alloc1); + { + return (!_M_is_leaked() && __alloc1 == __alloc2) + ? _M_refcopy() : _M_clone(__alloc1); } // Create & Destroy - static _Rep* + static _Rep* _S_create(size_t, const _Alloc&); - void + void _M_dispose(const _Alloc& __a) - { - if (__exchange_and_add(&_M_references, -1) <= 0) - _M_destroy(__a); + { + if (__exchange_and_add(&_M_references, -1) <= 0) + _M_destroy(__a); } // XXX MT - void + void _M_destroy(const _Alloc&) throw(); - _CharT* + _CharT* _M_refcopy() throw() - { - __atomic_add(&_M_references, 1); - return _M_refdata(); + { + __atomic_add(&_M_references, 1); + return _M_refdata(); } // XXX MT - _CharT* + _CharT* _M_clone(const _Alloc&, size_type __res = 0); }; @@ -224,45 +244,45 @@ namespace std // (carefully) in an empty string with one reference. static size_type _S_empty_rep_storage[(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)]; - _CharT* - _M_data() const + _CharT* + _M_data() const { return _M_dataplus._M_p; } - _CharT* - _M_data(_CharT* __p) + _CharT* + _M_data(_CharT* __p) { return (_M_dataplus._M_p = __p); } - _Rep* + _Rep* _M_rep() const { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); } // For the internal use we have functions similar to `begin'/`end' // but they do not call _M_leak. - iterator + iterator _M_ibegin() const { return iterator(_M_data()); } - iterator + iterator _M_iend() const { return iterator(_M_data() + this->size()); } - void + void _M_leak() // for use in begin() & non-const op[] - { - if (!_M_rep()->_M_is_leaked()) - _M_leak_hard(); + { + if (!_M_rep()->_M_is_leaked()) + _M_leak_hard(); } - iterator + iterator _M_check(size_type __pos) const - { + { if (__pos > this->size()) - __throw_out_of_range("basic_string::_M_check"); - return _M_ibegin() + __pos; + __throw_out_of_range("basic_string::_M_check"); + return _M_ibegin() + __pos; } // NB: _M_fold doesn't check for a bad __pos1 value. - iterator + iterator _M_fold(size_type __pos, size_type __off) const - { + { bool __testoff = __off < this->size() - __pos; size_type __newoff = __testoff ? __off : this->size() - __pos; return (_M_ibegin() + __pos + __newoff); @@ -273,8 +293,8 @@ namespace std template<class _Iterator> static void _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) - { - for (; __k1 != __k2; ++__k1, ++__p) + { + for (; __k1 != __k2; ++__k1, ++__p) traits_type::assign(*__p, *__k1); // These types are off. } @@ -285,7 +305,7 @@ namespace std static void _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) { _S_copy_chars(__p, __k1.base(), __k2.base()); } - + static void _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) { traits_type::copy(__p, __k1, __k2 - __k1); } @@ -294,13 +314,13 @@ namespace std _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) { traits_type::copy(__p, __k1, __k2 - __k1); } - void + void _M_mutate(size_type __pos, size_type __len1, size_type __len2); - void + void _M_leak_hard(); - static _Rep& + static _Rep& _S_empty_rep() { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); } @@ -309,10 +329,10 @@ namespace std // NB: We overload ctors in some cases instead of using default // arguments, per 17.4.4.4 para. 2 item 2. - inline + inline basic_string(); - explicit + explicit basic_string(const _Alloc& __a); // NB: per LWG issue 42, semantics different from IS: @@ -331,200 +351,173 @@ namespace std basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a = _Alloc()); - ~basic_string() + ~basic_string() { _M_rep()->_M_dispose(this->get_allocator()); } - basic_string& + basic_string& operator=(const basic_string& __str) { return this->assign(__str); } - basic_string& + basic_string& operator=(const _CharT* __s) { return this->assign(__s); } - basic_string& + basic_string& operator=(_CharT __c) { return this->assign(1, __c); } // Iterators: - iterator - begin() - { - _M_leak(); + iterator + begin() + { + _M_leak(); return iterator(_M_data()); } - const_iterator - begin() const + const_iterator + begin() const { return const_iterator(_M_data()); } - iterator + iterator end() { _M_leak(); return iterator(_M_data() + this->size()); } - const_iterator + const_iterator end() const { return const_iterator(_M_data() + this->size()); } - reverse_iterator - rbegin() + reverse_iterator + rbegin() { return reverse_iterator(this->end()); } - const_reverse_iterator - rbegin() const + const_reverse_iterator + rbegin() const { return const_reverse_iterator(this->end()); } - reverse_iterator - rend() + reverse_iterator + rend() { return reverse_iterator(this->begin()); } - const_reverse_iterator - rend() const + const_reverse_iterator + rend() const { return const_reverse_iterator(this->begin()); } public: // Capacity: - size_type + size_type size() const { return _M_rep()->_M_length; } - size_type + size_type length() const { return _M_rep()->_M_length; } - size_type + size_type max_size() const { return _Rep::_S_max_size; } - void + void resize(size_type __n, _CharT __c); - void + void resize(size_type __n) { this->resize(__n, _CharT()); } - size_type + size_type capacity() const { return _M_rep()->_M_capacity; } - void + void reserve(size_type __res_arg = 0); - void + void clear() { _M_mutate(0, this->size(), 0); } - bool + bool empty() const { return this->size() == 0; } // Element access: - const_reference - operator[] (size_type __pos) const + const_reference + operator[] (size_type __pos) const { return _M_data()[__pos]; } - reference - operator[](size_type __pos) - { - _M_leak(); - return _M_data()[__pos]; + reference + operator[](size_type __pos) + { + _M_leak(); + return _M_data()[__pos]; } - const_reference + const_reference at(size_type __n) const { if (__n >= this->size()) __throw_out_of_range("basic_string::at"); - return _M_data()[__n]; + return _M_data()[__n]; } - reference + reference at(size_type __n) { if (__n >= size()) __throw_out_of_range("basic_string::at"); - _M_leak(); - return _M_data()[__n]; + _M_leak(); + return _M_data()[__n]; } // Modifiers: - basic_string& + basic_string& operator+=(const basic_string& __str) { return this->append(__str); } - basic_string& + basic_string& operator+=(const _CharT* __s) { return this->append(__s); } - basic_string& + basic_string& operator+=(_CharT __c) { return this->append(size_type(1), __c); } - basic_string& + basic_string& append(const basic_string& __str); - basic_string& + basic_string& append(const basic_string& __str, size_type __pos, size_type __n); - basic_string& + basic_string& append(const _CharT* __s, size_type __n); - basic_string& + basic_string& append(const _CharT* __s) { return this->append(__s, traits_type::length(__s)); } - basic_string& + basic_string& append(size_type __n, _CharT __c); template<class _InputIterator> - basic_string& + basic_string& append(_InputIterator __first, _InputIterator __last) { return this->replace(_M_iend(), _M_iend(), __first, __last); } - void + void push_back(_CharT __c) { this->replace(_M_iend(), _M_iend(), 1, __c); } - basic_string& + basic_string& assign(const basic_string& __str); - basic_string& - assign(const basic_string& __str, size_type __pos, size_type __n) - { - const size_type __strsize = __str.size(); - if (__pos > __strsize) - __throw_out_of_range("basic_string::assign"); - const bool __testn = __n < __strsize - __pos; - const size_type __newsize = __testn ? __n : __strsize - __pos; - return this->assign(__str._M_data() + __pos, __newsize); - } + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n); - basic_string& - assign(const _CharT* __s, size_type __n) - { - if (__n > this->max_size()) - __throw_length_error("basic_string::assign"); - if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) - || less<const _CharT*>()(_M_data() + this->size(), __s)) - return _M_replace_safe(_M_ibegin(), _M_iend(), __s, __s + __n); - else - { - // Work in-place - const size_type __pos = __s - _M_data(); - if (__pos >= __n) - traits_type::copy(_M_data(), __s, __n); - else if (__pos) - traits_type::move(_M_data(), __s, __n); - _M_rep()->_M_length = __n; - _M_data()[__n] = _Rep::_S_terminal; - return *this; - } - } + basic_string& + assign(const _CharT* __s, size_type __n); - basic_string& + basic_string& assign(const _CharT* __s) { return this->assign(__s, traits_type::length(__s)); } - basic_string& + basic_string& assign(size_type __n, _CharT __c) { return this->replace(_M_ibegin(), _M_iend(), __n, __c); } template<class _InputIterator> - basic_string& + basic_string& assign(_InputIterator __first, _InputIterator __last) { return this->replace(_M_ibegin(), _M_iend(), __first, __last); } - void + void insert(iterator __p, size_type __n, _CharT __c) { this->replace(__p, __p, __n, __c); } @@ -532,93 +525,54 @@ namespace std void insert(iterator __p, _InputIterator __beg, _InputIterator __end) { this->replace(__p, __p, __beg, __end); } - basic_string& + basic_string& insert(size_type __pos1, const basic_string& __str) { return this->insert(__pos1, __str, 0, __str.size()); } - basic_string& + basic_string& insert(size_type __pos1, const basic_string& __str, - size_type __pos2, size_type __n) - { - const size_type __strsize = __str.size(); - if (__pos2 > __strsize) - __throw_out_of_range("basic_string::insert"); - const bool __testn = __n < __strsize - __pos2; - const size_type __newsize = __testn ? __n : __strsize - __pos2; - return this->insert(__pos1, __str._M_data() + __pos2, __newsize); - } + size_type __pos2, size_type __n); - basic_string& - insert(size_type __pos, const _CharT* __s, size_type __n) - { - const size_type __size = this->size(); - if (__pos > __size) - __throw_out_of_range("basic_string::insert"); - if (__size > this->max_size() - __n) - __throw_length_error("basic_string::insert"); - if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) - || less<const _CharT*>()(_M_data() + __size, __s)) - return _M_replace_safe(_M_ibegin() + __pos, _M_ibegin() + __pos, - __s, __s + __n); - else - { - // Work in-place. If _M_mutate reallocates the string, __s - // does not point anymore to valid data, therefore we save its - // offset, then we restore it. - const size_type __off = __s - _M_data(); - _M_mutate(__pos, 0, __n); - __s = _M_data() + __off; - _CharT* __p = _M_data() + __pos; - if (__s + __n <= __p) - traits_type::copy(__p, __s, __n); - else if (__s >= __p) - traits_type::copy(__p, __s + __n, __n); - else - { - traits_type::copy(__p, __s, __p - __s); - traits_type::copy(__p + (__p - __s), __p + __n, __n - (__p - __s)); - } - return *this; - } - } - - basic_string& + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n); + + basic_string& insert(size_type __pos, const _CharT* __s) { return this->insert(__pos, __s, traits_type::length(__s)); } - basic_string& + basic_string& insert(size_type __pos, size_type __n, _CharT __c) - { - this->insert(_M_check(__pos), __n, __c); - return *this; + { + this->insert(_M_check(__pos), __n, __c); + return *this; } - iterator + iterator insert(iterator __p, _CharT __c = _CharT()) { size_type __pos = __p - _M_ibegin(); this->insert(_M_check(__pos), size_type(1), __c); - _M_rep()->_M_set_leaked(); - return this->_M_ibegin() + __pos; + _M_rep()->_M_set_leaked(); + return this->_M_ibegin() + __pos; } - basic_string& + basic_string& erase(size_type __pos = 0, size_type __n = npos) - { + { return this->replace(_M_check(__pos), _M_fold(__pos, __n), - _M_data(), _M_data()); + _M_data(), _M_data()); } - iterator + iterator erase(iterator __position) { size_type __i = __position - _M_ibegin(); this->replace(__position, __position + 1, _M_data(), _M_data()); - _M_rep()->_M_set_leaked(); + _M_rep()->_M_set_leaked(); return _M_ibegin() + __i; } - iterator + iterator erase(iterator __first, iterator __last) { size_type __i = __first - _M_ibegin(); @@ -627,62 +581,44 @@ namespace std return _M_ibegin() + __i; } - basic_string& + basic_string& replace(size_type __pos, size_type __n, const basic_string& __str) { return this->replace(__pos, __n, __str._M_data(), __str.size()); } - basic_string& + basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2); - basic_string& + basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2) - { - const size_type __size = this->size(); - if (__pos > __size) - __throw_out_of_range("basic_string::replace"); - const bool __testn1 = __n1 < __size - __pos; - const size_type __foldn1 = __testn1 ? __n1 : __size - __pos; - if (__size - __foldn1 > this->max_size() - __n2) - __throw_length_error("basic_string::replace"); - if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) - || less<const _CharT*>()(_M_data() + __size, __s)) - return _M_replace_safe(_M_ibegin() + __pos, - _M_ibegin() + __pos + __foldn1, __s, __s + __n2); - // Todo: optimized in-place replace. - else return - _M_replace(_M_ibegin() + __pos, _M_ibegin() + __pos + __foldn1, - __s, __s + __n2, - typename iterator_traits<const _CharT*>::iterator_category()); - } + size_type __n2); - basic_string& + basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s) { return this->replace(__pos, __n1, __s, traits_type::length(__s)); } - basic_string& + basic_string& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { return this->replace(_M_check(__pos), _M_fold(__pos, __n1), __n2, __c); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const basic_string& __str) { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const _CharT* __s) { return this->replace(__i1, __i2, __s, traits_type::length(__s)); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, size_type __n, _CharT __c); template<class _InputIterator> - basic_string& + basic_string& replace(iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2) { return _M_replace(__i1, __i2, __k1, __k2, @@ -690,23 +626,23 @@ namespace std // Specializations for the common case of pointer and iterator: // useful to avoid the overhead of temporary buffering in _M_replace. - basic_string& + basic_string& replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2) { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(), __k2 - __k1); } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2) { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(), __k2 - __k1); @@ -714,13 +650,13 @@ namespace std private: template<class _InputIterator> - basic_string& - _M_replace(iterator __i1, iterator __i2, _InputIterator __k1, + basic_string& + _M_replace(iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2, input_iterator_tag); template<class _ForwardIterator> - basic_string& - _M_replace_safe(iterator __i1, iterator __i2, _ForwardIterator __k1, + basic_string& + _M_replace_safe(iterator __i1, iterator __i2, _ForwardIterator __k1, _ForwardIterator __k2); // _S_construct_aux is used to implement the 21.3.1 para 15 which @@ -733,7 +669,7 @@ namespace std typedef typename iterator_traits<_InIter>::iterator_category _Tag; return _S_construct(__beg, __end, __a, _Tag()); } - + template<class _InIter> static _CharT* _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a, @@ -742,7 +678,7 @@ namespace std return _S_construct(static_cast<size_type>(__beg), static_cast<value_type>(__end), __a); } - + template<class _InIter> static _CharT* _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a) @@ -756,7 +692,7 @@ namespace std static _CharT* _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a, input_iterator_tag); - + // For forward_iterators up to random_access_iterators, used for // string::iterator, _CharT*, etc. template<class _FwdIter> @@ -764,19 +700,19 @@ namespace std _S_construct(_FwdIter __beg, _FwdIter __end, const _Alloc& __a, forward_iterator_tag); - static _CharT* + static _CharT* _S_construct(size_type __req, _CharT __c, const _Alloc& __a); public: - size_type + size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const; - void + void swap(basic_string<_CharT, _Traits, _Alloc>& __s); // String operations: - const _CharT* + const _CharT* c_str() const { // MT: This assumes concurrent writes are OK. @@ -785,137 +721,137 @@ namespace std return _M_data(); } - const _CharT* + const _CharT* data() const { return _M_data(); } - allocator_type + allocator_type get_allocator() const { return _M_dataplus; } - size_type + size_type find(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type find(const basic_string& __str, size_type __pos = 0) const { return this->find(__str.data(), __pos, __str.size()); } - size_type + size_type find(const _CharT* __s, size_type __pos = 0) const { return this->find(__s, __pos, traits_type::length(__s)); } - size_type + size_type find(_CharT __c, size_type __pos = 0) const; - size_type + size_type rfind(const basic_string& __str, size_type __pos = npos) const { return this->rfind(__str.data(), __pos, __str.size()); } - size_type + size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type rfind(const _CharT* __s, size_type __pos = npos) const { return this->rfind(__s, __pos, traits_type::length(__s)); } - size_type + size_type rfind(_CharT __c, size_type __pos = npos) const; - size_type + size_type find_first_of(const basic_string& __str, size_type __pos = 0) const { return this->find_first_of(__str.data(), __pos, __str.size()); } - size_type + size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type find_first_of(const _CharT* __s, size_type __pos = 0) const { return this->find_first_of(__s, __pos, traits_type::length(__s)); } - size_type + size_type find_first_of(_CharT __c, size_type __pos = 0) const { return this->find(__c, __pos); } - size_type + size_type find_last_of(const basic_string& __str, size_type __pos = npos) const { return this->find_last_of(__str.data(), __pos, __str.size()); } - size_type + size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type find_last_of(const _CharT* __s, size_type __pos = npos) const { return this->find_last_of(__s, __pos, traits_type::length(__s)); } - size_type + size_type find_last_of(_CharT __c, size_type __pos = npos) const { return this->rfind(__c, __pos); } - size_type + size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const { return this->find_first_not_of(__str.data(), __pos, __str.size()); } - size_type - find_first_not_of(const _CharT* __s, size_type __pos, + size_type + find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const { return this->find_first_not_of(__s, __pos, traits_type::length(__s)); } - size_type + size_type find_first_not_of(_CharT __c, size_type __pos = 0) const; - size_type + size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const { return this->find_last_not_of(__str.data(), __pos, __str.size()); } - size_type - find_last_not_of(const _CharT* __s, size_type __pos, + size_type + find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const; - size_type + size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const { return this->find_last_not_of(__s, __pos, traits_type::length(__s)); } - size_type + size_type find_last_not_of(_CharT __c, size_type __pos = npos) const; - basic_string + basic_string substr(size_type __pos = 0, size_type __n = npos) const - { + { if (__pos > this->size()) __throw_out_of_range("basic_string::substr"); - return basic_string(*this, __pos, __n); + return basic_string(*this, __pos, __n); } - int + int compare(const basic_string& __str) const { size_type __size = this->size(); size_type __osize = __str.size(); - size_type __len = min(__size, __osize); - + size_type __len = std::min(__size, __osize); + int __r = traits_type::compare(_M_data(), __str.data(), __len); if (!__r) __r = __size - __osize; return __r; } - int + int compare(size_type __pos, size_type __n, const basic_string& __str) const; - int + int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const; - int + int compare(const _CharT* __s) const; // _GLIBCPP_RESOLVE_LIB_DEFECTS - // 5. String::compare specification questionable - int + // 5 String::compare specification questionable + int compare(size_type __pos, size_type __n1, const _CharT* __s) const; - int - compare(size_type __pos, size_type __n1, const _CharT* __s, + int + compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const; }; diff --git a/contrib/libstdc++/include/bits/basic_string.tcc b/contrib/libstdc++/include/bits/basic_string.tcc index 4a22d8967929..d3f1e8e36059 100644 --- a/contrib/libstdc++/include/bits/basic_string.tcc +++ b/contrib/libstdc++/include/bits/basic_string.tcc @@ -1,6 +1,6 @@ // Components for manipulating sequences of characters -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -137,14 +137,14 @@ namespace std _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a, forward_iterator_tag) { - size_type __dnew = static_cast<size_type>(distance(__beg, __end)); - if (__beg == __end && __a == _Alloc()) return _S_empty_rep()._M_refcopy(); // NB: Not required, but considered best practice. if (__builtin_expect(__beg == _InIter(), 0)) __throw_logic_error("attempt to create string with null pointer"); + + size_type __dnew = static_cast<size_type>(std::distance(__beg, __end)); // Check for out_of_range and length_error exceptions. _Rep* __r = _Rep::_S_create(__dnew, __a); @@ -254,6 +254,117 @@ namespace std } return *this; } + + template<typename _CharT, typename _Traits, typename _Alloc> + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + assign(const basic_string& __str, size_type __pos, size_type __n) + { + const size_type __strsize = __str.size(); + if (__pos > __strsize) + __throw_out_of_range("basic_string::assign"); + const bool __testn = __n < __strsize - __pos; + const size_type __newsize = __testn ? __n : __strsize - __pos; + return this->assign(__str._M_data() + __pos, __newsize); + } + + template<typename _CharT, typename _Traits, typename _Alloc> + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + assign(const _CharT* __s, size_type __n) + { + if (__n > this->max_size()) + __throw_length_error("basic_string::assign"); + if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) + || less<const _CharT*>()(_M_data() + this->size(), __s)) + return _M_replace_safe(_M_ibegin(), _M_iend(), __s, __s + __n); + else + { + // Work in-place + const size_type __pos = __s - _M_data(); + if (__pos >= __n) + traits_type::copy(_M_data(), __s, __n); + else if (__pos) + traits_type::move(_M_data(), __s, __n); + _M_rep()->_M_length = __n; + _M_data()[__n] = _Rep::_S_terminal; // grr. + return *this; + } + } + + template<typename _CharT, typename _Traits, typename _Alloc> + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n) + { + const size_type __strsize = __str.size(); + if (__pos2 > __strsize) + __throw_out_of_range("basic_string::insert"); + const bool __testn = __n < __strsize - __pos2; + const size_type __newsize = __testn ? __n : __strsize - __pos2; + return this->insert(__pos1, __str._M_data() + __pos2, __newsize); + } + + template<typename _CharT, typename _Traits, typename _Alloc> + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + insert(size_type __pos, const _CharT* __s, size_type __n) + { + const size_type __size = this->size(); + if (__pos > __size) + __throw_out_of_range("basic_string::insert"); + if (__size > this->max_size() - __n) + __throw_length_error("basic_string::insert"); + if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) + || less<const _CharT*>()(_M_data() + __size, __s)) + return _M_replace_safe(_M_ibegin() + __pos, _M_ibegin() + __pos, + __s, __s + __n); + else + { + // Work in-place. If _M_mutate reallocates the string, __s + // does not point anymore to valid data, therefore we save its + // offset, then we restore it. + const size_type __off = __s - _M_data(); + _M_mutate(__pos, 0, __n); + __s = _M_data() + __off; + _CharT* __p = _M_data() + __pos; + if (__s + __n <= __p) + traits_type::copy(__p, __s, __n); + else if (__s >= __p) + traits_type::copy(__p, __s + __n, __n); + else + { + traits_type::copy(__p, __s, __p - __s); + traits_type::copy(__p + (__p-__s), __p + __n, __n - (__p-__s)); + } + return *this; + } + } + + template<typename _CharT, typename _Traits, typename _Alloc> + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) + { + const size_type __size = this->size(); + if (__pos > __size) + __throw_out_of_range("basic_string::replace"); + const bool __testn1 = __n1 < __size - __pos; + const size_type __foldn1 = __testn1 ? __n1 : __size - __pos; + if (__size - __foldn1 > this->max_size() - __n2) + __throw_length_error("basic_string::replace"); + if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data()) + || less<const _CharT*>()(_M_data() + __size, __s)) + return _M_replace_safe(_M_ibegin() + __pos, + _M_ibegin() + __pos + __foldn1, __s, __s + __n2); + // Todo: optimized in-place replace. + else + return _M_replace(_M_ibegin() + __pos, _M_ibegin() + __pos + __foldn1, + __s, __s + __n2, + typename iterator_traits<const _CharT*>::iterator_category()); + } template<typename _CharT, typename _Traits, typename _Alloc> void @@ -523,7 +634,7 @@ namespace std _M_replace_safe(iterator __i1, iterator __i2, _ForwardIter __k1, _ForwardIter __k2) { - size_type __dnew = static_cast<size_type>(distance(__k1, __k2)); + size_type __dnew = static_cast<size_type>(std::distance(__k1, __k2)); size_type __dold = __i2 - __i1; size_type __dmax = this->max_size(); @@ -578,7 +689,8 @@ namespace std // Iff appending itself, string needs to pre-reserve the // correct size so that _M_mutate does not clobber the // iterators formed here. - size_type __len = min(__str.size() - __pos, __n) + this->size(); + size_type __len = std::min(size_type(__str.size() - __pos), + __n) + this->size(); if (__len > this->capacity()) this->reserve(__len); return _M_replace_safe(_M_iend(), _M_iend(), __str._M_check(__pos), @@ -709,7 +821,7 @@ namespace std size_type __size = this->size(); if (__n <= __size) { - __pos = std::min(__size - __n, __pos); + __pos = std::min(size_type(__size - __n), __pos); const _CharT* __data = _M_data(); do { @@ -848,8 +960,8 @@ namespace std if (__pos > __size) __throw_out_of_range("basic_string::compare"); - size_type __rsize= min(__size - __pos, __n); - size_type __len = min(__rsize, __osize); + size_type __rsize= std::min(size_type(__size - __pos), __n); + size_type __len = std::min(__rsize, __osize); int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); if (!__r) __r = __rsize - __osize; @@ -867,9 +979,9 @@ namespace std if (__pos1 > __size || __pos2 > __osize) __throw_out_of_range("basic_string::compare"); - size_type __rsize = min(__size - __pos1, __n1); - size_type __rosize = min(__osize - __pos2, __n2); - size_type __len = min(__rsize, __rosize); + size_type __rsize = std::min(size_type(__size - __pos1), __n1); + size_type __rosize = std::min(size_type(__osize - __pos2), __n2); + size_type __len = std::min(__rsize, __rosize); int __r = traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len); if (!__r) @@ -885,7 +997,7 @@ namespace std { size_type __size = this->size(); size_type __osize = traits_type::length(__s); - size_type __len = min(__size, __osize); + size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __s, __len); if (!__r) __r = __size - __osize; @@ -903,8 +1015,8 @@ namespace std __throw_out_of_range("basic_string::compare"); size_type __osize = traits_type::length(__s); - size_type __rsize = min(__size - __pos, __n1); - size_type __len = min(__rsize, __osize); + size_type __rsize = std::min(size_type(__size - __pos), __n1); + size_type __len = std::min(__rsize, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = __rsize - __osize; @@ -921,9 +1033,9 @@ namespace std if (__pos > __size) __throw_out_of_range("basic_string::compare"); - size_type __osize = min(traits_type::length(__s), __n2); - size_type __rsize = min(__size - __pos, __n1); - size_type __len = min(__rsize, __osize); + size_type __osize = std::min(traits_type::length(__s), __n2); + size_type __rsize = std::min(size_type(__size - __pos), __n1); + size_type __len = std::min(__rsize, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = __rsize - __osize; @@ -937,7 +1049,7 @@ namespace std { typedef typename _Alloc::size_type size_type; size_type __strsize = __str.size(); - size_type __bytes = min(__strsize, __bufsiz - 1); + size_type __bytes = std::min(__strsize, __bufsiz - 1); _Traits::copy(__buf, __str.data(), __bytes); __buf[__bytes] = _CharT(); } @@ -945,6 +1057,7 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_string<char>; extern template basic_istream<char>& @@ -974,6 +1087,7 @@ namespace std basic_istream<wchar_t>& getline(basic_istream<wchar_t>&, wstring&); #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/boost_concept_check.h b/contrib/libstdc++/include/bits/boost_concept_check.h index 29ca61baef72..d91c2e88e3c9 100644 --- a/contrib/libstdc++/include/bits/boost_concept_check.h +++ b/contrib/libstdc++/include/bits/boost_concept_check.h @@ -149,6 +149,8 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; }; __a = __b; // const required for argument to assignment } _Tp __a; + // possibly should be "Tp* a;" and then dereference "a" in constraint + // functions? present way would require a default ctor, i think... }; template <class _Tp> diff --git a/contrib/libstdc++/include/bits/c++config b/contrib/libstdc++/include/bits/c++config index cda776c22dac..1716e25318bd 100644 --- a/contrib/libstdc++/include/bits/c++config +++ b/contrib/libstdc++/include/bits/c++config @@ -1,6 +1,7 @@ // Predefined symbols and macros -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 +// 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 @@ -34,10 +35,9 @@ #include <bits/os_defines.h> // The current version of the C++ library in compressed ISO date format. -#define __GLIBCPP__ 20030205 +#define __GLIBCPP__ 20030711 -// This is necessary until GCC supports separate template -// compilation. +// This is necessary until GCC supports separate template compilation. #define _GLIBCPP_NO_TEMPLATE_EXPORT 1 // This is a hack around not having either pre-compiled headers or @@ -49,6 +49,16 @@ // by the compiler, but instead instantiated into the library binary. #define _GLIBCPP_FULLY_COMPLIANT_HEADERS 1 +// Allow use of the GNU syntax extension, "extern template." This +// extension is fully documented in the g++ manual, but in a nutshell, +// it inhibits all implicit instantiations and is used throughout the +// library to avoid multiple weak definitions for required types that +// are already explicitly instantiated in the library binary. This +// substantially reduces the binary size of resulting executables. +#ifndef _GLIBCPP_EXTERN_TEMPLATE +#define _GLIBCPP_EXTERN_TEMPLATE 1 +#endif + // To enable older, ARM-style iostreams and other anachronisms use this. //#define _GLIBCPP_DEPRECATED 1 @@ -77,6 +87,13 @@ #error __USE_MALLOC should never be defined. Read the release notes. #endif +// Create a boolean flag to be used to determine if --fast-math is set. +#ifdef __FAST_MATH__ +#define _GLIBCPP_FAST_MATH 1 +#else +#define _GLIBCPP_FAST_MATH 0 +#endif + // The remainder of the prewritten config is mostly automatic; all the // user hooks are listed above. diff --git a/contrib/libstdc++/include/bits/char_traits.h b/contrib/libstdc++/include/bits/char_traits.h index 41f943d9a59b..2b733cd94a01 100644 --- a/contrib/libstdc++/include/bits/char_traits.h +++ b/contrib/libstdc++/include/bits/char_traits.h @@ -42,14 +42,22 @@ #pragma GCC system_header -#include <cstring> // For memmove, memset, memchr -#include <bits/fpos.h> // For streampos +#include <cstring> // For memmove, memset, memchr +#include <bits/fpos.h> // For streampos namespace std { - /// 21.1.2 Basis for explicit _Traits specialization - /// NB: That for any given actual character type this definition is - /// probably wrong. + // 21.1 + /** + * @brief Basis for explicit traits specializations. + * + * @note For any given actual character type, this definition is + * probably wrong. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5 + * for advice on how to make use of this class for "unusual" character + * types. + */ template<class _CharT> struct char_traits { @@ -104,7 +112,7 @@ namespace std }; - /// 21.1.4 char_traits specializations + /// 21.1.3.1 char_traits specializations template<> struct char_traits<char> { @@ -174,6 +182,7 @@ namespace std #ifdef _GLIBCPP_USE_WCHAR_T + /// 21.1.3.2 char_traits specializations template<> struct char_traits<wchar_t> { diff --git a/contrib/libstdc++/include/bits/codecvt.h b/contrib/libstdc++/include/bits/codecvt.h index 3666e987d6de..9ab9f94e71d5 100644 --- a/contrib/libstdc++/include/bits/codecvt.h +++ b/contrib/libstdc++/include/bits/codecvt.h @@ -1,6 +1,6 @@ // Locale support (codecvt) -*- C++ -*- -// Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 2000, 2001, 2002, 2003 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 diff --git a/contrib/libstdc++/include/bits/concept_check.h b/contrib/libstdc++/include/bits/concept_check.h index 92ceefbd685e..88877ebf57e4 100644 --- a/contrib/libstdc++/include/bits/concept_check.h +++ b/contrib/libstdc++/include/bits/concept_check.h @@ -61,8 +61,7 @@ // Note that the obvious and elegant approach of // -//#define glibcpp_function_requires(C) \ -// boost::function_requires< boost::C >() +//#define glibcpp_function_requires(C) boost::function_requires< boost::C >() // // won't work due to concept templates with more than one parameter, e.g., // BinaryPredicateConcept. The preprocessor tries to split things up on diff --git a/contrib/libstdc++/include/bits/deque.tcc b/contrib/libstdc++/include/bits/deque.tcc new file mode 100644 index 000000000000..a8d43d024c29 --- /dev/null +++ b/contrib/libstdc++/include/bits/deque.tcc @@ -0,0 +1,779 @@ +// Deque implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001, 2002 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. + +/* + * + * 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. + */ + +/** @file deque.tcc + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +#ifndef __GLIBCPP_INTERNAL_DEQUE_TCC +#define __GLIBCPP_INTERNAL_DEQUE_TCC + +namespace std +{ + template <typename _Tp, typename _Alloc> + deque<_Tp,_Alloc>& + deque<_Tp,_Alloc>:: + operator=(const deque& __x) + { + const size_type __len = size(); + if (&__x != this) + { + if (__len >= __x.size()) + erase(copy(__x.begin(), __x.end(), _M_start), _M_finish); + else + { + const_iterator __mid = __x.begin() + difference_type(__len); + copy(__x.begin(), __mid, _M_start); + insert(_M_finish, __mid, __x.end()); + } + } + return *this; + } + + template <typename _Tp, typename _Alloc> + typename deque<_Tp,_Alloc>::iterator + deque<_Tp,_Alloc>:: + insert(iterator position, const value_type& __x) + { + if (position._M_cur == _M_start._M_cur) + { + push_front(__x); + return _M_start; + } + else if (position._M_cur == _M_finish._M_cur) + { + push_back(__x); + iterator __tmp = _M_finish; + --__tmp; + return __tmp; + } + else + return _M_insert_aux(position, __x); + } + + template <typename _Tp, typename _Alloc> + typename deque<_Tp,_Alloc>::iterator + deque<_Tp,_Alloc>:: + erase(iterator __position) + { + iterator __next = __position; + ++__next; + size_type __index = __position - _M_start; + if (__index < (size() >> 1)) + { + copy_backward(_M_start, __position, __next); + pop_front(); + } + else + { + copy(__next, _M_finish, __position); + pop_back(); + } + return _M_start + __index; + } + + template <typename _Tp, typename _Alloc> + typename deque<_Tp,_Alloc>::iterator + deque<_Tp,_Alloc>:: + erase(iterator __first, iterator __last) + { + if (__first == _M_start && __last == _M_finish) + { + clear(); + return _M_finish; + } + else + { + difference_type __n = __last - __first; + difference_type __elems_before = __first - _M_start; + if (static_cast<size_type>(__elems_before) < (size() - __n) / 2) + { + copy_backward(_M_start, __first, __last); + iterator __new_start = _M_start + __n; + _Destroy(_M_start, __new_start); + _M_destroy_nodes(_M_start._M_node, __new_start._M_node); + _M_start = __new_start; + } + else + { + copy(__last, _M_finish, __first); + iterator __new_finish = _M_finish - __n; + _Destroy(__new_finish, _M_finish); + _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1); + _M_finish = __new_finish; + } + return _M_start + __elems_before; + } + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + clear() + { + for (_Map_pointer __node = _M_start._M_node + 1; + __node < _M_finish._M_node; + ++__node) + { + _Destroy(*__node, *__node + _S_buffer_size()); + _M_deallocate_node(*__node); + } + + if (_M_start._M_node != _M_finish._M_node) + { + _Destroy(_M_start._M_cur, _M_start._M_last); + _Destroy(_M_finish._M_first, _M_finish._M_cur); + _M_deallocate_node(_M_finish._M_first); + } + else + _Destroy(_M_start._M_cur, _M_finish._M_cur); + + _M_finish = _M_start; + } + + template <typename _Tp, class _Alloc> + template <typename _InputIter> + void + deque<_Tp,_Alloc> + ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag) + { + iterator __cur = begin(); + for ( ; __first != __last && __cur != end(); ++__cur, ++__first) + *__cur = *__first; + if (__first == __last) + erase(__cur, end()); + else + insert(end(), __first, __last); + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x) + { + if (__pos._M_cur == _M_start._M_cur) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + try + { + uninitialized_fill(__new_start, _M_start, __x); + _M_start = __new_start; + } + catch(...) + { + _M_destroy_nodes(__new_start._M_node, _M_start._M_node); + __throw_exception_again; + } + } + else if (__pos._M_cur == _M_finish._M_cur) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + try + { + uninitialized_fill(_M_finish, __new_finish, __x); + _M_finish = __new_finish; + } + catch(...) + { + _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); + __throw_exception_again; + } + } + else + _M_insert_aux(__pos, __n, __x); + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_fill_initialize(const value_type& __value) + { + _Map_pointer __cur; + try + { + for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur) + uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value); + uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value); + } + catch(...) + { + _Destroy(_M_start, iterator(*__cur, __cur)); + __throw_exception_again; + } + } + + template <typename _Tp, typename _Alloc> + template <typename _InputIterator> + void + deque<_Tp,_Alloc>:: + _M_range_initialize(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + _M_initialize_map(0); + try + { + for ( ; __first != __last; ++__first) + push_back(*__first); + } + catch(...) + { + clear(); + __throw_exception_again; + } + } + + template <typename _Tp, typename _Alloc> + template <typename _ForwardIterator> + void + deque<_Tp,_Alloc>:: + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + forward_iterator_tag) + { + size_type __n = distance(__first, __last); + _M_initialize_map(__n); + + _Map_pointer __cur_node; + try + { + for (__cur_node = _M_start._M_node; + __cur_node < _M_finish._M_node; + ++__cur_node) + { + _ForwardIterator __mid = __first; + advance(__mid, _S_buffer_size()); + uninitialized_copy(__first, __mid, *__cur_node); + __first = __mid; + } + uninitialized_copy(__first, __last, _M_finish._M_first); + } + catch(...) + { + _Destroy(_M_start, iterator(*__cur_node, __cur_node)); + __throw_exception_again; + } + } + + // Called only if _M_finish._M_cur == _M_finish._M_last - 1. + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_push_back_aux(const value_type& __t) + { + value_type __t_copy = __t; + _M_reserve_map_at_back(); + *(_M_finish._M_node + 1) = _M_allocate_node(); + try + { + _Construct(_M_finish._M_cur, __t_copy); + _M_finish._M_set_node(_M_finish._M_node + 1); + _M_finish._M_cur = _M_finish._M_first; + } + catch(...) + { + _M_deallocate_node(*(_M_finish._M_node + 1)); + __throw_exception_again; + } + } + + #ifdef _GLIBCPP_DEPRECATED + // Called only if _M_finish._M_cur == _M_finish._M_last - 1. + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_push_back_aux() + { + _M_reserve_map_at_back(); + *(_M_finish._M_node + 1) = _M_allocate_node(); + try + { + _Construct(_M_finish._M_cur); + _M_finish._M_set_node(_M_finish._M_node + 1); + _M_finish._M_cur = _M_finish._M_first; + } + catch(...) + { + _M_deallocate_node(*(_M_finish._M_node + 1)); + __throw_exception_again; + } + } + #endif + + // Called only if _M_start._M_cur == _M_start._M_first. + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_push_front_aux(const value_type& __t) + { + value_type __t_copy = __t; + _M_reserve_map_at_front(); + *(_M_start._M_node - 1) = _M_allocate_node(); + try + { + _M_start._M_set_node(_M_start._M_node - 1); + _M_start._M_cur = _M_start._M_last - 1; + _Construct(_M_start._M_cur, __t_copy); + } + catch(...) + { + ++_M_start; + _M_deallocate_node(*(_M_start._M_node - 1)); + __throw_exception_again; + } + } + + #ifdef _GLIBCPP_DEPRECATED + // Called only if _M_start._M_cur == _M_start._M_first. + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_push_front_aux() + { + _M_reserve_map_at_front(); + *(_M_start._M_node - 1) = _M_allocate_node(); + try + { + _M_start._M_set_node(_M_start._M_node - 1); + _M_start._M_cur = _M_start._M_last - 1; + _Construct(_M_start._M_cur); + } + catch(...) + { + ++_M_start; + _M_deallocate_node(*(_M_start._M_node - 1)); + __throw_exception_again; + } + } + #endif + + // Called only if _M_finish._M_cur == _M_finish._M_first. + template <typename _Tp, typename _Alloc> + void deque<_Tp,_Alloc>:: + _M_pop_back_aux() + { + _M_deallocate_node(_M_finish._M_first); + _M_finish._M_set_node(_M_finish._M_node - 1); + _M_finish._M_cur = _M_finish._M_last - 1; + _Destroy(_M_finish._M_cur); + } + + // Called only if _M_start._M_cur == _M_start._M_last - 1. Note that + // if the deque has at least one element (a precondition for this member + // function), and if _M_start._M_cur == _M_start._M_last, then the deque + // must have at least two nodes. + template <typename _Tp, typename _Alloc> + void deque<_Tp,_Alloc>:: + _M_pop_front_aux() + { + _Destroy(_M_start._M_cur); + _M_deallocate_node(_M_start._M_first); + _M_start._M_set_node(_M_start._M_node + 1); + _M_start._M_cur = _M_start._M_first; + } + + template <typename _Tp, typename _Alloc> + template <typename _InputIterator> + void + deque<_Tp,_Alloc>:: + _M_range_insert_aux(iterator __pos, + _InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + copy(__first, __last, inserter(*this, __pos)); + } + + template <typename _Tp, typename _Alloc> + template <typename _ForwardIterator> + void + deque<_Tp,_Alloc>:: + _M_range_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + forward_iterator_tag) + { + size_type __n = distance(__first, __last); + if (__pos._M_cur == _M_start._M_cur) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + try + { + uninitialized_copy(__first, __last, __new_start); + _M_start = __new_start; + } + catch(...) + { + _M_destroy_nodes(__new_start._M_node, _M_start._M_node); + __throw_exception_again; + } + } + else if (__pos._M_cur == _M_finish._M_cur) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + try + { + uninitialized_copy(__first, __last, _M_finish); + _M_finish = __new_finish; + } + catch(...) + { + _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); + __throw_exception_again; + } + } + else + _M_insert_aux(__pos, __first, __last, __n); + } + + template <typename _Tp, typename _Alloc> + typename deque<_Tp, _Alloc>::iterator + deque<_Tp,_Alloc>:: + _M_insert_aux(iterator __pos, const value_type& __x) + { + difference_type __index = __pos - _M_start; + value_type __x_copy = __x; // XXX copy + if (static_cast<size_type>(__index) < size() / 2) + { + push_front(front()); + iterator __front1 = _M_start; + ++__front1; + iterator __front2 = __front1; + ++__front2; + __pos = _M_start + __index; + iterator __pos1 = __pos; + ++__pos1; + copy(__front2, __pos1, __front1); + } + else + { + push_back(back()); + iterator __back1 = _M_finish; + --__back1; + iterator __back2 = __back1; + --__back2; + __pos = _M_start + __index; + copy_backward(__pos, __back2, __back1); + } + *__pos = __x_copy; + return __pos; + } + + #ifdef _GLIBCPP_DEPRECATED + // Nothing seems to actually use this. According to the pattern followed by + // the rest of the SGI code, it would be called by the deprecated insert(pos) + // function, but that has been replaced. We'll take our time removing this + // anyhow; mark for 3.4. -pme + template <typename _Tp, typename _Alloc> + typename deque<_Tp,_Alloc>::iterator + deque<_Tp,_Alloc>:: + _M_insert_aux(iterator __pos) + { + difference_type __index = __pos - _M_start; + if (static_cast<size_type>(__index) < size() / 2) + { + push_front(front()); + iterator __front1 = _M_start; + ++__front1; + iterator __front2 = __front1; + ++__front2; + __pos = _M_start + __index; + iterator __pos1 = __pos; + ++__pos1; + copy(__front2, __pos1, __front1); + } + else + { + push_back(back()); + iterator __back1 = _M_finish; + --__back1; + iterator __back2 = __back1; + --__back2; + __pos = _M_start + __index; + copy_backward(__pos, __back2, __back1); + } + *__pos = value_type(); + return __pos; + } + #endif + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_insert_aux(iterator __pos, size_type __n, const value_type& __x) + { + const difference_type __elems_before = __pos - _M_start; + size_type __length = this->size(); + value_type __x_copy = __x; + if (__elems_before < difference_type(__length / 2)) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + iterator __old_start = _M_start; + __pos = _M_start + __elems_before; + try + { + if (__elems_before >= difference_type(__n)) + { + iterator __start_n = _M_start + difference_type(__n); + uninitialized_copy(_M_start, __start_n, __new_start); + _M_start = __new_start; + copy(__start_n, __pos, __old_start); + fill(__pos - difference_type(__n), __pos, __x_copy); + } + else + { + __uninitialized_copy_fill(_M_start, __pos, __new_start, + _M_start, __x_copy); + _M_start = __new_start; + fill(__old_start, __pos, __x_copy); + } + } + catch(...) + { + _M_destroy_nodes(__new_start._M_node, _M_start._M_node); + __throw_exception_again; + } + } + else + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + iterator __old_finish = _M_finish; + const difference_type __elems_after = + difference_type(__length) - __elems_before; + __pos = _M_finish - __elems_after; + try + { + if (__elems_after > difference_type(__n)) + { + iterator __finish_n = _M_finish - difference_type(__n); + uninitialized_copy(__finish_n, _M_finish, _M_finish); + _M_finish = __new_finish; + copy_backward(__pos, __finish_n, __old_finish); + fill(__pos, __pos + difference_type(__n), __x_copy); + } + else + { + __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n), + __x_copy, __pos, _M_finish); + _M_finish = __new_finish; + fill(__pos, __old_finish, __x_copy); + } + } + catch(...) + { + _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); + __throw_exception_again; + } + } + } + + template <typename _Tp, typename _Alloc> + template <typename _ForwardIterator> + void + deque<_Tp,_Alloc>:: + _M_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + size_type __n) + { + const difference_type __elemsbefore = __pos - _M_start; + size_type __length = size(); + if (static_cast<size_type>(__elemsbefore) < __length / 2) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + iterator __old_start = _M_start; + __pos = _M_start + __elemsbefore; + try + { + if (__elemsbefore >= difference_type(__n)) + { + iterator __start_n = _M_start + difference_type(__n); + uninitialized_copy(_M_start, __start_n, __new_start); + _M_start = __new_start; + copy(__start_n, __pos, __old_start); + copy(__first, __last, __pos - difference_type(__n)); + } + else + { + _ForwardIterator __mid = __first; + advance(__mid, difference_type(__n) - __elemsbefore); + __uninitialized_copy_copy(_M_start, __pos, __first, __mid, + __new_start); + _M_start = __new_start; + copy(__mid, __last, __old_start); + } + } + catch(...) + { + _M_destroy_nodes(__new_start._M_node, _M_start._M_node); + __throw_exception_again; + } + } + else + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + iterator __old_finish = _M_finish; + const difference_type __elemsafter = + difference_type(__length) - __elemsbefore; + __pos = _M_finish - __elemsafter; + try + { + if (__elemsafter > difference_type(__n)) + { + iterator __finish_n = _M_finish - difference_type(__n); + uninitialized_copy(__finish_n, _M_finish, _M_finish); + _M_finish = __new_finish; + copy_backward(__pos, __finish_n, __old_finish); + copy(__first, __last, __pos); + } + else + { + _ForwardIterator __mid = __first; + advance(__mid, __elemsafter); + __uninitialized_copy_copy(__mid, __last, __pos, + _M_finish, _M_finish); + _M_finish = __new_finish; + copy(__first, __mid, __pos); + } + } + catch(...) + { + _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); + __throw_exception_again; + } + } + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_new_elements_at_front(size_type __new_elems) + { + size_type __new_nodes + = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size(); + _M_reserve_map_at_front(__new_nodes); + size_type __i; + try + { + for (__i = 1; __i <= __new_nodes; ++__i) + *(_M_start._M_node - __i) = _M_allocate_node(); + } + catch(...) + { + for (size_type __j = 1; __j < __i; ++__j) + _M_deallocate_node(*(_M_start._M_node - __j)); + __throw_exception_again; + } + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_new_elements_at_back(size_type __new_elems) + { + size_type __new_nodes + = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size(); + _M_reserve_map_at_back(__new_nodes); + size_type __i; + try + { + for (__i = 1; __i <= __new_nodes; ++__i) + *(_M_finish._M_node + __i) = _M_allocate_node(); + } + catch(...) + { + for (size_type __j = 1; __j < __i; ++__j) + _M_deallocate_node(*(_M_finish._M_node + __j)); + __throw_exception_again; + } + } + + template <typename _Tp, typename _Alloc> + void + deque<_Tp,_Alloc>:: + _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) + { + size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1; + size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; + + _Map_pointer __new_nstart; + if (_M_map_size > 2 * __new_num_nodes) + { + __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 + + (__add_at_front ? __nodes_to_add : 0); + if (__new_nstart < _M_start._M_node) + copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); + else + copy_backward(_M_start._M_node, _M_finish._M_node + 1, + __new_nstart + __old_num_nodes); + } + else + { + size_type __new_map_size = + _M_map_size + max(_M_map_size, __nodes_to_add) + 2; + + _Map_pointer __new_map = _M_allocate_map(__new_map_size); + __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 + + (__add_at_front ? __nodes_to_add : 0); + copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); + _M_deallocate_map(_M_map, _M_map_size); + + _M_map = __new_map; + _M_map_size = __new_map_size; + } + + _M_start._M_set_node(__new_nstart); + _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); + } +} // namespace std + +#endif /* __GLIBCPP_INTERNAL_DEQUE_TCC */ + diff --git a/contrib/libstdc++/include/bits/fpos.h b/contrib/libstdc++/include/bits/fpos.h index 279e0ab16ba2..5432527421a6 100644 --- a/contrib/libstdc++/include/bits/fpos.h +++ b/contrib/libstdc++/include/bits/fpos.h @@ -48,7 +48,10 @@ namespace std { // 27.4.1 Types - // 27.4.3 Template class fpos + // [27.4.3] template class fpos + /** + * @doctodo + */ template<typename _StateT> class fpos { @@ -113,9 +116,10 @@ namespace std _M_position(streamoff __off) { _M_off = __off; } }; - // 27.2, paragraph 10 about fpos/char_traits circularity + /// 27.2, paragraph 10 about fpos/char_traits circularity typedef fpos<mbstate_t> streampos; # ifdef _GLIBCPP_USE_WCHAR_T + /// 27.2, paragraph 10 about fpos/char_traits circularity typedef fpos<mbstate_t> wstreampos; # endif } // namespace std diff --git a/contrib/libstdc++/include/bits/fstream.tcc b/contrib/libstdc++/include/bits/fstream.tcc index 0b3bec1c2630..c69ac9c72266 100644 --- a/contrib/libstdc++/include/bits/fstream.tcc +++ b/contrib/libstdc++/include/bits/fstream.tcc @@ -58,7 +58,7 @@ namespace std template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: - _M_destroy_internal_buffer() + _M_destroy_internal_buffer() throw() { if (_M_buf_allocated) { @@ -90,11 +90,18 @@ namespace std { _M_allocate_internal_buffer(); _M_mode = __mode; + + // Setup initial position of buffer. _M_set_indeterminate(); if ((__mode & ios_base::ate) && this->seekoff(0, ios_base::end, __mode) < 0) - this->close(); + { + // 27.8.1.3,4 + this->close(); + return __ret; + } + __ret = this; } } @@ -104,35 +111,46 @@ namespace std template<typename _CharT, typename _Traits> typename basic_filebuf<_CharT, _Traits>::__filebuf_type* basic_filebuf<_CharT, _Traits>:: - close() + close() throw() { - __filebuf_type *__ret = NULL; + __filebuf_type* __ret = NULL; if (this->is_open()) { - const int_type __eof = traits_type::eof(); - bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - if (__testput - && traits_type::eq_int_type(_M_really_overflow(__eof), __eof)) - return __ret; + bool __testfail = false; + try + { + const int_type __eof = traits_type::eof(); + bool __testput = _M_out_cur && _M_out_beg < _M_out_end; + if (__testput + && traits_type::eq_int_type(_M_really_overflow(__eof), + __eof)) + __testfail = true; + +#if 0 + // XXX not done + if (_M_last_overflowed) + { + _M_output_unshift(); + _M_really_overflow(__eof); + } +#endif + } + catch(...) + { + __testfail = true; + } // NB: Do this here so that re-opened filebufs will be cool... - _M_mode = ios_base::openmode(0); + this->_M_mode = ios_base::openmode(0); _M_destroy_internal_buffer(); _M_pback_destroy(); - -#if 0 - // XXX not done - if (_M_last_overflowed) - { - _M_output_unshift(); - _M_really_overflow(__eof); - } -#endif - if (_M_file.close()) + if (!_M_file.close()) + __testfail = true; + + if (!__testfail) __ret = this; } - _M_last_overflowed = false; return __ret; } @@ -144,9 +162,16 @@ namespace std { streamsize __ret = -1; bool __testin = _M_mode & ios_base::in; + const locale __loc = this->getloc(); + const __codecvt_type& __cvt = use_facet<__codecvt_type>(__loc); if (__testin && this->is_open()) - __ret = _M_in_end - _M_in_cur; + { + __ret = _M_in_end - _M_in_cur; + if (__cvt.always_noconv()) + __ret += _M_file.showmanyc_helper(); + } + _M_last_overflowed = false; return __ret; } @@ -198,21 +223,26 @@ namespace std } else { - // At the beginning of the buffer, need to make a - // putback position available. - this->seekoff(-1, ios_base::cur); - this->underflow(); - if (!__testeof) + // At the beginning of the buffer, need to make a + // putback position available. + // But the seek may fail (f.i., at the beginning of + // a file, see libstdc++/9439) and in that case + // we return traits_type::eof() + if (this->seekoff(-1, ios_base::cur) >= 0) { - if (!traits_type::eq(__c, *_M_in_cur)) - { - _M_pback_create(); - *_M_in_cur = __c; - } - __ret = __i; + this->underflow(); + if (!__testeof) + { + if (!traits_type::eq(__c, *_M_in_cur)) + { + _M_pback_create(); + *_M_in_cur = __c; + } + __ret = __i; + } + else + __ret = traits_type::not_eof(__i); } - else - __ret = traits_type::not_eof(__i); } } _M_last_overflowed = false; @@ -230,7 +260,9 @@ namespace std if (__testout) { - if (__testput) + if (traits_type::eq_int_type(__c, traits_type::eof())) + __ret = traits_type::not_eof(__c); + else if (__testput) { *_M_out_cur = traits_type::to_char_type(__c); _M_out_cur_move(1); @@ -268,14 +300,23 @@ namespace std char* __buf = static_cast<char*>(__builtin_alloca(__blen)); char* __bend; const char_type* __iend; - __res_type __r = __cvt.out(_M_state_cur, __ibuf, __ibuf + __ilen, - __iend, __buf, __buf + __blen, __bend); - // Result == ok, partial, noconv - if (__r != codecvt_base::error) + codecvt_base::result __r; + __r = __cvt.out(_M_state_cur, __ibuf, __ibuf + __ilen, + __iend, __buf, __buf + __blen, __bend); + + if (__r == codecvt_base::ok || __r == codecvt_base::partial) __blen = __bend - __buf; - // Result == error - else - __blen = 0; + else if (__r == codecvt_base::noconv) + { + // Same as the always_noconv case above. + __buf = reinterpret_cast<char*>(__ibuf); + __blen = __ilen; + } + else + { + // Result == error + __blen = 0; + } if (__blen) { @@ -291,11 +332,8 @@ namespace std __r = __cvt.out(_M_state_cur, __iresume, __iresume + __rlen, __iend, __buf, __buf + __blen, __bend); if (__r != codecvt_base::error) - __rlen = __bend - __buf; - else - __rlen = 0; - if (__rlen) { + __rlen = __bend - __buf; __elen += _M_file.xsputn(__buf, __rlen); __plen += __rlen; } @@ -310,7 +348,7 @@ namespace std { int_type __ret = traits_type::eof(); bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - bool __testunbuffered = _M_file.is_open() && !_M_buf_size_opt; + bool __testunbuffered = _M_file.is_open() && !_M_buf_size; if (__testput || __testunbuffered) { @@ -333,26 +371,32 @@ namespace std _M_convert_to_external(_M_out_beg, _M_out_end - _M_out_beg, __elen, __plen); - // Convert pending sequence to external representation, output. - // If eof, then just attempt sync. - if (!traits_type::eq_int_type(__c, traits_type::eof())) - { - char_type __pending = traits_type::to_char_type(__c); - _M_convert_to_external(&__pending, 1, __elen, __plen); - - // User code must flush when switching modes (thus don't sync). - if (__elen == __plen) + // Checks for codecvt.out failures and _M_file.xsputn failures, + // respectively, inside _M_convert_to_external. + if (__testunbuffered || (__elen && __elen == __plen)) + { + // Convert pending sequence to external representation, output. + // If eof, then just attempt sync. + if (!traits_type::eq_int_type(__c, traits_type::eof())) { - _M_set_indeterminate(); - __ret = traits_type::not_eof(__c); + char_type __pending = traits_type::to_char_type(__c); + _M_convert_to_external(&__pending, 1, __elen, __plen); + + // User code must flush when switching modes (thus + // don't sync). + if (__elen == __plen && __elen) + { + _M_set_indeterminate(); + __ret = traits_type::not_eof(__c); + } } - } - else if (!_M_file.sync()) - { - _M_set_indeterminate(); - __ret = traits_type::not_eof(__c); - } - } + else if (!_M_file.sync()) + { + _M_set_indeterminate(); + __ret = traits_type::not_eof(__c); + } + } + } _M_last_overflowed = true; return __ret; } @@ -391,12 +435,13 @@ namespace std bool __testin = (ios_base::in & _M_mode & __mode) != 0; bool __testout = (ios_base::out & _M_mode & __mode) != 0; - // Should probably do has_facet checks here. - int __width = use_facet<__codecvt_type>(_M_buf_locale).encoding(); + int __width = 0; + if (has_facet<__codecvt_type>(this->_M_buf_locale)) + __width = use_facet<__codecvt_type>(this->_M_buf_locale).encoding(); if (__width < 0) __width = 0; - bool __testfail = __off != 0 && __width <= 0; - + + bool __testfail = __off != 0 && __width <= 0; if (this->is_open() && !__testfail && (__testin || __testout)) { // Ditch any pback buffers to avoid confusion. @@ -420,7 +465,8 @@ namespace std //in else if (__testget && __way == ios_base::cur) __computed_off += _M_in_cur - _M_filepos; - + + // Return pos_type(off_type(-1)) in case of failure. __ret = _M_file.seekoff(__computed_off, __way, __mode); _M_set_indeterminate(); } @@ -428,8 +474,14 @@ namespace std // state, ie _M_file._offset == -1 else { - __ret = _M_file.seekoff(__off, ios_base::cur, __mode); - __ret += max(_M_out_cur, _M_in_cur) - _M_filepos; + pos_type __tmp = + _M_file.seekoff(__off, ios_base::cur, __mode); + if (__tmp >= 0) + { + // Seek successful. + __ret = __tmp; + __ret += max(_M_out_cur, _M_in_cur) - _M_filepos; + } } } _M_last_overflowed = false; @@ -473,6 +525,7 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_filebuf<char>; extern template class basic_ifstream<char>; extern template class basic_ofstream<char>; @@ -484,6 +537,7 @@ namespace std extern template class basic_ofstream<wchar_t>; extern template class basic_fstream<wchar_t>; #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/gslice_array.h b/contrib/libstdc++/include/bits/gslice_array.h index 8989ac5200ef..1116e9c7e97d 100644 --- a/contrib/libstdc++/include/bits/gslice_array.h +++ b/contrib/libstdc++/include/bits/gslice_array.h @@ -41,129 +41,131 @@ namespace std { - template<typename _Tp> class gslice_array + 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; + 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&) 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; + template<class _Dom> + void operator>>=(const _Expr<_Dom,_Tp>&) const; private: - _Array<_Tp> _M_array; - const valarray<size_t>& _M_index; + _Array<_Tp> _M_array; + const valarray<size_t>& _M_index; - friend class valarray<_Tp>; - - gslice_array (_Array<_Tp>, const valarray<size_t>&); + friend class valarray<_Tp>; + + gslice_array(_Array<_Tp>, const valarray<size_t>&); - // this constructor needs to be implemented. - gslice_array (const gslice_array&); + // this constructor needs to be implemented. + gslice_array(const gslice_array&); - // not implemented - gslice_array(); - gslice_array& operator= (const gslice_array&); + // not implemented + gslice_array(); + gslice_array& operator= (const gslice_array&); }; - template<typename _Tp> + template<typename _Tp> inline - gslice_array<_Tp>::gslice_array (_Array<_Tp> __a, - const valarray<size_t>& __i) - : _M_array (__a), _M_index (__i) {} + gslice_array<_Tp>::gslice_array(_Array<_Tp> __a, + const valarray<size_t>& __i) + : _M_array(__a), _M_index(__i) {} - template<typename _Tp> + template<typename _Tp> inline - gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a) - : _M_array (__a._M_array), _M_index (__a._M_index) {} + gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a) + : _M_array(__a._M_array), _M_index(__a._M_index) {} - template<typename _Tp> + template<typename _Tp> inline void - gslice_array<_Tp>::operator= (const _Tp& __t) + gslice_array<_Tp>::operator=(const _Tp& __t) const { - __valarray_fill (_M_array, _Array<size_t>(_M_index), - _M_index.size(), __t); + __valarray_fill(_M_array, _Array<size_t>(_M_index), + _M_index.size(), __t); } - template<typename _Tp> + template<typename _Tp> inline void - gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const + gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const { - __valarray_copy (_Array<_Tp> (__v), __v.size (), - _M_array, _Array<size_t>(_M_index)); + __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)); - } + template<typename _Tp> + template<class _Dom> + inline void + gslice_array<_Tp>::operator=(const _Expr<_Dom, _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 ()); \ -} \ +#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) + template<typename _Tp> \ + template<class _Dom> \ + inline void \ + gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _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(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) #undef _DEFINE_VALARRAY_OPERATOR diff --git a/contrib/libstdc++/include/bits/indirect_array.h b/contrib/libstdc++/include/bits/indirect_array.h index a5737e9eb04d..9fc973e2bbca 100644 --- a/contrib/libstdc++/include/bits/indirect_array.h +++ b/contrib/libstdc++/include/bits/indirect_array.h @@ -1,6 +1,7 @@ // The template and inlines for the -*- C++ -*- indirect_array class. -// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// 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 @@ -48,70 +49,70 @@ namespace std typedef _Tp value_type; // XXX: This is a proposed resolution for DR-253. - indirect_array& operator= (const indirect_array&); - - 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& operator=(const indirect_array&); + + 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&) const; // ~indirect_array(); - + template<class _Dom> - void operator= (const _Expr<_Dom, _Tp>&) const; + void operator=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator*= (const _Expr<_Dom, _Tp>&) const; + void operator*=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator/= (const _Expr<_Dom, _Tp>&) const; + void operator/=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator%= (const _Expr<_Dom, _Tp>&) const; + void operator%=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator+= (const _Expr<_Dom, _Tp>&) const; + void operator+=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator-= (const _Expr<_Dom, _Tp>&) const; + void operator-=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator^= (const _Expr<_Dom, _Tp>&) const; + void operator^=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator&= (const _Expr<_Dom, _Tp>&) const; + void operator&=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator|= (const _Expr<_Dom, _Tp>&) const; + void operator|=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator<<= (const _Expr<_Dom, _Tp>&) const; + void operator<<=(const _Expr<_Dom, _Tp>&) const; template<class _Dom> - void operator>>= (const _Expr<_Dom, _Tp>&) const; + void operator>>=(const _Expr<_Dom, _Tp>&) const; private: - indirect_array (const indirect_array&); - indirect_array (_Array<_Tp>, size_t, _Array<size_t>); + 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(); }; 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) {} + 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) {} + 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>& @@ -124,46 +125,47 @@ namespace std template<typename _Tp> inline void - indirect_array<_Tp>::operator= (const _Tp& __t) + indirect_array<_Tp>::operator=(const _Tp& __t) const { __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); } + 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); } + 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); \ -} \ +#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) + 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(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) #undef _DEFINE_VALARRAY_OPERATOR diff --git a/contrib/libstdc++/include/bits/ios_base.h b/contrib/libstdc++/include/bits/ios_base.h index a56475ccef60..3437f847c4a8 100644 --- a/contrib/libstdc++/include/bits/ios_base.h +++ b/contrib/libstdc++/include/bits/ios_base.h @@ -1,6 +1,6 @@ // Iostreams base classes -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -43,6 +43,8 @@ #pragma GCC system_header #include <bits/atomicity.h> +#include <bits/localefwd.h> +#include <bits/locale_classes.h> namespace std { @@ -145,11 +147,20 @@ namespace std enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 }; // 27.4.2 Class ios_base + /** + * @brief The very top of the I/O class hierarchy. + * + * This class defines everything that can be defined about I/O that does + * not depend on the type of characters being input or output. Most + * people will only see @c ios_base when they need to specify the full + * name of the various I/O flags (e.g., the openmodes). + */ class ios_base { public: // 27.4.2.1.1 Class ios_base::failure + /// These are thrown to indicate problems. Doc me. class failure : public exception { public: @@ -173,50 +184,152 @@ namespace std }; // 27.4.2.1.2 Type ios_base::fmtflags + /** + * @brief This is a bitmask type. + * + * @c "_Ios_Fmtflags" is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type fmtflags are: + * - boolalpha + * - dec + * - fixed + * - hex + * - internal + * - left + * - oct + * - right + * - scientific + * - showbase + * - showpoint + * - showpos + * - skipws + * - unitbuf + * - uppercase + * - adjustfield + * - basefield + * - floatfield + */ typedef _Ios_Fmtflags fmtflags; - // 27.4.2.1.2 Type fmtflags + /// Insert/extract @c bool in alphabetic rather than numeric format. static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha); + /// Converts integer input or generates integer output in decimal base. static const fmtflags dec = fmtflags(__ios_flags::_S_dec); + /// Generate floating-point output in fixed-point notation. static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed); + /// Converts integer input or generates integer output in hexadecimal base. static const fmtflags hex = fmtflags(__ios_flags::_S_hex); + /// Adds fill characters at a designated internal point in certain + /// generated output, or identical to @c right if no such point is + /// designated. static const fmtflags internal = fmtflags(__ios_flags::_S_internal); + /// Adds fill characters on the right (final positions) of certain + /// generated output. (I.e., the thing you print is flush left.) static const fmtflags left = fmtflags(__ios_flags::_S_left); + /// Converts integer input or generates integer output in octal base. static const fmtflags oct = fmtflags(__ios_flags::_S_oct); + /// Adds fill characters on the left (initial positions) of certain + /// generated output. (I.e., the thing you print is flush right.) static const fmtflags right = fmtflags(__ios_flags::_S_right); + /// Generates floating-point output in scientific notation. static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific); + /// Generates a prefix indicating the numeric base of generated integer + /// output. static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase); + /// Generates a decimal-point character unconditionally in generated + /// floating-point output. static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint); + /// Generates a + sign in non-negative generated numeric output. static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos); + /// Skips leading white space before certain input operations. static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws); + /// Flushes output after each output operation. static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf); + /// Replaces certain lowercase letters with their uppercase equivalents + /// in generated output. static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase); + /// A mask of left|right|internal. Useful for the 2-arg form of @c setf. static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield); + /// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf. static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield); + /// A mask of scientific|fixed. Useful for the 2-arg form of @c setf. static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield); // 27.4.2.1.3 Type ios_base::iostate + /** + * @brief This is a bitmask type. + * + * @c "_Ios_Iostate" is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type iostate are: + * - badbit + * - eofbit + * - failbit + * - goodbit + */ typedef _Ios_Iostate iostate; + /// Indicates a loss of integrity in an input or output sequence (such + /// as an irrecoverable read error from a file). static const iostate badbit = iostate(__ios_flags::_S_badbit); + /// Indicates that an input operation reached the end of an input sequence. static const iostate eofbit = iostate(__ios_flags::_S_eofbit); + /// Indicates that an input operation failed to read the expected + /// characters, or that an output operation failed to generate the + /// desired characters. static const iostate failbit = iostate(__ios_flags::_S_failbit); + /// Indicates all is well. static const iostate goodbit = iostate(0); - // 27.4.2.1.4 Type openmode + // 27.4.2.1.4 Type ios_base::openmode + /** + * @brief This is a bitmask type. + * + * @c "_Ios_Openmode" is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type openmode are: + * - app + * - ate + * - binary + * - in + * - out + * - trunc + */ typedef _Ios_Openmode openmode; + /// Seek to end before each write. static const openmode app = openmode(__ios_flags::_S_app); + /// Open and seek to end immediately after opening. static const openmode ate = openmode(__ios_flags::_S_ate); + /// Perform input and output in binary mode (as opposed to text mode). + /// This is probably not what you think it is; see + /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#3 and + /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#7 for more. static const openmode binary = openmode(__ios_flags::_S_bin); + /// Open for input. Default for @c ifstream and fstream. static const openmode in = openmode(__ios_flags::_S_in); + /// Open for output. Default for @c ofstream and fstream. static const openmode out = openmode(__ios_flags::_S_out); + /// Open for input. Default for @c ofstream. static const openmode trunc = openmode(__ios_flags::_S_trunc); - // 27.4.2.1.5 Type seekdir + // 27.4.2.1.5 Type ios_base::seekdir + /** + * @brief This is an enumerated type. + * + * @c "_Ios_Seekdir" is implementation-defined. Defined values + * of type seekdir are: + * - beg + * - cur, equivalent to @c SEEK_CUR in the C standard library. + * - end, equivalent to @c SEEK_END in the C standard library. + */ typedef _Ios_Seekdir seekdir; + /// Request a seek relative to the beginning of the stream. static const seekdir beg = seekdir(0); + /// Request a seek relative to the current position within the sequence. static const seekdir cur = seekdir(SEEK_CUR); + /// Request a seek relative to the current end of the sequence. static const seekdir end = seekdir(SEEK_END); #ifdef _GLIBCPP_DEPRECATED + // Annex D.6 typedef int io_state; typedef int open_mode; typedef int seek_dir; @@ -226,6 +339,9 @@ namespace std #endif // Callbacks; + /** + * @doctodo + */ enum event { erase_event, @@ -233,18 +349,30 @@ namespace std copyfmt_event }; + /** + * @doctodo + */ typedef void (*event_callback) (event, ios_base&, int); + /** + * @doctodo + */ void register_callback(event_callback __fn, int __index); protected: - // Data Members + //@{ + /** + * @if maint + * ios_base data members (doc me) + * @endif + */ streamsize _M_precision; streamsize _M_width; fmtflags _M_flags; iostate _M_exception; iostate _M_streambuf_state; + //@} // 27.4.2.6 Members for callbacks // 27.4.2.6 ios_base callbacks @@ -288,6 +416,7 @@ namespace std _Words _M_word_zero; // Guaranteed storage. + // The first 5 iword and pword slots are reserved for internal use. static const int _S_local_word_size = 8; _Words _M_local_word[_S_local_word_size]; @@ -323,15 +452,32 @@ namespace std static void _S_ios_destroy(); + // NB: Allows debugger applications use of the standard streams + // from operator new. _S_ios_base_init must be incremented in + // _S_ios_create _after_ initialization is completed. + static bool + _S_initialized() { return _S_ios_base_init; } + private: static int _S_ios_base_init; static bool _S_synced_with_stdio; }; - // Fmtflags state: + // [27.4.2.2] fmtflags state functions + /** + * @brief Access to format flags. + * @return The format control flags for both input and output. + */ inline fmtflags flags() const { return _M_flags; } + /** + * @brief Setting new format flags all at once. + * @param fmtfl The new flags to set. + * @return The previous format control flags. + * + * This function overwrites all the format flags with @a fmtfl. + */ inline fmtflags flags(fmtflags __fmtfl) { @@ -340,6 +486,14 @@ namespace std return __old; } + /** + * @brief Setting new format flags. + * @param fmtfl Additional flags to set. + * @return The previous format control flags. + * + * This function sets additional flags in format control. Flags that + * were previously set remain set. + */ inline fmtflags setf(fmtflags __fmtfl) { @@ -348,6 +502,15 @@ namespace std return __old; } + /** + * @brief Setting new format flags. + * @param fmtfl Additional flags to set. + * @param mask The flags mask for @a fmtfl. + * @return The previous format control flags. + * + * This function clears @a mask in the format flags, then sets + * @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield. + */ inline fmtflags setf(fmtflags __fmtfl, fmtflags __mask) { @@ -357,12 +520,32 @@ namespace std return __old; } + /** + * @brief Clearing format flags. + * @param mask The flags to unset. + * + * This function clears @a mask in the format flags. + */ inline void unsetf(fmtflags __mask) { _M_flags &= ~__mask; } + /** + * @brief Flags access. + * @return The precision to generate on certain output operations. + * + * @if maint + * Be careful if you try to give a definition of "precision" here; see + * DR 189. + * @endif + */ inline streamsize precision() const { return _M_precision; } + /** + * @brief Changing flags. + * @param prec The new precision value. + * @return The previous value of precision(). + */ inline streamsize precision(streamsize __prec) { @@ -371,9 +554,20 @@ namespace std return __old; } + /** + * @brief Flags access. + * @return The minimum field width to generate on output operations. + * + * "Minimum field width" refers to the number of characters. + */ inline streamsize width() const { return _M_width; } + /** + * @brief Changing flags. + * @param wide The new width value. + * @return The previous value of width(). + */ inline streamsize width(streamsize __wide) { @@ -382,20 +576,63 @@ namespace std return __old; } + // [27.4.2.4] ios_base static members + /** + * @brief Interaction with the standard C I/O objects. + * @param sync Whether to synchronize or not. + * @return True if the standard streams were previously synchronized. + * + * The synchronization referred to is @e only that between the standard + * C facilities (e.g., stdout) and the standard C++ objects (e.g., + * cout). User-declared streams are unaffected. See + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#8 for more. + */ static bool sync_with_stdio(bool __sync = true); - // Locales: + // [27.4.2.3] ios_base locale functions + /** + * @brief Setting a new locale. + * @param loc The new locale. + * @return The previous locale. + * + * Sets the new locale for this stream, and + * [XXX does something with callbacks]. + */ locale imbue(const locale& __loc); + /** + * @brief Locale access + * @return A copy of the current locale. + * + * If @c imbue(loc) has previously been called, then this function + * returns @c loc. Otherwise, it returns a copy of @c std::locale(), + * the global C++ locale. + */ inline locale getloc() const { return _M_ios_locale; } - // Storage: + /** + * @brief Locale access + * @return A reference to the current locale. + * + * Like getloc above, but returns a reference instead of + * generating a copy. + */ + inline const locale& + _M_getloc() const { return _M_ios_locale; } + + // [27.4.2.5] ios_base storage functions + /** + * @doctodo + */ static int xalloc() throw(); + /** + * @doctodo + */ inline long& iword(int __ix) { @@ -404,6 +641,9 @@ namespace std return __word._M_iword; } + /** + * @doctodo + */ inline void*& pword(int __ix) { @@ -413,6 +653,10 @@ namespace std } // Destructor + /** + * Destroys local storage and + * [XXX does something with callbacks]. + */ ~ios_base(); protected: @@ -428,7 +672,8 @@ namespace std #endif }; - // 27.4.5.1 fmtflags manipulators: + // [27.4.5.1] fmtflags manipulators + /// Calls base.setf(ios_base::boolalpha). inline ios_base& boolalpha(ios_base& __base) { @@ -436,6 +681,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::boolalpha). inline ios_base& noboolalpha(ios_base& __base) { @@ -443,6 +689,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::showbase). inline ios_base& showbase(ios_base& __base) { @@ -450,6 +697,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::showbase). inline ios_base& noshowbase(ios_base& __base) { @@ -457,6 +705,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::showpoint). inline ios_base& showpoint(ios_base& __base) { @@ -464,6 +713,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::showpoint). inline ios_base& noshowpoint(ios_base& __base) { @@ -471,6 +721,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::showpos). inline ios_base& showpos(ios_base& __base) { @@ -478,6 +729,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::showpos). inline ios_base& noshowpos(ios_base& __base) { @@ -485,6 +737,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::skipws). inline ios_base& skipws(ios_base& __base) { @@ -492,6 +745,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::skipws). inline ios_base& noskipws(ios_base& __base) { @@ -499,6 +753,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::uppercase). inline ios_base& uppercase(ios_base& __base) { @@ -506,6 +761,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::uppercase). inline ios_base& nouppercase(ios_base& __base) { @@ -513,6 +769,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::unitbuf). inline ios_base& unitbuf(ios_base& __base) { @@ -520,6 +777,7 @@ namespace std return __base; } + /// Calls base.unsetf(ios_base::unitbuf). inline ios_base& nounitbuf(ios_base& __base) { @@ -527,7 +785,8 @@ namespace std return __base; } - // 27.4.5.2 adjustfield anipulators: + // [27.4.5.2] adjustfield anipulators + /// Calls base.setf(ios_base::internal, ios_base::adjustfield). inline ios_base& internal(ios_base& __base) { @@ -535,6 +794,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::left, ios_base::adjustfield). inline ios_base& left(ios_base& __base) { @@ -542,6 +802,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::right, ios_base::adjustfield). inline ios_base& right(ios_base& __base) { @@ -549,7 +810,8 @@ namespace std return __base; } - // 27.4.5.3 basefield anipulators: + // [27.4.5.3] basefield anipulators + /// Calls base.setf(ios_base::dec, ios_base::basefield). inline ios_base& dec(ios_base& __base) { @@ -557,6 +819,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::hex, ios_base::basefield). inline ios_base& hex(ios_base& __base) { @@ -564,6 +827,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::oct, ios_base::basefield). inline ios_base& oct(ios_base& __base) { @@ -571,7 +835,8 @@ namespace std return __base; } - // 27.4.5.4 floatfield anipulators: + // [27.4.5.4] floatfield anipulators + /// Calls base.setf(ios_base::fixed, ios_base::floatfield). inline ios_base& fixed(ios_base& __base) { @@ -579,6 +844,7 @@ namespace std return __base; } + /// Calls base.setf(ios_base::scientific, ios_base::floatfield). inline ios_base& scientific(ios_base& __base) { diff --git a/contrib/libstdc++/include/bits/istream.tcc b/contrib/libstdc++/include/bits/istream.tcc index a6e49a923bd2..7ba67354978b 100644 --- a/contrib/libstdc++/include/bits/istream.tcc +++ b/contrib/libstdc++/include/bits/istream.tcc @@ -1,6 +1,6 @@ // istream classes -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -118,11 +118,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -155,11 +155,11 @@ namespace std #endif this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -182,11 +182,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -219,11 +219,11 @@ namespace std #endif this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -246,11 +246,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -273,11 +273,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -300,11 +300,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -328,11 +328,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -355,11 +355,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -383,11 +383,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -410,11 +410,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -437,11 +437,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -464,11 +464,11 @@ namespace std _M_fnumget->get(*this, 0, *this, __err, __n); this->setstate(__err); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -495,11 +495,11 @@ namespace std if (!__sbout || !__xtrct) this->setstate(ios_base::failbit); } - catch(exception& __fail) + catch(...) { // 27.6.2.5.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -527,11 +527,11 @@ namespace std else this->setstate(ios_base::eofbit | ios_base::failbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -561,11 +561,11 @@ namespace std else this->setstate(ios_base::eofbit | ios_base::failbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -600,11 +600,11 @@ namespace std if (traits_type::eq_int_type(__c, __eof)) this->setstate(ios_base::eofbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -643,11 +643,11 @@ namespace std if (traits_type::eq_int_type(__c, __eof)) this->setstate(ios_base::eofbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -694,11 +694,11 @@ namespace std this->setstate(ios_base::failbit); } } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -735,11 +735,11 @@ namespace std if (traits_type::eq_int_type(__c, __eof)) this->setstate(ios_base::eofbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -759,11 +759,11 @@ namespace std { try { __c = this->rdbuf()->sgetc(); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -786,11 +786,11 @@ namespace std if (_M_gcount != __n) this->setstate(ios_base::eofbit | ios_base::failbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -822,11 +822,11 @@ namespace std else this->setstate(ios_base::eofbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -841,6 +841,10 @@ namespace std basic_istream<_CharT, _Traits>:: putback(char_type __c) { +#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS +// 60. What is a formatted input function? + _M_gcount = 0; +#endif sentry __cerb(*this, true); if (__cerb) { @@ -852,11 +856,11 @@ namespace std || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -871,7 +875,10 @@ namespace std basic_istream<_CharT, _Traits>:: unget(void) { +#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS +// 60. What is a formatted input function? _M_gcount = 0; +#endif sentry __cerb(*this, true); if (__cerb) { @@ -883,11 +890,11 @@ namespace std || traits_type::eq_int_type(__sb->sungetc(), __eof)) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -902,8 +909,8 @@ namespace std basic_istream<_CharT, _Traits>:: sync(void) { + // DR60. Do not change _M_gcount. int __ret = -1; - _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { @@ -918,11 +925,11 @@ namespace std __ret = 0; } } - catch(exception& __fail) + catch(...) { // 27.6.1.3 paragraph 1 // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -935,6 +942,7 @@ namespace std basic_istream<_CharT, _Traits>:: tellg(void) { + // DR60. Do not change _M_gcount. pos_type __ret = pos_type(-1); if (!this->fail()) __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); @@ -947,7 +955,7 @@ namespace std basic_istream<_CharT, _Traits>:: seekg(pos_type __pos) { - _M_gcount = 0; + // DR60. Do not change _M_gcount. if (!this->fail()) { #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS @@ -967,7 +975,7 @@ namespace std basic_istream<_CharT, _Traits>:: seekg(off_type __off, ios_base::seekdir __dir) { - _M_gcount = 0; + // DR60. Do not change _M_gcount. if (!this->fail()) { #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS @@ -994,11 +1002,11 @@ namespace std { try { __in.get(__c); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __in.setstate(ios_base::badbit); + __in._M_setstate(ios_base::badbit); if ((__in.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -1026,7 +1034,7 @@ namespace std { // Figure out how many characters to extract. streamsize __num = __in.width(); - if (__num == 0) + if (__num <= 0) __num = numeric_limits<streamsize>::max(); const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc()); @@ -1036,9 +1044,9 @@ namespace std while (__extracted < __num - 1 && !_Traits::eq_int_type(__c, __eof) - && !__ctype.is(ctype_base::space, __c)) + && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c))) { - *__s++ = __c; + *__s++ = _Traits::to_char_type(__c); ++__extracted; __c = __sb->snextc(); } @@ -1051,11 +1059,11 @@ namespace std #endif __in.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __in.setstate(ios_base::badbit); + __in._M_setstate(ios_base::badbit); if ((__in.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -1081,7 +1089,7 @@ namespace std __int_type __c = __sb->sgetc(); while (!_Traits::eq_int_type(__c, __eof) - && __ctype.is(ctype_base::space, __c)) + && __ctype.is(ctype_base::space, _Traits::to_char_type(__c))) __c = __sb->snextc(); if (_Traits::eq_int_type(__c, __eof)) @@ -1119,7 +1127,7 @@ namespace std while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) - && !__ctype.is(ctype_base::space, __c)) + && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c))) { __str += _Traits::to_char_type(__c); ++__extracted; @@ -1189,6 +1197,7 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_istream<char>; extern template istream& ws(istream&); extern template istream& operator>>(istream&, char&); @@ -1204,4 +1213,5 @@ namespace std extern template wistream& operator>>(wistream&, wchar_t&); extern template wistream& operator>>(wistream&, wchar_t*); #endif +#endif } // namespace std diff --git a/contrib/libstdc++/include/bits/list.tcc b/contrib/libstdc++/include/bits/list.tcc new file mode 100644 index 000000000000..898a5020c23b --- /dev/null +++ b/contrib/libstdc++/include/bits/list.tcc @@ -0,0 +1,368 @@ +// List implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001, 2002 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. + +/* + * + * 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. + */ + +/** @file list.tcc + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +#ifndef __GLIBCPP_INTERNAL_LIST_TCC +#define __GLIBCPP_INTERNAL_LIST_TCC + +namespace std +{ + template<typename _Tp, typename _Alloc> + void + _List_base<_Tp,_Alloc>:: + __clear() + { + typedef _List_node<_Tp> _Node; + _Node* __cur = static_cast<_Node*>(_M_node->_M_next); + while (__cur != _M_node) + { + _Node* __tmp = __cur; + __cur = static_cast<_Node*>(__cur->_M_next); + _Destroy(&__tmp->_M_data); + _M_put_node(__tmp); + } + _M_node->_M_next = _M_node; + _M_node->_M_prev = _M_node; + } + + template<typename _Tp, typename _Alloc> + typename list<_Tp,_Alloc>::iterator + list<_Tp,_Alloc>:: + insert(iterator __position, const value_type& __x) + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_next = __position._M_node; + __tmp->_M_prev = __position._M_node->_M_prev; + __position._M_node->_M_prev->_M_next = __tmp; + __position._M_node->_M_prev = __tmp; + return __tmp; + } + + template<typename _Tp, typename _Alloc> + typename list<_Tp,_Alloc>::iterator + list<_Tp,_Alloc>:: + erase(iterator __position) + { + _List_node_base* __next_node = __position._M_node->_M_next; + _List_node_base* __prev_node = __position._M_node->_M_prev; + _Node* __n = static_cast<_Node*>(__position._M_node); + __prev_node->_M_next = __next_node; + __next_node->_M_prev = __prev_node; + _Destroy(&__n->_M_data); + _M_put_node(__n); + return iterator(static_cast<_Node*>(__next_node)); + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + resize(size_type __new_size, const value_type& __x) + { + iterator __i = begin(); + size_type __len = 0; + for ( ; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + insert(end(), __new_size - __len, __x); + } + + template<typename _Tp, typename _Alloc> + list<_Tp,_Alloc>& + list<_Tp,_Alloc>:: + operator=(const list& __x) + { + if (this != &__x) + { + iterator __first1 = begin(); + iterator __last1 = end(); + const_iterator __first2 = __x.begin(); + const_iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + *__first1++ = *__first2++; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + return *this; + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + _M_fill_assign(size_type __n, const value_type& __val) + { + iterator __i = begin(); + for ( ; __i != end() && __n > 0; ++__i, --__n) + *__i = __val; + if (__n > 0) + insert(end(), __n, __val); + else + erase(__i, end()); + } + + template<typename _Tp, typename _Alloc> + template <typename _InputIter> + void + list<_Tp,_Alloc>:: + _M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type) + { + iterator __first1 = begin(); + iterator __last1 = end(); + for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + remove(const value_type& __value) + { + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (*__first == __value) + erase(__first); + __first = __next; + } + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + unique() + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) return; + iterator __next = __first; + while (++__next != __last) + { + if (*__first == *__next) + erase(__next); + else + __first = __next; + __next = __first; + } + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + merge(list& __x) + { + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (*__first2 < *__first1) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + _M_transfer(__last1, __first2, __last2); + } + + // FIXME put this somewhere else + inline void + __List_base_reverse(_List_node_base* __p) + { + _List_node_base* __tmp = __p; + do { + std::swap(__tmp->_M_next, __tmp->_M_prev); + __tmp = __tmp->_M_prev; // Old next node is now prev. + } while (__tmp != __p); + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp,_Alloc>:: + sort() + { + // Do nothing if the list has length 0 or 1. + if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) + { + list __carry; + list __counter[64]; + int __fill = 0; + while (!empty()) + { + __carry.splice(__carry.begin(), *this, begin()); + int __i = 0; + while(__i < __fill && !__counter[__i].empty()) + { + __counter[__i].merge(__carry); + __carry.swap(__counter[__i++]); + } + __carry.swap(__counter[__i]); + if (__i == __fill) ++__fill; + } + + for (int __i = 1; __i < __fill; ++__i) + __counter[__i].merge(__counter[__i-1]); + swap(__counter[__fill-1]); + } + } + + template<typename _Tp, typename _Alloc> + template <typename _Predicate> + void + list<_Tp,_Alloc>:: + remove_if(_Predicate __pred) + { + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (__pred(*__first)) erase(__first); + __first = __next; + } + } + + template<typename _Tp, typename _Alloc> + template <typename _BinaryPredicate> + void + list<_Tp,_Alloc>:: + unique(_BinaryPredicate __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) return; + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + erase(__next); + else + __first = __next; + __next = __first; + } + } + + template<typename _Tp, typename _Alloc> + template <typename _StrictWeakOrdering> + void + list<_Tp,_Alloc>:: + merge(list& __x, _StrictWeakOrdering __comp) + { + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (__comp(*__first2, *__first1)) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) _M_transfer(__last1, __first2, __last2); + } + + template<typename _Tp, typename _Alloc> + template <typename _StrictWeakOrdering> + void + list<_Tp,_Alloc>:: + sort(_StrictWeakOrdering __comp) + { + // Do nothing if the list has length 0 or 1. + if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) + { + list __carry; + list __counter[64]; + int __fill = 0; + while (!empty()) + { + __carry.splice(__carry.begin(), *this, begin()); + int __i = 0; + while(__i < __fill && !__counter[__i].empty()) + { + __counter[__i].merge(__carry, __comp); + __carry.swap(__counter[__i++]); + } + __carry.swap(__counter[__i]); + if (__i == __fill) ++__fill; + } + + for (int __i = 1; __i < __fill; ++__i) + __counter[__i].merge(__counter[__i-1], __comp); + swap(__counter[__fill-1]); + } + } +} // namespace std + +#endif /* __GLIBCPP_INTERNAL_LIST_TCC */ diff --git a/contrib/libstdc++/include/bits/locale_classes.h b/contrib/libstdc++/include/bits/locale_classes.h new file mode 100644 index 000000000000..ddd23fb9726a --- /dev/null +++ b/contrib/libstdc++/include/bits/locale_classes.h @@ -0,0 +1,404 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 +// 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: 22.1 Locales +// + +/** @file localefwd.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +#ifndef _CPP_BITS_LOCALE_CLASSES_H +#define _CPP_BITS_LOCALE_CLASSES_H 1 + +#pragma GCC system_header + +#include <bits/localefwd.h> +#include <cstring> // For strcmp. +#include <string> +#include <bits/atomicity.h> + +namespace std +{ + class __locale_cache_base; + template<typename _Facet> class __locale_cache; + + // 22.1.1 Class locale + class locale + { + public: + // Types: + typedef unsigned int category; + + // Forward decls and friends: + class facet; + class id; + class _Impl; + + friend class facet; + friend class _Impl; + + template<typename _Facet> + friend const _Facet& + use_facet(const locale&); + + template<typename _Facet> + friend bool + has_facet(const locale&) throw(); + + template<typename _Facet> + friend const __locale_cache<_Facet>& + __use_cache(const locale&); + + // Category values: + // NB: Order must match _S_facet_categories definition in locale.cc + static const category none = 0; + static const category ctype = 1L << 0; + static const category numeric = 1L << 1; + static const category collate = 1L << 2; + static const category time = 1L << 3; + static const category monetary = 1L << 4; + static const category messages = 1L << 5; + static const category all = (ctype | numeric | collate | + time | monetary | messages); + + // Construct/copy/destroy: + locale() throw(); + + locale(const locale& __other) throw(); + + explicit + locale(const char* __s); + + locale(const locale& __base, const char* __s, category __cat); + + locale(const locale& __base, const locale& __add, category __cat); + + template<typename _Facet> + locale(const locale& __other, _Facet* __f); + + ~locale() throw(); + + const locale& + operator=(const locale& __other) throw(); + + template<typename _Facet> + locale + combine(const locale& __other) const; + + // Locale operations: + string + name() const; + + bool + operator==(const locale& __other) const throw (); + + inline bool + operator!=(const locale& __other) const throw () + { return !(this->operator==(__other)); } + + template<typename _Char, typename _Traits, typename _Alloc> + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; + + // Global locale objects: + static locale + global(const locale&); + + static const locale& + classic(); + + private: + // The (shared) implementation + _Impl* _M_impl; + + // The "C" reference locale + static _Impl* _S_classic; + + // Current global locale + static _Impl* _S_global; + + // Number of standard categories. For C++, these categories are + // collate, ctype, monetary, numeric, time, and messages. These + // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE, + // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE + // 1003.1-2001) specifies LC_MESSAGES. + static const size_t _S_categories_size = 6; + + // In addition to the standard categories, the underlying + // operating system is allowed to define extra LC_* + // macros. For GNU systems, the following are also valid: + // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, + // and LC_IDENTIFICATION. + static const size_t _S_extra_categories_size = _GLIBCPP_NUM_CATEGORIES; + + // Names of underlying locale categories. + // NB: locale::global() has to know how to modify all the + // underlying categories, not just the ones required by the C++ + // standard. + static const char* _S_categories[_S_categories_size + + _S_extra_categories_size]; + + explicit + locale(_Impl*) throw(); + + static inline void + _S_initialize() + { + if (!_S_classic) + classic(); + } + + static category + _S_normalize_category(category); + + void + _M_coalesce(const locale& __base, const locale& __add, category __cat); + }; + + + // Implementation object for locale + class locale::_Impl + { + public: + // Friends. + friend class locale; + friend class locale::facet; + + template<typename _Facet> + friend const _Facet& + use_facet(const locale&); + + template<typename _Facet> + friend bool + has_facet(const locale&) throw(); + + template<typename _Facet> + friend const __locale_cache<_Facet>& + __use_cache(const locale&); + + private: + // Data Members. + _Atomic_word _M_references; + facet** _M_facets; + size_t _M_facets_size; + + char* _M_names[_S_categories_size + + _S_extra_categories_size]; + static const locale::id* const _S_id_ctype[]; + static const locale::id* const _S_id_numeric[]; + static const locale::id* const _S_id_collate[]; + static const locale::id* const _S_id_time[]; + static const locale::id* const _S_id_monetary[]; + static const locale::id* const _S_id_messages[]; + static const locale::id* const* const _S_facet_categories[]; + + inline void + _M_add_reference() throw() + { __atomic_add(&_M_references, 1); } + + inline void + _M_remove_reference() throw() + { + if (__exchange_and_add(&_M_references, -1) == 1) + { + try + { delete this; } + catch(...) + { } + } + } + + _Impl(const _Impl&, size_t); + _Impl(const char*, size_t); + _Impl(facet**, size_t, bool); + + ~_Impl() throw(); + + _Impl(const _Impl&); // Not defined. + + void + operator=(const _Impl&); // Not defined. + + inline bool + _M_check_same_name() + { + bool __ret = true; + for (size_t __i = 0; + __ret && __i < _S_categories_size + _S_extra_categories_size - 1; + ++__i) + __ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0); + return __ret; + } + + void + _M_replace_categories(const _Impl*, category); + + void + _M_replace_category(const _Impl*, const locale::id* const*); + + void + _M_replace_facet(const _Impl*, const locale::id*); + + void + _M_install_facet(const locale::id*, facet*); + + template<typename _Facet> + inline void + _M_init_facet(_Facet* __facet) + { _M_install_facet(&_Facet::id, __facet); } + + // Retrieve the cache at __index. 0 is returned if the cache is + // missing. Cache is actually located at __index + + // _M_facets_size. __index must be < _M_facets_size. + inline __locale_cache_base* + _M_get_cache(size_t __index) + { + return (__locale_cache_base*)_M_facets[__index + _M_facets_size]; + } + + // Save the supplied cache at __id. Assumes _M_get_cache has been + // called. + void + _M_install_cache(__locale_cache_base* __cache, int __id) + { + _M_facets[__id + _M_facets_size] = + reinterpret_cast<locale::facet*>(__cache); + } + + }; + + template<typename _Facet> + locale::locale(const locale& __other, _Facet* __f) + { + _M_impl = new _Impl(*__other._M_impl, 1); + _M_impl->_M_install_facet(&_Facet::id, __f); + for (size_t __i = 0; + __i < _S_categories_size + _S_extra_categories_size; ++__i) + { + delete [] _M_impl->_M_names[__i]; + char* __new = new char[2]; + strcpy(__new, "*"); + _M_impl->_M_names[__i] = __new; + } + } + + + // 22.1.1.1.2 Class locale::facet + class locale::facet + { + private: + friend class locale; + friend class locale::_Impl; + + _Atomic_word _M_references; + + protected: + // Contains data from the underlying "C" library for the classic locale. + static __c_locale _S_c_locale; + + // String literal for the name of the classic locale. + static char _S_c_name[2]; + + explicit + facet(size_t __refs = 0) throw(); + + virtual + ~facet(); + + static void + _S_create_c_locale(__c_locale& __cloc, const char* __s, + __c_locale __old = 0); + + static __c_locale + _S_clone_c_locale(__c_locale& __cloc); + + static void + _S_destroy_c_locale(__c_locale& __cloc); + + private: + void + _M_add_reference() throw(); + + void + _M_remove_reference() throw(); + + facet(const facet&); // Not defined. + + void + operator=(const facet&); // Not defined. + }; + + + // 22.1.1.1.3 Class locale::id + class locale::id + { + private: + friend class locale; + friend class locale::_Impl; + template<typename _Facet> + friend const _Facet& + use_facet(const locale&); + template<typename _Facet> + friend bool + has_facet(const locale&) throw (); + + // NB: There is no accessor for _M_index because it may be used + // before the constructor is run; the effect of calling a member + // function (even an inline) would be undefined. + mutable size_t _M_index; + + // Last id number assigned. + static _Atomic_word _S_highwater; + + void + operator=(const id&); // Not defined. + + id(const id&); // Not defined. + + public: + // NB: This class is always a static data member, and thus can be + // counted on to be zero-initialized. + id(); + + inline size_t + _M_id() const + { + if (!_M_index) + _M_index = 1 + __exchange_and_add(&_S_highwater, 1); + return _M_index - 1; + } + }; +} // namespace std + +#endif diff --git a/contrib/libstdc++/include/bits/locale_facets.h b/contrib/libstdc++/include/bits/locale_facets.h index 6e42b3bb5eae..37f6875bc252 100644 --- a/contrib/libstdc++/include/bits/locale_facets.h +++ b/contrib/libstdc++/include/bits/locale_facets.h @@ -1,6 +1,6 @@ // Locale support -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -44,7 +44,9 @@ #include <ctime> // For struct tm #include <cwctype> // For wctype_t -#include <ios> // For ios_base +#include <iosfwd> +#include <bits/ios_base.h> // For ios_base, ios_base::iostate +#include <streambuf> namespace std { @@ -55,8 +57,109 @@ namespace std # define _GLIBCPP_NUM_FACETS 14 #endif + // Convert string to numeric value of type _Tv and store results. + // NB: This is specialized for all required types, there is no + // generic definition. + template<typename _Tv> + void + __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, + const __c_locale& __cloc, int __base = 10); + + // Explicit specializations for required types. + template<> + void + __convert_to_v(const char*, long&, ios_base::iostate&, + const __c_locale&, int); + + template<> + void + __convert_to_v(const char*, unsigned long&, ios_base::iostate&, + const __c_locale&, int); + +#ifdef _GLIBCPP_USE_LONG_LONG + template<> + void + __convert_to_v(const char*, long long&, ios_base::iostate&, + const __c_locale&, int); + + template<> + void + __convert_to_v(const char*, unsigned long long&, ios_base::iostate&, + const __c_locale&, int); +#endif + + template<> + void + __convert_to_v(const char*, float&, ios_base::iostate&, + const __c_locale&, int); + + template<> + void + __convert_to_v(const char*, double&, ios_base::iostate&, + const __c_locale&, int); + + template<> + void + __convert_to_v(const char*, long double&, ios_base::iostate&, + const __c_locale&, int); + + // NB: __pad is a struct, rather than a function, so it can be + // partially-specialized. template<typename _CharT, typename _Traits> - struct __pad; + struct __pad + { + static void + _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, + const _CharT* __olds, const streamsize __newlen, + const streamsize __oldlen, const bool __num); + }; + + // Used by both numeric and monetary facets. + // Check to make sure that the __grouping_tmp string constructed in + // money_get or num_get matches the canonical grouping for a given + // locale. + // __grouping_tmp is parsed L to R + // 1,222,444 == __grouping_tmp of "\1\3\3" + // __grouping is parsed R to L + // 1,222,444 == __grouping of "\3" == "\3\3\3" + template<typename _CharT> + bool + __verify_grouping(const basic_string<_CharT>& __grouping, + basic_string<_CharT>& __grouping_tmp); + + // Used by both numeric and monetary facets. + // Inserts "group separator" characters into an array of characters. + // It's recursive, one iteration per group. It moves the characters + // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this + // only with __gbeg != __gend. + template<typename _CharT> + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, const char* __gend, + const _CharT* __first, const _CharT* __last); + + // This template permits specializing facet output code for + // ostreambuf_iterator. For ostreambuf_iterator, sputn is + // significantly more efficient than incrementing iterators. + template<typename _CharT> + inline + ostreambuf_iterator<_CharT> + __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) + { + __s._M_put(__ws, __len); + return __s; + } + + // This is the unspecialized form of the template. + template<typename _CharT, typename _OutIter> + inline + _OutIter + __write(_OutIter __s, const _CharT* __ws, int __len) + { + for (int __j = 0; __j < __len; __j++, ++__s) + *__s = __ws[__j]; + return __s; + } // 22.2.1.1 Template class ctype // Include host and configuration specific ctype enums for ctype_base. @@ -424,14 +527,38 @@ namespace std // 22.2.1.5 Template class codecvt #include <bits/codecvt.h> - // 22.2.2 The numeric category. class __num_base { + public: + // NB: Code depends on the order of _S_atoms_out elements. + // Below are the indices into _S_atoms_out. + enum + { + _S_minus, + _S_plus, + _S_x, + _S_X, + _S_digits, + _S_digits_end = _S_digits + 16, + _S_udigits = _S_digits_end, + _S_udigits_end = _S_udigits + 16, + _S_e = _S_digits + 14, // For scientific notation, 'e' + _S_E = _S_udigits + 14, // For scientific notation, 'E' + _S_end = _S_udigits_end + }; + + // A list of valid numeric literals for output. This array + // contains chars that will be passed through the current locale's + // ctype<_CharT>.widen() and then used to render numbers. + // For the standard "C" locale, this is + // "-+xX0123456789abcdef0123456789ABCDEF". + static const char* _S_atoms_out; + protected: // String literal of acceptable (narrow) input, for num_get. // "0123456789eEabcdfABCDF" - static const char _S_atoms[]; + static const char* _S_atoms_in; enum { @@ -443,7 +570,7 @@ namespace std // num_put // Construct and return valid scanf format for floating point types. - static bool + static void _S_format_float(const ios_base& __io, char* __fptr, char __mod, streamsize __prec); @@ -454,6 +581,9 @@ namespace std template<typename _CharT> + class __locale_cache; + + template<typename _CharT> class numpunct : public locale::facet { public: @@ -461,6 +591,8 @@ namespace std typedef _CharT char_type; typedef basic_string<_CharT> string_type; + friend class __locale_cache<numpunct<_CharT> >; + static locale::id id; private: @@ -725,7 +857,6 @@ namespace std // Types: typedef _CharT char_type; typedef _OutIter iter_type; - static locale::id id; explicit @@ -775,6 +906,27 @@ namespace std _M_convert_float(iter_type, ios_base& __io, char_type __fill, char __mod, _ValueT __v) const; + void + _M_group_float(const string& __grouping, char_type __sep, + const char_type* __p, char_type* __new, char_type* __cs, + int& __len) const; + + template<typename _ValueT> + iter_type + _M_convert_int(iter_type, ios_base& __io, char_type __fill, + _ValueT __v) const; + + void + _M_group_int(const string& __grouping, char_type __sep, + ios_base& __io, char_type* __new, char_type* __cs, + int& __len) const; + + void + _M_pad(char_type __fill, streamsize __w, ios_base& __io, + char_type* __new, const char_type* __cs, int& __len) const; + +#if 1 + // XXX GLIBCXX_ABI Deprecated, compatibility only. template<typename _ValueT> iter_type _M_convert_int(iter_type, ios_base& __io, char_type __fill, @@ -791,8 +943,9 @@ namespace std iter_type _M_insert(iter_type, ios_base& __io, char_type __fill, const char_type* __ws, int __len) const; +#endif - virtual + virtual ~num_put() { }; virtual iter_type @@ -1805,6 +1958,93 @@ namespace std inline _CharT tolower(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).tolower(__c); } + + /** + * @if maint + * __locale_cache objects hold information extracted from facets in + * a form optimized for parsing and formatting. They are stored in + * a locale's facet array and accessed via __use_cache<_Facet>. + * + * The intent twofold: to avoid the costs of creating a locale + * object and to avoid calling the virtual functions in a locale's + * facet to look up data. + * @endif + */ + class __locale_cache_base + { + friend class std::locale::_Impl; + friend class locale; + + public: + virtual + ~__locale_cache_base() { } + + }; + + // This template doesn't really get used for anything except a + // placeholder for specializations + template<typename _Facet> + class __locale_cache : public __locale_cache_base + { + // ctor + __locale_cache(const locale&) {} + }; + + template<typename _CharT> + class __locale_cache<numpunct<_CharT> > : public __locale_cache_base + { + // Types: + typedef _CharT char_type; + typedef char_traits<_CharT> traits_type; + typedef basic_string<_CharT> string_type; + + public: + // Data Members: + + // The sign used to separate decimal values: for standard US + // locales, this would usually be: "." Abstracted from + // numpunct::decimal_point(). + _CharT _M_decimal_point; + + // The sign used to separate groups of digits into smaller + // strings that the eye can parse with less difficulty: for + // standard US locales, this would usually be: "," Abstracted + // from numpunct::thousands_sep(). + _CharT _M_thousands_sep; + + // However the US's "false" and "true" are translated. From + // numpunct::truename() and numpunct::falsename(), respectively. + const _CharT* _M_truename; + const _CharT* _M_falsename; + + // If we are checking groupings. This should be equivalent to + // numpunct::groupings().size() != 0 + bool _M_use_grouping; + + // If we are using numpunct's groupings, this is the current + // grouping string in effect (from numpunct::grouping()). + const char* _M_grouping; + + // A list of valid numeric literals: for the standard "C" + // locale, this is "-+xX0123456789abcdef0123456789ABCDEF". This + // array contains the chars after having been passed through the + // current locale's ctype<_CharT>.widen(). + + // Copied here from __locale_cache<ctype> to save multiple cache + // access in num_put functions. + _CharT _M_atoms_out[__num_base::_S_end]; + + // ctor + __locale_cache(const locale& __loc); + __locale_cache(const locale& __loc, bool); + + ~__locale_cache() + { + delete [] _M_truename; + delete [] _M_falsename; + delete [] _M_grouping; + } + }; } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/locale_facets.tcc b/contrib/libstdc++/include/bits/locale_facets.tcc index 1bf3d7ce7962..b8b9918741ff 100644 --- a/contrib/libstdc++/include/bits/locale_facets.tcc +++ b/contrib/libstdc++/include/bits/locale_facets.tcc @@ -1,6 +1,6 @@ // Locale support -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -36,13 +36,13 @@ #pragma GCC system_header #include <cerrno> -#include <clocale> // For localeconv -#include <cstdlib> // For strof, strtold -#include <cmath> // For ceil -#include <cctype> // For isspace -#include <limits> // For numeric_limits +#include <clocale> // For localeconv +#include <cstdlib> // For strof, strtold +#include <cmath> // For ceil +#include <cctype> // For isspace +#include <limits> // For numeric_limits +#include <typeinfo> // For bad_cast. #include <bits/streambuf_iterator.h> -#include <typeinfo> // For bad_cast. namespace std { @@ -86,6 +86,23 @@ namespace std return (__i < __loc._M_impl->_M_facets_size && __facets[__i]); } + // Routine to access a cache for the locale. If the cache didn't + // exist before, it gets constructed on the fly. + template<typename _Facet> + inline const __locale_cache<_Facet>& + __use_cache(const locale& __loc) + { + size_t __i = _Facet::id._M_id(); + if (__builtin_expect(__i >= __loc._M_impl->_M_facets_size,false)) + __throw_bad_cast(); + __locale_cache_base* __cache = __loc._M_impl->_M_get_cache(__i); + if (__builtin_expect(!__cache, false)) + { + __cache = new __locale_cache<_Facet>(__loc); + __loc._M_impl->_M_install_cache(__cache, __i); + } + return static_cast<const __locale_cache<_Facet>&>(*__cache); + } // Stage 1: Determine a conversion specifier. template<typename _CharT, typename _InIter> @@ -113,7 +130,7 @@ namespace std } // Next, strip leading zeros. - const char_type __zero = __ctype.widen(_S_atoms[_M_zero]); + const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]); bool __found_zero = false; while (__traits_type::eq(__c, __zero) && __beg != __end) { @@ -122,14 +139,14 @@ namespace std } if (__found_zero) { - __xtrc += _S_atoms[_M_zero]; + __xtrc += _S_atoms_in[_M_zero]; ++__pos; } // Only need acceptable digits for floating point numbers. const size_t __len = _M_E - _M_zero + 1; char_type __watoms[__len]; - __ctype.widen(_S_atoms, _S_atoms + __len, __watoms); + __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms); bool __found_dec = false; bool __found_sci = false; const char_type __dec = __np.decimal_point(); @@ -150,7 +167,7 @@ namespace std { // Try first for acceptable digit; record it if found. ++__pos; - __xtrc += _S_atoms[__p - __watoms]; + __xtrc += _S_atoms_in[__p - __watoms]; ++__sep_pos; __c = *(++__beg); } @@ -261,7 +278,7 @@ namespace std } // Next, strip leading zeros and check required digits for base formats. - const char_type __zero = __ctype.widen(_S_atoms[_M_zero]); + const char_type __zero = __ctype.widen(_S_atoms_in[_M_zero]); const char_type __x = __ctype.widen('x'); const char_type __X = __ctype.widen('X'); if (__base == 10) @@ -274,7 +291,7 @@ namespace std } if (__found_zero) { - __xtrc += _S_atoms[_M_zero]; + __xtrc += _S_atoms_in[_M_zero]; ++__pos; if (__basefield == 0) { @@ -296,7 +313,7 @@ namespace std { if (__traits_type::eq(__c, __zero) && __beg != __end) { - __xtrc += _S_atoms[_M_zero]; + __xtrc += _S_atoms_in[_M_zero]; ++__pos; __c = *(++__beg); if ((__traits_type::eq(__c, __x) || __traits_type::eq(__c, __X)) @@ -319,7 +336,7 @@ namespace std // Extract. char_type __watoms[_M_size]; - __ctype.widen(_S_atoms, _S_atoms + __len, __watoms); + __ctype.widen(_S_atoms_in, _S_atoms_in + __len, __watoms); string __found_grouping; const string __grouping = __np.grouping(); bool __check_grouping = __grouping.size(); @@ -333,7 +350,7 @@ namespace std if (__p && !__traits_type::eq(__c, char_type())) { // Try first for acceptable digit; record it if found. - __xtrc += _S_atoms[__p - __watoms]; + __xtrc += _S_atoms_in[__p - __watoms]; ++__pos; ++__sep_pos; __c = *(++__beg); @@ -606,14 +623,251 @@ namespace std return __beg; } - // The following code uses snprintf (or sprintf(), when _GLIBCPP_USE_C99 - // is not defined) to convert floating point values for insertion into a - // stream. An optimization would be to replace them with code that works - // directly on a wide buffer and then use __pad to do the padding. - // It would be good to replace them anyway to gain back the efficiency - // that C++ provides by knowing up front the type of the values to insert. - // Also, sprintf is dangerous since may lead to accidental buffer overruns. - // This implementation follows the C++ standard fairly directly as + // For use by integer and floating-point types after they have been + // converted into a char_type string. + template<typename _CharT, typename _OutIter> + void + num_put<_CharT, _OutIter>:: + _M_pad(_CharT __fill, streamsize __w, ios_base& __io, + _CharT* __new, const _CharT* __cs, int& __len) const + { + // [22.2.2.2.2] Stage 3. + // If necessary, pad. + __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs, + __w, __len, true); + __len = static_cast<int>(__w); + } + + // Forwarding functions to peel signed from unsigned integer types. + template<typename _CharT> + inline int + __int_to_char(_CharT* __out, const int __size, long __v, + const _CharT* __lit, ios_base::fmtflags __flags) + { + unsigned long __ul = static_cast<unsigned long>(__v); + bool __neg = false; + if (__v < 0) + { + __ul = -__ul; + __neg = true; + } + return __int_to_char(__out, __size, __ul, __lit, __flags, __neg); + } + + template<typename _CharT> + inline int + __int_to_char(_CharT* __out, const int __size, unsigned long __v, + const _CharT* __lit, ios_base::fmtflags __flags) + { return __int_to_char(__out, __size, __v, __lit, __flags, false); } + +#ifdef _GLIBCPP_USE_LONG_LONG + template<typename _CharT> + inline int + __int_to_char(_CharT* __out, const int __size, long long __v, + const _CharT* __lit, ios_base::fmtflags __flags) + { + unsigned long long __ull = static_cast<unsigned long long>(__v); + bool __neg = false; + if (__v < 0) + { + __ull = -__ull; + __neg = true; + } + return __int_to_char(__out, __size, __ull, __lit, __flags, __neg); + } + + template<typename _CharT> + inline int + __int_to_char(_CharT* __out, const int __size, unsigned long long __v, + const _CharT* __lit, ios_base::fmtflags __flags) + { return __int_to_char(__out, __size, __v, __lit, __flags, false); } +#endif + + template<typename _CharT, typename _ValueT> + int + __int_to_char(_CharT* __out, const int __size, _ValueT __v, + const _CharT* __lit, ios_base::fmtflags __flags, bool __neg) + { + // Don't write base if already 0. + const bool __showbase = (__flags & ios_base::showbase) && __v; + const ios_base::fmtflags __basefield = __flags & ios_base::basefield; + _CharT* __buf = __out + __size - 1; + _CharT* __bufend = __out + __size; + + if (__builtin_expect(__basefield != ios_base::oct && + __basefield != ios_base::hex, true)) + { + // Decimal. + do + { + *__buf-- = __lit[(__v % 10) + __num_base::_S_digits]; + __v /= 10; + } + while (__v != 0); + if (__neg) + *__buf-- = __lit[__num_base::_S_minus]; + else if (__flags & ios_base::showpos) + *__buf-- = __lit[__num_base::_S_plus]; + } + else if (__basefield == ios_base::oct) + { + // Octal. + do + { + *__buf-- = __lit[(__v & 0x7) + __num_base::_S_digits]; + __v >>= 3; + } + while (__v != 0); + if (__showbase) + *__buf-- = __lit[__num_base::_S_digits]; + } + else + { + // Hex. + const bool __uppercase = __flags & ios_base::uppercase; + int __case_offset = __uppercase + ? __num_base::_S_udigits : __num_base::_S_digits; + do + { + *__buf-- = __lit[(__v & 0xf) + __case_offset]; + __v >>= 4; + } + while (__v != 0); + if (__showbase) + { + // 'x' or 'X' + *__buf-- = __lit[__num_base::_S_x + __uppercase]; + // '0' + *__buf-- = __lit[__num_base::_S_digits]; + } + } + int __ret = __bufend - __buf - 1; + return __ret; + } + + template<typename _CharT, typename _OutIter> + void + num_put<_CharT, _OutIter>:: + _M_group_int(const string& __grouping, _CharT __sep, ios_base& __io, + _CharT* __new, _CharT* __cs, int& __len) const + { + // By itself __add_grouping cannot deal correctly with __ws when + // ios::showbase is set and ios_base::oct || ios_base::hex. + // Therefore we take care "by hand" of the initial 0, 0x or 0X. + // However, remember that the latter do not occur if the number + // printed is '0' (__len == 1). + streamsize __off = 0; + const ios_base::fmtflags __basefield = __io.flags() + & ios_base::basefield; + if ((__io.flags() & ios_base::showbase) && __len > 1) + if (__basefield == ios_base::oct) + { + __off = 1; + *__new = *__cs; + } + else if (__basefield == ios_base::hex) + { + __off = 2; + *__new = *__cs; + *(__new + 1) = *(__cs + 1); + } + _CharT* __p; + __p = __add_grouping(__new + __off, __sep, + __grouping.c_str(), + __grouping.c_str() + __grouping.size(), + __cs + __off, __cs + __len); + __len = __p - __new; + } + + template<typename _CharT, typename _OutIter> + template<typename _ValueT> + _OutIter + num_put<_CharT, _OutIter>:: + _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, + _ValueT __v) const + { + typedef numpunct<_CharT> __facet_type; + typedef __locale_cache<numpunct<_CharT> > __cache_type; + const locale& __loc = __io._M_getloc(); + const __cache_type& __lc = __use_cache<__facet_type>(__loc); + const _CharT* __lit = __lc._M_atoms_out; + + // Long enough to hold hex, dec, and octal representations. + int __ilen = 4 * sizeof(_ValueT); + _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __ilen)); + // [22.2.2.2.2] Stage 1, numeric conversion to character. + // Result is returned right-justified in the buffer. + int __len; + __len = __int_to_char(&__cs[0], __ilen, __v, __lit, __io.flags()); + __cs = __cs + __ilen - __len; + + // Add grouping, if necessary. + _CharT* __cs2; + if (__lc._M_use_grouping) + { + // Grouping can add (almost) as many separators as the + // number of digits, but no more. + __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + _M_group_int(__lc._M_grouping, __lc._M_thousands_sep, __io, + __cs2, __cs, __len); + __cs = __cs2; + } + + // Pad. + _CharT* __cs3; + streamsize __w = __io.width(); + if (__w > static_cast<streamsize>(__len)) + { + __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs = __cs3; + } + __io.width(0); + + // [22.2.2.2.2] Stage 4. + // Write resulting, fully-formatted string to output iterator. + return __write(__s, __cs, __len); + } + + template<typename _CharT, typename _OutIter> + void + num_put<_CharT, _OutIter>:: + _M_group_float(const string& __grouping, _CharT __sep, const _CharT* __p, + _CharT* __new, _CharT* __cs, int& __len) const + { +#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS + //282. What types does numpunct grouping refer to? + // Add grouping, if necessary. + _CharT* __p2; + int __declen = __p ? __p - __cs : __len; + __p2 = __add_grouping(__new, __sep, + __grouping.c_str(), + __grouping.c_str() + __grouping.size(), + __cs, __cs + __declen); + + // Tack on decimal part. + int __newlen = __p2 - __new; + if (__p) + { + char_traits<_CharT>::copy(__p2, __p, __len - __declen); + __newlen += __len - __declen; + } + __len = __newlen; +#endif + } + + // The following code uses snprintf (or sprintf(), when + // _GLIBCPP_USE_C99 is not defined) to convert floating point values + // for insertion into a stream. An optimization would be to replace + // them with code that works directly on a wide buffer and then use + // __pad to do the padding. It would be good to replace them anyway + // to gain back the efficiency that C++ provides by knowing up front + // the type of the values to insert. Also, sprintf is dangerous + // since may lead to accidental buffer overruns. This + // implementation follows the C++ standard fairly directly as // outlined in 22.2.2.2 [lib.locale.num.put] template<typename _CharT, typename _OutIter> template<typename _ValueT> @@ -622,53 +876,55 @@ namespace std _M_convert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, _ValueT __v) const { - // Note: digits10 is rounded down: we need to add 1 to ensure - // we get the full available precision. - // Then, in general, one more 1 needs to be added since, when the - // %{g,G} conversion specifiers are chosen inside _S_format_float, the - // precision field is "the maximum number of significant digits", *not* - // the "number of digits to appear after the decimal point", as happens - // for %{e,E,f,F} (C99, 7.19.6.1,4). + // Note: digits10 is rounded down: add 1 to ensure the maximum + // available precision. Then, in general, one more 1 needs to + // be added since, when the %{g,G} conversion specifiers are + // chosen inside _S_format_float, the precision field is "the + // maximum number of significant digits", *not* the "number of + // digits to appear after the decimal point", as happens for + // %{e,E,f,F} (C99, 7.19.6.1,4). const int __max_digits = numeric_limits<_ValueT>::digits10 + 2; - streamsize __prec = __io.precision(); + // Use default precision if out of range. + streamsize __prec = __io.precision(); if (__prec > static_cast<streamsize>(__max_digits)) __prec = static_cast<streamsize>(__max_digits); + else if (__prec < static_cast<streamsize>(0)) + __prec = static_cast<streamsize>(6); - // Long enough for the max format spec. - char __fbuf[16]; + typedef numpunct<_CharT> __facet_type; + typedef __locale_cache<numpunct<_CharT> > __cache_type; + const locale __loc = __io._M_getloc(); + const __cache_type& __lc = __use_cache<__facet_type>(__loc); // [22.2.2.2.2] Stage 1, numeric conversion to character. int __len; + // Long enough for the max format spec. + char __fbuf[16]; + #ifdef _GLIBCPP_USE_C99 - // First try a buffer perhaps big enough (for sure sufficient for - // non-ios_base::fixed outputs) + // First try a buffer perhaps big enough (for sure sufficient + // for non-ios_base::fixed outputs) int __cs_size = __max_digits * 3; char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); - const bool __fp = _S_format_float(__io, __fbuf, __mod, __prec); - if (__fp) - __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, - _S_c_locale, __prec); - else - __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, _S_c_locale); + _S_format_float(__io, __fbuf, __mod, __prec); + __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, + _S_c_locale, __prec); // If the buffer was not large enough, try again with the correct size. if (__len >= __cs_size) { __cs_size = __len + 1; __cs = static_cast<char*>(__builtin_alloca(__cs_size)); - if (__fp) - __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, - _S_c_locale, __prec); - else - __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, - _S_c_locale); + __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, + _S_c_locale, __prec); } #else // Consider the possibility of long ios_base::fixed outputs const bool __fixed = __io.flags() & ios_base::fixed; const int __max_exp = numeric_limits<_ValueT>::max_exponent10; + // ios_base::fixed outputs may need up to __max_exp+1 chars // for the integer part + up to __max_digits chars for the // fractional part + 3 chars for sign, decimal point, '\0'. On @@ -678,187 +934,53 @@ namespace std : __max_digits * 3; char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); - if (_S_format_float(__io, __fbuf, __mod, __prec)) - __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale, __prec); - else - __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale); + _S_format_float(__io, __fbuf, __mod, __prec); + __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale, __prec); #endif - return _M_widen_float(__s, __io, __fill, __cs, __len); - } - template<typename _CharT, typename _OutIter> - template<typename _ValueT> - _OutIter - num_put<_CharT, _OutIter>:: - _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, - char __modl, _ValueT __v) const - { - // [22.2.2.2.2] Stage 1, numeric conversion to character. - - // Long enough for the max format spec. - char __fbuf[16]; - _S_format_int(__io, __fbuf, __mod, __modl); -#ifdef _GLIBCPP_USE_C99 - // First try a buffer perhaps big enough. - int __cs_size = 64; - char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); - int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, - _S_c_locale); - // If the buffer was not large enough, try again with the correct size. - if (__len >= __cs_size) - { - __cs_size = __len + 1; - __cs = static_cast<char*>(__builtin_alloca(__cs_size)); - __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, - _S_c_locale); - } -#else - // Leave room for "+/-," "0x," and commas. This size is - // arbitrary, but should be largely sufficient. - char __cs[128]; - int __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale); -#endif - return _M_widen_int(__s, __io, __fill, __cs, __len); - } - - template<typename _CharT, typename _OutIter> - _OutIter - num_put<_CharT, _OutIter>:: - _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, - int __len) const - { - typedef char_traits<_CharT> __traits_type; // [22.2.2.2.2] Stage 2, convert to char_type, using correct // numpunct.decimal_point() values for '.' and adding grouping. - const locale __loc = __io.getloc(); const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len)); - // Grouping can add (almost) as many separators as the number of - // digits, but no more. - _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len * 2)); __ctype.widen(__cs, __cs + __len, __ws); // Replace decimal point. + const _CharT __cdec = __ctype.widen('.'); + const _CharT __dec = __lc._M_decimal_point; const _CharT* __p; - const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); - if (__p = __traits_type::find(__ws, __len, __ctype.widen('.'))) - __ws[__p - __ws] = __np.decimal_point(); + if (__p = char_traits<_CharT>::find(__ws, __len, __cdec)) + __ws[__p - __ws] = __dec; -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -//282. What types does numpunct grouping refer to? // Add grouping, if necessary. - const string __grouping = __np.grouping(); - ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield; - if (__grouping.size()) + _CharT* __ws2; + if (__lc._M_use_grouping) { - _CharT* __p2; - int __declen = __p ? __p - __ws : __len; - __p2 = __add_grouping(__ws2, __np.thousands_sep(), - __grouping.c_str(), - __grouping.c_str() + __grouping.size(), - __ws, __ws + __declen); - int __newlen = __p2 - __ws2; - - // Tack on decimal part. - if (__p) - { - __traits_type::copy(__p2, __p, __len - __declen); - __newlen += __len - __declen; - } - - // Switch strings, establish correct new length. - __ws = __ws2; - __len = __newlen; + // Grouping can add (almost) as many separators as the + // number of digits, but no more. + __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + _M_group_float(__lc._M_grouping, __lc._M_thousands_sep, __p, + __ws2, __ws, __len); + __ws = __ws2; } -#endif - return _M_insert(__s, __io, __fill, __ws, __len); - } - template<typename _CharT, typename _OutIter> - _OutIter - num_put<_CharT, _OutIter>:: - _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, - int __len) const - { - // [22.2.2.2.2] Stage 2, convert to char_type, using correct - // numpunct.decimal_point() values for '.' and adding grouping. - const locale __loc = __io.getloc(); - const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); - _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len)); - // Grouping can add (almost) as many separators as the number of - // digits, but no more. - _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len * 2)); - __ctype.widen(__cs, __cs + __len, __ws); - - // Add grouping, if necessary. - const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); - const string __grouping = __np.grouping(); - const ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield; - if (__grouping.size()) - { - // By itself __add_grouping cannot deal correctly with __ws when - // ios::showbase is set and ios_base::oct || ios_base::hex. - // Therefore we take care "by hand" of the initial 0, 0x or 0X. - // However, remember that the latter do not occur if the number - // printed is '0' (__len == 1). - streamsize __off = 0; - if ((__io.flags() & ios_base::showbase) && __len > 1) - if (__basefield == ios_base::oct) - { - __off = 1; - *__ws2 = *__ws; - } - else if (__basefield == ios_base::hex) - { - __off = 2; - *__ws2 = *__ws; - *(__ws2 + 1) = *(__ws + 1); - } - _CharT* __p; - __p = __add_grouping(__ws2 + __off, __np.thousands_sep(), - __grouping.c_str(), - __grouping.c_str() + __grouping.size(), - __ws + __off, __ws + __len); - __len = __p - __ws2; - // Switch strings. - __ws = __ws2; - } - return _M_insert(__s, __io, __fill, __ws, __len); - } - - // For use by integer and floating-point types after they have been - // converted into a char_type string. - template<typename _CharT, typename _OutIter> - _OutIter - num_put<_CharT, _OutIter>:: - _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws, - int __len) const - { - typedef char_traits<_CharT> __traits_type; - // [22.2.2.2.2] Stage 3. + // Pad. + _CharT* __ws3; streamsize __w = __io.width(); - _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __w)); if (__w > static_cast<streamsize>(__len)) { - __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws, - __w, __len, true); - __len = static_cast<int>(__w); - // Switch strings. - __ws = __ws2; + __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws = __ws3; } __io.width(0); - + // [22.2.2.2.2] Stage 4. // Write resulting, fully-formatted string to output iterator. - for (int __j = 0; __j < __len; ++__j, ++__s) - *__s = __ws[__j]; - return __s; - } + return __write(__s, __ws, __len); + } template<typename _CharT, typename _OutIter> _OutIter @@ -869,19 +991,35 @@ namespace std if ((__flags & ios_base::boolalpha) == 0) { unsigned long __uv = __v; - __s = _M_convert_int(__s, __io, __fill, 'u', char(), __uv); + __s = _M_convert_int(__s, __io, __fill, __uv); } else { - typedef basic_string<_CharT> __string_type; - locale __loc = __io.getloc(); - const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + typedef numpunct<_CharT> __facet_type; + typedef __locale_cache<numpunct<_CharT> > __cache_type; + const locale __loc = __io._M_getloc(); + const __cache_type& __lc = __use_cache<__facet_type>(__loc); + + typedef basic_string<_CharT> __string_type; __string_type __name; if (__v) - __name = __np.truename(); + __name = __lc._M_truename; else - __name = __np.falsename(); - __s = _M_insert(__s, __io, __fill, __name.c_str(), __name.size()); + __name = __lc._M_falsename; + + const _CharT* __cs = __name.c_str(); + int __len = __name.size(); + _CharT* __cs3; + streamsize __w = __io.width(); + if (__w > static_cast<streamsize>(__len)) + { + __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs = __cs3; + } + __io.width(0); + __s = __write(__s, __cs, __len); } return __s; } @@ -890,28 +1028,28 @@ namespace std _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const - { return _M_convert_int(__s, __io, __fill, 'd', char(), __v); } + { return _M_convert_int(__s, __io, __fill, __v); } template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long __v) const - { return _M_convert_int(__s, __io, __fill, 'u', char(), __v); } + { return _M_convert_int(__s, __io, __fill, __v); } #ifdef _GLIBCPP_USE_LONG_LONG template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const - { return _M_convert_int(__s, __b, __fill, 'd', 'l', __v); } + { return _M_convert_int(__s, __b, __fill, __v); } template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long long __v) const - { return _M_convert_int(__s, __io, __fill, 'u', 'l', __v); } + { return _M_convert_int(__s, __io, __fill, __v); } #endif template<typename _CharT, typename _OutIter> @@ -939,7 +1077,7 @@ namespace std __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase)); try { - __s = _M_convert_int(__s, __io, __fill, 'u', char(), + __s = _M_convert_int(__s, __io, __fill, reinterpret_cast<unsigned long>(__v)); __io.flags(__flags); } @@ -1196,7 +1334,8 @@ namespace std char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); int __len = __convert_from_v(__cs, 0, "%.01Lf", __units, _S_c_locale); #endif - _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __cs_size)); + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __cs_size)); __ctype.widen(__cs, __cs + __len, __ws); string_type __digits(__ws); return this->do_put(__s, __intl, __io, __fill, __digits); @@ -1290,7 +1429,7 @@ namespace std const char* __gend = __gbeg + __grouping.size(); const int __n = (__end - __beg) * 2; _CharT* __ws2 = - static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n)); + static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n)); _CharT* __ws_end = __add_grouping(__ws2, __sep, __gbeg, __gend, __beg, __end); __value.insert(0, __ws2, __ws_end - __ws2); @@ -1359,8 +1498,7 @@ namespace std } // Write resulting, fully-formatted string to output iterator. - for (size_type __j = 0; __j < __len; ++__j, ++__s) - *__s = __res[__j]; + __s = __write(__s, __res.c_str(), __len); } __io.width(0); return __s; @@ -1616,7 +1754,8 @@ namespace std ios_base::iostate& __err) const { typedef char_traits<_CharT> __traits_type; - int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int) * __indexlen)); + int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int) + * __indexlen)); size_t __nmatches = 0; size_t __pos = 0; bool __testvalid = true; @@ -1628,7 +1767,7 @@ namespace std if (__c == __names[__i1][0]) __matches[__nmatches++] = __i1; - while(__nmatches > 1) + while (__nmatches > 1) { // Find smallest matching string. size_t __minlen = 10; @@ -1853,8 +1992,7 @@ namespace std } else __format = __c; - __s = this->do_put(__s, __io, char_type(), __tm, __format, - __mod); + __s = this->do_put(__s, __io, _CharT(), __tm, __format, __mod); } else { @@ -1878,8 +2016,7 @@ namespace std // NB: This size is arbitrary. Should this be a data member, // initialized at construction? const size_t __maxlen = 64; - char_type* __res = - static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen)); + char_type* __res = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen)); // NB: In IEE 1003.1-200x, and perhaps other locale models, it // is possible that the format character will be longer than one @@ -1903,10 +2040,7 @@ namespace std __tp._M_put(__res, __maxlen, __fmt, __tm); // Write resulting, fully-formatted string to output iterator. - size_t __len = char_traits<char_type>::length(__res); - for (size_t __i = 0; __i < __len; ++__i, ++__s) - *__s = __res[__i]; - return __s; + return __write(__s, __res, char_traits<char_type>::length(__res)); } @@ -1928,9 +2062,37 @@ namespace std do_compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const { + // strcoll assumes zero-terminated strings so we make a copy + // and then put a zero at the end. const string_type __one(__lo1, __hi1); const string_type __two(__lo2, __hi2); - return _M_compare(__one.c_str(), __two.c_str()); + + const _CharT* __p = __one.c_str(); + const _CharT* __pend = __one.c_str() + __one.length(); + const _CharT* __q = __two.c_str(); + const _CharT* __qend = __two.c_str() + __two.length(); + + // strcoll stops when it sees a nul character so we break + // the strings into zero-terminated substrings and pass those + // to strcoll. + for (;;) + { + int __res = _M_compare(__p, __q); + if (__res) + return __res; + + __p += char_traits<_CharT>::length(__p); + __q += char_traits<_CharT>::length(__q); + if (__p == __pend && __q == __qend) + return 0; + else if (__p == __pend) + return -1; + else if (__q == __qend) + return 1; + + __p++; + __q++; + } } template<typename _CharT> @@ -1938,19 +2100,43 @@ namespace std collate<_CharT>:: do_transform(const _CharT* __lo, const _CharT* __hi) const { + // strxfrm assumes zero-terminated strings so we make a copy + string_type __str(__lo, __hi); + + const _CharT* __p = __str.c_str(); + const _CharT* __pend = __str.c_str() + __str.length(); + size_t __len = (__hi - __lo) * 2; - // First try a buffer perhaps big enough. - _CharT* __c = - static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len)); - size_t __res = _M_transform(__c, __lo, __len); - // If the buffer was not large enough, try again with the correct size. - if (__res >= __len) + + string_type __ret; + + // strxfrm stops when it sees a nul character so we break + // the string into zero-terminated substrings and pass those + // to strxfrm. + for (;;) { - __c = - static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__res + 1))); - _M_transform(__c, __lo, __res + 1); + // First try a buffer perhaps big enough. + _CharT* __c = + static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len)); + size_t __res = _M_transform(__c, __p, __len); + // If the buffer was not large enough, try again with the + // correct size. + if (__res >= __len) + { + __len = __res + 1; + __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __res = _M_transform(__c, __p, __res + 1); + } + + __ret.append(__c, __res); + __p += char_traits<_CharT>::length(__p); + if (__p == __pend) + return __ret; + + __p++; + __ret.push_back(_CharT()); } - return string_type(__c); } template<typename _CharT> @@ -1965,22 +2151,6 @@ namespace std return static_cast<long>(__val); } - // Convert string to numeric value of type _Tv and store results. - // NB: This is specialized for all required types, there is no - // generic definition. - template<typename _Tv> - void - __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, - const __c_locale& __cloc, int __base = 10); - - // Convert numeric value of type _Tv to string and return length of string. - // If snprintf is available use it, otherwise fall back to the unsafe sprintf - // which, in general, can be dangerous and should be avoided. - template<typename _Tv> - int - __convert_from_v(char* __out, const int __size, const char* __fmt, - _Tv __v, const __c_locale&, int __prec = -1); - // Construct correctly padded string, as per 22.2.2.2.2 // Assumes // __newlen > __oldlen @@ -1993,15 +2163,6 @@ namespace std // NB: Of the two parameters, _CharT can be deduced from the // function arguments. The other (_Traits) has to be explicitly specified. template<typename _CharT, typename _Traits> - struct __pad - { - static void - _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, - const _CharT* __olds, const streamsize __newlen, - const streamsize __oldlen, const bool __num); - }; - - template<typename _CharT, typename _Traits> void __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, @@ -2009,7 +2170,8 @@ namespace std const streamsize __oldlen, const bool __num) { size_t __plen = static_cast<size_t>(__newlen - __oldlen); - _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __plen)); + _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __plen)); _Traits::assign(__pads, __plen, __fill); _CharT* __beg; @@ -2079,14 +2241,6 @@ namespace std __newlen - __beglen - __mod); } - // Used by both numeric and monetary facets. - // Check to make sure that the __grouping_tmp string constructed in - // money_get or num_get matches the canonical grouping for a given - // locale. - // __grouping_tmp is parsed L to R - // 1,222,444 == __grouping_tmp of "/1/3/3" - // __grouping is parsed R to L - // 1,222,444 == __grouping of "/3" == "/3/3/3" template<typename _CharT> bool __verify_grouping(const basic_string<_CharT>& __grouping, @@ -2111,11 +2265,6 @@ namespace std return __test; } - // Used by both numeric and monetary facets. - // Inserts "group separator" characters into an array of characters. - // It's recursive, one iteration per group. It moves the characters - // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this - // only with __gbeg != __gend. template<typename _CharT> _CharT* __add_grouping(_CharT* __s, _CharT __sep, @@ -2136,9 +2285,249 @@ namespace std return __s; } +#if 1 + // XXX GLIBCXX_ABI Deprecated, compatibility only. + template<typename _CharT, typename _OutIter> + template<typename _ValueT> + _OutIter + num_put<_CharT, _OutIter>:: + _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, + char __modl, _ValueT __v) const + { + // [22.2.2.2.2] Stage 1, numeric conversion to character. + + // Long enough for the max format spec. + char __fbuf[16]; + _S_format_int(__io, __fbuf, __mod, __modl); +#ifdef _GLIBCPP_USE_C99 + // First try a buffer perhaps big enough. + int __cs_size = 64; + char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); + int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, + _S_c_locale); + // If the buffer was not large enough, try again with the correct size. + if (__len >= __cs_size) + { + __cs_size = __len + 1; + __cs = static_cast<char*>(__builtin_alloca(__cs_size)); + __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, + _S_c_locale); + } +#else + // Leave room for "+/-," "0x," and commas. This size is + // arbitrary, but should be largely sufficient. + char __cs[128]; + int __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale); +#endif + return _M_widen_int(__s, __io, __fill, __cs, __len); + } + + template<typename _CharT, typename _OutIter> + _OutIter + num_put<_CharT, _OutIter>:: + _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, + int __len) const + { + typedef char_traits<_CharT> __traits_type; + // [22.2.2.2.2] Stage 2, convert to char_type, using correct + // numpunct.decimal_point() values for '.' and adding grouping. + const locale __loc = __io.getloc(); + const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + // Grouping can add (almost) as many separators as the number of + // digits, but no more. + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + __ctype.widen(__cs, __cs + __len, __ws); + + // Replace decimal point. + const _CharT* __p; + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + if (__p = __traits_type::find(__ws, __len, __ctype.widen('.'))) + __ws[__p - __ws] = __np.decimal_point(); + +#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS +//282. What types does numpunct grouping refer to? + // Add grouping, if necessary. + const string __grouping = __np.grouping(); + if (__grouping.size()) + { + _CharT* __p2; + int __declen = __p ? __p - __ws : __len; + __p2 = __add_grouping(__ws2, __np.thousands_sep(), + __grouping.c_str(), + __grouping.c_str() + __grouping.size(), + __ws, __ws + __declen); + int __newlen = __p2 - __ws2; + + // Tack on decimal part. + if (__p) + { + __traits_type::copy(__p2, __p, __len - __declen); + __newlen += __len - __declen; + } + + // Switch strings, establish correct new length. + __ws = __ws2; + __len = __newlen; + } +#endif + return _M_insert(__s, __io, __fill, __ws, __len); + } + + template<typename _CharT, typename _OutIter> + _OutIter + num_put<_CharT, _OutIter>:: + _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, + int __len) const + { + // [22.2.2.2.2] Stage 2, convert to char_type, using correct + // numpunct.decimal_point() values for '.' and adding grouping. + const locale __loc = __io.getloc(); + const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + // Grouping can add (almost) as many separators as the number of + // digits, but no more. + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + __ctype.widen(__cs, __cs + __len, __ws); + + // Add grouping, if necessary. + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + const string __grouping = __np.grouping(); + if (__grouping.size()) + { + // By itself __add_grouping cannot deal correctly with __ws when + // ios::showbase is set and ios_base::oct || ios_base::hex. + // Therefore we take care "by hand" of the initial 0, 0x or 0X. + // However, remember that the latter do not occur if the number + // printed is '0' (__len == 1). + streamsize __off = 0; + const ios_base::fmtflags __basefield = __io.flags() + & ios_base::basefield; + if ((__io.flags() & ios_base::showbase) && __len > 1) + if (__basefield == ios_base::oct) + { + __off = 1; + *__ws2 = *__ws; + } + else if (__basefield == ios_base::hex) + { + __off = 2; + *__ws2 = *__ws; + *(__ws2 + 1) = *(__ws + 1); + } + _CharT* __p; + __p = __add_grouping(__ws2 + __off, __np.thousands_sep(), + __grouping.c_str(), + __grouping.c_str() + __grouping.size(), + __ws + __off, __ws + __len); + __len = __p - __ws2; + // Switch strings. + __ws = __ws2; + } + return _M_insert(__s, __io, __fill, __ws, __len); + } + + // For use by integer and floating-point types after they have been + // converted into a char_type string. + template<typename _CharT, typename _OutIter> + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws, + int __len) const + { + typedef char_traits<_CharT> __traits_type; + // [22.2.2.2.2] Stage 3. + // If necessary, pad. + streamsize __w = __io.width(); + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + if (__w > static_cast<streamsize>(__len)) + { + __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws, + __w, __len, true); + __len = static_cast<int>(__w); + // Switch strings. + __ws = __ws2; + } + __io.width(0); + + // [22.2.2.2.2] Stage 4. + // Write resulting, fully-formatted string to output iterator. + return __write(__s, __ws, __len); + } +#endif + + template<typename _CharT> + __locale_cache<numpunct<_CharT> >::__locale_cache(const locale& __loc) + : _M_truename(0), _M_falsename(0), _M_use_grouping(false), + _M_grouping(0) + { + if (has_facet<numpunct<_CharT> >(__loc)) + { + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + _M_decimal_point = __np.decimal_point(); + _M_thousands_sep = __np.thousands_sep(); + + string_type __false = __np.falsename(); + _CharT* __falsename = new _CharT[__false.length() + 1]; + __false.copy(__falsename, __false.length()); + __falsename[__false.length()] = _CharT(); + _M_falsename = __falsename; + + string_type __true = __np.truename(); + _CharT* __truename = new _CharT[__true.length() + 1]; + __true.copy(__truename, __true.length()); + __truename[__true.length()] = _CharT(); + _M_truename = __truename; + + string __grouping = __np.grouping(); + char* __group = new char[__grouping.length() + 1]; + __grouping.copy(__group, __grouping.length()); + __group[__grouping.length()] = 0; + _M_grouping = __group; + + _M_use_grouping = __grouping.length() != 0 + && __grouping.data()[0] != 0; + } + + if (has_facet<ctype<_CharT> >(__loc)) + { + const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc); + __ct.widen(__num_base::_S_atoms_out, + __num_base::_S_atoms_out + __num_base::_S_end, + _M_atoms_out); + } + } + + // Static locale cache initialization. Only instantiated with char + // and wchar_t, so no need to check has_facet. + template<typename _CharT> + __locale_cache<numpunct<_CharT> >:: + __locale_cache(const locale& __loc, bool) + { + // Grab pointers to numpunct static strings + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + _M_thousands_sep = __np._M_thousands_sep; + _M_decimal_point = __np._M_decimal_point; + _M_falsename = __np._M_falsename; + _M_truename = __np._M_truename; + _M_grouping = __np._M_grouping; + _M_use_grouping = false; + + const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc); + __ct.widen(__num_base::_S_atoms_out, + __num_base::_S_atoms_out + __num_base::_S_end, + _M_atoms_out); + } + // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class moneypunct<char, false>; extern template class moneypunct<char, true>; extern template class moneypunct_byname<char, false>; @@ -2392,6 +2781,7 @@ namespace std bool has_facet<messages<wchar_t> >(const locale&); #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/localefwd.h b/contrib/libstdc++/include/bits/localefwd.h index dedc76452360..ac9e1a95425a 100644 --- a/contrib/libstdc++/include/bits/localefwd.h +++ b/contrib/libstdc++/include/bits/localefwd.h @@ -1,6 +1,6 @@ // Locale support -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -37,18 +37,15 @@ * You should not attempt to use it directly. */ -#ifndef _CPP_BITS_LOCCORE_H -#define _CPP_BITS_LOCCORE_H 1 +#ifndef _CPP_BITS_LOCALE_FWD_H +#define _CPP_BITS_LOCALE_FWD_H 1 #pragma GCC system_header #include <bits/c++config.h> #include <bits/c++locale.h> // Defines __c_locale, config-specific includes -#include <climits> // For CHAR_BIT -#include <cctype> // For isspace, etc. -#include <string> // For string. +#include <iosfwd> // For ostreambuf_iterator, istreambuf_iterator #include <bits/functexcept.h> -#include <bits/atomicity.h> namespace std { @@ -108,7 +105,6 @@ namespace std inline _CharT tolower(_CharT, const locale&); - // 22.2.1 and 22.2.1.3 ctype class ctype_base; template<typename _CharT> @@ -175,327 +171,6 @@ namespace std template<typename _CharT> class messages_byname; - // 22.1.1 Class locale - class locale - { - public: - // Types: - typedef unsigned int category; - - // Forward decls and friends: - class facet; - class id; - class _Impl; - - friend class facet; - friend class _Impl; - - template<typename _Facet> - friend const _Facet& - use_facet(const locale&); - - template<typename _Facet> - friend bool - has_facet(const locale&) throw(); - - // Category values: - // NB: Order must match _S_facet_categories definition in locale.cc - static const category none = 0; - static const category ctype = 1L << 0; - static const category numeric = 1L << 1; - static const category collate = 1L << 2; - static const category time = 1L << 3; - static const category monetary = 1L << 4; - static const category messages = 1L << 5; - static const category all = (ctype | numeric | collate | - time | monetary | messages); - - // Construct/copy/destroy: - locale() throw(); - - locale(const locale& __other) throw(); - - explicit - locale(const char* __s); - - locale(const locale& __base, const char* __s, category __cat); - - locale(const locale& __base, const locale& __add, category __cat); - - template<typename _Facet> - locale(const locale& __other, _Facet* __f); - - ~locale() throw(); - - const locale& - operator=(const locale& __other) throw(); - - template<typename _Facet> - locale - combine(const locale& __other) const; - - // Locale operations: - string - name() const; - - bool - operator==(const locale& __other) const throw (); - - inline bool - operator!=(const locale& __other) const throw () - { return !(this->operator==(__other)); } - - template<typename _Char, typename _Traits, typename _Alloc> - bool - operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, - const basic_string<_Char, _Traits, _Alloc>& __s2) const; - - // Global locale objects: - static locale - global(const locale&); - - static const locale& - classic(); - - private: - // The (shared) implementation - _Impl* _M_impl; - - // The "C" reference locale - static _Impl* _S_classic; - - // Current global locale - static _Impl* _S_global; - - // Number of standard categories. For C++, these categories are - // collate, ctype, monetary, numeric, time, and messages. These - // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE, - // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE - // 1003.1-2001) specifies LC_MESSAGES. - static const size_t _S_categories_size = 6; - - // In addition to the standard categories, the underlying - // operating system is allowed to define extra LC_* - // macros. For GNU systems, the following are also valid: - // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, - // and LC_IDENTIFICATION. - static const size_t _S_extra_categories_size = _GLIBCPP_NUM_CATEGORIES; - - // Names of underlying locale categories. - // NB: locale::global() has to know how to modify all the - // underlying categories, not just the ones required by the C++ - // standard. - static const char* _S_categories[_S_categories_size - + _S_extra_categories_size]; - - explicit - locale(_Impl*) throw(); - - static inline void - _S_initialize() - { - if (!_S_classic) - classic(); - } - - static category - _S_normalize_category(category); - - void - _M_coalesce(const locale& __base, const locale& __add, category __cat); - }; - - - // Implementation object for locale - class locale::_Impl - { - public: - // Friends. - friend class locale; - friend class locale::facet; - - template<typename _Facet> - friend const _Facet& - use_facet(const locale&); - - template<typename _Facet> - friend bool - has_facet(const locale&) throw(); - - private: - // Data Members. - _Atomic_word _M_references; - facet** _M_facets; - size_t _M_facets_size; - - char* _M_names[_S_categories_size - + _S_extra_categories_size]; - static const locale::id* const _S_id_ctype[]; - static const locale::id* const _S_id_numeric[]; - static const locale::id* const _S_id_collate[]; - static const locale::id* const _S_id_time[]; - static const locale::id* const _S_id_monetary[]; - static const locale::id* const _S_id_messages[]; - static const locale::id* const* const _S_facet_categories[]; - - inline void - _M_add_reference() throw() - { __atomic_add(&_M_references, 1); } - - inline void - _M_remove_reference() throw() - { - if (__exchange_and_add(&_M_references, -1) == 1) - { - try - { delete this; } - catch(...) - { } - } - } - - _Impl(const _Impl&, size_t); - _Impl(const char*, size_t); - _Impl(facet**, size_t, bool); - - ~_Impl() throw(); - - _Impl(const _Impl&); // Not defined. - - void - operator=(const _Impl&); // Not defined. - - inline bool - _M_check_same_name() - { - bool __ret = true; - for (size_t __i = 0; - __ret && __i < _S_categories_size + _S_extra_categories_size - 1; - ++__i) - __ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0); - return __ret; - } - - void - _M_replace_categories(const _Impl*, category); - - void - _M_replace_category(const _Impl*, const locale::id* const*); - - void - _M_replace_facet(const _Impl*, const locale::id*); - - void - _M_install_facet(const locale::id*, facet*); - - template<typename _Facet> - inline void - _M_init_facet(_Facet* __facet) - { _M_install_facet(&_Facet::id, __facet); } - }; - - template<typename _Facet> - locale::locale(const locale& __other, _Facet* __f) - { - _M_impl = new _Impl(*__other._M_impl, 1); - _M_impl->_M_install_facet(&_Facet::id, __f); - for (size_t __i = 0; - __i < _S_categories_size + _S_extra_categories_size; ++__i) - { - delete [] _M_impl->_M_names[__i]; - char* __new = new char[2]; - strcpy(__new, "*"); - _M_impl->_M_names[__i] = __new; - } - } - - // 22.1.1.1.2 Class locale::facet - class locale::facet - { - private: - friend class locale; - friend class locale::_Impl; - - _Atomic_word _M_references; - - protected: - // Contains data from the underlying "C" library for for the - // classic locale. - static __c_locale _S_c_locale; - - // String literal for the name of the classic locale. - static char _S_c_name[2]; - - explicit - facet(size_t __refs = 0) throw(); - - virtual - ~facet(); - - static void - _S_create_c_locale(__c_locale& __cloc, const char* __s, - __c_locale __old = 0); - - static __c_locale - _S_clone_c_locale(__c_locale& __cloc); - - static void - _S_destroy_c_locale(__c_locale& __cloc); - - private: - void - _M_add_reference() throw(); - - void - _M_remove_reference() throw(); - - facet(const facet&); // Not defined. - - void - operator=(const facet&); // Not defined. - }; - - - // 22.1.1.1.3 Class locale::id - class locale::id - { - private: - friend class locale; - friend class locale::_Impl; - template<typename _Facet> - friend const _Facet& - use_facet(const locale&); - template<typename _Facet> - friend bool - has_facet(const locale&) throw (); - - // NB: There is no accessor for _M_index because it may be used - // before the constructor is run; the effect of calling a member - // function (even an inline) would be undefined. - mutable size_t _M_index; - - // Last id number assigned. - static _Atomic_word _S_highwater; - - void - operator=(const id&); // Not defined. - - id(const id&); // Not defined. - - public: - // NB: This class is always a static data member, and thus can be - // counted on to be zero-initialized. - id(); - - inline size_t - _M_id() const - { - if (!_M_index) - _M_index = 1 + __exchange_and_add(&_S_highwater, 1); - return _M_index - 1; - } - }; - template<typename _Facet> const _Facet& use_facet(const locale& __loc); diff --git a/contrib/libstdc++/include/bits/mask_array.h b/contrib/libstdc++/include/bits/mask_array.h index 13c01d3cc226..df23a46ef0bd 100644 --- a/contrib/libstdc++/include/bits/mask_array.h +++ b/contrib/libstdc++/include/bits/mask_array.h @@ -1,6 +1,7 @@ // The template and inlines for the -*- C++ -*- mask_array class. -// Copyright (C) 1997-2001 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// 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 @@ -41,120 +42,119 @@ namespace std { - template <class _Tp> class mask_array + template <class _Tp> + class mask_array { public: - typedef _Tp value_type; + 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&); + 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&) const; // ~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> + 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> + template<class _Dom> void operator>>=(const _Expr<_Dom,_Tp>&) const; private: - mask_array (_Array<_Tp>, size_t, _Array<bool>); - friend class valarray<_Tp>; + 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&); + 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(const mask_array<_Tp>& a) + : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {} - template<typename _Tp> + 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) {} + 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> + template<typename _Tp> inline void - mask_array<_Tp>::operator= (const _Tp& __t) - { __valarray_fill (_M_array, _M_sz, _M_mask, __t); } + mask_array<_Tp>::operator=(const _Tp& __t) const + { __valarray_fill(_M_array, _M_sz, _M_mask, __t); } - template<typename _Tp> + 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); } + 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); } + template<typename _Tp> + template<class _Ex> + inline void + mask_array<_Tp>::operator=(const _Expr<_Ex, _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 ()); \ -} \ +#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) + template<typename _Tp> \ + template<class _Dom> \ + inline void \ + mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _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(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) #undef _DEFINE_VALARRAY_OPERATOR diff --git a/contrib/libstdc++/include/bits/ostream.tcc b/contrib/libstdc++/include/bits/ostream.tcc index e42eca29192f..ab15ae8703be 100644 --- a/contrib/libstdc++/include/bits/ostream.tcc +++ b/contrib/libstdc++/include/bits/ostream.tcc @@ -41,11 +41,19 @@ namespace std template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>::sentry:: sentry(basic_ostream<_CharT,_Traits>& __os) - : _M_ok(__os.good()), _M_os(__os) + : _M_os(__os) { - // XXX MT - if (_M_ok && __os.tie()) - __os.tie()->flush(); + // XXX MT + if (__os.tie() && __os.good()) + __os.tie()->flush(); + + if (__os.good()) + _M_ok = true; + else + { + _M_ok = false; + __os.setstate(ios_base::failbit); + } } template<typename _CharT, typename _Traits> @@ -58,11 +66,11 @@ namespace std { try { __pf(*this); } - catch(exception& __fail) + catch(...) { // 27.6.2.5.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -80,11 +88,11 @@ namespace std { try { __pf(*this); } - catch(exception& __fail) + catch(...) { // 27.6.2.5.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -102,11 +110,11 @@ namespace std { try { __pf(*this); } - catch(exception& __fail) + catch(...) { // 27.6.2.5.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -126,11 +134,11 @@ namespace std if (!__copy_streambufs(*this, __sbin, this->rdbuf())) this->setstate(ios_base::failbit); } - catch(exception& __fail) + catch(...) { // 27.6.2.5.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -153,11 +161,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -190,11 +198,11 @@ namespace std this->setstate(ios_base::badbit); } } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -215,11 +223,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -254,11 +262,11 @@ namespace std this->setstate(ios_base::badbit); } } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -279,11 +287,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -305,11 +313,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -330,11 +338,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -355,11 +363,11 @@ namespace std if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) this->setstate(ios_base::badbit); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); + this->_M_setstate(ios_base::badbit); if ((this->exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -468,7 +476,7 @@ namespace std { try { - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__w + 1))); __pads[0] = __c; streamsize __len = 1; @@ -481,11 +489,11 @@ namespace std __out.write(__pads, __len); __out.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); + __out._M_setstate(ios_base::badbit); if ((__out.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -504,7 +512,7 @@ namespace std { try { - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; char* __pads = static_cast<char*>(__builtin_alloca(__w + 1)); __pads[0] = __c; streamsize __len = 1; @@ -517,11 +525,11 @@ namespace std __out.write(__pads, __len); __out.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); + __out._M_setstate(ios_base::badbit); if ((__out.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -539,7 +547,7 @@ namespace std { try { - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); streamsize __len = static_cast<streamsize>(_Traits::length(__s)); if (__w > __len) @@ -552,11 +560,11 @@ namespace std __out.write(__s, __len); __out.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); + __out._M_setstate(ios_base::badbit); if ((__out.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -588,7 +596,7 @@ namespace std try { streamsize __len = static_cast<streamsize>(__clen); - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); if (__w > __len) @@ -601,11 +609,11 @@ namespace std __out.write(__str, __len); __out.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); + __out._M_setstate(ios_base::badbit); if ((__out.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -626,7 +634,7 @@ namespace std { try { - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; char* __pads = static_cast<char*>(__builtin_alloca(__w)); streamsize __len = static_cast<streamsize>(_Traits::length(__s)); @@ -640,11 +648,11 @@ namespace std __out.write(__s, __len); __out.width(0); } - catch(exception& __fail) + catch(...) { // 27.6.1.2.1 Common requirements. // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); + __out._M_setstate(ios_base::badbit); if ((__out.exceptions() & ios_base::badbit) != 0) __throw_exception_again; } @@ -665,7 +673,7 @@ namespace std if (__cerb) { const _CharT* __s = __str.data(); - streamsize __w = __out.width(); + const streamsize __w = __out.width() > 0 ? __out.width() : 0; _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); streamsize __len = static_cast<streamsize>(__str.size()); #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS @@ -689,6 +697,7 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_ostream<char>; extern template ostream& endl(ostream&); extern template ostream& ends(ostream&); @@ -710,4 +719,5 @@ namespace std extern template wostream& operator<<(wostream&, const wchar_t*); extern template wostream& operator<<(wostream&, const char*); #endif +#endif } // namespace std diff --git a/contrib/libstdc++/include/bits/slice_array.h b/contrib/libstdc++/include/bits/slice_array.h index cca3e63f0ae5..2502ef4ebee9 100644 --- a/contrib/libstdc++/include/bits/slice_array.h +++ b/contrib/libstdc++/include/bits/slice_array.h @@ -1,6 +1,6 @@ // The template and inlines for the -*- C++ -*- slice_array class. -// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 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 @@ -41,134 +41,171 @@ 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; - template<typename _Tp> + private: + size_t _M_off; // offset + size_t _M_sz; // size + size_t _M_st; // stride unit + }; + + // The default constructor constructor is not required to initialize + // data members with any meaningful values, so we choose to do nothing. + 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; } + + template<typename _Tp> class slice_array { public: - typedef _Tp value_type; + typedef _Tp value_type; // This constructor is implemented since we need to return a value. - slice_array (const slice_array&); + slice_array(const slice_array&); // This operator must be public. See DR-253. - slice_array& operator= (const slice_array&); - - 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; - + slice_array& operator=(const slice_array&); + + 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 &) const; + // ~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; + 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; - // not implemented - slice_array (); + // not implemented + 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(_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(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 slice_array<_Tp>::~slice_array () {} template<typename _Tp> - inline slice_array<_Tp>& - slice_array<_Tp>::operator=(const slice_array<_Tp>& __a) - { - __valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, - _M_array, _M_stride); - return *this; - } - + inline slice_array<_Tp>& + slice_array<_Tp>::operator=(const slice_array<_Tp>& __a) + { + __valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, + _M_array, _M_stride); + return *this; + } - template<typename _Tp> + template<typename _Tp> inline void - slice_array<_Tp>::operator= (const _Tp& __t) - { __valarray_fill (_M_array, _M_sz, _M_stride, __t); } + slice_array<_Tp>::operator=(const _Tp& __t) const + { __valarray_fill(_M_array, _M_sz, _M_stride, __t); } - template<typename _Tp> + 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); } + 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> + 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); } + 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));\ -} \ +#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); \ -} + 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) +_DEFINE_VALARRAY_OPERATOR(*, __multiplies) +_DEFINE_VALARRAY_OPERATOR(/, __divides) +_DEFINE_VALARRAY_OPERATOR(%, __modulus) +_DEFINE_VALARRAY_OPERATOR(+, __plus) +_DEFINE_VALARRAY_OPERATOR(-, __minus) +_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) #undef _DEFINE_VALARRAY_OPERATOR diff --git a/contrib/libstdc++/include/bits/stl_alloc.h b/contrib/libstdc++/include/bits/stl_alloc.h index 238986d7eeb6..9677c3e89ee9 100644 --- a/contrib/libstdc++/include/bits/stl_alloc.h +++ b/contrib/libstdc++/include/bits/stl_alloc.h @@ -1,6 +1,6 @@ // Allocators -*- C++ -*- -// Copyright (C) 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2003 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 @@ -85,7 +85,6 @@ #include <cstddef> #include <cstdlib> #include <cstring> -#include <cassert> #include <bits/functexcept.h> // For __throw_bad_alloc #include <bits/stl_threads.h> @@ -129,10 +128,7 @@ namespace std { private: static void* _S_oom_malloc(size_t); - - // _GLIBCPP_DEPRECATED static void* _S_oom_realloc(void*, size_t); - static void (* __malloc_alloc_oom_handler)(); public: @@ -149,7 +145,6 @@ namespace std deallocate(void* __p, size_t /* __n */) { free(__p); } - // _GLIBCPP_DEPRECATED static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz) { @@ -191,7 +186,6 @@ namespace std } } - // _GLIBCPP_DEPRECATED template<int __inst> void* __malloc_alloc_template<__inst>:: @@ -256,10 +250,7 @@ namespace std /** * @if maint * An adaptor for an underlying allocator (_Alloc) to check the size - * arguments for debugging. Errors are reported using assert; these - * checks can be disabled via NDEBUG, but the space penalty is still - * paid, therefore it is far better to just use the underlying allocator - * by itelf when no checking is desired. + * arguments for debugging. * * "There is some evidence that this can confuse Purify." - SGI comment * @@ -288,16 +279,17 @@ namespace std deallocate(void* __p, size_t __n) { char* __real_p = (char*)__p - (int) _S_extra; - assert(*(size_t*)__real_p == __n); + if (*(size_t*)__real_p != __n) + abort(); _Alloc::deallocate(__real_p, __n + (int) _S_extra); } - // _GLIBCPP_DEPRECATED static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz) { char* __real_p = (char*)__p - (int) _S_extra; - assert(*(size_t*)__real_p == __old_sz); + if (*(size_t*)__real_p != __old_sz) + abort(); char* __result = (char*) _Alloc::reallocate(__real_p, __old_sz + (int) _S_extra, __new_sz + (int) _S_extra); @@ -405,8 +397,6 @@ namespace std __atomic_add(&_S_force_new, 1); else __atomic_add(&_S_force_new, -1); - // Trust but verify... - assert(_S_force_new != 0); } if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0)) @@ -454,7 +444,6 @@ namespace std } } - // _GLIBCPP_DEPRECATED static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz); }; @@ -511,8 +500,8 @@ namespace std _Obj* volatile* __my_free_list = _S_free_list + _S_freelist_index(__bytes_left); - ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list; - *__my_free_list = (_Obj*)_S_start_free; + ((_Obj*)(void*)_S_start_free) -> _M_free_list_link = *__my_free_list; + *__my_free_list = (_Obj*)(void*)_S_start_free; } _S_start_free = (char*) __new_alloc::allocate(__bytes_to_get); if (_S_start_free == 0) @@ -570,12 +559,12 @@ namespace std __my_free_list = _S_free_list + _S_freelist_index(__n); // Build free list in chunk. - __result = (_Obj*)__chunk; - *__my_free_list = __next_obj = (_Obj*)(__chunk + __n); + __result = (_Obj*)(void*)__chunk; + *__my_free_list = __next_obj = (_Obj*)(void*)(__chunk + __n); for (__i = 1; ; __i++) { __current_obj = __next_obj; - __next_obj = (_Obj*)((char*)__next_obj + __n); + __next_obj = (_Obj*)(void*)((char*)__next_obj + __n); if (__nobjs - 1 == __i) { __current_obj -> _M_free_list_link = 0; @@ -588,7 +577,6 @@ namespace std } - // _GLIBCPP_DEPRECATED template<bool threads, int inst> void* __default_alloc_template<threads, inst>:: @@ -976,9 +964,11 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class allocator<char>; extern template class allocator<wchar_t>; extern template class __default_alloc_template<true,0>; +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/stl_bvector.h b/contrib/libstdc++/include/bits/stl_bvector.h index ce6df71b67f8..2c97d470582e 100644 --- a/contrib/libstdc++/include/bits/stl_bvector.h +++ b/contrib/libstdc++/include/bits/stl_bvector.h @@ -91,13 +91,6 @@ public: void flip() { *_M_p ^= _M_mask; } }; -inline void swap(_Bit_reference __x, _Bit_reference __y) -{ - bool __tmp = __x; - __x = __y; - __y = __tmp; -} - struct _Bit_iterator_base : public iterator<random_access_iterator_tag, bool> { _Bit_type * _M_p; @@ -363,8 +356,8 @@ template <typename _Alloc> typedef _Bit_iterator iterator; typedef _Bit_const_iterator const_iterator; - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type; allocator_type get_allocator() const { @@ -637,6 +630,14 @@ template <typename _Alloc> std::swap(_M_finish, __x._M_finish); std::swap(_M_end_of_storage, __x._M_end_of_storage); } + + // [23.2.5]/1, third-to-last entry in synopsis listing + static void swap(reference __x, reference __y) { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + iterator insert(iterator __position, bool __x = bool()) { difference_type __n = __position - begin(); if (_M_finish._M_p != _M_end_of_storage && __position == end()) diff --git a/contrib/libstdc++/include/bits/stl_deque.h b/contrib/libstdc++/include/bits/stl_deque.h index cbe87796770f..454fed31bf73 100644 --- a/contrib/libstdc++/include/bits/stl_deque.h +++ b/contrib/libstdc++/include/bits/stl_deque.h @@ -1,4 +1,4 @@ -// deque implementation -*- C++ -*- +// Deque implementation -*- C++ -*- // Copyright (C) 2001, 2002 Free Software Foundation, Inc. // @@ -58,1625 +58,1546 @@ * You should not attempt to use it directly. */ -#include <bits/concept_check.h> -#include <bits/stl_iterator_base_types.h> -#include <bits/stl_iterator_base_funcs.h> - #ifndef __GLIBCPP_INTERNAL_DEQUE_H #define __GLIBCPP_INTERNAL_DEQUE_H +#include <bits/concept_check.h> +#include <bits/stl_iterator_base_types.h> +#include <bits/stl_iterator_base_funcs.h> -// Since this entire file is within namespace std, there's no reason to -// waste two spaces along the left column. Thus the leading indentation is -// slightly violated from here on. namespace std { - -/** - * @if maint - * @brief This function controls the size of memory nodes. - * @param size The size of an element. - * @return The number (not bytesize) of elements per node. - * - * This function started off as a compiler kludge from SGI, but seems to - * be a useful wrapper around a repeated constant expression. - * @endif -*/ -inline size_t -__deque_buf_size(size_t __size) -{ return __size < 512 ? size_t(512 / __size) : size_t(1); } - - -/// A deque::iterator. -/** - * Quite a bit of intelligence here. Much of the functionality of deque is - * actually passed off to this class. A deque holds two of these internally, - * marking its valid range. Access to elements is done as offsets of either - * of those two, relying on operator overloading in this class. - * - * @if maint - * All the functions are op overloads except for _M_set_node. - * @endif -*/ -template <class _Tp, class _Ref, class _Ptr> -struct _Deque_iterator -{ - typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; - typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; - static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } - - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Ptr pointer; - typedef _Ref reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp** _Map_pointer; - typedef _Deque_iterator _Self; - - _Tp* _M_cur; - _Tp* _M_first; - _Tp* _M_last; - _Map_pointer _M_node; - - _Deque_iterator(_Tp* __x, _Map_pointer __y) - : _M_cur(__x), _M_first(*__y), - _M_last(*__y + _S_buffer_size()), _M_node(__y) {} - _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {} - _Deque_iterator(const iterator& __x) - : _M_cur(__x._M_cur), _M_first(__x._M_first), - _M_last(__x._M_last), _M_node(__x._M_node) {} - - reference operator*() const { return *_M_cur; } - pointer operator->() const { return _M_cur; } - - _Self& operator++() { - ++_M_cur; - if (_M_cur == _M_last) { - _M_set_node(_M_node + 1); - _M_cur = _M_first; + /** + * @if maint + * @brief This function controls the size of memory nodes. + * @param size The size of an element. + * @return The number (not byte size) of elements per node. + * + * This function started off as a compiler kludge from SGI, but seems to + * be a useful wrapper around a repeated constant expression. The '512' is + * tuneable (and no other code needs to change), but no investigation has + * been done since inheriting the SGI code. + * @endif + */ + inline size_t + __deque_buf_size(size_t __size) + { return __size < 512 ? size_t(512 / __size) : size_t(1); } + + + /** + * @brief A deque::iterator. + * + * Quite a bit of intelligence here. Much of the functionality of deque is + * actually passed off to this class. A deque holds two of these internally, + * marking its valid range. Access to elements is done as offsets of either + * of those two, relying on operator overloading in this class. + * + * @if maint + * All the functions are op overloads except for _M_set_node. + * @endif + */ + template <typename _Tp, typename _Ref, typename _Ptr> + struct _Deque_iterator + { + typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; + typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; + static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } + + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Ptr pointer; + typedef _Ref reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp** _Map_pointer; + typedef _Deque_iterator _Self; + + _Tp* _M_cur; + _Tp* _M_first; + _Tp* _M_last; + _Map_pointer _M_node; + + _Deque_iterator(_Tp* __x, _Map_pointer __y) + : _M_cur(__x), _M_first(*__y), + _M_last(*__y + _S_buffer_size()), _M_node(__y) {} + _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {} + _Deque_iterator(const iterator& __x) + : _M_cur(__x._M_cur), _M_first(__x._M_first), + _M_last(__x._M_last), _M_node(__x._M_node) {} + + reference operator*() const { return *_M_cur; } + pointer operator->() const { return _M_cur; } + + _Self& operator++() { + ++_M_cur; + if (_M_cur == _M_last) { + _M_set_node(_M_node + 1); + _M_cur = _M_first; + } + return *this; + } + _Self operator++(int) { + _Self __tmp = *this; + ++*this; + return __tmp; + } + + _Self& operator--() { + if (_M_cur == _M_first) { + _M_set_node(_M_node - 1); + _M_cur = _M_last; + } + --_M_cur; + return *this; + } + _Self operator--(int) { + _Self __tmp = *this; + --*this; + return __tmp; + } + + _Self& operator+=(difference_type __n) + { + difference_type __offset = __n + (_M_cur - _M_first); + if (__offset >= 0 && __offset < difference_type(_S_buffer_size())) + _M_cur += __n; + else { + difference_type __node_offset = + __offset > 0 ? __offset / difference_type(_S_buffer_size()) + : -difference_type((-__offset - 1) / _S_buffer_size()) - 1; + _M_set_node(_M_node + __node_offset); + _M_cur = _M_first + + (__offset - __node_offset * difference_type(_S_buffer_size())); + } + return *this; + } + + _Self operator+(difference_type __n) const + { + _Self __tmp = *this; + return __tmp += __n; + } + + _Self& operator-=(difference_type __n) { return *this += -__n; } + + _Self operator-(difference_type __n) const { + _Self __tmp = *this; + return __tmp -= __n; + } + + reference operator[](difference_type __n) const { return *(*this + __n); } + + /** @if maint + * Prepares to traverse new_node. Sets everything except _M_cur, which + * should therefore be set by the caller immediately afterwards, based on + * _M_first and _M_last. + * @endif + */ + void + _M_set_node(_Map_pointer __new_node) + { + _M_node = __new_node; + _M_first = *__new_node; + _M_last = _M_first + difference_type(_S_buffer_size()); } - return *this; + }; + + // Note: we also provide overloads whose operands are of the same type in + // order to avoid ambiguous overload resolution when std::rel_ops operators + // are in scope (for additional details, see libstdc++/3628) + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) + { + return __x._M_cur == __y._M_cur; } - _Self operator++(int) { - _Self __tmp = *this; - ++*this; - return __tmp; + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return __x._M_cur == __y._M_cur; } - - _Self& operator--() { - if (_M_cur == _M_first) { - _M_set_node(_M_node - 1); - _M_cur = _M_last; - } - --_M_cur; - return *this; + + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) + { + return !(__x == __y); } - _Self operator--(int) { - _Self __tmp = *this; - --*this; - return __tmp; + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return !(__x == __y); } - - _Self& operator+=(difference_type __n) + + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) { - difference_type __offset = __n + (_M_cur - _M_first); - if (__offset >= 0 && __offset < difference_type(_S_buffer_size())) - _M_cur += __n; - else { - difference_type __node_offset = - __offset > 0 ? __offset / difference_type(_S_buffer_size()) - : -difference_type((-__offset - 1) / _S_buffer_size()) - 1; - _M_set_node(_M_node + __node_offset); - _M_cur = _M_first + - (__offset - __node_offset * difference_type(_S_buffer_size())); - } - return *this; + return (__x._M_node == __y._M_node) ? + (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node); } - - _Self operator+(difference_type __n) const + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) { - _Self __tmp = *this; - return __tmp += __n; + return (__x._M_node == __y._M_node) ? + (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node); } - - _Self& operator-=(difference_type __n) { return *this += -__n; } - - _Self operator-(difference_type __n) const { - _Self __tmp = *this; - return __tmp -= __n; + + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) + { + return __y < __x; } - - reference operator[](difference_type __n) const { return *(*this + __n); } - - /** @if maint - * Prepares to traverse new_node. Sets everything except _M_cur, which - * should therefore be set by the caller immediately afterwards, based on - * _M_first and _M_last. - * @endif - */ - void _M_set_node(_Map_pointer __new_node) { - _M_node = __new_node; - _M_first = *__new_node; - _M_last = _M_first + difference_type(_S_buffer_size()); + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return __y < __x; } -}; - -// Note: we also provide overloads whose operands are of the same type in -// order to avoid ambiguos overload resolution when std::rel_ops operators -// are in scope (for additional details, see libstdc++/3628) -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return __x._M_cur == __y._M_cur; -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return __x._M_cur == __y._M_cur; -} - -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return !(__x == __y); -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return !(__x == __y); -} - -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return (__x._M_node == __y._M_node) ? - (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node); -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return (__x._M_node == __y._M_node) ? - (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node); -} - -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return __y < __x; -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return __y < __x; -} - -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return !(__y < __x); -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return !(__y < __x); -} - -template <class _Tp, class _Ref, class _Ptr> -inline bool -operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, - const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) -{ - return !(__x < __y); -} - -template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> -inline bool -operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return !(__x < __y); -} - -// _GLIBCPP_RESOLVE_LIB_DEFECTS -// According to the resolution of DR179 not only the various comparison -// operators but also operator- must accept mixed iterator/const_iterator -// parameters. -template <typename _Tp, typename _RefL, typename _PtrL, - typename _RefR, typename _PtrR> -inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type -operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, - const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) -{ - return _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type - (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) * - (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + - (__y._M_last - __y._M_cur); -} - -template <class _Tp, class _Ref, class _Ptr> -inline _Deque_iterator<_Tp, _Ref, _Ptr> -operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x) -{ - return __x + __n; -} - - -/// @if maint Primary default version. @endif -/** - * @if maint - * Deque base class. It has two purposes. First, its constructor - * and destructor allocate (but don't initialize) storage. This makes - * exception safety easier. Second, the base class encapsulates all of - * the differences between SGI-style allocators and standard-conforming - * allocators. There are two versions: this ordinary one, and the - * space-saving specialization for instanceless allocators. - * @endif -*/ -template <class _Tp, class _Alloc, bool __is_static> -class _Deque_alloc_base -{ -public: - typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type; - allocator_type get_allocator() const { return _M_node_allocator; } - - _Deque_alloc_base(const allocator_type& __a) - : _M_node_allocator(__a), _M_map_allocator(__a), - _M_map(0), _M_map_size(0) - {} - -protected: - typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type - _Map_allocator_type; - - allocator_type _M_node_allocator; - _Map_allocator_type _M_map_allocator; - - _Tp* _M_allocate_node() { - return _M_node_allocator.allocate(__deque_buf_size(sizeof(_Tp))); + + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) + { + return !(__y < __x); } - void _M_deallocate_node(_Tp* __p) { - _M_node_allocator.deallocate(__p, __deque_buf_size(sizeof(_Tp))); + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return !(__y < __x); } - _Tp** _M_allocate_map(size_t __n) - { return _M_map_allocator.allocate(__n); } - void _M_deallocate_map(_Tp** __p, size_t __n) - { _M_map_allocator.deallocate(__p, __n); } - - _Tp** _M_map; - size_t _M_map_size; -}; - -/// @if maint Specialization for instanceless allocators. @endif -template <class _Tp, class _Alloc> -class _Deque_alloc_base<_Tp, _Alloc, true> -{ -public: - typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Deque_alloc_base(const allocator_type&) : _M_map(0), _M_map_size(0) {} -protected: - typedef typename _Alloc_traits<_Tp, _Alloc>::_Alloc_type _Node_alloc_type; - typedef typename _Alloc_traits<_Tp*, _Alloc>::_Alloc_type _Map_alloc_type; - - _Tp* _M_allocate_node() { - return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); + template <typename _Tp, typename _Ref, typename _Ptr> + inline bool + operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) + { + return !(__x < __y); } - void _M_deallocate_node(_Tp* __p) { - _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); + + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline bool + operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return !(__x < __y); } - _Tp** _M_allocate_map(size_t __n) - { return _Map_alloc_type::allocate(__n); } - void _M_deallocate_map(_Tp** __p, size_t __n) - { _Map_alloc_type::deallocate(__p, __n); } - - _Tp** _M_map; - size_t _M_map_size; -}; - - -/** - * @if maint - * Deque base class. Using _Alloc_traits in the instantiation of the parent - * class provides the compile-time dispatching mentioned in the parent's docs. - * This class provides the unified face for deque's allocation. - * - * Nothing in this class ever constructs or destroys an actual Tp element. - * (Deque handles that itself.) Only/All memory management is performed here. - * @endif -*/ -template <class _Tp, class _Alloc> -class _Deque_base - : public _Deque_alloc_base<_Tp,_Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> -{ -public: - typedef _Deque_alloc_base<_Tp,_Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> - _Base; - typedef typename _Base::allocator_type allocator_type; - typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator; - typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; - - _Deque_base(const allocator_type& __a, size_t __num_elements) - : _Base(__a), _M_start(), _M_finish() - { _M_initialize_map(__num_elements); } - _Deque_base(const allocator_type& __a) - : _Base(__a), _M_start(), _M_finish() {} - ~_Deque_base(); - -protected: - void _M_initialize_map(size_t); - void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish); - void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish); - enum { _S_initial_map_size = 8 }; - -protected: - iterator _M_start; - iterator _M_finish; -}; - - -template <class _Tp, class _Alloc> -_Deque_base<_Tp,_Alloc>::~_Deque_base() -{ - if (_M_map) { - _M_destroy_nodes(_M_start._M_node, _M_finish._M_node + 1); - _M_deallocate_map(_M_map, _M_map_size); + + // _GLIBCPP_RESOLVE_LIB_DEFECTS + // According to the resolution of DR179 not only the various comparison + // operators but also operator- must accept mixed iterator/const_iterator + // parameters. + template <typename _Tp, typename _RefL, typename _PtrL, + typename _RefR, typename _PtrR> + inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type + operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) + { + return _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type + (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) * + (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + + (__y._M_last - __y._M_cur); } -} - -/** - * @if maint - * @brief Layout storage. - * @param num_elements The count of T's for which to allocate space at first. - * @return Nothing. - * - * The initial underlying memory layout is a bit complicated... - * @endif -*/ -template <class _Tp, class _Alloc> -void -_Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) -{ - size_t __num_nodes = - __num_elements / __deque_buf_size(sizeof(_Tp)) + 1; - - _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2); - _M_map = _M_allocate_map(_M_map_size); - - _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2; - _Tp** __nfinish = __nstart + __num_nodes; - - try - { _M_create_nodes(__nstart, __nfinish); } - catch(...) - { - _M_deallocate_map(_M_map, _M_map_size); - _M_map = 0; - _M_map_size = 0; - __throw_exception_again; - } - _M_start._M_set_node(__nstart); - _M_finish._M_set_node(__nfinish - 1); - _M_start._M_cur = _M_start._M_first; - _M_finish._M_cur = _M_finish._M_first + - __num_elements % __deque_buf_size(sizeof(_Tp)); -} - -template <class _Tp, class _Alloc> -void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish) -{ - _Tp** __cur; - try { - for (__cur = __nstart; __cur < __nfinish; ++__cur) - *__cur = _M_allocate_node(); + template <typename _Tp, typename _Ref, typename _Ptr> + inline _Deque_iterator<_Tp, _Ref, _Ptr> + operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x) + { + return __x + __n; } - catch(...) - { - _M_destroy_nodes(__nstart, __cur); - __throw_exception_again; - } -} - -template <class _Tp, class _Alloc> -void -_Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) -{ - for (_Tp** __n = __nstart; __n < __nfinish; ++__n) - _M_deallocate_node(*__n); -} - - -/** - * @ingroup Containers - * @ingroup Sequences - * - * Meets the requirements of a <a href="tables.html#65">container</a>, a - * <a href="tables.html#66">reversible container</a>, and a - * <a href="tables.html#67">sequence</a>, including the - * <a href="tables.html#68">optional sequence requirements</a>. - * - * Placeholder: see http://www.sgi.com/tech/stl/Deque.html for now. - * - * In previous HP/SGI versions of deque, there was an extra template parameter - * so users could control the node size. This extension turned out to violate - * the C++ standard (it can be detected using template template parameters), - * and it was removed. - * - * @if maint - * Here's how a deque<Tp> manages memory. Each deque has 4 members: - * - * - Tp** _M_map - * - size_t _M_map_size - * - iterator _M_start, _M_finish - * - * map_size is at least 8. %map is an array of map_size pointers-to-"nodes". - * (The name has nothing to do with the std::map class.) - * - * A "node" has no specific type name as such, but it is referred to as - * "node" in this file. It is a simple array-of-Tp. If Tp is very large, - * there will be one Tp element per node (i.e., an "array" of one). - * For non-huge Tp's, node size is inversely related to Tp size: the - * larger the Tp, the fewer Tp's will fit in a node. The goal here is to - * keep the total size of a node relatively small and constant over different - * Tp's, to improve allocator efficiency. - * - * **** As I write this, the nodes are /not/ allocated using the high-speed - * memory pool. There are 20 hours left in the year; perhaps I can fix - * this before 2002. - * - * Not every pointer in the %map array will point to a node. If the initial - * number of elements in the deque is small, the /middle/ %map pointers will - * be valid, and the ones at the edges will be unused. This same situation - * will arise as the %map grows: available %map pointers, if any, will be on - * the ends. As new nodes are created, only a subset of the %map's pointers - * need to be copied "outward". - * - * Class invariants: - * - For any nonsingular iterator i: - * - i.node points to a member of the %map array. (Yes, you read that - * correctly: i.node does not actually point to a node.) The member of - * the %map array is what actually points to the node. - * - i.first == *(i.node) (This points to the node (first Tp element).) - * - i.last == i.first + node_size - * - i.cur is a pointer in the range [i.first, i.last). NOTE: - * the implication of this is that i.cur is always a dereferenceable - * pointer, even if i is a past-the-end iterator. - * - Start and Finish are always nonsingular iterators. NOTE: this means that - * an empty deque must have one node, a deque with <N elements (where N is - * the node buffer size) must have one node, a deque with N through (2N-1) - * elements must have two nodes, etc. - * - For every node other than start.node and finish.node, every element in the - * node is an initialized object. If start.node == finish.node, then - * [start.cur, finish.cur) are initialized objects, and the elements outside - * that range are uninitialized storage. Otherwise, [start.cur, start.last) - * and [finish.first, finish.cur) are initialized objects, and [start.first, - * start.cur) and [finish.cur, finish.last) are uninitialized storage. - * - [%map, %map + map_size) is a valid, non-empty range. - * - [start.node, finish.node] is a valid range contained within - * [%map, %map + map_size). - * - A pointer in the range [%map, %map + map_size) points to an allocated node - * if and only if the pointer is in the range [start.node, finish.node]. - * - * Here's the magic: nothing in deque is "aware" of the discontiguous storage! - * - * The memory setup and layout occurs in the parent, _Base, and the iterator - * class is entirely responsible for "leaping" from one node to the next. All - * the implementation routines for deque itself work only through the start - * and finish iterators. This keeps the routines simple and sane, and we can - * use other standard algorithms as well. - * @endif -*/ -template <class _Tp, class _Alloc = allocator<_Tp> > -class deque : protected _Deque_base<_Tp, _Alloc> -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - - typedef _Deque_base<_Tp, _Alloc> _Base; - -public: - typedef _Tp value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - typedef typename _Base::allocator_type allocator_type; - allocator_type get_allocator() const { return _Base::get_allocator(); } - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; - -protected: - typedef pointer* _Map_pointer; - static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } - - // Functions controlling memory layout, and nothing else. - using _Base::_M_initialize_map; - using _Base::_M_create_nodes; - using _Base::_M_destroy_nodes; - using _Base::_M_allocate_node; - using _Base::_M_deallocate_node; - using _Base::_M_allocate_map; - using _Base::_M_deallocate_map; - - /** @if maint - * A total of four data members accumulated down the heirarchy. If the - * _Alloc type requires separate instances, then two of them will also be - * included in each deque. + + + /// @if maint Primary default version. @endif + /** + * @if maint + * Deque base class. It has two purposes. First, its constructor + * and destructor allocate (but don't initialize) storage. This makes + * %exception safety easier. Second, the base class encapsulates all of + * the differences between SGI-style allocators and standard-conforming + * allocators. (See stl_alloc.h for more on this topic.) There are two + * versions: this ordinary one, and the space-saving specialization for + * instanceless allocators. * @endif */ - using _Base::_M_map; - using _Base::_M_map_size; - using _Base::_M_start; - using _Base::_M_finish; - -public: // Basic accessors - iterator begin() { return _M_start; } - iterator end() { return _M_finish; } - const_iterator begin() const { return _M_start; } - const_iterator end() const { return _M_finish; } - - reverse_iterator rbegin() { return reverse_iterator(_M_finish); } - reverse_iterator rend() { return reverse_iterator(_M_start); } - const_reverse_iterator rbegin() const - { return const_reverse_iterator(_M_finish); } - const_reverse_iterator rend() const - { return const_reverse_iterator(_M_start); } - - reference operator[](size_type __n) - { return _M_start[difference_type(__n)]; } - const_reference operator[](size_type __n) const - { return _M_start[difference_type(__n)]; } - - void _M_range_check(size_type __n) const { - if (__n >= this->size()) - __throw_out_of_range("deque"); - } - - reference at(size_type __n) - { _M_range_check(__n); return (*this)[__n]; } - const_reference at(size_type __n) const - { _M_range_check(__n); return (*this)[__n]; } - - reference front() { return *_M_start; } - reference back() { - iterator __tmp = _M_finish; - --__tmp; - return *__tmp; - } - const_reference front() const { return *_M_start; } - const_reference back() const { - const_iterator __tmp = _M_finish; - --__tmp; - return *__tmp; - } - - size_type size() const { return _M_finish - _M_start; } - size_type max_size() const { return size_type(-1); } - bool empty() const { return _M_finish == _M_start; } - -public: // Constructor, destructor. - explicit deque(const allocator_type& __a = allocator_type()) - : _Base(__a, 0) {} - deque(const deque& __x) : _Base(__x.get_allocator(), __x.size()) - { uninitialized_copy(__x.begin(), __x.end(), _M_start); } - deque(size_type __n, const value_type& __value, - const allocator_type& __a = allocator_type()) : _Base(__a, __n) - { _M_fill_initialize(__value); } - - explicit - deque(size_type __n) - : _Base(allocator_type(), __n) - { _M_fill_initialize(value_type()); } - - // Check whether it's an integral type. If so, it's not an iterator. - template<class _InputIterator> - deque(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) + template <typename _Tp, typename _Alloc, bool __is_static> + class _Deque_alloc_base + { + public: + typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type; + allocator_type get_allocator() const { return _M_node_allocator; } + + _Deque_alloc_base(const allocator_type& __a) + : _M_node_allocator(__a), _M_map_allocator(__a), + _M_map(0), _M_map_size(0) + {} + + protected: + typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type + _Map_allocator_type; + + _Tp* + _M_allocate_node() { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_initialize_dispatch(__first, __last, _Integral()); + return _M_node_allocator.allocate(__deque_buf_size(sizeof(_Tp))); } - - template<class _Integer> + void - _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + _M_deallocate_node(_Tp* __p) { - _M_initialize_map(__n); - _M_fill_initialize(__x); + _M_node_allocator.deallocate(__p, __deque_buf_size(sizeof(_Tp))); } - - template<class _InputIter> + + _Tp** + _M_allocate_map(size_t __n) + { return _M_map_allocator.allocate(__n); } + void - _M_initialize_dispatch(_InputIter __first, _InputIter __last, __false_type) + _M_deallocate_map(_Tp** __p, size_t __n) + { _M_map_allocator.deallocate(__p, __n); } + + allocator_type _M_node_allocator; + _Map_allocator_type _M_map_allocator; + _Tp** _M_map; + size_t _M_map_size; + }; + + /// @if maint Specialization for instanceless allocators. @endif + template <typename _Tp, typename _Alloc> + class _Deque_alloc_base<_Tp, _Alloc, true> + { + public: + typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type; + allocator_type get_allocator() const { return allocator_type(); } + + _Deque_alloc_base(const allocator_type&) + : _M_map(0), _M_map_size(0) + {} + + protected: + typedef typename _Alloc_traits<_Tp,_Alloc>::_Alloc_type _Node_alloc_type; + typedef typename _Alloc_traits<_Tp*,_Alloc>::_Alloc_type _Map_alloc_type; + + _Tp* + _M_allocate_node() { - typedef typename iterator_traits<_InputIter>::iterator_category _IterCategory; - _M_range_initialize(__first, __last, _IterCategory()); - } - - ~deque() - { _Destroy(_M_start, _M_finish); } - - deque& operator= (const deque& __x) { - const size_type __len = size(); - if (&__x != this) { - if (__len >= __x.size()) - erase(copy(__x.begin(), __x.end(), _M_start), _M_finish); - else { - const_iterator __mid = __x.begin() + difference_type(__len); - copy(__x.begin(), __mid, _M_start); - insert(_M_finish, __mid, __x.end()); - } - } - return *this; - } - - void swap(deque& __x) { - std::swap(_M_start, __x._M_start); - std::swap(_M_finish, __x._M_finish); - std::swap(_M_map, __x._M_map); - std::swap(_M_map_size, __x._M_map_size); - } - -public: - // assign(), a generalized assignment member function. Two - // versions: one that takes a count, and one that takes a range. - // The range version is a member template, so we dispatch on whether - // or not the type is an integer. - - void _M_fill_assign(size_type __n, const _Tp& __val) { - if (__n > size()) { - fill(begin(), end(), __val); - insert(end(), __n - size(), __val); - } - else { - erase(begin() + __n, end()); - fill(begin(), end(), __val); + return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); } - } - - void - assign(size_type __n, const _Tp& __val) - { _M_fill_assign(__n, __val); } - - template<class _InputIterator> + void - assign(_InputIterator __first, _InputIterator __last) + _M_deallocate_node(_Tp* __p) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); + _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); } - -private: // helper functions for assign() - - template<class _Integer> - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign(static_cast<size_type>(__n), static_cast<_Tp>(__val)); } - - template<class _InputIterator> + + _Tp** + _M_allocate_map(size_t __n) + { return _Map_alloc_type::allocate(__n); } + void - _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type) - { - typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory; - _M_assign_aux(__first, __last, _IterCategory()); - } - - template <class _InputIterator> - void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template <class _ForwardIterator> - void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) { - size_type __len = distance(__first, __last); - if (__len > size()) { - _ForwardIterator __mid = __first; - advance(__mid, size()); - copy(__first, __mid, begin()); - insert(end(), __mid, __last); - } - else - erase(copy(__first, __last, begin()), end()); - } - -public: // push_* and pop_* + _M_deallocate_map(_Tp** __p, size_t __n) + { _Map_alloc_type::deallocate(__p, __n); } - void - push_back(const value_type& __t) - { - if (_M_finish._M_cur != _M_finish._M_last - 1) { - _Construct(_M_finish._M_cur, __t); - ++_M_finish._M_cur; - } - else - _M_push_back_aux(__t); - } - - void - push_back() + _Tp** _M_map; + size_t _M_map_size; + }; + + + /** + * @if maint + * Deque base class. Using _Alloc_traits in the instantiation of the parent + * class provides the compile-time dispatching mentioned in the parent's + * docs. This class provides the unified face for %deque's allocation. + * + * Nothing in this class ever constructs or destroys an actual Tp element. + * (Deque handles that itself.) Only/All memory management is performed + * here. + * @endif + */ + template <typename _Tp, typename _Alloc> + class _Deque_base + : public _Deque_alloc_base<_Tp,_Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> { - if (_M_finish._M_cur != _M_finish._M_last - 1) { - _Construct(_M_finish._M_cur); - ++_M_finish._M_cur; - } - else - _M_push_back_aux(); - } - - void - push_front(const value_type& __t) + public: + typedef _Deque_alloc_base<_Tp,_Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + _Base; + typedef typename _Base::allocator_type allocator_type; + typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator; + typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; + + _Deque_base(const allocator_type& __a, size_t __num_elements) + : _Base(__a), _M_start(), _M_finish() + { _M_initialize_map(__num_elements); } + _Deque_base(const allocator_type& __a) + : _Base(__a), _M_start(), _M_finish() {} + ~_Deque_base(); + + protected: + void _M_initialize_map(size_t); + void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish); + void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish); + enum { _S_initial_map_size = 8 }; + + iterator _M_start; + iterator _M_finish; + }; + + + template <typename _Tp, typename _Alloc> + _Deque_base<_Tp,_Alloc>::~_Deque_base() { - if (_M_start._M_cur != _M_start._M_first) { - _Construct(_M_start._M_cur - 1, __t); - --_M_start._M_cur; + if (_M_map) + { + _M_destroy_nodes(_M_start._M_node, _M_finish._M_node + 1); + _M_deallocate_map(_M_map, _M_map_size); } - else - _M_push_front_aux(__t); } - + + /** + * @if maint + * @brief Layout storage. + * @param num_elements The count of T's for which to allocate space + * at first. + * @return Nothing. + * + * The initial underlying memory layout is a bit complicated... + * @endif + */ + template <typename _Tp, typename _Alloc> void - push_front() + _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) { - if (_M_start._M_cur != _M_start._M_first) { - _Construct(_M_start._M_cur - 1); - --_M_start._M_cur; - } - else - _M_push_front_aux(); + size_t __num_nodes = + __num_elements / __deque_buf_size(sizeof(_Tp)) + 1; + + _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2); + _M_map = _M_allocate_map(_M_map_size); + + // For "small" maps (needing less than _M_map_size nodes), allocation + // starts in the middle elements and grows outwards. So nstart may be the + // beginning of _M_map, but for small maps it may be as far in as _M_map+3. + + _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2; + _Tp** __nfinish = __nstart + __num_nodes; + + try + { _M_create_nodes(__nstart, __nfinish); } + catch(...) + { + _M_deallocate_map(_M_map, _M_map_size); + _M_map = 0; + _M_map_size = 0; + __throw_exception_again; + } + + _M_start._M_set_node(__nstart); + _M_finish._M_set_node(__nfinish - 1); + _M_start._M_cur = _M_start._M_first; + _M_finish._M_cur = _M_finish._M_first + + __num_elements % __deque_buf_size(sizeof(_Tp)); } - - - void - pop_back() + + template <typename _Tp, typename _Alloc> + void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish) { - if (_M_finish._M_cur != _M_finish._M_first) { - --_M_finish._M_cur; - _Destroy(_M_finish._M_cur); - } - else - _M_pop_back_aux(); + _Tp** __cur; + try + { + for (__cur = __nstart; __cur < __nfinish; ++__cur) + *__cur = _M_allocate_node(); + } + catch(...) + { + _M_destroy_nodes(__nstart, __cur); + __throw_exception_again; + } } - + + template <typename _Tp, typename _Alloc> void - pop_front() + _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) { - if (_M_start._M_cur != _M_start._M_last - 1) { - _Destroy(_M_start._M_cur); - ++_M_start._M_cur; - } - else - _M_pop_front_aux(); + for (_Tp** __n = __nstart; __n < __nfinish; ++__n) + _M_deallocate_node(*__n); } - -public: // Insert - - iterator - insert(iterator position, const value_type& __x) + + + /** + * @brief A standard container using fixed-size memory allocation and + * constant-time manipulation of elements at either end. + * + * @ingroup Containers + * @ingroup Sequences + * + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and a + * <a href="tables.html#67">sequence</a>, including the + * <a href="tables.html#68">optional sequence requirements</a>. + * + * In previous HP/SGI versions of deque, there was an extra template + * parameter so users could control the node size. This extension turned + * out to violate the C++ standard (it can be detected using template + * template parameters), and it was removed. + * + * @if maint + * Here's how a deque<Tp> manages memory. Each deque has 4 members: + * + * - Tp** _M_map + * - size_t _M_map_size + * - iterator _M_start, _M_finish + * + * map_size is at least 8. %map is an array of map_size pointers-to-"nodes". + * (The name %map has nothing to do with the std::map class, and "nodes" + * should not be confused with std::list's usage of "node".) + * + * A "node" has no specific type name as such, but it is referred to as + * "node" in this file. It is a simple array-of-Tp. If Tp is very large, + * there will be one Tp element per node (i.e., an "array" of one). + * For non-huge Tp's, node size is inversely related to Tp size: the + * larger the Tp, the fewer Tp's will fit in a node. The goal here is to + * keep the total size of a node relatively small and constant over different + * Tp's, to improve allocator efficiency. + * + * **** As I write this, the nodes are /not/ allocated using the high-speed + * memory pool. There are 20 hours left in the year; perhaps I can fix + * this before 2002. + * + * Not every pointer in the %map array will point to a node. If the initial + * number of elements in the deque is small, the /middle/ %map pointers will + * be valid, and the ones at the edges will be unused. This same situation + * will arise as the %map grows: available %map pointers, if any, will be on + * the ends. As new nodes are created, only a subset of the %map's pointers + * need to be copied "outward". + * + * Class invariants: + * - For any nonsingular iterator i: + * - i.node points to a member of the %map array. (Yes, you read that + * correctly: i.node does not actually point to a node.) The member of + * the %map array is what actually points to the node. + * - i.first == *(i.node) (This points to the node (first Tp element).) + * - i.last == i.first + node_size + * - i.cur is a pointer in the range [i.first, i.last). NOTE: + * the implication of this is that i.cur is always a dereferenceable + * pointer, even if i is a past-the-end iterator. + * - Start and Finish are always nonsingular iterators. NOTE: this means that + * an empty deque must have one node, a deque with <N elements (where N is + * the node buffer size) must have one node, a deque with N through (2N-1) + * elements must have two nodes, etc. + * - For every node other than start.node and finish.node, every element in + * the node is an initialized object. If start.node == finish.node, then + * [start.cur, finish.cur) are initialized objects, and the elements outside + * that range are uninitialized storage. Otherwise, [start.cur, start.last) + * and [finish.first, finish.cur) are initialized objects, and [start.first, + * start.cur) and [finish.cur, finish.last) are uninitialized storage. + * - [%map, %map + map_size) is a valid, non-empty range. + * - [start.node, finish.node] is a valid range contained within + * [%map, %map + map_size). + * - A pointer in the range [%map, %map + map_size) points to an allocated + * node if and only if the pointer is in the range + * [start.node, finish.node]. + * + * Here's the magic: nothing in deque is "aware" of the discontiguous + * storage! + * + * The memory setup and layout occurs in the parent, _Base, and the iterator + * class is entirely responsible for "leaping" from one node to the next. + * All the implementation routines for deque itself work only through the + * start and finish iterators. This keeps the routines simple and sane, + * and we can use other standard algorithms as well. + * @endif + */ + template <typename _Tp, typename _Alloc = allocator<_Tp> > + class deque : protected _Deque_base<_Tp, _Alloc> { - if (position._M_cur == _M_start._M_cur) { - push_front(__x); - return _M_start; - } - else if (position._M_cur == _M_finish._M_cur) { - push_back(__x); - iterator __tmp = _M_finish; - --__tmp; - return __tmp; - } - else { - return _M_insert_aux(position, __x); - } - } - - iterator - insert(iterator __position) - { return insert(__position, value_type()); } - - void - insert(iterator __pos, size_type __n, const value_type& __x) - { _M_fill_insert(__pos, __n, __x); } - - void - _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); - - // Check whether it's an integral type. If so, it's not an iterator. - template<class _InputIterator> + // concept requirements + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + + typedef _Deque_base<_Tp, _Alloc> _Base; + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef typename _Base::allocator_type allocator_type; + + protected: + typedef pointer* _Map_pointer; + static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } + + // Functions controlling memory layout, and nothing else. + using _Base::_M_initialize_map; + using _Base::_M_create_nodes; + using _Base::_M_destroy_nodes; + using _Base::_M_allocate_node; + using _Base::_M_deallocate_node; + using _Base::_M_allocate_map; + using _Base::_M_deallocate_map; + + /** @if maint + * A total of four data members accumulated down the heirarchy. If the + * _Alloc type requires separate instances, then two of them will also be + * included in each deque. + * @endif + */ + using _Base::_M_map; + using _Base::_M_map_size; + using _Base::_M_start; + using _Base::_M_finish; + + public: + // [23.2.1.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + /** + * @brief Default constructor creates no elements. + */ + explicit + deque(const allocator_type& __a = allocator_type()) + : _Base(__a, 0) {} + + /** + * @brief Create a %deque with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * + * This constructor fills the %deque with @a n copies of @a value. + */ + deque(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__a, __n) + { _M_fill_initialize(__value); } + + /** + * @brief Create a %deque with default elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %deque with @a n copies of a + * default-constructed element. + */ + explicit + deque(size_type __n) + : _Base(allocator_type(), __n) + { _M_fill_initialize(value_type()); } + + /** + * @brief %Deque copy constructor. + * @param x A %deque of identical element and allocator types. + * + * The newly-created %deque uses a copy of the allocation object used + * by @a x. + */ + deque(const deque& __x) + : _Base(__x.get_allocator(), __x.size()) + { uninitialized_copy(__x.begin(), __x.end(), _M_start); } + + /** + * @brief Builds a %deque from a range. + * @param first An input iterator. + * @param last An input iterator. + * + * Create a %deque consisting of copies of the elements from [first,last). + * + * If the iterators are forward, bidirectional, or random-access, then + * this will call the elements' copy constructor N times (where N is + * distance(first,last)) and do no memory reallocation. But if only + * input iterators are used, then this will do at most 2N calls to the + * copy constructor, and logN memory reallocations. + */ + template<typename _InputIterator> + deque(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } + + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + ~deque() { _Destroy(_M_start, _M_finish); } + + /** + * @brief %Deque assignment operator. + * @param x A %deque of identical element and allocator types. + * + * All the elements of @a x are copied, but unlike the copy constructor, + * the allocator object is not copied. + */ + deque& + operator=(const deque& __x); + + /** + * @brief Assigns a given value to a %deque. + * @param n Number of elements to be assigned. + * @param val Value to be assigned. + * + * This function fills a %deque with @a n copies of the given value. + * Note that the assignment completely changes the %deque and that the + * resulting %deque's size is the same as the number of elements assigned. + * Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %deque. + * @param first An input iterator. + * @param last An input iterator. + * + * This function fills a %deque with copies of the elements in the + * range [first,last). + * + * Note that the assignment completely changes the %deque and that the + * resulting %deque's size is the same as the number of elements assigned. + * Old data may be lost. + */ + template<typename _InputIterator> + void + assign(_InputIterator __first, _InputIterator __last) + { + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const { return _Base::get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first element in the + * %deque. Iteration is done in ordinary element order. + */ + iterator + begin() { return _M_start; } + + /** + * Returns a read-only (constant) iterator that points to the first element + * in the %deque. Iteration is done in ordinary element order. + */ + const_iterator + begin() const { return _M_start; } + + /** + * Returns a read/write iterator that points one past the last element in + * the %deque. Iteration is done in ordinary element order. + */ + iterator + end() { return _M_finish; } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %deque. Iteration is done in ordinary element order. + */ + const_iterator + end() const { return _M_finish; } + + /** + * Returns a read/write reverse iterator that points to the last element in + * the %deque. Iteration is done in reverse element order. + */ + reverse_iterator + rbegin() { return reverse_iterator(_M_finish); } + + /** + * Returns a read-only (constant) reverse iterator that points to the last + * element in the %deque. Iteration is done in reverse element order. + */ + const_reverse_iterator + rbegin() const { return const_reverse_iterator(_M_finish); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first element in the %deque. Iteration is done in reverse element + * order. + */ + reverse_iterator + rend() { return reverse_iterator(_M_start); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first element in the %deque. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + rend() const { return const_reverse_iterator(_M_start); } + + // [23.2.1.2] capacity + /** Returns the number of elements in the %deque. */ + size_type + size() const { return _M_finish - _M_start; } + + /** Returns the size() of the largest possible %deque. */ + size_type + max_size() const { return size_type(-1); } + + /** + * @brief Resizes the %deque to the specified number of elements. + * @param new_size Number of elements the %deque should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %deque to the specified number of + * elements. If the number is smaller than the %deque's current size the + * %deque is truncated, otherwise the %deque is extended and new elements + * are populated with given data. + */ void - insert(iterator __pos, _InputIterator __first, _InputIterator __last) + resize(size_type __new_size, const value_type& __x) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); + const size_type __len = size(); + if (__new_size < __len) + erase(_M_start + __new_size, _M_finish); + else + insert(_M_finish, __new_size - __len, __x); } - - template<class _Integer> + + /** + * @brief Resizes the %deque to the specified number of elements. + * @param new_size Number of elements the %deque should contain. + * + * This function will resize the %deque to the specified number of + * elements. If the number is smaller than the %deque's current size the + * %deque is truncated, otherwise the %deque is extended and new elements + * are default-constructed. + */ void - _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type) - { _M_fill_insert(__pos, static_cast<size_type>(__n), static_cast<value_type>(__x)); } - - template<class _InputIterator> + resize(size_type new_size) { resize(new_size, value_type()); } + + /** + * Returns true if the %deque is empty. (Thus begin() would equal end().) + */ + bool empty() const { return _M_finish == _M_start; } + + // element access + /** + * @brief Subscript access to the data contained in the %deque. + * @param n The index of the element for which data should be accessed. + * @return Read/write reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and out_of_range + * lookups are not defined. (For checked lookups see at().) + */ + reference + operator[](size_type __n) { return _M_start[difference_type(__n)]; } + + /** + * @brief Subscript access to the data contained in the %deque. + * @param n The index of the element for which data should be accessed. + * @return Read-only (constant) reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and out_of_range + * lookups are not defined. (For checked lookups see at().) + */ + const_reference + operator[](size_type __n) const { return _M_start[difference_type(__n)]; } + + protected: + /// @if maint Safety check used only from at(). @endif void - _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type) + _M_range_check(size_type __n) const { - typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory; - insert(__pos, __first, __last, _IterCategory()); - } - - void resize(size_type __new_size, const value_type& __x) { - const size_type __len = size(); - if (__new_size < __len) - erase(_M_start + __new_size, _M_finish); - else - insert(_M_finish, __new_size - __len, __x); - } - - void resize(size_type new_size) { resize(new_size, value_type()); } - -public: // Erase - iterator erase(iterator __pos) { - iterator __next = __pos; - ++__next; - size_type __index = __pos - _M_start; - if (__index < (size() >> 1)) { - copy_backward(_M_start, __pos, __next); - pop_front(); - } - else { - copy(__next, _M_finish, __pos); - pop_back(); - } - return _M_start + __index; - } - - iterator erase(iterator __first, iterator __last); - void clear(); - -protected: // Internal construction/destruction - - void _M_fill_initialize(const value_type& __value); - - template <class _InputIterator> - void _M_range_initialize(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template <class _ForwardIterator> - void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - -protected: // Internal push_* and pop_* - - void _M_push_back_aux(const value_type&); - void _M_push_back_aux(); - void _M_push_front_aux(const value_type&); - void _M_push_front_aux(); - void _M_pop_back_aux(); - void _M_pop_front_aux(); - -protected: // Internal insert functions - - template <class _InputIterator> - void insert(iterator __pos, _InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template <class _ForwardIterator> - void insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - - iterator _M_insert_aux(iterator __pos, const value_type& __x); - iterator _M_insert_aux(iterator __pos); - void _M_insert_aux(iterator __pos, size_type __n, const value_type& __x); - - template <class _ForwardIterator> - void _M_insert_aux(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - size_type __n); - - iterator _M_reserve_elements_at_front(size_type __n) { - size_type __vacancies = _M_start._M_cur - _M_start._M_first; - if (__n > __vacancies) - _M_new_elements_at_front(__n - __vacancies); - return _M_start - difference_type(__n); - } - - iterator _M_reserve_elements_at_back(size_type __n) { - size_type __vacancies = (_M_finish._M_last - _M_finish._M_cur) - 1; - if (__n > __vacancies) - _M_new_elements_at_back(__n - __vacancies); - return _M_finish + difference_type(__n); - } - - void _M_new_elements_at_front(size_type __new_elements); - void _M_new_elements_at_back(size_type __new_elements); - -protected: // Allocation of _M_map and nodes - - // Makes sure the _M_map has space for new nodes. Does not actually - // add the nodes. Can invalidate _M_map pointers. (And consequently, - // deque iterators.) - - void _M_reserve_map_at_back (size_type __nodes_to_add = 1) { - if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map)) - _M_reallocate_map(__nodes_to_add, false); - } - - void _M_reserve_map_at_front (size_type __nodes_to_add = 1) { - if (__nodes_to_add > size_type(_M_start._M_node - _M_map)) - _M_reallocate_map(__nodes_to_add, true); - } - - void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); -}; - -// Non-inline member functions - -template <class _Tp, class _Alloc> -template <class _InputIter> -void deque<_Tp, _Alloc> - ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag) -{ - iterator __cur = begin(); - for ( ; __first != __last && __cur != end(); ++__cur, ++__first) - *__cur = *__first; - if (__first == __last) - erase(__cur, end()); - else - insert(end(), __first, __last); -} - -template <class _Tp, class _Alloc> -void deque<_Tp, _Alloc>::_M_fill_insert(iterator __pos, - size_type __n, const value_type& __x) -{ - if (__pos._M_cur == _M_start._M_cur) { - iterator __new_start = _M_reserve_elements_at_front(__n); - try { - uninitialized_fill(__new_start, _M_start, __x); - _M_start = __new_start; - } - catch(...) - { - _M_destroy_nodes(__new_start._M_node, _M_start._M_node); - __throw_exception_again; - } - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - try { - uninitialized_fill(_M_finish, __new_finish, __x); - _M_finish = __new_finish; - } - catch(...) - { - _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); - __throw_exception_again; - } - } - else - _M_insert_aux(__pos, __n, __x); -} - -template <class _Tp, class _Alloc> -typename deque<_Tp,_Alloc>::iterator -deque<_Tp,_Alloc>::erase(iterator __first, iterator __last) -{ - if (__first == _M_start && __last == _M_finish) { - clear(); - return _M_finish; - } - else { - difference_type __n = __last - __first; - difference_type __elems_before = __first - _M_start; - if (static_cast<size_type>(__elems_before) < (size() - __n) / 2) { - copy_backward(_M_start, __first, __last); - iterator __new_start = _M_start + __n; - _Destroy(_M_start, __new_start); - _M_destroy_nodes(_M_start._M_node, __new_start._M_node); - _M_start = __new_start; - } - else { - copy(__last, _M_finish, __first); - iterator __new_finish = _M_finish - __n; - _Destroy(__new_finish, _M_finish); - _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1); - _M_finish = __new_finish; + if (__n >= this->size()) + __throw_out_of_range("deque [] access out of range"); } - return _M_start + __elems_before; - } -} - -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::clear() -{ - for (_Map_pointer __node = _M_start._M_node + 1; - __node < _M_finish._M_node; - ++__node) { - _Destroy(*__node, *__node + _S_buffer_size()); - _M_deallocate_node(*__node); - } - - if (_M_start._M_node != _M_finish._M_node) { - _Destroy(_M_start._M_cur, _M_start._M_last); - _Destroy(_M_finish._M_first, _M_finish._M_cur); - _M_deallocate_node(_M_finish._M_first); - } - else - _Destroy(_M_start._M_cur, _M_finish._M_cur); - - _M_finish = _M_start; -} - -/** - * @if maint - * @brief Fills the deque with copies of value. - * @param value Initial value. - * @return Nothing. - * @pre _M_start and _M_finish have already been initialized, but none of the - * deque's elements have yet been constructed. - * - * This function is called only when the user provides an explicit size (with - * or without an explicit exemplar value). - * @endif -*/ -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __value) -{ - _Map_pointer __cur; - try { - for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur) - uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value); - uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value); - } - catch(...) + + public: + /** + * @brief Provides access to the data contained in the %deque. + * @param n The index of the element for which data should be accessed. + * @return Read/write reference to data. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is first + * checked that it is in the range of the deque. The function throws + * out_of_range if the check fails. + */ + reference + at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } + + /** + * @brief Provides access to the data contained in the %deque. + * @param n The index of the element for which data should be accessed. + * @return Read-only (constant) reference to data. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is first + * checked that it is in the range of the deque. The function throws + * out_of_range if the check fails. + */ + const_reference + at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } + + /** + * Returns a read/write reference to the data at the first element of the + * %deque. + */ + reference + front() { return *_M_start; } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %deque. + */ + const_reference + front() const { return *_M_start; } + + /** + * Returns a read/write reference to the data at the last element of the + * %deque. + */ + reference + back() { - _Destroy(_M_start, iterator(*__cur, __cur)); - __throw_exception_again; + iterator __tmp = _M_finish; + --__tmp; + return *__tmp; } -} - -/** @{ - * @if maint - * @brief Fills the deque with whatever is in [first,last). - * @param first An input iterator. - * @param last An input iterator. - * @return Nothing. - * - * If the iterators are actually forward iterators (or better), then the - * memory layout can be done all at once. Else we move forward using - * push_back on each value from the iterator. - * @endif -*/ -template <class _Tp, class _Alloc> template <class _InputIterator> -void deque<_Tp,_Alloc>::_M_range_initialize(_InputIterator __first, - _InputIterator __last, - input_iterator_tag) -{ - _M_initialize_map(0); - try { - for ( ; __first != __last; ++__first) - push_back(*__first); - } - catch(...) + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %deque. + */ + const_reference + back() const { - clear(); - __throw_exception_again; - } -} - -template <class _Tp, class _Alloc> template <class _ForwardIterator> -void deque<_Tp,_Alloc>::_M_range_initialize(_ForwardIterator __first, - _ForwardIterator __last, - forward_iterator_tag) -{ - size_type __n = distance(__first, __last); - _M_initialize_map(__n); - - _Map_pointer __cur_node; - try { - for (__cur_node = _M_start._M_node; - __cur_node < _M_finish._M_node; - ++__cur_node) { - _ForwardIterator __mid = __first; - advance(__mid, _S_buffer_size()); - uninitialized_copy(__first, __mid, *__cur_node); - __first = __mid; + const_iterator __tmp = _M_finish; + --__tmp; + return *__tmp; } - uninitialized_copy(__first, __last, _M_finish._M_first); - } - catch(...) + + // [23.2.1.2] modifiers + /** + * @brief Add data to the front of the %deque. + * @param x Data to be added. + * + * This is a typical stack operation. The function creates an element at + * the front of the %deque and assigns the given data to it. Due to the + * nature of a %deque this operation can be done in constant time. + */ + void + push_front(const value_type& __x) { - _Destroy(_M_start, iterator(*__cur_node, __cur_node)); - __throw_exception_again; + if (_M_start._M_cur != _M_start._M_first) { + _Construct(_M_start._M_cur - 1, __x); + --_M_start._M_cur; + } + else + _M_push_front_aux(__x); } -} -/** @} */ - -// Called only if _M_finish._M_cur == _M_finish._M_last - 1. -template <class _Tp, class _Alloc> -void -deque<_Tp,_Alloc>::_M_push_back_aux(const value_type& __t) -{ - value_type __t_copy = __t; - _M_reserve_map_at_back(); - *(_M_finish._M_node + 1) = _M_allocate_node(); - try { - _Construct(_M_finish._M_cur, __t_copy); - _M_finish._M_set_node(_M_finish._M_node + 1); - _M_finish._M_cur = _M_finish._M_first; - } - catch(...) + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Add data to the front of the %deque. + * + * This is a typical stack operation. The function creates a + * default-constructed element at the front of the %deque. Due to the + * nature of a %deque this operation can be done in constant time. You + * should consider using push_front(value_type()) instead. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + void + push_front() { - _M_deallocate_node(*(_M_finish._M_node + 1)); - __throw_exception_again; + if (_M_start._M_cur != _M_start._M_first) { + _Construct(_M_start._M_cur - 1); + --_M_start._M_cur; + } + else + _M_push_front_aux(); } -} - -// Called only if _M_finish._M_cur == _M_finish._M_last - 1. -template <class _Tp, class _Alloc> -void -deque<_Tp,_Alloc>::_M_push_back_aux() -{ - _M_reserve_map_at_back(); - *(_M_finish._M_node + 1) = _M_allocate_node(); - try { - _Construct(_M_finish._M_cur); - _M_finish._M_set_node(_M_finish._M_node + 1); - _M_finish._M_cur = _M_finish._M_first; - } - catch(...) + #endif + + /** + * @brief Add data to the end of the %deque. + * @param x Data to be added. + * + * This is a typical stack operation. The function creates an element at + * the end of the %deque and assigns the given data to it. Due to the + * nature of a %deque this operation can be done in constant time. + */ + void + push_back(const value_type& __x) { - _M_deallocate_node(*(_M_finish._M_node + 1)); - __throw_exception_again; + if (_M_finish._M_cur != _M_finish._M_last - 1) { + _Construct(_M_finish._M_cur, __x); + ++_M_finish._M_cur; + } + else + _M_push_back_aux(__x); } -} - -// Called only if _M_start._M_cur == _M_start._M_first. -template <class _Tp, class _Alloc> -void -deque<_Tp,_Alloc>::_M_push_front_aux(const value_type& __t) -{ - value_type __t_copy = __t; - _M_reserve_map_at_front(); - *(_M_start._M_node - 1) = _M_allocate_node(); - try { - _M_start._M_set_node(_M_start._M_node - 1); - _M_start._M_cur = _M_start._M_last - 1; - _Construct(_M_start._M_cur, __t_copy); - } - catch(...) + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Add data to the end of the %deque. + * + * This is a typical stack operation. The function creates a + * default-constructed element at the end of the %deque. Due to the nature + * of a %deque this operation can be done in constant time. You should + * consider using push_back(value_type()) instead. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + void + push_back() { - ++_M_start; - _M_deallocate_node(*(_M_start._M_node - 1)); - __throw_exception_again; + if (_M_finish._M_cur != _M_finish._M_last - 1) { + _Construct(_M_finish._M_cur); + ++_M_finish._M_cur; + } + else + _M_push_back_aux(); } -} - -// Called only if _M_start._M_cur == _M_start._M_first. -template <class _Tp, class _Alloc> -void -deque<_Tp,_Alloc>::_M_push_front_aux() -{ - _M_reserve_map_at_front(); - *(_M_start._M_node - 1) = _M_allocate_node(); - try { - _M_start._M_set_node(_M_start._M_node - 1); - _M_start._M_cur = _M_start._M_last - 1; - _Construct(_M_start._M_cur); - } - catch(...) + #endif + + /** + * @brief Removes first element. + * + * This is a typical stack operation. It shrinks the %deque by one. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop_front() is called. + */ + void + pop_front() { - ++_M_start; - _M_deallocate_node(*(_M_start._M_node - 1)); - __throw_exception_again; + if (_M_start._M_cur != _M_start._M_last - 1) { + _Destroy(_M_start._M_cur); + ++_M_start._M_cur; + } + else + _M_pop_front_aux(); } -} - -// Called only if _M_finish._M_cur == _M_finish._M_first. -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_pop_back_aux() -{ - _M_deallocate_node(_M_finish._M_first); - _M_finish._M_set_node(_M_finish._M_node - 1); - _M_finish._M_cur = _M_finish._M_last - 1; - _Destroy(_M_finish._M_cur); -} - -// Called only if _M_start._M_cur == _M_start._M_last - 1. Note that -// if the deque has at least one element (a precondition for this member -// function), and if _M_start._M_cur == _M_start._M_last, then the deque -// must have at least two nodes. -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_pop_front_aux() -{ - _Destroy(_M_start._M_cur); - _M_deallocate_node(_M_start._M_first); - _M_start._M_set_node(_M_start._M_node + 1); - _M_start._M_cur = _M_start._M_first; -} - -template <class _Tp, class _Alloc> template <class _InputIterator> -void deque<_Tp,_Alloc>::insert(iterator __pos, - _InputIterator __first, _InputIterator __last, - input_iterator_tag) -{ - copy(__first, __last, inserter(*this, __pos)); -} - -template <class _Tp, class _Alloc> template <class _ForwardIterator> -void -deque<_Tp,_Alloc>::insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) { - size_type __n = distance(__first, __last); - if (__pos._M_cur == _M_start._M_cur) { - iterator __new_start = _M_reserve_elements_at_front(__n); - try { - uninitialized_copy(__first, __last, __new_start); - _M_start = __new_start; + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %deque by one. + * + * Note that no data is returned, and if the last element's data is + * needed, it should be retrieved before pop_back() is called. + */ + void + pop_back() + { + if (_M_finish._M_cur != _M_finish._M_first) { + --_M_finish._M_cur; + _Destroy(_M_finish._M_cur); + } + else + _M_pop_back_aux(); } - catch(...) + + /** + * @brief Inserts given value into %deque before specified iterator. + * @param position An iterator into the %deque. + * @param x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before the specified + * location. + */ + iterator + insert(iterator position, const value_type& __x); + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Inserts an element into the %deque. + * @param position An iterator into the %deque. + * @return An iterator that points to the inserted element. + * + * This function will insert a default-constructed element before the + * specified location. You should consider using + * insert(position,value_type()) instead. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + iterator + insert(iterator __position) + { return insert(__position, value_type()); } + #endif + + /** + * @brief Inserts a number of copies of given data into the %deque. + * @param position An iterator into the %deque. + * @param n Number of elements to be inserted. + * @param x Data to be inserted. + * + * This function will insert a specified number of copies of the given data + * before the location specified by @a position. + */ + void + insert(iterator __position, size_type __n, const value_type& __x) + { _M_fill_insert(__position, __n, __x); } + + /** + * @brief Inserts a range into the %deque. + * @param pos An iterator into the %deque. + * @param first An input iterator. + * @param last An input iterator. + * + * This function will insert copies of the data in the range [first,last) + * into the %deque before the location specified by @a pos. This is + * known as "range insert." + */ + template<typename _InputIterator> + void + insert(iterator __pos, _InputIterator __first, _InputIterator __last) { - _M_destroy_nodes(__new_start._M_node, _M_start._M_node); - __throw_exception_again; + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); } - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - try { - uninitialized_copy(__first, __last, _M_finish); - _M_finish = __new_finish; + + /** + * @brief Remove element at given position. + * @param position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %deque by one. + * + * The user is cautioned that + * this function only erases the element, and that if the element is itself + * a pointer, the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibilty. + */ + iterator + erase(iterator __position); + + /** + * @brief Remove a range of elements. + * @param first Iterator pointing to the first element to be erased. + * @param last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a last + * prior to erasing (or end()). + * + * This function will erase the elements in the range [first,last) and + * shorten the %deque accordingly. + * + * The user is cautioned that + * this function only erases the elements, and that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + iterator + erase(iterator __first, iterator __last); + + /** + * @brief Swaps data with another %deque. + * @param x A %deque of the same element and allocator types. + * + * This exchanges the elements between two deques in constant time. + * (Four pointers, so it should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(d1,d2) will feed to this function. + */ + void + swap(deque& __x) + { + std::swap(_M_start, __x._M_start); + std::swap(_M_finish, __x._M_finish); + std::swap(_M_map, __x._M_map); + std::swap(_M_map_size, __x._M_map_size); } - catch(...) + + /** + * Erases all the elements. Note that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibilty. + */ + void clear(); + + protected: + // Internal constructor functions follow. + + // called by the range constructor to implement [23.1.1]/9 + template<typename _Integer> + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) { - _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); - __throw_exception_again; + _M_initialize_map(__n); + _M_fill_initialize(__x); } - } - else - _M_insert_aux(__pos, __first, __last, __n); -} - -template <class _Tp, class _Alloc> -typename deque<_Tp, _Alloc>::iterator -deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, const value_type& __x) -{ - difference_type __index = __pos - _M_start; - value_type __x_copy = __x; - if (static_cast<size_type>(__index) < size() / 2) { - push_front(front()); - iterator __front1 = _M_start; - ++__front1; - iterator __front2 = __front1; - ++__front2; - __pos = _M_start + __index; - iterator __pos1 = __pos; - ++__pos1; - copy(__front2, __pos1, __front1); - } - else { - push_back(back()); - iterator __back1 = _M_finish; - --__back1; - iterator __back2 = __back1; - --__back2; - __pos = _M_start + __index; - copy_backward(__pos, __back2, __back1); - } - *__pos = __x_copy; - return __pos; -} - -template <class _Tp, class _Alloc> -typename deque<_Tp,_Alloc>::iterator -deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos) -{ - difference_type __index = __pos - _M_start; - if (static_cast<size_type>(__index) < size() / 2) { - push_front(front()); - iterator __front1 = _M_start; - ++__front1; - iterator __front2 = __front1; - ++__front2; - __pos = _M_start + __index; - iterator __pos1 = __pos; - ++__pos1; - copy(__front2, __pos1, __front1); - } - else { - push_back(back()); - iterator __back1 = _M_finish; - --__back1; - iterator __back2 = __back1; - --__back2; - __pos = _M_start + __index; - copy_backward(__pos, __back2, __back1); - } - *__pos = value_type(); - return __pos; -} - -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, - size_type __n, - const value_type& __x) -{ - const difference_type __elems_before = __pos - _M_start; - size_type __length = this->size(); - value_type __x_copy = __x; - if (__elems_before < difference_type(__length / 2)) { - iterator __new_start = _M_reserve_elements_at_front(__n); - iterator __old_start = _M_start; - __pos = _M_start + __elems_before; - try { - if (__elems_before >= difference_type(__n)) { - iterator __start_n = _M_start + difference_type(__n); - uninitialized_copy(_M_start, __start_n, __new_start); - _M_start = __new_start; - copy(__start_n, __pos, __old_start); - fill(__pos - difference_type(__n), __pos, __x_copy); - } - else { - __uninitialized_copy_fill(_M_start, __pos, __new_start, - _M_start, __x_copy); - _M_start = __new_start; - fill(__old_start, __pos, __x_copy); - } - } - catch(...) - { - _M_destroy_nodes(__new_start._M_node, _M_start._M_node); - __throw_exception_again; + + // called by the range constructor to implement [23.1.1]/9 + template<typename _InputIter> + void + _M_initialize_dispatch(_InputIter __first, _InputIter __last, + __false_type) + { + typedef typename iterator_traits<_InputIter>::iterator_category + _IterCategory; + _M_range_initialize(__first, __last, _IterCategory()); } - } - else { - iterator __new_finish = _M_reserve_elements_at_back(__n); - iterator __old_finish = _M_finish; - const difference_type __elems_after = - difference_type(__length) - __elems_before; - __pos = _M_finish - __elems_after; - try { - if (__elems_after > difference_type(__n)) { - iterator __finish_n = _M_finish - difference_type(__n); - uninitialized_copy(__finish_n, _M_finish, _M_finish); - _M_finish = __new_finish; - copy_backward(__pos, __finish_n, __old_finish); - fill(__pos, __pos + difference_type(__n), __x_copy); + + // called by the second initialize_dispatch above + //@{ + /** + * @if maint + * @brief Fills the deque with whatever is in [first,last). + * @param first An input iterator. + * @param last An input iterator. + * @return Nothing. + * + * If the iterators are actually forward iterators (or better), then the + * memory layout can be done all at once. Else we move forward using + * push_back on each value from the iterator. + * @endif + */ + template <typename _InputIterator> + void + _M_range_initialize(_InputIterator __first, _InputIterator __last, + input_iterator_tag); + + // called by the second initialize_dispatch above + template <typename _ForwardIterator> + void + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + forward_iterator_tag); + //@} + + /** + * @if maint + * @brief Fills the %deque with copies of value. + * @param value Initial value. + * @return Nothing. + * @pre _M_start and _M_finish have already been initialized, but none of + * the %deque's elements have yet been constructed. + * + * This function is called only when the user provides an explicit size + * (with or without an explicit exemplar value). + * @endif + */ + void + _M_fill_initialize(const value_type& __value); + + + // Internal assign functions follow. The *_aux functions do the actual + // assignment work for the range versions. + + // called by the range assign to implement [23.1.1]/9 + template<typename _Integer> + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { + _M_fill_assign(static_cast<size_type>(__n), + static_cast<value_type>(__val)); } - else { - __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n), - __x_copy, __pos, _M_finish); - _M_finish = __new_finish; - fill(__pos, __old_finish, __x_copy); + + // called by the range assign to implement [23.1.1]/9 + template<typename _InputIter> + void + _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type) + { + typedef typename iterator_traits<_InputIter>::iterator_category + _IterCategory; + _M_assign_aux(__first, __last, _IterCategory()); } - } - catch(...) - { - _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); - __throw_exception_again; + + // called by the second assign_dispatch above + template <typename _InputIterator> + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + input_iterator_tag); + + // called by the second assign_dispatch above + template <typename _ForwardIterator> + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + forward_iterator_tag) + { + size_type __len = distance(__first, __last); + if (__len > size()) { + _ForwardIterator __mid = __first; + advance(__mid, size()); + copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + else + erase(copy(__first, __last, begin()), end()); } - } -} - -template <class _Tp, class _Alloc> template <class _ForwardIterator> -void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, - _ForwardIterator __first, - _ForwardIterator __last, - size_type __n) -{ - const difference_type __elemsbefore = __pos - _M_start; - size_type __length = size(); - if (static_cast<size_type>(__elemsbefore) < __length / 2) { - iterator __new_start = _M_reserve_elements_at_front(__n); - iterator __old_start = _M_start; - __pos = _M_start + __elemsbefore; - try { - if (__elemsbefore >= difference_type(__n)) { - iterator __start_n = _M_start + difference_type(__n); - uninitialized_copy(_M_start, __start_n, __new_start); - _M_start = __new_start; - copy(__start_n, __pos, __old_start); - copy(__first, __last, __pos - difference_type(__n)); + + // Called by assign(n,t), and the range assign when it turns out to be the + // same thing. + void + _M_fill_assign(size_type __n, const value_type& __val) + { + if (__n > size()) + { + fill(begin(), end(), __val); + insert(end(), __n - size(), __val); } - else { - _ForwardIterator __mid = __first; - advance(__mid, difference_type(__n) - __elemsbefore); - __uninitialized_copy_copy(_M_start, __pos, __first, __mid, - __new_start); - _M_start = __new_start; - copy(__mid, __last, __old_start); + else + { + erase(begin() + __n, end()); + fill(begin(), end(), __val); } } - catch(...) + + + //@{ + /** + * @if maint + * @brief Helper functions for push_* and pop_*. + * @endif + */ + void _M_push_back_aux(const value_type&); + void _M_push_front_aux(const value_type&); + #ifdef _GLIBCPP_DEPRECATED + void _M_push_back_aux(); + void _M_push_front_aux(); + #endif + void _M_pop_back_aux(); + void _M_pop_front_aux(); + //@} + + + // Internal insert functions follow. The *_aux functions do the actual + // insertion work when all shortcuts fail. + + // called by the range insert to implement [23.1.1]/9 + template<typename _Integer> + void + _M_insert_dispatch(iterator __pos, + _Integer __n, _Integer __x, __true_type) { - _M_destroy_nodes(__new_start._M_node, _M_start._M_node); - __throw_exception_again; - } - } - else { - iterator __new_finish = _M_reserve_elements_at_back(__n); - iterator __old_finish = _M_finish; - const difference_type __elemsafter = - difference_type(__length) - __elemsbefore; - __pos = _M_finish - __elemsafter; - try { - if (__elemsafter > difference_type(__n)) { - iterator __finish_n = _M_finish - difference_type(__n); - uninitialized_copy(__finish_n, _M_finish, _M_finish); - _M_finish = __new_finish; - copy_backward(__pos, __finish_n, __old_finish); - copy(__first, __last, __pos); - } - else { - _ForwardIterator __mid = __first; - advance(__mid, __elemsafter); - __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish); - _M_finish = __new_finish; - copy(__first, __mid, __pos); + _M_fill_insert(__pos, static_cast<size_type>(__n), + static_cast<value_type>(__x)); } - } - catch(...) + + // called by the range insert to implement [23.1.1]/9 + template<typename _InputIterator> + void + _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + __false_type) { - _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1); - __throw_exception_again; + typedef typename iterator_traits<_InputIterator>::iterator_category + _IterCategory; + _M_range_insert_aux(__pos, __first, __last, _IterCategory()); } + + // called by the second insert_dispatch above + template <typename _InputIterator> + void + _M_range_insert_aux(iterator __pos, _InputIterator __first, + _InputIterator __last, input_iterator_tag); + + // called by the second insert_dispatch above + template <typename _ForwardIterator> + void + _M_range_insert_aux(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, forward_iterator_tag); + + // Called by insert(p,n,x), and the range insert when it turns out to be + // the same thing. Can use fill functions in optimal situations, otherwise + // passes off to insert_aux(p,n,x). + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + // called by insert(p,x) + iterator + _M_insert_aux(iterator __pos, const value_type& __x); + + // called by insert(p,n,x) via fill_insert + void + _M_insert_aux(iterator __pos, size_type __n, const value_type& __x); + + // called by range_insert_aux for forward iterators + template <typename _ForwardIterator> + void + _M_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + size_type __n); + + #ifdef _GLIBCPP_DEPRECATED + // unused, see comment in implementation + iterator _M_insert_aux(iterator __pos); + #endif + + //@{ + /** + * @if maint + * @brief Memory-handling helpers for the previous internal insert + * functions. + * @endif + */ + iterator + _M_reserve_elements_at_front(size_type __n) + { + size_type __vacancies = _M_start._M_cur - _M_start._M_first; + if (__n > __vacancies) + _M_new_elements_at_front(__n - __vacancies); + return _M_start - difference_type(__n); + } + + iterator + _M_reserve_elements_at_back(size_type __n) + { + size_type __vacancies = (_M_finish._M_last - _M_finish._M_cur) - 1; + if (__n > __vacancies) + _M_new_elements_at_back(__n - __vacancies); + return _M_finish + difference_type(__n); + } + + void + _M_new_elements_at_front(size_type __new_elements); + + void + _M_new_elements_at_back(size_type __new_elements); + //@} + + + //@{ + /** + * @if maint + * @brief Memory-handling helpers for the major %map. + * + * Makes sure the _M_map has space for new nodes. Does not actually add + * the nodes. Can invalidate _M_map pointers. (And consequently, %deque + * iterators.) + * @endif + */ + void + _M_reserve_map_at_back (size_type __nodes_to_add = 1) + { + if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map)) + _M_reallocate_map(__nodes_to_add, false); + } + + void + _M_reserve_map_at_front (size_type __nodes_to_add = 1) + { + if (__nodes_to_add > size_type(_M_start._M_node - _M_map)) + _M_reallocate_map(__nodes_to_add, true); + } + + void + _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); + //@} + }; + + + /** + * @brief Deque equality comparison. + * @param x A %deque. + * @param y A %deque of the same type as @a x. + * @return True iff the size and elements of the deques are equal. + * + * This is an equivalence relation. It is linear in the size of the + * deques. Deques are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ + template <typename _Tp, typename _Alloc> + inline bool operator==(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { + return __x.size() == __y.size() && + equal(__x.begin(), __x.end(), __y.begin()); } -} - -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_new_elements_at_front(size_type __new_elems) -{ - size_type __new_nodes - = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size(); - _M_reserve_map_at_front(__new_nodes); - size_type __i; - try { - for (__i = 1; __i <= __new_nodes; ++__i) - *(_M_start._M_node - __i) = _M_allocate_node(); + + /** + * @brief Deque ordering relation. + * @param x A %deque. + * @param y A %deque of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. + * + * This is a total ordering relation. It is linear in the size of the + * deques. The elements must be comparable with @c <. + * + * See std::lexographical_compare() for how the determination is made. + */ + template <typename _Tp, typename _Alloc> + inline bool operator<(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { + return lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } - catch(...) { - for (size_type __j = 1; __j < __i; ++__j) - _M_deallocate_node(*(_M_start._M_node - __j)); - __throw_exception_again; + + /// Based on operator== + template <typename _Tp, typename _Alloc> + inline bool operator!=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) { + return !(__x == __y); } -} - -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_new_elements_at_back(size_type __new_elems) -{ - size_type __new_nodes - = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size(); - _M_reserve_map_at_back(__new_nodes); - size_type __i; - try { - for (__i = 1; __i <= __new_nodes; ++__i) - *(_M_finish._M_node + __i) = _M_allocate_node(); + + /// Based on operator< + template <typename _Tp, typename _Alloc> + inline bool operator>(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) { + return __y < __x; } - catch(...) { - for (size_type __j = 1; __j < __i; ++__j) - _M_deallocate_node(*(_M_finish._M_node + __j)); - __throw_exception_again; + + /// Based on operator< + template <typename _Tp, typename _Alloc> + inline bool operator<=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) { + return !(__y < __x); } -} - -template <class _Tp, class _Alloc> -void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add, - bool __add_at_front) -{ - size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1; - size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; - - _Map_pointer __new_nstart; - if (_M_map_size > 2 * __new_num_nodes) { - __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 - + (__add_at_front ? __nodes_to_add : 0); - if (__new_nstart < _M_start._M_node) - copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); - else - copy_backward(_M_start._M_node, _M_finish._M_node + 1, - __new_nstart + __old_num_nodes); + + /// Based on operator< + template <typename _Tp, typename _Alloc> + inline bool operator>=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) { + return !(__x < __y); } - else { - size_type __new_map_size = - _M_map_size + max(_M_map_size, __nodes_to_add) + 2; - - _Map_pointer __new_map = _M_allocate_map(__new_map_size); - __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 - + (__add_at_front ? __nodes_to_add : 0); - copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); - _M_deallocate_map(_M_map, _M_map_size); - - _M_map = __new_map; - _M_map_size = __new_map_size; + + /// See std::deque::swap(). + template <typename _Tp, typename _Alloc> + inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) + { + __x.swap(__y); } - - _M_start._M_set_node(__new_nstart); - _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); -} - - -// Nonmember functions. - -template <class _Tp, class _Alloc> -inline bool operator==(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return __x.size() == __y.size() && - equal(__x.begin(), __x.end(), __y.begin()); -} - -template <class _Tp, class _Alloc> -inline bool operator<(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -template <class _Tp, class _Alloc> -inline bool operator!=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__x == __y); -} - -template <class _Tp, class _Alloc> -inline bool operator>(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return __y < __x; -} - -template <class _Tp, class _Alloc> -inline bool operator<=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__y < __x); -} -template <class _Tp, class _Alloc> -inline bool operator>=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__x < __y); -} - -template <class _Tp, class _Alloc> -inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) { - __x.swap(__y); -} - } // namespace std #endif /* __GLIBCPP_INTERNAL_DEQUE_H */ - diff --git a/contrib/libstdc++/include/bits/stl_iterator.h b/contrib/libstdc++/include/bits/stl_iterator.h index 6fb0d81339f0..529ad7741756 100644 --- a/contrib/libstdc++/include/bits/stl_iterator.h +++ b/contrib/libstdc++/include/bits/stl_iterator.h @@ -106,9 +106,12 @@ namespace std public: /** - * The default constructor gives an undefined state to this %iterator. + * The default constructor default-initializes member @p current. + * If it is a pointer, that means it is zero-initialized. */ - reverse_iterator() { } + // _GLIBCPP_RESOLVE_LIB_DEFECTS + // 235 No specification of default ctor for reverse_iterator + reverse_iterator() : current() { } /** * This %iterator will move in the opposite direction that @p x does. @@ -317,6 +320,8 @@ namespace std // 24.4.2.2.1 back_insert_iterator /** + * @brief Turns assignment into insertion. + * * These are output iterators, constructed from a container-of-T. * Assigning a T to the iterator appends it to the container using * push_back. @@ -387,6 +392,8 @@ namespace std { return back_insert_iterator<_Container>(__x); } /** + * @brief Turns assignment into insertion. + * * These are output iterators, constructed from a container-of-T. * Assigning a T to the iterator prepends it to the container using * push_front. @@ -456,6 +463,8 @@ namespace std { return front_insert_iterator<_Container>(__x); } /** + * @brief Turns assignment into insertion. + * * These are output iterators, constructed from a container-of-T. * Assigning a T to the iterator inserts it in the container at the * %iterator's position, rather than overwriting the value at that diff --git a/contrib/libstdc++/include/bits/stl_iterator_base_funcs.h b/contrib/libstdc++/include/bits/stl_iterator_base_funcs.h index 8389f5e7d03a..7c245d056c6d 100644 --- a/contrib/libstdc++/include/bits/stl_iterator_base_funcs.h +++ b/contrib/libstdc++/include/bits/stl_iterator_base_funcs.h @@ -67,113 +67,105 @@ #pragma GCC system_header #include <bits/concept_check.h> -// Since this entire file is within namespace std, there's no reason to -// waste two spaces along the left column. Thus the leading indentation is -// slightly violated from here on. namespace std { -template<typename _InputIterator> - inline typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) - { - // concept requirements - __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>) - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) { - ++__first; ++__n; + template<typename _InputIterator> + inline typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + // concept requirements + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>) + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; } - return __n; - } - -template<typename _RandomAccessIterator> - inline typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - // concept requirements - __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>) - return __last - __first; - } - -/** - * @brief A generalization of pointer arithmetic. - * @param first An input iterator. - * @param last An input iterator. - * @return The distance between them. - * - * Returns @c n such that first + n == last. This requires that @p last - * must be reachable from @p first. Note that @c n may be negative. - * - * For random access iterators, this uses their @c + and @c - operations - * and are constant time. For other %iterator classes they are linear time. -*/ -template<typename _InputIterator> - inline typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - // concept requirements -- taken care of in __distance - return __distance(__first, __last, __iterator_category(__first)); - } - -template<typename _InputIter, typename _Distance> - inline void - __advance(_InputIter& __i, _Distance __n, input_iterator_tag) - { - // concept requirements - __glibcpp_function_requires(_InputIteratorConcept<_InputIter>) - while (__n--) ++__i; - } - -template<typename _BidirectionalIterator, typename _Distance> - inline void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - // concept requirements - __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>) - - if (__n > 0) + + template<typename _RandomAccessIterator> + inline typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + // concept requirements + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>) + return __last - __first; + } + + /** + * @brief A generalization of pointer arithmetic. + * @param first An input iterator. + * @param last An input iterator. + * @return The distance between them. + * + * Returns @c n such that first + n == last. This requires that @p last + * must be reachable from @p first. Note that @c n may be negative. + * + * For random access iterators, this uses their @c + and @c - operations + * and are constant time. For other %iterator classes they are linear time. + */ + template<typename _InputIterator> + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + // concept requirements -- taken care of in __distance + return __distance(__first, __last, __iterator_category(__first)); + } + + template<typename _InputIter, typename _Distance> + inline void + __advance(_InputIter& __i, _Distance __n, input_iterator_tag) + { + // concept requirements + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>) while (__n--) ++__i; - else - while (__n++) --__i; - } - -template<typename _RandomAccessIterator, typename _Distance> - inline void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - // concept requirements - __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>) - __i += __n; - } - -/** - * @brief A generalization of pointer arithmetic. - * @param i An input iterator. - * @param n The "delta" by which to change @p i. - * @return Nothing. - * - * This increments @p i by @p n. For bidirectional and random access - * iterators, @p n may be negative, in which case @p i is decremented. - * - * For random access iterators, this uses their @c + and @c - operations - * and are constant time. For other %iterator classes they are linear time. -*/ -template<typename _InputIterator, typename _Distance> - inline void - advance(_InputIterator& __i, _Distance __n) - { - // concept requirements -- taken care of in __advance - __advance(__i, __n, __iterator_category(__i)); - } - + } + + template<typename _BidirectionalIterator, typename _Distance> + inline void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + // concept requirements + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>) + + if (__n > 0) + while (__n--) ++__i; + else + while (__n++) --__i; + } + + template<typename _RandomAccessIterator, typename _Distance> + inline void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + // concept requirements + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>) + __i += __n; + } + + /** + * @brief A generalization of pointer arithmetic. + * @param i An input iterator. + * @param n The "delta" by which to change @p i. + * @return Nothing. + * + * This increments @p i by @p n. For bidirectional and random access + * iterators, @p n may be negative, in which case @p i is decremented. + * + * For random access iterators, this uses their @c + and @c - operations + * and are constant time. For other %iterator classes they are linear time. + */ + template<typename _InputIterator, typename _Distance> + inline void + advance(_InputIterator& __i, _Distance __n) + { + // concept requirements -- taken care of in __advance + __advance(__i, __n, __iterator_category(__i)); + } } // namespace std #endif /* __GLIBCPP_INTERNAL_ITERATOR_BASE_FUNCS_H */ - - -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/stl_iterator_base_types.h b/contrib/libstdc++/include/bits/stl_iterator_base_types.h index 5dff8fc3f447..8b040e496023 100644 --- a/contrib/libstdc++/include/bits/stl_iterator_base_types.h +++ b/contrib/libstdc++/include/bits/stl_iterator_base_types.h @@ -68,13 +68,13 @@ namespace std { + //@{ /** * @defgroup iterator_tags Iterator Tags * These are empty types, used to distinguish different iterators. The * distinction is not made by what they contain, but simply by what they * are. Different underlying algorithms can then be used based on the * different operations supporetd by different iterator types. - * @{ */ /// Marking input iterators. struct input_iterator_tag {}; @@ -90,6 +90,8 @@ namespace std /** + * @brief Common %iterator class. + * * This class does nothing but define nested typedefs. %Iterator classes * can inherit from this class to save some work. The typedefs are then * used in specializations and overloading. @@ -98,8 +100,9 @@ namespace std * such as @c operator++ and the like. (How could there be?) */ template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, - typename _Pointer = _Tp*, typename _Reference = _Tp&> - struct iterator { + typename _Pointer = _Tp*, typename _Reference = _Tp&> + struct iterator + { /// One of the @link iterator_tags tag types@endlink. typedef _Category iterator_category; /// The type "pointed to" by the iterator. diff --git a/contrib/libstdc++/include/bits/stl_list.h b/contrib/libstdc++/include/bits/stl_list.h index 3d470b1f25f0..fcba3598df24 100644 --- a/contrib/libstdc++/include/bits/stl_list.h +++ b/contrib/libstdc++/include/bits/stl_list.h @@ -65,215 +65,263 @@ namespace std { - + // Supporting structures are split into common and templated types; the + // latter publicly inherits from the former in an effort to reduce code + // duplication. This results in some "needless" static_cast'ing later on, + // but it's all safe downcasting. + + /// @if maint Common part of a node in the %list. @endif struct _List_node_base { - _List_node_base* _M_next; - _List_node_base* _M_prev; + _List_node_base* _M_next; ///< Self-explanatory + _List_node_base* _M_prev; ///< Self-explanatory }; - + + /// @if maint An actual node in the %list. @endif template<typename _Tp> struct _List_node : public _List_node_base - { - _Tp _M_data; - }; - + { + _Tp _M_data; ///< User's data. + }; + + + /** + * @if maint + * @brief Common part of a list::iterator. + * + * A simple type to walk a doubly-linked list. All operations here should + * be self-explanatory after taking any decent introductory data structures + * course. + * @endif + */ struct _List_iterator_base { - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef bidirectional_iterator_tag iterator_category; - + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef bidirectional_iterator_tag iterator_category; + + /// The only member points to the %list element. _List_node_base* _M_node; - + _List_iterator_base(_List_node_base* __x) : _M_node(__x) { } - + _List_iterator_base() { } - + + /// Walk the %list forward. void _M_incr() { _M_node = _M_node->_M_next; } - + + /// Walk the %list backward. void _M_decr() { _M_node = _M_node->_M_prev; } - + bool operator==(const _List_iterator_base& __x) const { return _M_node == __x._M_node; } - + bool operator!=(const _List_iterator_base& __x) const { return _M_node != __x._M_node; } - }; - + }; + + /** + * @brief A list::iterator. + * + * In addition to being used externally, a list holds one of these + * internally, pointing to the sequence of data. + * + * @if maint + * All the functions are op overloads. + * @endif + */ template<typename _Tp, typename _Ref, typename _Ptr> struct _List_iterator : public _List_iterator_base + { + typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator; + typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; + typedef _List_iterator<_Tp,_Ref,_Ptr> _Self; + + typedef _Tp value_type; + typedef _Ptr pointer; + typedef _Ref reference; + typedef _List_node<_Tp> _Node; + + _List_iterator(_Node* __x) + : _List_iterator_base(__x) + { } + + _List_iterator() + { } + + _List_iterator(const iterator& __x) + : _List_iterator_base(__x._M_node) + { } + + reference + operator*() const + { return static_cast<_Node*>(_M_node)->_M_data; } + // Must downcast from List_node_base to _List_node to get to _M_data. + + pointer + operator->() const + { return &(operator*()); } + + _Self& + operator++() { - typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator; - typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; - typedef _List_iterator<_Tp,_Ref,_Ptr> _Self; - - typedef _Tp value_type; - typedef _Ptr pointer; - typedef _Ref reference; - typedef _List_node<_Tp> _Node; - - _List_iterator(_Node* __x) - : _List_iterator_base(__x) - { } - - _List_iterator() - { } - - _List_iterator(const iterator& __x) - : _List_iterator_base(__x._M_node) - { } - - reference - operator*() const - { return ((_Node*) _M_node)->_M_data; } - - pointer - operator->() const - { return &(operator*()); } - - _Self& - operator++() - { - this->_M_incr(); - return *this; - } - - _Self - operator++(int) - { - _Self __tmp = *this; - this->_M_incr(); - return __tmp; - } - - _Self& - operator--() - { - this->_M_decr(); - return *this; - } - - _Self - operator--(int) - { - _Self __tmp = *this; - this->_M_decr(); - return __tmp; - } - }; - - - // Base class that encapsulates details of allocators. Three cases: - // an ordinary standard-conforming allocator, a standard-conforming - // allocator with no non-static data, and an SGI-style allocator. - // This complexity is necessary only because we're worrying about backward - // compatibility and because we want to avoid wasting storage on an - // allocator instance if it isn't necessary. - - - // Base for general standard-conforming allocators. + this->_M_incr(); + return *this; + } + + _Self + operator++(int) + { + _Self __tmp = *this; + this->_M_incr(); + return __tmp; + } + + _Self& + operator--() + { + this->_M_decr(); + return *this; + } + + _Self + operator--(int) + { + _Self __tmp = *this; + this->_M_decr(); + return __tmp; + } + }; + + + /// @if maint Primary default version. @endif + /** + * @if maint + * See bits/stl_deque.h's _Deque_alloc_base for an explanation. + * @endif + */ template<typename _Tp, typename _Allocator, bool _IsStatic> class _List_alloc_base - { - public: - typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type - allocator_type; - - allocator_type - get_allocator() const - { return _Node_allocator; } - - _List_alloc_base(const allocator_type& __a) - : _Node_allocator(__a) - { } - - protected: - _List_node<_Tp>* - _M_get_node() - { return _Node_allocator.allocate(1); } - - void - _M_put_node(_List_node<_Tp>* __p) - { _Node_allocator.deallocate(__p, 1); } - - protected: - typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type - _Node_allocator; - - _List_node<_Tp>* _M_node; - }; - - // Specialization for instanceless allocators. - + { + public: + typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type + allocator_type; + + allocator_type + get_allocator() const { return _M_node_allocator; } + + _List_alloc_base(const allocator_type& __a) + : _M_node_allocator(__a) + { } + + protected: + _List_node<_Tp>* + _M_get_node() + { return _M_node_allocator.allocate(1); } + + void + _M_put_node(_List_node<_Tp>* __p) + { _M_node_allocator.deallocate(__p, 1); } + + // NOTA BENE + // The stored instance is not actually of "allocator_type"'s type. Instead + // we rebind the type to Allocator<List_node<Tp>>, which according to + // [20.1.5]/4 should probably be the same. List_node<Tp> is not the same + // size as Tp (it's two pointers larger), and specializations on Tp may go + // unused because List_node<Tp> is being bound instead. + // + // We put this to the test in get_allocator above; if the two types are + // actually different, there had better be a conversion between them. + // + // None of the predefined allocators shipped with the library (as of 3.1) + // use this instantiation anyhow; they're all instanceless. + typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type + _M_node_allocator; + + _List_node<_Tp>* _M_node; + }; + + /// @if maint Specialization for instanceless allocators. @endif template<typename _Tp, typename _Allocator> class _List_alloc_base<_Tp, _Allocator, true> + { + public: + typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type + allocator_type; + + allocator_type + get_allocator() const { return allocator_type(); } + + _List_alloc_base(const allocator_type&) + { } + + protected: + // See comment in primary template class about why this is safe for the + // standard predefined classes. + typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type + _Alloc_type; + + _List_node<_Tp>* + _M_get_node() + { return _Alloc_type::allocate(1); } + + void + _M_put_node(_List_node<_Tp>* __p) + { _Alloc_type::deallocate(__p, 1); } + + _List_node<_Tp>* _M_node; + }; + + + /** + * @if maint + * See bits/stl_deque.h's _Deque_base for an explanation. + * @endif + */ + template <typename _Tp, typename _Alloc> + class _List_base + : public _List_alloc_base<_Tp, _Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + { + public: + typedef _List_alloc_base<_Tp, _Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + _Base; + typedef typename _Base::allocator_type allocator_type; + + _List_base(const allocator_type& __a) + : _Base(__a) { - public: - typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type - allocator_type; - - allocator_type - get_allocator() const - { return allocator_type(); } - - _List_alloc_base(const allocator_type&) - { } - - protected: - typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type - _Alloc_type; - - _List_node<_Tp>* - _M_get_node() - { return _Alloc_type::allocate(1); } - - void - _M_put_node(_List_node<_Tp>* __p) - { _Alloc_type::deallocate(__p, 1); } - - protected: - _List_node<_Tp>* _M_node; - }; - - template<typename _Tp, typename _Alloc> - class _List_base - : public _List_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + _M_node = _M_get_node(); + _M_node->_M_next = _M_node; + _M_node->_M_prev = _M_node; + } + + // This is what actually destroys the list. + ~_List_base() { - public: - typedef _List_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> - _Base; - typedef typename _Base::allocator_type allocator_type; - - _List_base(const allocator_type& __a) - : _Base(__a) - { - _M_node = _M_get_node(); - _M_node->_M_next = _M_node; - _M_node->_M_prev = _M_node; - } - - ~_List_base() - { - clear(); - _M_put_node(_M_node); - } - - void clear(); - }; - + __clear(); + _M_put_node(_M_node); + } + + void + __clear(); + }; + + /** + * @brief A standard container with linear time access to elements, and + * fixed time insertion/deletion at any point in the sequence. + * * @ingroup Containers * @ingroup Sequences * @@ -283,384 +331,778 @@ namespace std * <a href="tables.html#68">optional sequence requirements</a> with the * %exception of @c at and @c operator[]. * - * @doctodo + * This is a @e doubly @e linked %list. Traversal up and down the %list + * requires linear time, but adding and removing elements (or @e nodes) is + * done in constant time, regardless of where the change takes place. + * Unlike std::vector and std::deque, random-access iterators are not + * provided, so subscripting ( @c [] ) access is not allowed. For algorithms + * which only need sequential access, this lack makes no difference. + * + * Also unlike the other standard containers, std::list provides specialized + * algorithms %unique to linked lists, such as splicing, sorting, and + * in-place reversal. + * + * @if maint + * A couple points on memory allocation for list<Tp>: * + * First, we never actually allocate a Tp, we allocate List_node<Tp>'s + * and trust [20.1.5]/4 to DTRT. This is to ensure that after elements from + * %list<X,Alloc1> are spliced into %list<X,Alloc2>, destroying the memory of + * the second %list is a valid operation, i.e., Alloc1 giveth and Alloc2 + * taketh away. + * + * Second, a %list conceptually represented as + * @code + * A <---> B <---> C <---> D + * @endcode + * is actually circular; a link exists between A and D. The %list class + * holds (as its only data member) a private list::iterator pointing to + * @e D, not to @e A! To get to the head of the %list, we start at the tail + * and move forward by one. When this member iterator's next/previous + * pointers refer to itself, the %list is %empty. + * @endif */ template<typename _Tp, typename _Alloc = allocator<_Tp> > class list : protected _List_base<_Tp, _Alloc> + { + // concept requirements + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + + typedef _List_base<_Tp, _Alloc> _Base; + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator; + typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef typename _Base::allocator_type allocator_type; + + protected: + // Note that pointers-to-_Node's can be ctor-converted to iterator types. + typedef _List_node<_Tp> _Node; + + /** @if maint + * One data member plus two memory-handling functions. If the _Alloc + * type requires separate instances, then one of those will also be + * included, accumulated from the topmost parent. + * @endif + */ + using _Base::_M_node; + using _Base::_M_put_node; + using _Base::_M_get_node; + + /** + * @if maint + * @param x An instance of user data. + * + * Allocates space for a new node and constructs a copy of @a x in it. + * @endif + */ + _Node* + _M_create_node(const value_type& __x) { - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - - typedef _List_base<_Tp, _Alloc> _Base; - protected: - typedef void* _Void_pointer; - - public: - typedef _Tp value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef _List_node<_Tp> _Node; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - typedef typename _Base::allocator_type allocator_type; - - typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator; - typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; - - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; - - protected: - using _Base::_M_node; - using _Base::_M_put_node; - using _Base::_M_get_node; - - protected: - _Node* - _M_create_node(const _Tp& __x) + _Node* __p = _M_get_node(); + try { + _Construct(&__p->_M_data, __x); + } + catch(...) { - _Node* __p = _M_get_node(); - try { - _Construct(&__p->_M_data, __x); - } - catch(...) - { - _M_put_node(__p); - __throw_exception_again; - } - return __p; + _M_put_node(__p); + __throw_exception_again; } - - _Node* - _M_create_node() + return __p; + } + + /** + * @if maint + * Allocates space for a new node and default-constructs a new instance + * of @c value_type in it. + * @endif + */ + _Node* + _M_create_node() + { + _Node* __p = _M_get_node(); + try { + _Construct(&__p->_M_data); + } + catch(...) { - _Node* __p = _M_get_node(); - try { - _Construct(&__p->_M_data); - } - catch(...) - { - _M_put_node(__p); - __throw_exception_again; - } - return __p; + _M_put_node(__p); + __throw_exception_again; } - - public: - allocator_type - get_allocator() const - { return _Base::get_allocator(); } - - explicit - list(const allocator_type& __a = allocator_type()) + return __p; + } + + public: + // [23.2.2.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + /** + * @brief Default constructor creates no elements. + */ + explicit + list(const allocator_type& __a = allocator_type()) + : _Base(__a) { } + + /** + * @brief Create a %list with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * + * This constructor fills the %list with @a n copies of @a value. + */ + list(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) : _Base(__a) - { } - - iterator - begin() - { return static_cast<_Node*>(_M_node->_M_next); } - - const_iterator - begin() const - { return static_cast<_Node*>(_M_node->_M_next); } - - iterator - end() - { return _M_node; } - - const_iterator - end() const - { return _M_node; } - - reverse_iterator - rbegin() - { return reverse_iterator(end()); } - - const_reverse_iterator - rbegin() const - { return const_reverse_iterator(end()); } - - reverse_iterator - rend() - { return reverse_iterator(begin()); } - - const_reverse_iterator - rend() const - { return const_reverse_iterator(begin()); } - - bool - empty() const - { return _M_node->_M_next == _M_node; } - - size_type - size() const - { return distance(begin(), end()); } - - size_type - max_size() const - { return size_type(-1); } - - reference - front() - { return *begin(); } - - const_reference - front() const - { return *begin(); } - - reference - back() - { return *(--end()); } - - const_reference - back() const - { return *(--end()); } - + { this->insert(begin(), __n, __value); } + + /** + * @brief Create a %list with default elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %list with @a n copies of a + * default-constructed element. + */ + explicit + list(size_type __n) + : _Base(allocator_type()) + { this->insert(begin(), __n, value_type()); } + + /** + * @brief %List copy constructor. + * @param x A %list of identical element and allocator types. + * + * The newly-created %list uses a copy of the allocation object used + * by @a x. + */ + list(const list& __x) + : _Base(__x.get_allocator()) + { this->insert(begin(), __x.begin(), __x.end()); } + + /** + * @brief Builds a %list from a range. + * @param first An input iterator. + * @param last An input iterator. + * + * Create a %list consisting of copies of the elements from [first,last). + * This is linear in N (where N is distance(first,last)). + * + * @if maint + * We don't need any dispatching tricks here, because insert does all of + * that anyway. + * @endif + */ + template<typename _InputIterator> + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { this->insert(begin(), __first, __last); } + + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + ~list() { } + + /** + * @brief %List assignment operator. + * @param x A %list of identical element and allocator types. + * + * All the elements of @a x are copied, but unlike the copy constructor, + * the allocator object is not copied. + */ + list& + operator=(const list& __x); + + /** + * @brief Assigns a given value to a %list. + * @param n Number of elements to be assigned. + * @param val Value to be assigned. + * + * This function fills a %list with @a n copies of the given value. + * Note that the assignment completely changes the %list and that the + * resulting %list's size is the same as the number of elements assigned. + * Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %list. + * @param first An input iterator. + * @param last An input iterator. + * + * This function fills a %list with copies of the elements in the + * range [first,last). + * + * Note that the assignment completely changes the %list and that the + * resulting %list's size is the same as the number of elements assigned. + * Old data may be lost. + */ + template<typename _InputIterator> void - swap(list<_Tp, _Alloc>& __x) - { std::swap(_M_node, __x._M_node); } - - iterator - insert(iterator __position, const _Tp& __x) + assign(_InputIterator __first, _InputIterator __last) { - _Node* __tmp = _M_create_node(__x); - __tmp->_M_next = __position._M_node; - __tmp->_M_prev = __position._M_node->_M_prev; - __position._M_node->_M_prev->_M_next = __tmp; - __position._M_node->_M_prev = __tmp; - return __tmp; + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_assign_dispatch(__first, __last, _Integral()); } - - iterator - insert(iterator __position) - { return insert(__position, _Tp()); } - - // Check whether it's an integral type. If so, it's not an iterator. - template<typename _Integer> - void - _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type) - { _M_fill_insert(__pos, (size_type) __n, (_Tp) __x); } - - template<typename _InputIterator> - void - _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type); - - template<typename _InputIterator> - void - insert(iterator __pos, _InputIterator __first, _InputIterator __last) - { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); - } - - void - insert(iterator __pos, size_type __n, const _Tp& __x) - { _M_fill_insert(__pos, __n, __x); } - - void - _M_fill_insert(iterator __pos, size_type __n, const _Tp& __x); - - void - push_front(const _Tp& __x) - { insert(begin(), __x); } - - void - push_front() - { insert(begin()); } - - void - push_back(const _Tp& __x) - { insert(end(), __x); } - + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const { return _Base::get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first element in the + * %list. Iteration is done in ordinary element order. + */ + iterator + begin() { return static_cast<_Node*>(_M_node->_M_next); } + + /** + * Returns a read-only (constant) iterator that points to the first element + * in the %list. Iteration is done in ordinary element order. + */ + const_iterator + begin() const { return static_cast<_Node*>(_M_node->_M_next); } + + /** + * Returns a read/write iterator that points one past the last element in + * the %list. Iteration is done in ordinary element order. + */ + iterator + end() { return _M_node; } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %list. Iteration is done in ordinary element order. + */ + const_iterator + end() const { return _M_node; } + + /** + * Returns a read/write reverse iterator that points to the last element in + * the %list. Iteration is done in reverse element order. + */ + reverse_iterator + rbegin() { return reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points to the last + * element in the %list. Iteration is done in reverse element order. + */ + const_reverse_iterator + rbegin() const { return const_reverse_iterator(end()); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first element in the %list. Iteration is done in reverse element + * order. + */ + reverse_iterator + rend() { return reverse_iterator(begin()); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first element in the %list. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + + // [23.2.2.2] capacity + /** + * Returns true if the %list is empty. (Thus begin() would equal end().) + */ + bool + empty() const { return _M_node->_M_next == _M_node; } + + /** Returns the number of elements in the %list. */ + size_type + size() const { return distance(begin(), end()); } + + /** Returns the size() of the largest possible %list. */ + size_type + max_size() const { return size_type(-1); } + + /** + * @brief Resizes the %list to the specified number of elements. + * @param new_size Number of elements the %list should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %list to the specified number of + * elements. If the number is smaller than the %list's current size the + * %list is truncated, otherwise the %list is extended and new elements + * are populated with given data. + */ + void + resize(size_type __new_size, const value_type& __x); + + /** + * @brief Resizes the %list to the specified number of elements. + * @param new_size Number of elements the %list should contain. + * + * This function will resize the %list to the specified number of + * elements. If the number is smaller than the %list's current size the + * %list is truncated, otherwise the %list is extended and new elements + * are default-constructed. + */ + void + resize(size_type __new_size) { this->resize(__new_size, value_type()); } + + // element access + /** + * Returns a read/write reference to the data at the first element of the + * %list. + */ + reference + front() { return *begin(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %list. + */ + const_reference + front() const { return *begin(); } + + /** + * Returns a read/write reference to the data at the last element of the + * %list. + */ + reference + back() { return *(--end()); } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %list. + */ + const_reference + back() const { return *(--end()); } + + // [23.2.2.3] modifiers + /** + * @brief Add data to the front of the %list. + * @param x Data to be added. + * + * This is a typical stack operation. The function creates an element at + * the front of the %list and assigns the given data to it. Due to the + * nature of a %list this operation can be done in constant time, and + * does not invalidate iterators and references. + */ + void + push_front(const value_type& __x) { this->insert(begin(), __x); } + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Add data to the front of the %list. + * + * This is a typical stack operation. The function creates a + * default-constructed element at the front of the %list. Due to the + * nature of a %list this operation can be done in constant time. You + * should consider using push_front(value_type()) instead. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + void + push_front() { this->insert(begin(), value_type()); } + #endif + + /** + * @brief Removes first element. + * + * This is a typical stack operation. It shrinks the %list by one. + * Due to the nature of a %list this operation can be done in constant + * time, and only invalidates iterators/references to the element being + * removed. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop_front() is called. + */ + void + pop_front() { this->erase(begin()); } + + /** + * @brief Add data to the end of the %list. + * @param x Data to be added. + * + * This is a typical stack operation. The function creates an element at + * the end of the %list and assigns the given data to it. Due to the + * nature of a %list this operation can be done in constant time, and + * does not invalidate iterators and references. + */ + void + push_back(const value_type& __x) { this->insert(end(), __x); } + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Add data to the end of the %list. + * + * This is a typical stack operation. The function creates a + * default-constructed element at the end of the %list. Due to the nature + * of a %list this operation can be done in constant time. You should + * consider using push_back(value_type()) instead. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + void + push_back() { this->insert(end(), value_type()); } + #endif + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %list by one. + * Due to the nature of a %list this operation can be done in constant + * time, and only invalidates iterators/references to the element being + * removed. + * + * Note that no data is returned, and if the last element's data is + * needed, it should be retrieved before pop_back() is called. + */ + void + pop_back() + { + iterator __tmp = end(); + this->erase(--__tmp); + } + + /** + * @brief Inserts given value into %list before specified iterator. + * @param position An iterator into the %list. + * @param x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before the specified + * location. + * Due to the nature of a %list this operation can be done in constant + * time, and does not invalidate iterators and references. + */ + iterator + insert(iterator __position, const value_type& __x); + + #ifdef _GLIBCPP_DEPRECATED + /** + * @brief Inserts an element into the %list. + * @param position An iterator into the %list. + * @return An iterator that points to the inserted element. + * + * This function will insert a default-constructed element before the + * specified location. You should consider using + * insert(position,value_type()) instead. + * Due to the nature of a %list this operation can be done in constant + * time, and does not invalidate iterators and references. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. You must + * define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see + * c++config.h. + */ + iterator + insert(iterator __position) { return insert(__position, value_type()); } + #endif + + /** + * @brief Inserts a number of copies of given data into the %list. + * @param position An iterator into the %list. + * @param n Number of elements to be inserted. + * @param x Data to be inserted. + * + * This function will insert a specified number of copies of the given data + * before the location specified by @a position. + * + * Due to the nature of a %list this operation can be done in constant + * time, and does not invalidate iterators and references. + */ + void + insert(iterator __pos, size_type __n, const value_type& __x) + { _M_fill_insert(__pos, __n, __x); } + + /** + * @brief Inserts a range into the %list. + * @param pos An iterator into the %list. + * @param first An input iterator. + * @param last An input iterator. + * + * This function will insert copies of the data in the range [first,last) + * into the %list before the location specified by @a pos. + * + * Due to the nature of a %list this operation can be done in constant + * time, and does not invalidate iterators and references. + */ + template<typename _InputIterator> void - push_back() - { insert(end()); } - - iterator - erase(iterator __position) + insert(iterator __pos, _InputIterator __first, _InputIterator __last) { - _List_node_base* __next_node = __position._M_node->_M_next; - _List_node_base* __prev_node = __position._M_node->_M_prev; - _Node* __n = static_cast<_Node*>(__position._M_node); - __prev_node->_M_next = __next_node; - __next_node->_M_prev = __prev_node; - _Destroy(&__n->_M_data); - _M_put_node(__n); - return iterator(static_cast<_Node*>(__next_node)); + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); } - - iterator - erase(iterator __first, iterator __last); - - void - clear() - { _Base::clear(); } - - void - resize(size_type __new_size, const _Tp& __x); - - void - resize(size_type __new_size) - { this->resize(__new_size, _Tp()); } - + + /** + * @brief Remove element at given position. + * @param position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %list by one. + * + * Due to the nature of a %list this operation can be done in constant + * time, and only invalidates iterators/references to the element being + * removed. + * The user is also cautioned that + * this function only erases the element, and that if the element is itself + * a pointer, the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibilty. + */ + iterator + erase(iterator __position); + + /** + * @brief Remove a range of elements. + * @param first Iterator pointing to the first element to be erased. + * @param last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a last + * prior to erasing (or end()). + * + * This function will erase the elements in the range [first,last) and + * shorten the %list accordingly. + * + * Due to the nature of a %list this operation can be done in constant + * time, and only invalidates iterators/references to the element being + * removed. + * The user is also cautioned that + * this function only erases the elements, and that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + iterator + erase(iterator __first, iterator __last) + { + while (__first != __last) + erase(__first++); + return __last; + } + + /** + * @brief Swaps data with another %list. + * @param x A %list of the same element and allocator types. + * + * This exchanges the elements between two lists in constant time. + * (It is only swapping a single pointer, so it should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(l1,l2) will feed to this function. + */ + void + swap(list& __x) { std::swap(_M_node, __x._M_node); } + + /** + * Erases all the elements. Note that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibilty. + */ + void + clear() { _Base::__clear(); } + + // [23.2.2.4] list operations + /** + * @doctodo + */ + void + splice(iterator __position, list& __x) + { + if (!__x.empty()) + this->_M_transfer(__position, __x.begin(), __x.end()); + } + + /** + * @doctodo + */ + void + splice(iterator __position, list&, iterator __i) + { + iterator __j = __i; + ++__j; + if (__position == __i || __position == __j) return; + this->_M_transfer(__position, __i, __j); + } + + /** + * @doctodo + */ + void + splice(iterator __position, list&, iterator __first, iterator __last) + { + if (__first != __last) + this->_M_transfer(__position, __first, __last); + } + + /** + * @doctodo + */ + void + remove(const _Tp& __value); + + /** + * @doctodo + */ + template<typename _Predicate> void - pop_front() - { erase(begin()); } - + remove_if(_Predicate); + + /** + * @doctodo + */ + void + unique(); + + /** + * @doctodo + */ + template<typename _BinaryPredicate> void - pop_back() - { - iterator __tmp = end(); - erase(--__tmp); - } - - list(size_type __n, const _Tp& __value, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { insert(begin(), __n, __value); } - - explicit - list(size_type __n) - : _Base(allocator_type()) - { insert(begin(), __n, _Tp()); } - - // We don't need any dispatching tricks here, because insert does all of - // that anyway. - template<typename _InputIterator> - list(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { insert(begin(), __first, __last); } - - list(const list<_Tp, _Alloc>& __x) - : _Base(__x.get_allocator()) - { insert(begin(), __x.begin(), __x.end()); } - - ~list() - { } - - list<_Tp, _Alloc>& - operator=(const list<_Tp, _Alloc>& __x); - - public: - // assign(), a generalized assignment member function. Two - // versions: one that takes a count, and one that takes a range. - // The range version is a member template, so we dispatch on whether - // or not the type is an integer. - + unique(_BinaryPredicate); + + /** + * @doctodo + */ + void + merge(list& __x); + + /** + * @doctodo + */ + template<typename _StrictWeakOrdering> void - assign(size_type __n, const _Tp& __val) - { _M_fill_assign(__n, __val); } - + merge(list&, _StrictWeakOrdering); + + /** + * @doctodo + */ + void + reverse() { __List_base_reverse(this->_M_node); } + + /** + * @doctodo + */ + void + sort(); + + /** + * @doctodo + */ + template<typename _StrictWeakOrdering> void - _M_fill_assign(size_type __n, const _Tp& __val); - - template<typename _InputIterator> - void - assign(_InputIterator __first, _InputIterator __last) - { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); - } - - template<typename _Integer> - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign((size_type) __n, (_Tp) __val); } - - template<typename _InputIterator> - void - _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type); - - protected: + sort(_StrictWeakOrdering); + + protected: + // Internal assign functions follow. + + // called by the range assign to implement [23.1.1]/9 + template<typename _Integer> void - _M_transfer(iterator __position, iterator __first, iterator __last) + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) { - if (__position != __last) { - // Remove [first, last) from its old position. - __last._M_node->_M_prev->_M_next = __position._M_node; - __first._M_node->_M_prev->_M_next = __last._M_node; - __position._M_node->_M_prev->_M_next = __first._M_node; - - // Splice [first, last) into its new position. - _List_node_base* __tmp = __position._M_node->_M_prev; - __position._M_node->_M_prev = __last._M_node->_M_prev; - __last._M_node->_M_prev = __first._M_node->_M_prev; - __first._M_node->_M_prev = __tmp; - } + _M_fill_assign(static_cast<size_type>(__n), + static_cast<value_type>(__val)); } - - public: + + // called by the range assign to implement [23.1.1]/9 + template<typename _InputIter> void - splice(iterator __position, list& __x) - { - if (!__x.empty()) - this->_M_transfer(__position, __x.begin(), __x.end()); - } - + _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type); + + // Called by assign(n,t), and the range assign when it turns out to be the + // same thing. + void + _M_fill_assign(size_type __n, const value_type& __val); + + + // Internal insert functions follow. + + // called by the range insert to implement [23.1.1]/9 + template<typename _Integer> void - splice(iterator __position, list&, iterator __i) + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, + __true_type) { - iterator __j = __i; - ++__j; - if (__position == __i || __position == __j) return; - this->_M_transfer(__position, __i, __j); + _M_fill_insert(__pos, static_cast<size_type>(__n), + static_cast<value_type>(__x)); } - + + // called by the range insert to implement [23.1.1]/9 + template<typename _InputIterator> void - splice(iterator __position, list&, iterator __first, iterator __last) + _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + __false_type) { - if (__first != __last) - this->_M_transfer(__position, __first, __last); + for ( ; __first != __last; ++__first) + insert(__pos, *__first); } - - void - remove(const _Tp& __value); - - void - unique(); - - void - merge(list& __x); - - void - reverse(); - - void - sort(); - - template<typename _Predicate> - void - remove_if(_Predicate); - - template<typename _BinaryPredicate> - void - unique(_BinaryPredicate); - - template<typename _StrictWeakOrdering> - void - merge(list&, _StrictWeakOrdering); - - template<typename _StrictWeakOrdering> - void - sort(_StrictWeakOrdering); - }; - + + // Called by insert(p,n,x), and the range insert when it turns out to be + // the same thing. + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x) + { + for ( ; __n > 0; --__n) + insert(__pos, __x); + } + + + // Moves the elements from [first,last) before position. + void + _M_transfer(iterator __position, iterator __first, iterator __last) + { + if (__position != __last) { + // Remove [first, last) from its old position. + __last._M_node->_M_prev->_M_next = __position._M_node; + __first._M_node->_M_prev->_M_next = __last._M_node; + __position._M_node->_M_prev->_M_next = __first._M_node; + + // Splice [first, last) into its new position. + _List_node_base* __tmp = __position._M_node->_M_prev; + __position._M_node->_M_prev = __last._M_node->_M_prev; + __last._M_node->_M_prev = __first._M_node->_M_prev; + __first._M_node->_M_prev = __tmp; + } + } + }; + + + /** + * @brief List equality comparison. + * @param x A %list. + * @param y A %list of the same type as @a x. + * @return True iff the size and elements of the lists are equal. + * + * This is an equivalence relation. It is linear in the size of the + * lists. Lists are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ template<typename _Tp, typename _Alloc> - inline bool + inline bool operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) { typedef typename list<_Tp,_Alloc>::const_iterator const_iterator; const_iterator __end1 = __x.end(); const_iterator __end2 = __y.end(); - + const_iterator __i1 = __x.begin(); const_iterator __i2 = __y.begin(); while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) { @@ -669,7 +1111,18 @@ namespace std } return __i1 == __end1 && __i2 == __end2; } - + + /** + * @brief List ordering relation. + * @param x A %list. + * @param y A %list of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. + * + * This is a total ordering relation. It is linear in the size of the + * lists. The elements must be comparable with @c <. + * + * See std::lexographical_compare() for how the determination is made. + */ template<typename _Tp, typename _Alloc> inline bool operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) @@ -677,313 +1130,36 @@ namespace std return lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } - + + /// Based on operator== template<typename _Tp, typename _Alloc> inline bool operator!=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) { return !(__x == __y); } - + + /// Based on operator< template<typename _Tp, typename _Alloc> inline bool operator>(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) { return __y < __x; } - + + /// Based on operator< template<typename _Tp, typename _Alloc> inline bool operator<=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) { return !(__y < __x); } - + + /// Based on operator< template<typename _Tp, typename _Alloc> inline bool operator>=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) { return !(__x < __y); } - + + /// See std::list::swap(). template<typename _Tp, typename _Alloc> - inline void + inline void swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) { __x.swap(__y); } - - // move these to stl_list.tcc - - template<typename _Tp, typename _Alloc> - void _List_base<_Tp,_Alloc>:: - clear() - { - _List_node<_Tp>* __cur = static_cast<_List_node<_Tp>*>(_M_node->_M_next); - while (__cur != _M_node) { - _List_node<_Tp>* __tmp = __cur; - __cur = static_cast<_List_node<_Tp>*>(__cur->_M_next); - _Destroy(&__tmp->_M_data); - _M_put_node(__tmp); - } - _M_node->_M_next = _M_node; - _M_node->_M_prev = _M_node; - } - - template<typename _Tp, typename _Alloc> - template <typename _InputIter> - void list<_Tp, _Alloc>:: - _M_insert_dispatch(iterator __position, _InputIter __first, _InputIter __last, - __false_type) - { - for ( ; __first != __last; ++__first) - insert(__position, *__first); - - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - _M_fill_insert(iterator __position, size_type __n, const _Tp& __x) - { - for ( ; __n > 0; --__n) - insert(__position, __x); - } - - template<typename _Tp, typename _Alloc> - typename list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>:: - erase(iterator __first, iterator __last) - { - while (__first != __last) - erase(__first++); - return __last; - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - resize(size_type __new_size, const _Tp& __x) - { - iterator __i = begin(); - size_type __len = 0; - for ( ; __i != end() && __len < __new_size; ++__i, ++__len) - ; - if (__len == __new_size) - erase(__i, end()); - else // __i == end() - insert(end(), __new_size - __len, __x); - } - - template<typename _Tp, typename _Alloc> - list<_Tp, _Alloc>& list<_Tp, _Alloc>:: - operator=(const list<_Tp, _Alloc>& __x) - { - if (this != &__x) { - iterator __first1 = begin(); - iterator __last1 = end(); - const_iterator __first2 = __x.begin(); - const_iterator __last2 = __x.end(); - while (__first1 != __last1 && __first2 != __last2) - *__first1++ = *__first2++; - if (__first2 == __last2) - erase(__first1, __last1); - else - insert(__last1, __first2, __last2); - } - return *this; - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - _M_fill_assign(size_type __n, const _Tp& __val) { - iterator __i = begin(); - for ( ; __i != end() && __n > 0; ++__i, --__n) - *__i = __val; - if (__n > 0) - insert(end(), __n, __val); - else - erase(__i, end()); - } - - template<typename _Tp, typename _Alloc> - template <typename _InputIter> - void list<_Tp, _Alloc>:: - _M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type) - { - iterator __first1 = begin(); - iterator __last1 = end(); - for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) - *__first1 = *__first2; - if (__first2 == __last2) - erase(__first1, __last1); - else - insert(__last1, __first2, __last2); - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - remove(const _Tp& __value) - { - iterator __first = begin(); - iterator __last = end(); - while (__first != __last) { - iterator __next = __first; - ++__next; - if (*__first == __value) erase(__first); - __first = __next; - } - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - unique() - { - iterator __first = begin(); - iterator __last = end(); - if (__first == __last) return; - iterator __next = __first; - while (++__next != __last) { - if (*__first == *__next) - erase(__next); - else - __first = __next; - __next = __first; - } - } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - merge(list<_Tp, _Alloc>& __x) - { - iterator __first1 = begin(); - iterator __last1 = end(); - iterator __first2 = __x.begin(); - iterator __last2 = __x.end(); - while (__first1 != __last1 && __first2 != __last2) - if (*__first2 < *__first1) { - iterator __next = __first2; - _M_transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) _M_transfer(__last1, __first2, __last2); - } - - inline void - __List_base_reverse(_List_node_base* __p) - { - _List_node_base* __tmp = __p; - do { - std::swap(__tmp->_M_next, __tmp->_M_prev); - __tmp = __tmp->_M_prev; // Old next node is now prev. - } while (__tmp != __p); - } - - template<typename _Tp, typename _Alloc> - inline void list<_Tp, _Alloc>:: - reverse() - { __List_base_reverse(this->_M_node); } - - template<typename _Tp, typename _Alloc> - void list<_Tp, _Alloc>:: - sort() - { - // Do nothing if the list has length 0 or 1. - if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) { - list<_Tp, _Alloc> __carry; - list<_Tp, _Alloc> __counter[64]; - int __fill = 0; - while (!empty()) { - __carry.splice(__carry.begin(), *this, begin()); - int __i = 0; - while(__i < __fill && !__counter[__i].empty()) { - __counter[__i].merge(__carry); - __carry.swap(__counter[__i++]); - } - __carry.swap(__counter[__i]); - if (__i == __fill) ++__fill; - } - - for (int __i = 1; __i < __fill; ++__i) - __counter[__i].merge(__counter[__i-1]); - swap(__counter[__fill-1]); - } - } - - template<typename _Tp, typename _Alloc> - template <typename _Predicate> - void list<_Tp, _Alloc>:: - remove_if(_Predicate __pred) - { - iterator __first = begin(); - iterator __last = end(); - while (__first != __last) { - iterator __next = __first; - ++__next; - if (__pred(*__first)) erase(__first); - __first = __next; - } - } - - template<typename _Tp, typename _Alloc> - template <typename _BinaryPredicate> - void list<_Tp, _Alloc>:: - unique(_BinaryPredicate __binary_pred) - { - iterator __first = begin(); - iterator __last = end(); - if (__first == __last) return; - iterator __next = __first; - while (++__next != __last) { - if (__binary_pred(*__first, *__next)) - erase(__next); - else - __first = __next; - __next = __first; - } - } - - template<typename _Tp, typename _Alloc> - template <typename _StrictWeakOrdering> - void list<_Tp, _Alloc>:: - merge(list<_Tp, _Alloc>& __x, _StrictWeakOrdering __comp) - { - iterator __first1 = begin(); - iterator __last1 = end(); - iterator __first2 = __x.begin(); - iterator __last2 = __x.end(); - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first2, *__first1)) { - iterator __next = __first2; - _M_transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) _M_transfer(__last1, __first2, __last2); - } - - template<typename _Tp, typename _Alloc> - template <typename _StrictWeakOrdering> - void list<_Tp, _Alloc>:: - sort(_StrictWeakOrdering __comp) - { - // Do nothing if the list has length 0 or 1. - if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) { - list<_Tp, _Alloc> __carry; - list<_Tp, _Alloc> __counter[64]; - int __fill = 0; - while (!empty()) { - __carry.splice(__carry.begin(), *this, begin()); - int __i = 0; - while(__i < __fill && !__counter[__i].empty()) { - __counter[__i].merge(__carry, __comp); - __carry.swap(__counter[__i++]); - } - __carry.swap(__counter[__i]); - if (__i == __fill) ++__fill; - } - - for (int __i = 1; __i < __fill; ++__i) - __counter[__i].merge(__counter[__i-1], __comp); - swap(__counter[__fill-1]); - } - } - -} // namespace std +} // namespace std #endif /* __GLIBCPP_INTERNAL_LIST_H */ - -// vi:set ts=2 sw=2: -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/stl_map.h b/contrib/libstdc++/include/bits/stl_map.h index 07c62e4fb5b4..ed47bbb44e73 100644 --- a/contrib/libstdc++/include/bits/stl_map.h +++ b/contrib/libstdc++/include/bits/stl_map.h @@ -58,446 +58,604 @@ * You should not attempt to use it directly. */ -#ifndef _CPP_BITS_STL_MAP_H -#define _CPP_BITS_STL_MAP_H 1 +#ifndef __GLIBCPP_INTERNAL_MAP_H +#define __GLIBCPP_INTERNAL_MAP_H #include <bits/concept_check.h> namespace std { - -/** - * @brief A standard container made up of pairs (see std::pair in <utility>) - * which can be retrieved based on a key. - * - * This is an associative container. Values contained within it can be - * quickly retrieved through a key element. Example: MyMap["First"] would - * return the data associated with the key "First". -*/ -template <class _Key, class _Tp, class _Compare = less<_Key>, - class _Alloc = allocator<pair<const _Key, _Tp> > > -class map -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); - -public: - // typedefs: - typedef _Key key_type; - typedef _Tp data_type; - typedef _Tp mapped_type; - typedef pair<const _Key, _Tp> value_type; - typedef _Compare key_compare; - - class value_compare - : public binary_function<value_type, value_type, bool> { - friend class map<_Key,_Tp,_Compare,_Alloc>; - protected : - _Compare comp; - value_compare(_Compare __c) : comp(__c) {} - public: - bool operator()(const value_type& __x, const value_type& __y) const { - return comp(__x.first, __y.first); - } - }; - -private: - typedef _Rb_tree<key_type, value_type, - _Select1st<value_type>, key_compare, _Alloc> _Rep_type; - _Rep_type _M_t; // red-black tree representing map -public: - typedef typename _Rep_type::pointer pointer; - typedef typename _Rep_type::const_pointer const_pointer; - typedef typename _Rep_type::reference reference; - typedef typename _Rep_type::const_reference const_reference; - typedef typename _Rep_type::iterator iterator; - typedef typename _Rep_type::const_iterator const_iterator; - typedef typename _Rep_type::reverse_iterator reverse_iterator; - typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; - typedef typename _Rep_type::size_type size_type; - typedef typename _Rep_type::difference_type difference_type; - typedef typename _Rep_type::allocator_type allocator_type; - - // allocation/deallocation - - map() : _M_t(_Compare(), allocator_type()) {} - explicit map(const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) {} - - template <class _InputIterator> - map(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - template <class _InputIterator> - map(_InputIterator __first, _InputIterator __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } - map(const map<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {} - - map<_Key,_Tp,_Compare,_Alloc>& - operator=(const map<_Key, _Tp, _Compare, _Alloc>& __x) - { - _M_t = __x._M_t; - return *this; - } - - // accessors: - - key_compare key_comp() const { return _M_t.key_comp(); } - value_compare value_comp() const { return value_compare(_M_t.key_comp()); } - allocator_type get_allocator() const { return _M_t.get_allocator(); } - - /** - * Returns a read/write iterator that points to the first pair in the map. - * Iteration is done in ascending order according to the keys. - */ - iterator begin() { return _M_t.begin(); } - - /** - * Returns a read-only (constant) iterator that points to the first pair - * in the map. Iteration is done in ascending order according to the keys. - */ - const_iterator begin() const { return _M_t.begin(); } - - /** - * Returns a read/write iterator that points one past the last pair in the - * map. Iteration is done in ascending order according to the keys. - */ - iterator end() { return _M_t.end(); } - - /** - * Returns a read-only (constant) iterator that points one past the last - * pair in the map. Iteration is done in ascending order according to the - * keys. - */ - const_iterator end() const { return _M_t.end(); } - /** - * Returns a read/write reverse iterator that points to the last pair in - * the map. Iteration is done in descending order according to the keys. - */ - reverse_iterator rbegin() { return _M_t.rbegin(); } - - /** - * Returns a read-only (constant) reverse iterator that points to the last - * pair in the map. Iteration is done in descending order according to - * the keys. - */ - const_reverse_iterator rbegin() const { return _M_t.rbegin(); } - - /** - * Returns a read/write reverse iterator that points to one before the - * first pair in the map. Iteration is done in descending order according - * to the keys. - */ - reverse_iterator rend() { return _M_t.rend(); } - - /** - * Returns a read-only (constant) reverse iterator that points to one - * before the first pair in the map. Iteration is done in descending order - * according to the keys. - */ - const_reverse_iterator rend() const { return _M_t.rend(); } - - /** Returns true if the map is empty. (Thus begin() would equal end().) */ - bool empty() const { return _M_t.empty(); } - /** Returns the size of the map. */ - size_type size() const { return _M_t.size(); } - /** Returns the maximum size of the map. */ - size_type max_size() const { return _M_t.max_size(); } - - /** - * @brief Subscript ( [] ) access to map data. - * @param k The key for which data should be retrieved. - * - * Allows for easy lookup with the subscript ( [] ) operator. Returns the - * data associated with the key specified in subscript. If the key does - * not exist a pair with that key is created with a default value, which - * is then returned. - */ - _Tp& operator[](const key_type& __k) { - iterator __i = lower_bound(__k); - // __i->first is greater than or equivalent to __k. - if (__i == end() || key_comp()(__k, (*__i).first)) - __i = insert(__i, value_type(__k, _Tp())); - return (*__i).second; - } - - void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } - - // insert/erase - /** - * @brief Attempts to insert a std::pair into the map. - * @param x Pair to be inserted (see std::make_pair for easy creation of - * pairs). - * @return A pair of which the first element is an iterator that points - * to the possibly inserted pair, a second element of type bool - * to show if the pair was actually inserted. + * @brief A standard container made up of (key,value) pairs, which can be + * retrieved based on a key, in logarithmic time. * - * This function attempts to insert a (key, value) pair into the map. A - * map relies on unique keys and thus a pair is only inserted if its first - * element (the key) is not already present in the map. - */ - pair<iterator,bool> insert(const value_type& __x) - { return _M_t.insert_unique(__x); } - - /** - * @brief Attempts to insert a std::pair into the map. - * @param position An iterator that serves as a hint as to where the - * pair should be inserted. - * @param x Pair to be inserted (see std::make_pair for easy creation of - * pairs). - * @return An iterator that points to the inserted (key,value) pair. + * @ingroup Containers + * @ingroup Assoc_containers * - * This function is not concerned about whether the insertion took place - * or not and thus does not return a boolean like the single-argument - * insert() does. Note that the first parameter is only a hint and can - * potentially improve the performance of the insertion process. A bad - * hint would cause no gains in efficiency. - */ - iterator insert(iterator position, const value_type& __x) - { return _M_t.insert_unique(position, __x); } - - /** - * @brief A template function that attemps to insert elements from - * another range (possibly another map). - * @param first Iterator pointing to the start of the range to be inserted. - * @param last Iterator pointing to the end of the range. - */ - template <class _InputIterator> - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_unique(__first, __last); - } - - /** - * @brief Erases an element from a map. - * @param position An iterator pointing to the element to be erased. + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and an + * <a href="tables.html#69">associative container</a> (using unique keys). + * For a @c map<Key,T> the key_type is Key, the mapped_type is T, and the + * value_type is std::pair<const Key,T>. * - * This function erases an element, pointed to by the given iterator, from - * a map. Note that this function only erases the element, and that if - * the element is itself a pointer, the pointed-to memory is not touched - * in any way. Managing the pointer is the user's responsibilty. - */ - void erase(iterator __position) { _M_t.erase(__position); } - - /** - * @brief Erases an element according to the provided key. - * @param x Key of element to be erased. - * @return Doc me! (Number of elements that match key? Only makes sense - * with multimap) - * - * This function erases an element, located by the given key, from a map. - * Note that this function only erases the element, and that if - * the element is itself a pointer, the pointed-to memory is not touched - * in any way. Managing the pointer is the user's responsibilty. - */ - size_type erase(const key_type& __x) { return _M_t.erase(__x); } - - /** - * @brief Erases a [first,last) range of elements from a map. - * @param first Iterator pointing to the start of the range to be erased. - * @param last Iterator pointing to the end of the range to be erased. - * - * This function erases a sequence of elements from a map. - * Note that this function only erases the element, and that if - * the element is itself a pointer, the pointed-to memory is not touched - * in any way. Managing the pointer is the user's responsibilty. - */ - void erase(iterator __first, iterator __last) - { _M_t.erase(__first, __last); } - - /** Erases all elements in a map. Note that this function only erases - * the elements, and that if the elements themselves are pointers, the - * pointed-to memory is not touched in any way. Managing the pointer is - * the user's responsibilty. - */ - void clear() { _M_t.clear(); } - - // map operations: - - /** - * @brief Tries to locate an element in a map. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to sought-after element, or end() if not - * found. - * - * This function takes a key and tries to locate the element with which - * the key matches. If successful the function returns an iterator - * pointing to the sought after pair. If unsuccessful it returns the - * one past the end ( end() ) iterator. - */ - iterator find(const key_type& __x) { return _M_t.find(__x); } - - /** - * @brief Tries to locate an element in a map. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to sought-after - * element, or end() if not found. - * - * This function takes a key and tries to locate the element with which - * the key matches. If successful the function returns a constant iterator - * pointing to the sought after pair. If unsuccessful it returns the - * one past the end ( end() ) iterator. - */ - const_iterator find(const key_type& __x) const { return _M_t.find(__x); } - - /** - * @brief Finds the number of elements with given key. - * @param x Key of (key, value) pairs to be located. - * @return Number of elements with specified key. - * - * This function only makes sense for multimaps. - */ - size_type count(const key_type& __x) const { - return _M_t.find(__x) == _M_t.end() ? 0 : 1; - } - - /** - * @brief Finds the beginning of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to first element matching given key, or - * end() if not found. - * - * This function is useful only with std::multimap. It returns the first - * element of a subsequence of elements that matches the given key. If - * unsuccessful it returns an iterator pointing to the first element that - * has a greater value than given key or end() if no such element exists. - */ - iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); } - - /** - * @brief Finds the beginning of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to first element - * matching given key, or end() if not found. + * Maps support bidirectional iterators. * - * This function is useful only with std::multimap. It returns the first - * element of a subsequence of elements that matches the given key. If - * unsuccessful the iterator will point to the next greatest element or, - * if no such greater element exists, to end(). + * @if maint + * The private tree data is declared exactly the same way for map and + * multimap; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + * @endif */ - const_iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - - /** - * @brief Finds the end of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to last element matching given key. - * - * This function only makes sense with multimaps. - */ - iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); } - - /** - * @brief Finds the end of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to last element matching - * given key. - * - * This function only makes sense with multimaps. - */ - const_iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - + template <typename _Key, typename _Tp, typename _Compare = less<_Key>, + typename _Alloc = allocator<pair<const _Key, _Tp> > > + class map + { + // concept requirements + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept) + + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef pair<const _Key, _Tp> value_type; + typedef _Compare key_compare; + + class value_compare + : public binary_function<value_type, value_type, bool> + { + friend class map<_Key,_Tp,_Compare,_Alloc>; + protected: + _Compare comp; + value_compare(_Compare __c) : comp(__c) {} + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + /// @if maint This turns a red-black tree into a [multi]map. @endif + typedef _Rb_tree<key_type, value_type, + _Select1st<value_type>, key_compare, _Alloc> _Rep_type; + /// @if maint The actual tree structure. @endif + _Rep_type _M_t; + + public: + // many of these are specified differently in ISO, but the following are + // "functionally equivalent" + typedef typename _Rep_type::allocator_type allocator_type; + typedef typename _Rep_type::reference reference; + typedef typename _Rep_type::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::pointer pointer; + typedef typename _Rep_type::const_pointer const_pointer; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + + // [23.3.1.1] construct/copy/destroy + // (get_allocator() is normally listed in this section, but seems to have + // been accidentally omitted in the printed standard) + /** + * @brief Default constructor creates no elements. + */ + map() : _M_t(_Compare(), allocator_type()) { } + + // for some reason this was made a separate function + /** + * @brief Default constructor creates no elements. + */ + explicit + map(const _Compare& __comp, const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { } + + /** + * @brief Map copy constructor. + * @param x A %map of identical element and allocator types. + * + * The newly-created %map uses a copy of the allocation object used + * by @a x. + */ + map(const map& __x) + : _M_t(__x._M_t) { } + + /** + * @brief Builds a %map from a range. + * @param first An input iterator. + * @param last An input iterator. + * + * Create a %map consisting of copies of the elements from [first,last). + * This is linear in N if the range is already sorted, and NlogN + * otherwise (where N is distance(first,last)). + */ + template <typename _InputIterator> + map(_InputIterator __first, _InputIterator __last) + : _M_t(_Compare(), allocator_type()) + { _M_t.insert_unique(__first, __last); } + + /** + * @brief Builds a %map from a range. + * @param first An input iterator. + * @param last An input iterator. + * @param comp A comparison functor. + * @param a An allocator object. + * + * Create a %map consisting of copies of the elements from [first,last). + * This is linear in N if the range is already sorted, and NlogN + * otherwise (where N is distance(first,last)). + */ + template <typename _InputIterator> + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) + { _M_t.insert_unique(__first, __last); } + + // FIXME There is no dtor declared, but we should have something generated + // by Doxygen. I don't know what tags to add to this paragraph to make + // that happen: + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + + /** + * @brief Map assignment operator. + * @param x A %map of identical element and allocator types. + * + * All the elements of @a x are copied, but unlike the copy constructor, + * the allocator object is not copied. + */ + map& + operator=(const map& __x) + { + _M_t = __x._M_t; + return *this; + } + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const { return _M_t.get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first pair in the %map. + * Iteration is done in ascending order according to the keys. + */ + iterator + begin() { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %map. Iteration is done in ascending order according to the + * keys. + */ + const_iterator + begin() const { return _M_t.begin(); } + + /** + * Returns a read/write iterator that points one past the last pair in the + * %map. Iteration is done in ascending order according to the keys. + */ + iterator + end() { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %map. Iteration is done in ascending order according to the + * keys. + */ + const_iterator + end() const { return _M_t.end(); } + + /** + * Returns a read/write reverse iterator that points to the last pair in + * the %map. Iteration is done in descending order according to the keys. + */ + reverse_iterator + rbegin() { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the last + * pair in the %map. Iteration is done in descending order according to + * the keys. + */ + const_reverse_iterator + rbegin() const { return _M_t.rbegin(); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first pair in the %map. Iteration is done in descending order according + * to the keys. + */ + reverse_iterator + rend() { return _M_t.rend(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %map. Iteration is done in descending + * order according to the keys. + */ + const_reverse_iterator + rend() const { return _M_t.rend(); } + + // capacity + /** Returns true if the %map is empty. (Thus begin() would equal end().) */ + bool + empty() const { return _M_t.empty(); } + + /** Returns the size of the %map. */ + size_type + size() const { return _M_t.size(); } + + /** Returns the maximum size of the %map. */ + size_type + max_size() const { return _M_t.max_size(); } + + // [23.3.1.2] element access + /** + * @brief Subscript ( @c [] ) access to %map data. + * @param k The key for which data should be retrieved. + * @return A reference to the data of the (key,data) %pair. + * + * Allows for easy lookup with the subscript ( @c [] ) operator. Returns + * data associated with the key specified in subscript. If the key does + * not exist, a pair with that key is created using default values, which + * is then returned. + * + * Lookup requires logarithmic time. + */ + mapped_type& + operator[](const key_type& __k) + { + // concept requirements + __glibcpp_function_requires(_DefaultConstructibleConcept<mapped_type>) + + iterator __i = lower_bound(__k); + // __i->first is greater than or equivalent to __k. + if (__i == end() || key_comp()(__k, (*__i).first)) + __i = insert(__i, value_type(__k, mapped_type())); + return (*__i).second; + } + + // modifiers + /** + * @brief Attempts to insert a std::pair into the %map. + * @param x Pair to be inserted (see std::make_pair for easy creation of + * pairs). + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted pair, and the second is a bool that + * is true if the pair was actually inserted. + * + * This function attempts to insert a (key, value) %pair into the %map. + * A %map relies on unique keys and thus a %pair is only inserted if its + * first element (the key) is not already present in the %map. + * + * Insertion requires logarithmic time. + */ + pair<iterator,bool> + insert(const value_type& __x) + { return _M_t.insert_unique(__x); } + + /** + * @brief Attempts to insert a std::pair into the %map. + * @param position An iterator that serves as a hint as to where the + * pair should be inserted. + * @param x Pair to be inserted (see std::make_pair for easy creation of + * pairs). + * @return An iterator that points to the element with key of @a x (may + * or may not be the %pair passed in). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument + * insert() does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4 + * for more on "hinting". + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator + insert(iterator position, const value_type& __x) + { return _M_t.insert_unique(position, __x); } + + /** + * @brief A template function that attemps to insert a range of elements. + * @param first Iterator pointing to the start of the range to be + * inserted. + * @param last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template <typename _InputIterator> + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t.insert_unique(__first, __last); } + + /** + * @brief Erases an element from a %map. + * @param position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given iterator, from + * a %map. Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibilty. + */ + void + erase(iterator __position) { _M_t.erase(__position); } + + /** + * @brief Erases elements according to the provided key. + * @param x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibilty. + */ + size_type + erase(const key_type& __x) { return _M_t.erase(__x); } + + /** + * @brief Erases a [first,last) range of elements from a %map. + * @param first Iterator pointing to the start of the range to be erased. + * @param last Iterator pointing to the end of the range to be erased. + * + * This function erases a sequence of elements from a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibilty. + */ + void + erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } + + /** + * @brief Swaps data with another %map. + * @param x A %map of the same element and allocator types. + * + * This exchanges the elements between two maps in constant time. + * (It is only swapping a pointer, an integer, and an instance of + * the @c Compare type (which itself is often stateless and empty), so it + * should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(m1,m2) will feed to this function. + */ + void + swap(map& __x) { _M_t.swap(__x._M_t); } + + /** + * Erases all elements in a %map. Note that this function only erases + * the elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibilty. + */ + void + clear() { _M_t.clear(); } + + // observers + /** + * Returns the key comparison object out of which the %map was constructed. + */ + key_compare + key_comp() const { return _M_t.key_comp(); } + + /** + * Returns a value comparison object, built from the key comparison + * object out of which the %map was constructed. + */ + value_compare + value_comp() const { return value_compare(_M_t.key_comp()); } + + // [23.3.1.3] map operations + /** + * @brief Tries to locate an element in a %map. + * @param x Key of (key, value) %pair to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) { return _M_t.find(__x); } + + /** + * @brief Tries to locate an element in a %map. + * @param x Key of (key, value) %pair to be located. + * @return Read-only (constant) iterator pointing to sought-after + * element, or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns a constant iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + const_iterator + find(const key_type& __x) const { return _M_t.find(__x); } + + /** + * @brief Finds the number of elements with given key. + * @param x Key of (key, value) pairs to be located. + * @return Number of elements with specified key. + * + * This function only makes sense for multimaps; for map the result will + * either be 0 (not present) or 1 (present). + */ + size_type + count(const key_type& __x) const + { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Iterator pointing to first element matching given key, or + * end() if not found. + * + * This function is useful only with multimaps. It returns the first + * element of a subsequence of elements that matches the given key. If + * unsuccessful it returns an iterator pointing to the first element that + * has a greater value than given key or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first element + * matching given key, or end() if not found. + * + * This function is useful only with multimaps. It returns the first + * element of a subsequence of elements that matches the given key. If + * unsuccessful the iterator will point to the next greatest element or, + * if no such greater element exists, to end(). + */ + const_iterator + lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Iterator pointing to last element matching given key. + * + * This function only makes sense with multimaps. + */ + iterator + upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to last element matching + * given key. + * + * This function only makes sense with multimaps. + */ + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param x Key of (key, value) pairs to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function returns a pair of which the first + * element possibly points to the first element matching the given key + * and the second element possibly points to the last element matching the + * given key. If unsuccessful the first element of the returned pair will + * contain an iterator pointing to the next greatest element or, if no such + * greater element exists, to end(). + * + * This function only makes sense for multimaps. + */ + pair<iterator,iterator> + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param x Key of (key, value) pairs to be located. + * @return Pair of read-only (constant) iterators that possibly points to + * the subsequence matching given key. + * + * This function returns a pair of which the first + * element possibly points to the first element matching the given key + * and the second element possibly points to the last element matching the + * given key. If unsuccessful the first element of the returned pair will + * contain an iterator pointing to the next greatest element or, if no such + * a greater element exists, to end(). + * + * This function only makes sense for multimaps. + */ + pair<const_iterator,const_iterator> + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + template <typename _K1, typename _T1, typename _C1, typename _A1> + friend bool operator== (const map<_K1,_T1,_C1,_A1>&, + const map<_K1,_T1,_C1,_A1>&); + template <typename _K1, typename _T1, typename _C1, typename _A1> + friend bool operator< (const map<_K1,_T1,_C1,_A1>&, + const map<_K1,_T1,_C1,_A1>&); + }; + + /** - * @brief Finds a subsequence matching given key. - * @param x Key of (key, value) pairs to be located. - * @return Pair of iterators that possibly points to the subsequence - * matching given key. + * @brief Map equality comparison. + * @param x A %map. + * @param y A %map of the same type as @a x. + * @return True iff the size and elements of the maps are equal. * - * This function improves on lower_bound() and upper_bound() by giving a more - * elegant and efficient solution. It returns a pair of which the first - * element possibly points to the first element matching the given key - * and the second element possibly points to the last element matching the - * given key. If unsuccessful the first element of the returned pair will - * contain an iterator pointing to the next greatest element or, if no such - * greater element exists, to end(). - * - * This function only makes sense for multimaps. + * This is an equivalence relation. It is linear in the size of the + * maps. Maps are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. */ - pair<iterator,iterator> equal_range(const key_type& __x) { - return _M_t.equal_range(__x); - } - + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return __x._M_t == __y._M_t; } + /** - * @brief Finds a subsequence matching given key. - * @param x Key of (key, value) pairs to be located. - * @return Pair of read-only (constant) iterators that possibly points to - * the subsequence matching given key. + * @brief Map ordering relation. + * @param x A %map. + * @param y A %map of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. * - * This function improves on lower_bound() and upper_bound() by giving a more - * elegant and efficient solution. It returns a pair of which the first - * element possibly points to the first element matching the given key - * and the second element possibly points to the last element matching the - * given key. If unsuccessful the first element of the returned pair will - * contain an iterator pointing to the next greatest element or, if no such - * a greater element exists, to end(). + * This is a total ordering relation. It is linear in the size of the + * maps. The elements must be comparable with @c <. * - * This function only makes sense for multimaps. + * See std::lexographical_compare() for how the determination is made. */ - pair<const_iterator,const_iterator> equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - - template <class _K1, class _T1, class _C1, class _A1> - friend bool operator== (const map<_K1, _T1, _C1, _A1>&, - const map<_K1, _T1, _C1, _A1>&); - template <class _K1, class _T1, class _C1, class _A1> - friend bool operator< (const map<_K1, _T1, _C1, _A1>&, - const map<_K1, _T1, _C1, _A1>&); -}; - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t == __y._M_t; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x, - map<_Key,_Tp,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Based on operator== + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x, + const map<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__x < __y); } + + /// See std::map::swap(). + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline void + swap(map<_Key,_Tp,_Compare,_Alloc>& __x, map<_Key,_Tp,_Compare,_Alloc>& __y) + { __x.swap(__y); } } // namespace std -#endif /* _CPP_BITS_STL_MAP_H */ - -// Local Variables: -// mode:C++ -// End: +#endif /* __GLIBCPP_INTERNAL_MAP_H */ diff --git a/contrib/libstdc++/include/bits/stl_multimap.h b/contrib/libstdc++/include/bits/stl_multimap.h index 5947d7537a67..0fa79a8d139e 100644 --- a/contrib/libstdc++/include/bits/stl_multimap.h +++ b/contrib/libstdc++/include/bits/stl_multimap.h @@ -1,6 +1,6 @@ // Multimap implementation -*- C++ -*- -// Copyright (C) 2001 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002 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 @@ -65,427 +65,572 @@ namespace std { -// Forward declaration of operators < and ==, needed for friend declaration. -template <class _Key, class _Tp, - class _Compare = less<_Key>, - class _Alloc = allocator<pair<const _Key, _Tp> > > -class multimap; - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y); - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y); - -/** - * @brief A standard container made up of pairs (see std::pair in <utility>) - * which can be retrieved based on a key. - * - * This is an associative container. Values contained within it can be - * quickly retrieved through a key element. In contrast with a map a - * multimap can have multiple duplicate keys. -*/ -template <class _Key, class _Tp, class _Compare, class _Alloc> -class multimap -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); - -public: - -// typedefs: - - typedef _Key key_type; - typedef _Tp data_type; - typedef _Tp mapped_type; - typedef pair<const _Key, _Tp> value_type; - typedef _Compare key_compare; - - class value_compare : public binary_function<value_type, value_type, bool> { - friend class multimap<_Key,_Tp,_Compare,_Alloc>; - protected: - _Compare comp; - value_compare(_Compare __c) : comp(__c) {} - public: - bool operator()(const value_type& __x, const value_type& __y) const { - return comp(__x.first, __y.first); - } - }; - -private: - typedef _Rb_tree<key_type, value_type, - _Select1st<value_type>, key_compare, _Alloc> _Rep_type; - _Rep_type _M_t; // red-black tree representing multimap -public: - typedef typename _Rep_type::pointer pointer; - typedef typename _Rep_type::const_pointer const_pointer; - typedef typename _Rep_type::reference reference; - typedef typename _Rep_type::const_reference const_reference; - typedef typename _Rep_type::iterator iterator; - typedef typename _Rep_type::const_iterator const_iterator; - typedef typename _Rep_type::reverse_iterator reverse_iterator; - typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; - typedef typename _Rep_type::size_type size_type; - typedef typename _Rep_type::difference_type difference_type; - typedef typename _Rep_type::allocator_type allocator_type; - -// allocation/deallocation - - multimap() : _M_t(_Compare(), allocator_type()) { } - explicit multimap(const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { } - - template <class _InputIterator> - multimap(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - - template <class _InputIterator> - multimap(_InputIterator __first, _InputIterator __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } - multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { } - - multimap<_Key,_Tp,_Compare,_Alloc>& - operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) { - _M_t = __x._M_t; - return *this; - } - - // accessors: - - key_compare key_comp() const { return _M_t.key_comp(); } - value_compare value_comp() const { return value_compare(_M_t.key_comp()); } - allocator_type get_allocator() const { return _M_t.get_allocator(); } - + // Forward declaration of operators < and ==, needed for friend declaration. + + template <typename _Key, typename _Tp, + typename _Compare = less<_Key>, + typename _Alloc = allocator<pair<const _Key, _Tp> > > + class multimap; + + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y); + + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y); + /** - * Returns a read/write iterator that points to the first pair in the - * multimap. Iteration is done in ascending order according to the keys. - */ - iterator begin() { return _M_t.begin(); } - - /** - * Returns a read-only (constant) iterator that points to the first pair - * in the multimap. Iteration is done in ascending order according to the - * keys. - */ - const_iterator begin() const { return _M_t.begin(); } - - /** - * Returns a read/write iterator that points one past the last pair in the - * multimap. Iteration is done in ascending order according to the keys. - */ - iterator end() { return _M_t.end(); } - - /** - * Returns a read-only (constant) iterator that points one past the last - * pair in the multimap. Iteration is done in ascending order according - * to the keys. - */ - const_iterator end() const { return _M_t.end(); } - - /** - * Returns a read/write reverse iterator that points to the last pair in - * the multimap. Iteration is done in descending order according to the - * keys. - */ - reverse_iterator rbegin() { return _M_t.rbegin(); } - - /** - * Returns a read-only (constant) reverse iterator that points to the last - * pair in the multimap. Iteration is done in descending order according - * to the keys. - */ - const_reverse_iterator rbegin() const { return _M_t.rbegin(); } - - /** - * Returns a read/write reverse iterator that points to one before the - * first pair in the multimap. Iteration is done in descending order - * according to the keys. - */ - reverse_iterator rend() { return _M_t.rend(); } - - /** - * Returns a read-only (constant) reverse iterator that points to one - * before the first pair in the multimap. Iteration is done in descending - * order according to the keys. - */ - const_reverse_iterator rend() const { return _M_t.rend(); } - - /** Returns true if the map is empty. (Thus begin() would equal end().) */ - bool empty() const { return _M_t.empty(); } - - /** Returns the size of the map. */ - size_type size() const { return _M_t.size(); } - - /** Returns the maximum size of the map. */ - size_type max_size() const { return _M_t.max_size(); } - - void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } - - // insert/erase - /** - * @brief Inserts a std::pair into the multimap. - * @param x Pair to be inserted (see std::make_pair for easy creation of - * pairs). - * @return An iterator that points to the inserted (key,value) pair. + * @brief A standard container made up of (key,value) pairs, which can be + * retrieved based on a key, in logarithmic time. * - * This function inserts a (key, value) pair into the multimap. Contrary - * to a std::map the multimap does not rely on unique keys and thus a - * multiple pairs with the same key can be inserted. - */ - iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); } - - /** - * @brief Inserts a std::pair into the multimap. - * @param position An iterator that serves as a hint as to where the - * pair should be inserted. - * @param x Pair to be inserted (see std::make_pair for easy creation of - * pairs). - * @return An iterator that points to the inserted (key,value) pair. + * @ingroup Containers + * @ingroup Assoc_containers * - * This function inserts a (key, value) pair into the multimap. Contrary - * to a std::map the multimap does not rely on unique keys and thus a - * multiple pairs with the same key can be inserted. - * Note that the first parameter is only a hint and can potentially - * improve the performance of the insertion process. A bad hint would - * cause no gains in efficiency. - */ - iterator insert(iterator __position, const value_type& __x) { - return _M_t.insert_equal(__position, __x); - } - - /** - * @brief A template function that attemps to insert elements from - * another range (possibly another multimap or standard container). - * @param first Iterator pointing to the start of the range to be - * inserted. - * @param last Iterator pointing to the end of the range to be inserted. - */ - template <class _InputIterator> - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_equal(__first, __last); - } - - /** - * @brief Erases an element from a multimap. - * @param position An iterator pointing to the element to be erased. - * - * This function erases an element, pointed to by the given iterator, from - * a mutlimap. Note that this function only erases the element, and that - * if the element is itself a pointer, the pointed-to memory is not - * touched in any way. Managing the pointer is the user's responsibilty. - */ - void erase(iterator __position) { _M_t.erase(__position); } - - /** - * @brief Erases an element according to the provided key. - * @param x Key of element to be erased. - * @return Doc me! (Number of elements erased?) + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and an + * <a href="tables.html#69">associative container</a> (using equivalent + * keys). For a @c multimap<Key,T> the key_type is Key, the mapped_type + * is T, and the value_type is std::pair<const Key,T>. * - * This function erases all elements, located by the given key, from a - * multimap. - * Note that this function only erases the element, and that if - * the element is itself a pointer, the pointed-to memory is not touched - * in any way. Managing the pointer is the user's responsibilty. - */ - size_type erase(const key_type& __x) { return _M_t.erase(__x); } - - /** - * @brief Erases a [first,last) range of elements from a multimap. - * @param first Iterator pointing to the start of the range to be erased. - * @param last Iterator pointing to the end of the range to be erased. - * - * This function erases a sequence of elements from a multimap. - * Note that this function only erases the elements, and that if - * the elements themselves are pointers, the pointed-to memory is not - * touched in any way. Managing the pointer is the user's responsibilty. - */ - void erase(iterator __first, iterator __last) - { _M_t.erase(__first, __last); } - - /** Erases all elements in a multimap. Note that this function only erases - * the elements, and that if the elements themselves are pointers, the - * pointed-to memory is not touched in any way. Managing the pointer is - * the user's responsibilty. - */ - void clear() { _M_t.clear(); } - - // multimap operations: - - /** - * @brief Tries to locate an element in a multimap. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to sought-after (first matching?) element, - * or end() if not found. - * - * This function takes a key and tries to locate the element with which - * the key matches. If successful the function returns an iterator - * pointing to the sought after pair. If unsuccessful it returns the - * one past the end ( end() ) iterator. - */ - iterator find(const key_type& __x) { return _M_t.find(__x); } - - /** - * @brief Tries to locate an element in a multimap. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to sought-after (first - * matching?) element, or end() if not found. - * - * This function takes a key and tries to locate the element with which - * the key matches. If successful the function returns a constant iterator - * pointing to the sought after pair. If unsuccessful it returns the - * one past the end ( end() ) iterator. - */ - const_iterator find(const key_type& __x) const { return _M_t.find(__x); } - - /** - * @brief Finds the number of elements with given key. - * @param x Key of (key, value) pairs to be located. - * @return Number of elements with specified key. - */ - size_type count(const key_type& __x) const { return _M_t.count(__x); } - - /** - * @brief Finds the beginning of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to first element matching given key, or - * end() if not found. + * Multimaps support bidirectional iterators. * - * This function returns the first element of a subsequence of elements - * that matches the given key. If unsuccessful it returns an iterator - * pointing to the first element that has a greater value than given key - * or end() if no such element exists. + * @if maint + * The private tree data is declared exactly the same way for map and + * multimap; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + * @endif */ - iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); } - + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + class multimap + { + // concept requirements + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept) + + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef pair<const _Key, _Tp> value_type; + typedef _Compare key_compare; + + class value_compare + : public binary_function<value_type, value_type, bool> + { + friend class multimap<_Key,_Tp,_Compare,_Alloc>; + protected: + _Compare comp; + value_compare(_Compare __c) : comp(__c) {} + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + /// @if maint This turns a red-black tree into a [multi]map. @endif + typedef _Rb_tree<key_type, value_type, + _Select1st<value_type>, key_compare, _Alloc> _Rep_type; + /// @if maint The actual tree structure. @endif + _Rep_type _M_t; + + public: + // many of these are specified differently in ISO, but the following are + // "functionally equivalent" + typedef typename _Rep_type::allocator_type allocator_type; + typedef typename _Rep_type::reference reference; + typedef typename _Rep_type::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::pointer pointer; + typedef typename _Rep_type::const_pointer const_pointer; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + + // [23.3.2] construct/copy/destroy + // (get_allocator() is also listed in this section) + /** + * @brief Default constructor creates no elements. + */ + multimap() : _M_t(_Compare(), allocator_type()) { } + + // for some reason this was made a separate function + /** + * @brief Default constructor creates no elements. + */ + explicit + multimap(const _Compare& __comp, const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { } + + /** + * @brief %Multimap copy constructor. + * @param x A %multimap of identical element and allocator types. + * + * The newly-created %multimap uses a copy of the allocation object used + * by @a x. + */ + multimap(const multimap& __x) + : _M_t(__x._M_t) { } + + /** + * @brief Builds a %multimap from a range. + * @param first An input iterator. + * @param last An input iterator. + * + * Create a %multimap consisting of copies of the elements from + * [first,last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(first,last)). + */ + template <typename _InputIterator> + multimap(_InputIterator __first, _InputIterator __last) + : _M_t(_Compare(), allocator_type()) + { _M_t.insert_equal(__first, __last); } + + /** + * @brief Builds a %multimap from a range. + * @param first An input iterator. + * @param last An input iterator. + * @param comp A comparison functor. + * @param a An allocator object. + * + * Create a %multimap consisting of copies of the elements from + * [first,last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(first,last)). + */ + template <typename _InputIterator> + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) + { _M_t.insert_equal(__first, __last); } + + // FIXME There is no dtor declared, but we should have something generated + // by Doxygen. I don't know what tags to add to this paragraph to make + // that happen: + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + + /** + * @brief %Multimap assignment operator. + * @param x A %multimap of identical element and allocator types. + * + * All the elements of @a x are copied, but unlike the copy constructor, + * the allocator object is not copied. + */ + multimap& + operator=(const multimap& __x) + { + _M_t = __x._M_t; + return *this; + } + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const { return _M_t.get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first pair in the + * %multimap. Iteration is done in ascending order according to the keys. + */ + iterator + begin() { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %multimap. Iteration is done in ascending order according to the + * keys. + */ + const_iterator + begin() const { return _M_t.begin(); } + + /** + * Returns a read/write iterator that points one past the last pair in the + * %multimap. Iteration is done in ascending order according to the keys. + */ + iterator + end() { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %multimap. Iteration is done in ascending order according + * to the keys. + */ + const_iterator + end() const { return _M_t.end(); } + + /** + * Returns a read/write reverse iterator that points to the last pair in + * the %multimap. Iteration is done in descending order according to the + * keys. + */ + reverse_iterator + rbegin() { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the last + * pair in the %multimap. Iteration is done in descending order according + * to the keys. + */ + const_reverse_iterator + rbegin() const { return _M_t.rbegin(); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first pair in the %multimap. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rend() { return _M_t.rend(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %multimap. Iteration is done in descending + * order according to the keys. + */ + const_reverse_iterator + rend() const { return _M_t.rend(); } + + // capacity + /** Returns true if the %multimap is empty. */ + bool + empty() const { return _M_t.empty(); } + + /** Returns the size of the %multimap. */ + size_type + size() const { return _M_t.size(); } + + /** Returns the maximum size of the %multimap. */ + size_type + max_size() const { return _M_t.max_size(); } + + // modifiers + /** + * @brief Inserts a std::pair into the %multimap. + * @param x Pair to be inserted (see std::make_pair for easy creation of + * pairs). + * @return An iterator that points to the inserted (key,value) pair. + * + * This function inserts a (key, value) pair into the %multimap. Contrary + * to a std::map the %multimap does not rely on unique keys and thus + * multiple pairs with the same key can be inserted. + * + * Insertion requires logarithmic time. + */ + iterator + insert(const value_type& __x) { return _M_t.insert_equal(__x); } + + /** + * @brief Inserts a std::pair into the %multimap. + * @param position An iterator that serves as a hint as to where the + * pair should be inserted. + * @param x Pair to be inserted (see std::make_pair for easy creation of + * pairs). + * @return An iterator that points to the inserted (key,value) pair. + * + * This function inserts a (key, value) pair into the %multimap. Contrary + * to a std::map the %multimap does not rely on unique keys and thus + * multiple pairs with the same key can be inserted. + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4 + * for more on "hinting". + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator + insert(iterator __position, const value_type& __x) + { return _M_t.insert_equal(__position, __x); } + + /** + * @brief A template function that attemps to insert a range of elements. + * @param first Iterator pointing to the start of the range to be + * inserted. + * @param last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template <typename _InputIterator> + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t.insert_equal(__first, __last); } + + /** + * @brief Erases an element from a %multimap. + * @param position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given iterator, from + * a %multimap. Note that this function only erases the element, and that + * if the element is itself a pointer, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's responsibilty. + */ + void + erase(iterator __position) { _M_t.erase(__position); } + + /** + * @brief Erases elements according to the provided key. + * @param x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all elements located by the given key from a + * %multimap. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibilty. + */ + size_type + erase(const key_type& __x) { return _M_t.erase(__x); } + + /** + * @brief Erases a [first,last) range of elements from a %multimap. + * @param first Iterator pointing to the start of the range to be erased. + * @param last Iterator pointing to the end of the range to be erased. + * + * This function erases a sequence of elements from a %multimap. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's responsibilty. + */ + void + erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } + + /** + * @brief Swaps data with another %multimap. + * @param x A %multimap of the same element and allocator types. + * + * This exchanges the elements between two multimaps in constant time. + * (It is only swapping a pointer, an integer, and an instance of + * the @c Compare type (which itself is often stateless and empty), so it + * should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(m1,m2) will feed to this function. + */ + void + swap(multimap& __x) { _M_t.swap(__x._M_t); } + + /** + * Erases all elements in a %multimap. Note that this function only erases + * the elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibilty. + */ + void + clear() { _M_t.clear(); } + + // observers + /** + * Returns the key comparison object out of which the %multimap + * was constructed. + */ + key_compare + key_comp() const { return _M_t.key_comp(); } + + /** + * Returns a value comparison object, built from the key comparison + * object out of which the %multimap was constructed. + */ + value_compare + value_comp() const { return value_compare(_M_t.key_comp()); } + + // multimap operations + /** + * @brief Tries to locate an element in a %multimap. + * @param x Key of (key, value) pair to be located. + * @return Iterator pointing to sought-after element, + * or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) { return _M_t.find(__x); } + + /** + * @brief Tries to locate an element in a %multimap. + * @param x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to sought-after + * element, or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns a constant iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + const_iterator + find(const key_type& __x) const { return _M_t.find(__x); } + + /** + * @brief Finds the number of elements with given key. + * @param x Key of (key, value) pairs to be located. + * @return Number of elements with specified key. + */ + size_type + count(const key_type& __x) const { return _M_t.count(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Iterator pointing to first element matching given key, or + * end() if not found. + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first element + * matching given key, or end() if not found. + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful the iterator will point + * to the next greatest element or, if no such greater element exists, to + * end(). + */ + const_iterator + lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Iterator pointing to last element matching given key. + */ + iterator + upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to last element matching + * given key. + */ + const_iterator + upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param x Key of (key, value) pairs to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function returns a pair of which the first + * element possibly points to the first element matching the given key + * and the second element possibly points to the last element matching the + * given key. If unsuccessful the first element of the returned pair will + * contain an iterator pointing to the next greatest element or, if no such + * greater element exists, to end(). + */ + pair<iterator,iterator> + equal_range(const key_type& __x) { return _M_t.equal_range(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param x Key of (key, value) pairs to be located. + * @return Pair of read-only (constant) iterators that possibly points to + * the subsequence matching given key. + * + * This function returns a pair of which the first + * element possibly points to the first element matching the given key + * and the second element possibly points to the last element matching the + * given key. If unsuccessful the first element of the returned pair will + * contain an iterator pointing to the next greatest element or, if no such + * a greater element exists, to end(). + */ + pair<const_iterator,const_iterator> + equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } + + template <typename _K1, typename _T1, typename _C1, typename _A1> + friend bool operator== (const multimap<_K1,_T1,_C1,_A1>&, + const multimap<_K1,_T1,_C1,_A1>&); + template <typename _K1, typename _T1, typename _C1, typename _A1> + friend bool operator< (const multimap<_K1,_T1,_C1,_A1>&, + const multimap<_K1,_T1,_C1,_A1>&); + }; + + /** - * @brief Finds the beginning of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to first element - * matching given key, or end() if not found. + * @brief Multimap equality comparison. + * @param x A %multimap. + * @param y A %multimap of the same type as @a x. + * @return True iff the size and elements of the maps are equal. * - * This function returns the first element of a subsequence of elements - * that matches the given key. If unsuccessful the iterator will point - * to the next greatest element or, if no such greater element exists, to - * end(). - */ - const_iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - - /** - * @brief Finds the end of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Iterator pointing to last element matching given key. + * This is an equivalence relation. It is linear in the size of the + * multimaps. Multimaps are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. */ - iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); } - - /** - * @brief Finds the end of a subsequence matching given key. - * @param x Key of (key, value) pair to be located. - * @return Read-only (constant) iterator pointing to last element matching - * given key. - */ - const_iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { + return __x._M_t == __y._M_t; + } + /** - * @brief Finds a subsequence matching given key. - * @param x Key of (key, value) pairs to be located. - * @return Pair of iterators that possibly points to the subsequence - * matching given key. + * @brief Multimap ordering relation. + * @param x A %multimap. + * @param y A %multimap of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. * - * This function improves on lower_bound() and upper_bound() by giving a more - * elegant and efficient solution. It returns a pair of which the first - * element possibly points to the first element matching the given key - * and the second element possibly points to the last element matching the - * given key. If unsuccessful the first element of the returned pair will - * contain an iterator pointing to the next greatest element or, if no such - * greater element exists, to end(). - */ - pair<iterator,iterator> equal_range(const key_type& __x) { - return _M_t.equal_range(__x); - } - - /** - * @brief Finds a subsequence matching given key. - * @param x Key of (key, value) pairs to be located. - * @return Pair of read-only (constant) iterators that possibly points to - * the subsequence matching given key. + * This is a total ordering relation. It is linear in the size of the + * multimaps. The elements must be comparable with @c <. * - * This function improves on lower_bound() and upper_bound() by giving a more - * elegant and efficient solution. It returns a pair of which the first - * element possibly points to the first element matching the given key - * and the second element possibly points to the last element matching the - * given key. If unsuccessful the first element of the returned pair will - * contain an iterator pointing to the next greatest element or, if no such - * a greater element exists, to end(). + * See std::lexographical_compare() for how the determination is made. */ - pair<const_iterator,const_iterator> equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - - template <class _K1, class _T1, class _C1, class _A1> - friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&, - const multimap<_K1, _T1, _C1, _A1>&); - template <class _K1, class _T1, class _C1, class _A1> - friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&, - const multimap<_K1, _T1, _C1, _A1>&); -}; - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t == __y._M_t; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template <class _Key, class _Tp, class _Compare, class _Alloc> -inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x, - multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Based on operator== + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline bool + operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { return !(__x < __y); } + + /// See std::multimap::swap(). + template <typename _Key, typename _Tp, typename _Compare, typename _Alloc> + inline void + swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x, + multimap<_Key,_Tp,_Compare,_Alloc>& __y) + { __x.swap(__y); } } // namespace std #endif /* __GLIBCPP_INTERNAL_MULTIMAP_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/stl_queue.h b/contrib/libstdc++/include/bits/stl_queue.h index 5503640187ac..ff2ba266aab7 100644 --- a/contrib/libstdc++/include/bits/stl_queue.h +++ b/contrib/libstdc++/include/bits/stl_queue.h @@ -1,6 +1,6 @@ // Queue implementation -*- C++ -*- -// Copyright (C) 2001 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002 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 @@ -65,180 +65,366 @@ namespace std { - -// Forward declarations of operators < and ==, needed for friend declaration. - -template <class _Tp, - class _Sequence = deque<_Tp> > -class queue; - -template <class _Tp, class _Seq> -inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); - -template <class _Tp, class _Seq> -inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); - - -template <class _Tp, class _Sequence> -class queue -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - __glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept) - __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept) - typedef typename _Sequence::value_type _Sequence_value_type; - __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept); - - template <class _Tp1, class _Seq1> - friend bool operator== (const queue<_Tp1, _Seq1>&, - const queue<_Tp1, _Seq1>&); - template <class _Tp1, class _Seq1> - friend bool operator< (const queue<_Tp1, _Seq1>&, - const queue<_Tp1, _Seq1>&); -public: - typedef typename _Sequence::value_type value_type; - typedef typename _Sequence::size_type size_type; - typedef _Sequence container_type; - - typedef typename _Sequence::reference reference; - typedef typename _Sequence::const_reference const_reference; -protected: - _Sequence c; -public: - explicit queue(const _Sequence& __c = _Sequence()) : c(__c) {} - - bool empty() const { return c.empty(); } - size_type size() const { return c.size(); } - reference front() { return c.front(); } - const_reference front() const { return c.front(); } - reference back() { return c.back(); } - const_reference back() const { return c.back(); } - void push(const value_type& __x) { c.push_back(__x); } - void pop() { c.pop_front(); } -}; - -template <class _Tp, class _Sequence> -bool -operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __x.c == __y.c; -} - -template <class _Tp, class _Sequence> -bool -operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __x.c < __y.c; -} - -template <class _Tp, class _Sequence> -bool -operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__x == __y); -} - -template <class _Tp, class _Sequence> -bool -operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __y < __x; -} - -template <class _Tp, class _Sequence> -bool -operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__y < __x); -} - -template <class _Tp, class _Sequence> -bool -operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__x < __y); -} - -template <class _Tp, - class _Sequence = vector<_Tp>, - class _Compare = less<typename _Sequence::value_type> > -class priority_queue -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - __glibcpp_class_requires(_Sequence, _SequenceConcept) - __glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept) - typedef typename _Sequence::value_type _Sequence_value_type; - __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept); - __glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept); - -public: - typedef typename _Sequence::value_type value_type; - typedef typename _Sequence::size_type size_type; - typedef _Sequence container_type; - - typedef typename _Sequence::reference reference; - typedef typename _Sequence::const_reference const_reference; -protected: - _Sequence c; - _Compare comp; -public: - explicit priority_queue(const _Compare& __x = _Compare(), - const _Sequence& __s = _Sequence()) - : c(__s), comp(__x) - { make_heap(c.begin(), c.end(), comp); } - - template <class _InputIterator> - priority_queue(_InputIterator __first, _InputIterator __last, - const _Compare& __x = _Compare(), - const _Sequence& __s = _Sequence()) - : c(__s), comp(__x) - { - c.insert(c.end(), __first, __last); - make_heap(c.begin(), c.end(), comp); - } - - bool empty() const { return c.empty(); } - size_type size() const { return c.size(); } - const_reference top() const { return c.front(); } - - void - push(const value_type& __x) + // Forward declarations of operators < and ==, needed for friend declaration. + + template <typename _Tp, typename _Sequence = deque<_Tp> > + class queue; + + template <typename _Tp, typename _Seq> + inline bool operator==(const queue<_Tp,_Seq>&, const queue<_Tp,_Seq>&); + + template <typename _Tp, typename _Seq> + inline bool operator<(const queue<_Tp,_Seq>&, const queue<_Tp,_Seq>&); + + + /** + * @brief A standard container giving FIFO behavior. + * + * @ingroup Containers + * @ingroup Sequences + * + * Meets many of the requirements of a + * <a href="tables.html#65">container</a>, + * but does not define anything to do with iterators. Very few of the + * other standard container interfaces are defined. + * + * This is not a true container, but an @e adaptor. It holds another + * container, and provides a wrapper interface to that container. The + * wrapper is what enforces strict first-in-first-out %queue behavior. + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::deque, but it can be any type + * that supports @c front, @c back, @c push_back, and @c pop_front, + * such as std::list or an appropriate user-defined type. + * + * Members not found in "normal" containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c push and + * @c pop, which are standard %queue/FIFO operations. + */ + template <typename _Tp, typename _Sequence> + class queue { - try - { - c.push_back(__x); - push_heap(c.begin(), c.end(), comp); - } - catch(...) - { - c.clear(); - __throw_exception_again; - } - } - - void - pop() + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + __glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept) + __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept) + __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + + template <typename _Tp1, typename _Seq1> + friend bool operator== (const queue<_Tp1, _Seq1>&, + const queue<_Tp1, _Seq1>&); + template <typename _Tp1, typename _Seq1> + friend bool operator< (const queue<_Tp1, _Seq1>&, + const queue<_Tp1, _Seq1>&); + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + /** + * 'c' is the underlying container. Maintainers wondering why this isn't + * uglified as per style guidelines should note that this name is + * specified in the standard, [23.2.3.1]. (Why? Presumably for the same + * reason that it's protected instead of private: to allow derivation. + * But none of the other containers allow for derivation. Odd.) + */ + _Sequence c; + + public: + /** + * @brief Default constructor creates no elements. + */ + explicit + queue(const _Sequence& __c = _Sequence()) + : c(__c) {} + + /** + * Returns true if the %queue is empty. + */ + bool + empty() const { return c.empty(); } + + /** Returns the number of elements in the %queue. */ + size_type + size() const { return c.size(); } + + /** + * Returns a read/write reference to the data at the first element of the + * %queue. + */ + reference + front() { return c.front(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %queue. + */ + const_reference + front() const { return c.front(); } + + /** + * Returns a read/write reference to the data at the last element of the + * %queue. + */ + reference + back() { return c.back(); } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %queue. + */ + const_reference + back() const { return c.back(); } + + /** + * @brief Add data to the end of the %queue. + * @param x Data to be added. + * + * This is a typical %queue operation. The function creates an element at + * the end of the %queue and assigns the given data to it. + * The time complexity of the operation depends on the underlying + * sequence. + */ + void + push(const value_type& __x) { c.push_back(__x); } + + /** + * @brief Removes first element. + * + * This is a typical %queue operation. It shrinks the %queue by one. + * The time complexity of the operation depends on the underlying + * sequence. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop() is called. + */ + void + pop() { c.pop_front(); } + }; + + + /** + * @brief Queue equality comparison. + * @param x A %queue. + * @param y A %queue of the same type as @a x. + * @return True iff the size and elements of the queues are equal. + * + * This is an equivalence relation. Complexity and semantics depend on the + * underlying sequence type, but the expected rules are: this relation is + * linear in the size of the sequences, and queues are considered equivalent + * if their sequences compare equal. + */ + template <typename _Tp, typename _Sequence> + inline bool + operator==(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return __x.c == __y.c; } + + /** + * @brief Queue ordering relation. + * @param x A %queue. + * @param y A %queue of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. + * + * This is an total ordering relation. Complexity and semantics depend on + * the underlying sequence type, but the expected rules are: this relation + * is linear in the size of the sequences, the elements must be comparable + * with @c <, and std::lexographical_compare() is usually used to make the + * determination. + */ + template <typename _Tp, typename _Sequence> + inline bool + operator<(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return __x.c < __y.c; } + + /// Based on operator== + template <typename _Tp, typename _Sequence> + inline bool + operator!=(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return !(__x == __y); } + + /// Based on operator< + template <typename _Tp, typename _Sequence> + inline bool + operator>(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return __y < __x; } + + /// Based on operator< + template <typename _Tp, typename _Sequence> + inline bool + operator<=(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return !(__y < __x); } + + /// Based on operator< + template <typename _Tp, typename _Sequence> + inline bool + operator>=(const queue<_Tp,_Sequence>& __x, const queue<_Tp,_Sequence>& __y) + { return !(__x < __y); } + + + /** + * @brief A standard container automatically sorting its contents. + * + * @ingroup Containers + * @ingroup Sequences + * + * This is not a true container, but an @e adaptor. It holds another + * container, and provides a wrapper interface to that container. The + * wrapper is what enforces sorting and first-in-first-out %queue behavior. + * Very few of the standard container/sequence interface requirements are + * met (e.g., iterators). + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::vector, but it can be any type + * that supports @c front(), @c push_back, @c pop_back, and random-access + * iterators, such as std::deque or an appropriate user-defined type. + * + * The third template parameter supplies the means of making priority + * comparisons. It defaults to @c less<value_type> but can be anything + * defining a strict weak ordering. + * + * Members not found in "normal" containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c push, + * @c pop, and @c top, which are standard %queue/FIFO operations. + * + * @note No equality/comparison operators are provided for %priority_queue. + * + * @note Sorting of the elements takes place as they are added to, and + * removed from, the %priority_queue using the %priority_queue's + * member functions. If you access the elements by other means, and + * change their data such that the sorting order would be different, + * the %priority_queue will not re-sort the elements for you. (How + * could it know to do so?) + */ + template <typename _Tp, typename _Sequence = vector<_Tp>, + typename _Compare = less<typename _Sequence::value_type> > + class priority_queue { - try - { - pop_heap(c.begin(), c.end(), comp); - c.pop_back(); - } - catch(...) - { - c.clear(); - __throw_exception_again; + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + __glibcpp_class_requires(_Sequence, _SequenceConcept) + __glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept) + __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + __glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept) + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + // See queue::c for notes on these names. + _Sequence c; + _Compare comp; + + public: + /** + * @brief Default constructor creates no elements. + */ + explicit + priority_queue(const _Compare& __x = _Compare(), + const _Sequence& __s = _Sequence()) + : c(__s), comp(__x) + { make_heap(c.begin(), c.end(), comp); } + + /** + * @brief Builds a %queue from a range. + * @param first An input iterator. + * @param last An input iterator. + * @param x A comparison functor describing a strict weak ordering. + * @param s An initial sequence with which to start. + * + * Begins by copying @a s, inserting a copy of the elements from + * @a [first,last) into the copy of @a s, then ordering the copy + * according to @a x. + * + * For more information on function objects, see the documentation on + * @link s20_3_1_base functor base classes@endlink. + */ + template <typename _InputIterator> + priority_queue(_InputIterator __first, _InputIterator __last, + const _Compare& __x = _Compare(), + const _Sequence& __s = _Sequence()) + : c(__s), comp(__x) + { + c.insert(c.end(), __first, __last); + make_heap(c.begin(), c.end(), comp); } - } -}; - -// no equality is provided - + + /** + * Returns true if the %queue is empty. + */ + bool + empty() const { return c.empty(); } + + /** Returns the number of elements in the %queue. */ + size_type + size() const { return c.size(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %queue. + */ + const_reference + top() const { return c.front(); } + + /** + * @brief Add data to the %queue. + * @param x Data to be added. + * + * This is a typical %queue operation. + * The time complexity of the operation depends on the underlying + * sequence. + */ + void + push(const value_type& __x) + { + try + { + c.push_back(__x); + push_heap(c.begin(), c.end(), comp); + } + catch(...) + { + c.clear(); + __throw_exception_again; + } + } + + /** + * @brief Removes first element. + * + * This is a typical %queue operation. It shrinks the %queue by one. + * The time complexity of the operation depends on the underlying + * sequence. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop() is called. + */ + void + pop() + { + try + { + pop_heap(c.begin(), c.end(), comp); + c.pop_back(); + } + catch(...) + { + c.clear(); + __throw_exception_again; + } + } + }; + + // No equality/comparison operators are provided for priority_queue. } // namespace std #endif /* __GLIBCPP_INTERNAL_QUEUE_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/stl_stack.h b/contrib/libstdc++/include/bits/stl_stack.h index 0a80b109f6a8..7f2496c383eb 100644 --- a/contrib/libstdc++/include/bits/stl_stack.h +++ b/contrib/libstdc++/include/bits/stl_stack.h @@ -1,6 +1,6 @@ // Stack implementation -*- C++ -*- -// Copyright (C) 2001 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002 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 @@ -65,96 +65,186 @@ namespace std { - -// Forward declarations of operators == and <, needed for friend declaration. - -template <class _Tp, - class _Sequence = deque<_Tp> > -class stack; - -template <class _Tp, class _Seq> -bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y); - -template <class _Tp, class _Seq> -bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y); - - -template <class _Tp, class _Sequence> -class stack -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept) - typedef typename _Sequence::value_type _Sequence_value_type; - __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept); - - template <class _Tp1, class _Seq1> - friend bool operator== (const stack<_Tp1, _Seq1>&, - const stack<_Tp1, _Seq1>&); - template <class _Tp1, class _Seq1> - friend bool operator< (const stack<_Tp1, _Seq1>&, - const stack<_Tp1, _Seq1>&); -public: - typedef typename _Sequence::value_type value_type; - typedef typename _Sequence::size_type size_type; - typedef _Sequence container_type; - - typedef typename _Sequence::reference reference; - typedef typename _Sequence::const_reference const_reference; -protected: - _Sequence c; -public: - stack() : c() {} - explicit stack(const _Sequence& __s) : c(__s) {} - - bool empty() const { return c.empty(); } - size_type size() const { return c.size(); } - reference top() { return c.back(); } - const_reference top() const { return c.back(); } - void push(const value_type& __x) { c.push_back(__x); } - void pop() { c.pop_back(); } -}; - -template <class _Tp, class _Seq> -bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __x.c == __y.c; -} - -template <class _Tp, class _Seq> -bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __x.c < __y.c; -} - -template <class _Tp, class _Seq> -bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__x == __y); -} - -template <class _Tp, class _Seq> -bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __y < __x; -} - -template <class _Tp, class _Seq> -bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__y < __x); -} - -template <class _Tp, class _Seq> -bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__x < __y); -} - + // Forward declarations of operators == and <, needed for friend declaration. + + template <typename _Tp, typename _Sequence = deque<_Tp> > + class stack; + + template <typename _Tp, typename _Seq> + inline bool operator==(const stack<_Tp,_Seq>& __x, + const stack<_Tp,_Seq>& __y); + + template <typename _Tp, typename _Seq> + inline bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y); + + + /** + * @brief A standard container giving FILO behavior. + * + * @ingroup Containers + * @ingroup Sequences + * + * Meets many of the requirements of a + * <a href="tables.html#65">container</a>, + * but does not define anything to do with iterators. Very few of the + * other standard container interfaces are defined. + * + * This is not a true container, but an @e adaptor. It holds another + * container, and provides a wrapper interface to that container. The + * wrapper is what enforces strict first-in-last-out %stack behavior. + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::deque, but it can be any type + * that supports @c back, @c push_back, and @c pop_front, such as + * std::list, std::vector, or an appropriate user-defined type. + * + * Members not found in "normal" containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c push, + * @c pop, and @c top, which are standard %stack/FILO operations. + */ + template <typename _Tp, typename _Sequence> + class stack + { + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept) + __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + + template <typename _Tp1, typename _Seq1> + friend bool operator== (const stack<_Tp1, _Seq1>&, + const stack<_Tp1, _Seq1>&); + template <typename _Tp1, typename _Seq1> + friend bool operator< (const stack<_Tp1, _Seq1>&, + const stack<_Tp1, _Seq1>&); + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + // See queue::c for notes on this name. + _Sequence c; + + public: + // XXX removed old def ctor, added def arg to this one to match 14882 + /** + * @brief Default constructor creates no elements. + */ + explicit + stack(const _Sequence& __c = _Sequence()) + : c(__c) {} + + /** + * Returns true if the %stack is empty. + */ + bool + empty() const { return c.empty(); } + + /** Returns the number of elements in the %stack. */ + size_type + size() const { return c.size(); } + + /** + * Returns a read/write reference to the data at the first element of the + * %stack. + */ + reference + top() { return c.back(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %stack. + */ + const_reference + top() const { return c.back(); } + + /** + * @brief Add data to the top of the %stack. + * @param x Data to be added. + * + * This is a typical %stack operation. The function creates an element at + * the top of the %stack and assigns the given data to it. + * The time complexity of the operation depends on the underlying + * sequence. + */ + void + push(const value_type& __x) { c.push_back(__x); } + + /** + * @brief Removes first element. + * + * This is a typical %stack operation. It shrinks the %stack by one. + * The time complexity of the operation depends on the underlying + * sequence. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop() is called. + */ + void + pop() { c.pop_back(); } + }; + + + /** + * @brief Stack equality comparison. + * @param x A %stack. + * @param y A %stack of the same type as @a x. + * @return True iff the size and elements of the stacks are equal. + * + * This is an equivalence relation. Complexity and semantics depend on the + * underlying sequence type, but the expected rules are: this relation is + * linear in the size of the sequences, and stacks are considered equivalent + * if their sequences compare equal. + */ + template <typename _Tp, typename _Seq> + inline bool + operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return __x.c == __y.c; } + + /** + * @brief Stack ordering relation. + * @param x A %stack. + * @param y A %stack of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. + * + * This is an total ordering relation. Complexity and semantics depend on + * the underlying sequence type, but the expected rules are: this relation + * is linear in the size of the sequences, the elements must be comparable + * with @c <, and std::lexographical_compare() is usually used to make the + * determination. + */ + template <typename _Tp, typename _Seq> + inline bool + operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return __x.c < __y.c; } + + /// Based on operator== + template <typename _Tp, typename _Seq> + inline bool + operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return !(__x == __y); } + + /// Based on operator< + template <typename _Tp, typename _Seq> + inline bool + operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return __y < __x; } + + /// Based on operator< + template <typename _Tp, typename _Seq> + inline bool + operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return !(__y < __x); } + + /// Based on operator< + template <typename _Tp, typename _Seq> + inline bool + operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) + { return !(__x < __y); } } // namespace std #endif /* __GLIBCPP_INTERNAL_STACK_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/stl_threads.h b/contrib/libstdc++/include/bits/stl_threads.h index 0150cd58c85c..b21ebdd36d64 100644 --- a/contrib/libstdc++/include/bits/stl_threads.h +++ b/contrib/libstdc++/include/bits/stl_threads.h @@ -1,6 +1,6 @@ // Threading support -*- C++ -*- -// Copyright (C) 2001 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002 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 @@ -126,6 +126,7 @@ namespace std return __result; } #endif +} //namespace std // Locking class. Note that this class *does not have a // constructor*. It must be initialized either statically, with @@ -141,13 +142,18 @@ namespace std // functions, and no private or protected members. #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION) +namespace __gnu_cxx +{ extern __gthread_mutex_t _GLIBCPP_mutex; extern __gthread_mutex_t *_GLIBCPP_mutex_address; extern __gthread_once_t _GLIBCPP_once; extern void _GLIBCPP_mutex_init (void); extern void _GLIBCPP_mutex_address_init (void); +} #endif +namespace std +{ struct _STL_mutex_lock { // The class must be statically initialized with __STL_MUTEX_INITIALIZER. @@ -164,22 +170,24 @@ namespace std // There should be no code in this path given the usage rules above. #elif defined(__GTHREAD_MUTEX_INIT_FUNCTION) if (_M_init_flag) return; - if (__gthread_once (&_GLIBCPP_once, _GLIBCPP_mutex_init) != 0 + if (__gthread_once (&__gnu_cxx::_GLIBCPP_once, + __gnu_cxx::_GLIBCPP_mutex_init) != 0 && __gthread_active_p ()) abort (); - __gthread_mutex_lock (&_GLIBCPP_mutex); + __gthread_mutex_lock (&__gnu_cxx::_GLIBCPP_mutex); if (!_M_init_flag) { // Even though we have a global lock, we use __gthread_once to be // absolutely certain the _M_lock mutex is only initialized once on // multiprocessor systems. - _GLIBCPP_mutex_address = &_M_lock; - if (__gthread_once (&_M_once, _GLIBCPP_mutex_address_init) != 0 + __gnu_cxx::_GLIBCPP_mutex_address = &_M_lock; + if (__gthread_once (&_M_once, + __gnu_cxx::_GLIBCPP_mutex_address_init) != 0 && __gthread_active_p ()) abort (); _M_init_flag = 1; } - __gthread_mutex_unlock (&_GLIBCPP_mutex); + __gthread_mutex_unlock (&__gnu_cxx::_GLIBCPP_mutex); #endif } diff --git a/contrib/libstdc++/include/bits/stl_tree.h b/contrib/libstdc++/include/bits/stl_tree.h index d2ae142e9265..1e7fdf5db2da 100644 --- a/contrib/libstdc++/include/bits/stl_tree.h +++ b/contrib/libstdc++/include/bits/stl_tree.h @@ -457,7 +457,7 @@ namespace std if (__w->_M_right == 0 || __w->_M_right->_M_color == _M_black) { - if (__w->_M_left) __w->_M_left->_M_color = _M_black; + __w->_M_left->_M_color = _M_black; __w->_M_color = _M_red; _Rb_tree_rotate_right(__w, __root); __w = __x_parent->_M_right; @@ -494,7 +494,7 @@ namespace std { if (__w->_M_left == 0 || __w->_M_left->_M_color == _M_black) { - if (__w->_M_right) __w->_M_right->_M_color = _M_black; + __w->_M_right->_M_color = _M_black; __w->_M_color = _M_red; _Rb_tree_rotate_left(__w, __root); __w = __x_parent->_M_left; @@ -702,8 +702,8 @@ namespace std typedef _Rb_tree_iterator<value_type, const_reference, const_pointer> const_iterator; - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; private: iterator diff --git a/contrib/libstdc++/include/bits/stl_vector.h b/contrib/libstdc++/include/bits/stl_vector.h index ef3b1c26e74c..53547322d651 100644 --- a/contrib/libstdc++/include/bits/stl_vector.h +++ b/contrib/libstdc++/include/bits/stl_vector.h @@ -67,1019 +67,926 @@ namespace std { - -// The vector base class serves two purposes. First, its constructor -// and destructor allocate (but don't initialize) storage. This makes -// exception safety easier. Second, the base class encapsulates all of -// the differences between SGI-style allocators and standard-conforming -// allocators. - -// Base class for ordinary allocators. -template <class _Tp, class _Allocator, bool _IsStatic> -class _Vector_alloc_base { -public: - typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type - allocator_type; - allocator_type get_allocator() const { return _M_data_allocator; } - - _Vector_alloc_base(const allocator_type& __a) - : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) - {} - -protected: - allocator_type _M_data_allocator; - _Tp* _M_start; - _Tp* _M_finish; - _Tp* _M_end_of_storage; - - _Tp* _M_allocate(size_t __n) - { return _M_data_allocator.allocate(__n); } - void _M_deallocate(_Tp* __p, size_t __n) - { if (__p) _M_data_allocator.deallocate(__p, __n); } -}; - -// Specialization for allocators that have the property that we don't -// actually have to store an allocator object. -template <class _Tp, class _Allocator> -class _Vector_alloc_base<_Tp, _Allocator, true> { -public: - typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type - allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Vector_alloc_base(const allocator_type&) - : _M_start(0), _M_finish(0), _M_end_of_storage(0) - {} - -protected: - _Tp* _M_start; - _Tp* _M_finish; - _Tp* _M_end_of_storage; - - typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type; - _Tp* _M_allocate(size_t __n) - { return _Alloc_type::allocate(__n); } - void _M_deallocate(_Tp* __p, size_t __n) - { _Alloc_type::deallocate(__p, __n);} -}; - -template <class _Tp, class _Alloc> -struct _Vector_base - : public _Vector_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> -{ - typedef _Vector_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> - _Base; - typedef typename _Base::allocator_type allocator_type; - - _Vector_base(const allocator_type& __a) : _Base(__a) {} - _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) { - _M_start = _M_allocate(__n); - _M_finish = _M_start; - _M_end_of_storage = _M_start + __n; - } - - ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); } -}; - - -/** - * @brief A standard container which offers fixed time access to individual - * elements in any order. - * - * @ingroup Containers - * @ingroup Sequences - * - * Meets the requirements of a <a href="tables.html#65">container</a>, a - * <a href="tables.html#66">reversible container</a>, and a - * <a href="tables.html#67">sequence</a>, including the - * <a href="tables.html#68">optional sequence requirements</a> with the - * %exception of @c push_front and @c pop_front. - * - * In some terminology a vector can be described as a dynamic C-style array, - * it offers fast and efficient access to individual elements in any order - * and saves the user from worrying about memory and size allocation. - * Subscripting ( [] ) access is also provided as with C-style arrays. -*/ -template <class _Tp, class _Alloc = allocator<_Tp> > -class vector : protected _Vector_base<_Tp, _Alloc> -{ - // concept requirements - __glibcpp_class_requires(_Tp, _SGIAssignableConcept) - -private: - typedef _Vector_base<_Tp, _Alloc> _Base; - typedef vector<_Tp, _Alloc> vector_type; -public: - typedef _Tp value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator; - typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type> - const_iterator; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - typedef typename _Base::allocator_type allocator_type; - allocator_type get_allocator() const { return _Base::get_allocator(); } - - typedef reverse_iterator<const_iterator> const_reverse_iterator; - typedef reverse_iterator<iterator> reverse_iterator; - -protected: - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_M_start; - using _Base::_M_finish; - using _Base::_M_end_of_storage; - -protected: - void _M_insert_aux(iterator __position, const _Tp& __x); - void _M_insert_aux(iterator __position); - -public: - /** - * Returns a read/write iterator that points to the first element in the - * vector. Iteration is done in ordinary element order. - */ - iterator begin() { return iterator (_M_start); } - - /** - * Returns a read-only (constant) iterator that points to the first element - * in the vector. Iteration is done in ordinary element order. - */ - const_iterator begin() const - { return const_iterator (_M_start); } - + /// @if maint Primary default version. @endif /** - * Returns a read/write iterator that points one past the last element in - * the vector. Iteration is done in ordinary element order. + * @if maint + * See bits/stl_deque.h's _Deque_alloc_base for an explanation. + * @endif */ - iterator end() { return iterator (_M_finish); } - - /** - * Returns a read-only (constant) iterator that points one past the last - * element in the vector. Iteration is done in ordinary element order. - */ - const_iterator end() const { return const_iterator (_M_finish); } - - /** - * Returns a read/write reverse iterator that points to the last element in - * the vector. Iteration is done in reverse element order. - */ - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - /** - * Returns a read-only (constant) reverse iterator that points to the last - * element in the vector. Iteration is done in reverse element order. - */ - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - /** - * Returns a read/write reverse iterator that points to one before the - * first element in the vector. Iteration is done in reverse element - * order. - */ - reverse_iterator rend() - { return reverse_iterator(begin()); } - - /** - * Returns a read-only (constant) reverse iterator that points to one - * before the first element in the vector. Iteration is done in reverse - * element order. - */ - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - /** Returns the number of elements in the vector. */ - size_type size() const - { return size_type(end() - begin()); } - - /** Returns the size of the largest possible vector. */ - size_type max_size() const - { return size_type(-1) / sizeof(_Tp); } - - /** - * Returns the amount of memory that has been alocated for the current - * elements (?). - */ - size_type capacity() const - { return size_type(const_iterator(_M_end_of_storage) - begin()); } - - /** - * Returns true if the vector is empty. (Thus begin() would equal end().) - */ - bool empty() const - { return begin() == end(); } - + template<typename _Tp, typename _Allocator, bool _IsStatic> + class _Vector_alloc_base + { + public: + typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type + allocator_type; + + allocator_type + get_allocator() const { return _M_data_allocator; } + + _Vector_alloc_base(const allocator_type& __a) + : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) + { } + + protected: + allocator_type _M_data_allocator; + _Tp* _M_start; + _Tp* _M_finish; + _Tp* _M_end_of_storage; + + _Tp* + _M_allocate(size_t __n) { return _M_data_allocator.allocate(__n); } + + void + _M_deallocate(_Tp* __p, size_t __n) + { if (__p) _M_data_allocator.deallocate(__p, __n); } + }; + + /// @if maint Specialization for instanceless allocators. @endif + template<typename _Tp, typename _Allocator> + class _Vector_alloc_base<_Tp, _Allocator, true> + { + public: + typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type + allocator_type; + + allocator_type + get_allocator() const { return allocator_type(); } + + _Vector_alloc_base(const allocator_type&) + : _M_start(0), _M_finish(0), _M_end_of_storage(0) + { } + + protected: + _Tp* _M_start; + _Tp* _M_finish; + _Tp* _M_end_of_storage; + + typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type; + + _Tp* + _M_allocate(size_t __n) { return _Alloc_type::allocate(__n); } + + void + _M_deallocate(_Tp* __p, size_t __n) { _Alloc_type::deallocate(__p, __n);} + }; + + /** - * @brief Subscript access to the data contained in the vector. - * @param n The element for which data should be accessed. - * @return Read/write reference to data. - * - * This operator allows for easy, array-style, data access. - * Note that data access with this operator is unchecked and out_of_range - * lookups are not defined. (For checked lookups see at().) + * @if maint + * See bits/stl_deque.h's _Deque_base for an explanation. + * @endif */ - reference operator[](size_type __n) { return *(begin() + __n); } - + template<typename _Tp, typename _Alloc> + struct _Vector_base + : public _Vector_alloc_base<_Tp, _Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + { + public: + typedef _Vector_alloc_base<_Tp, _Alloc, + _Alloc_traits<_Tp, _Alloc>::_S_instanceless> + _Base; + typedef typename _Base::allocator_type allocator_type; + + _Vector_base(const allocator_type& __a) + : _Base(__a) { } + + _Vector_base(size_t __n, const allocator_type& __a) + : _Base(__a) + { + _M_start = _M_allocate(__n); + _M_finish = _M_start; + _M_end_of_storage = _M_start + __n; + } + + ~_Vector_base() + { _M_deallocate(_M_start, _M_end_of_storage - _M_start); } + }; + + /** - * @brief Subscript access to the data contained in the vector. - * @param n The element for which data should be accessed. - * @return Read-only (constant) reference to data. + * @brief A standard container which offers fixed time access to individual + * elements in any order. * - * This operator allows for easy, array-style, data access. - * Note that data access with this operator is unchecked and out_of_range - * lookups are not defined. (For checked lookups see at().) - */ - const_reference operator[](size_type __n) const { return *(begin() + __n); } - - void _M_range_check(size_type __n) const { - if (__n >= this->size()) - __throw_out_of_range("vector"); - } - - /** - * @brief Provides access to the data contained in the vector. - * @param n The element for which data should be accessed. - * @return Read/write reference to data. + * @ingroup Containers + * @ingroup Sequences * - * This function provides for safer data access. The parameter is first - * checked that it is in the range of the vector. The function throws - * out_of_range if the check fails. - */ - reference at(size_type __n) - { _M_range_check(__n); return (*this)[__n]; } - - /** - * @brief Provides access to the data contained in the vector. - * @param n The element for which data should be accessed. - * @return Read-only (constant) reference to data. + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and a + * <a href="tables.html#67">sequence</a>, including the + * <a href="tables.html#68">optional sequence requirements</a> with the + * %exception of @c push_front and @c pop_front. * - * This function provides for safer data access. The parameter is first - * checked that it is in the range of the vector. The function throws - * out_of_range if the check fails. + * In some terminology a %vector can be described as a dynamic C-style array, + * it offers fast and efficient access to individual elements in any order + * and saves the user from worrying about memory and size allocation. + * Subscripting ( @c [] ) access is also provided as with C-style arrays. */ - const_reference at(size_type __n) const - { _M_range_check(__n); return (*this)[__n]; } - - - explicit vector(const allocator_type& __a = allocator_type()) - : _Base(__a) {} - - vector(size_type __n, const _Tp& __value, - const allocator_type& __a = allocator_type()) - : _Base(__n, __a) - { _M_finish = uninitialized_fill_n(_M_start, __n, __value); } - - explicit vector(size_type __n) - : _Base(__n, allocator_type()) - { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); } - - vector(const vector<_Tp, _Alloc>& __x) - : _Base(__x.size(), __x.get_allocator()) - { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); } - - // Check whether it's an integral type. If so, it's not an iterator. - template <class _InputIterator> - vector(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) + template<typename _Tp, typename _Alloc = allocator<_Tp> > + class vector : protected _Vector_base<_Tp, _Alloc> + { + // Concept requirements. + __glibcpp_class_requires(_Tp, _SGIAssignableConcept) + + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef vector<_Tp, _Alloc> vector_type; + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator; + typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type> + const_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef typename _Base::allocator_type allocator_type; + + protected: + /** @if maint + * These two functions and three data members are all from the + * top-most base class, which varies depending on the type of + * %allocator. They should be pretty self-explanatory, as + * %vector uses a simple contiguous allocation scheme. @endif + */ + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_M_start; + using _Base::_M_finish; + using _Base::_M_end_of_storage; + + public: + // [23.2.4.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + /** + * @brief Default constructor creates no elements. + */ + explicit + vector(const allocator_type& __a = allocator_type()) + : _Base(__a) { } + + /** + * @brief Create a %vector with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * + * This constructor fills the %vector with @a n copies of @a value. + */ + vector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__n, __a) + { _M_finish = uninitialized_fill_n(_M_start, __n, __value); } + + /** + * @brief Create a %vector with default elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %vector with @a n copies of a + * default-constructed element. + */ + explicit + vector(size_type __n) + : _Base(__n, allocator_type()) + { _M_finish = uninitialized_fill_n(_M_start, __n, value_type()); } + + /** + * @brief %Vector copy constructor. + * @param x A %vector of identical element and allocator types. + * + * The newly-created %vector uses a copy of the allocation + * object used by @a x. All the elements of @a x are copied, + * but any extra memory in + * @a x (for fast expansion) will not be copied. + */ + vector(const vector& __x) + : _Base(__x.size(), __x.get_allocator()) + { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); } + + /** + * @brief Builds a %vector from a range. + * @param first An input iterator. + * @param last An input iterator. + * + * Create a %vector consisting of copies of the elements from + * [first,last). + * + * If the iterators are forward, bidirectional, or random-access, then + * this will call the elements' copy constructor N times (where N is + * distance(first,last)) and do no memory reallocation. But if only + * input iterators are used, then this will do at most 2N calls to the + * copy constructor, and logN memory reallocations. + */ + template<typename _InputIterator> + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) : _Base(__a) - { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_initialize_aux(__first, __last, _Integral()); - } - - template <class _Integer> - void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) - { - _M_start = _M_allocate(__n); - _M_end_of_storage = _M_start + __n; - _M_finish = uninitialized_fill_n(_M_start, __n, __value); - } - - template<class _InputIterator> - void - _M_initialize_aux(_InputIterator __first, _InputIterator __last, __false_type) - { - typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory; + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } + + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibilty. + */ + ~vector() { _Destroy(_M_start, _M_finish); } + + /** + * @brief %Vector assignment operator. + * @param x A %vector of identical element and allocator types. + * + * All the elements of @a x are copied, but any extra memory in + * @a x (for fast expansion) will not be copied. Unlike the + * copy constructor, the allocator object is not copied. + */ + vector& + operator=(const vector& __x); + + /** + * @brief Assigns a given value to a %vector. + * @param n Number of elements to be assigned. + * @param val Value to be assigned. + * + * This function fills a %vector with @a n copies of the given + * value. Note that the assignment completely changes the + * %vector and that the resulting %vector's size is the same as + * the number of elements assigned. Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %vector. + * @param first An input iterator. + * @param last An input iterator. + * + * This function fills a %vector with copies of the elements in the + * range [first,last). + * + * Note that the assignment completely changes the %vector and + * that the resulting %vector's size is the same as the number + * of elements assigned. Old data may be lost. + */ + template<typename _InputIterator> + void + assign(_InputIterator __first, _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const { return _Base::get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first element in the + * %vector. Iteration is done in ordinary element order. + */ + iterator + begin() { return iterator (_M_start); } + + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %vector. Iteration is done in ordinary + * element order. + */ + const_iterator + begin() const { return const_iterator (_M_start); } + + /** + * Returns a read/write iterator that points one past the last + * element in the %vector. Iteration is done in ordinary + * element order. + */ + iterator + end() { return iterator (_M_finish); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %vector. Iteration is done in ordinary element order. + */ + const_iterator + end() const { return const_iterator (_M_finish); } + + /** + * Returns a read/write reverse iterator that points to the + * last element in the %vector. Iteration is done in reverse + * element order. + */ + reverse_iterator + rbegin() { return reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last element in the %vector. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + rbegin() const { return const_reverse_iterator(end()); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first element in the %vector. Iteration is done in reverse element + * order. + */ + reverse_iterator + rend() { return reverse_iterator(begin()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first element in the %vector. Iteration + * is done in reverse element order. + */ + const_reverse_iterator + rend() const { return const_reverse_iterator(begin()); } + + // [23.2.4.2] capacity + /** Returns the number of elements in the %vector. */ + size_type + size() const { return size_type(end() - begin()); } + + /** Returns the size() of the largest possible %vector. */ + size_type + max_size() const { return size_type(-1) / sizeof(value_type); } + + /** + * @brief Resizes the %vector to the specified number of elements. + * @param new_size Number of elements the %vector should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * the %vector is extended and new elements are populated with + * given data. + */ + void + resize(size_type __new_size, const value_type& __x) + { + if (__new_size < size()) + erase(begin() + __new_size, end()); + else + insert(end(), __new_size - size(), __x); + } + + /** + * @brief Resizes the %vector to the specified number of elements. + * @param new_size Number of elements the %vector should contain. + * + * This function will resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * the %vector is extended and new elements are + * default-constructed. + */ + void + resize(size_type __new_size) { resize(__new_size, value_type()); } + + /** + * Returns the total number of elements that the %vector can hold before + * needing to allocate more memory. + */ + size_type + capacity() const + { return size_type(const_iterator(_M_end_of_storage) - begin()); } + + /** + * Returns true if the %vector is empty. (Thus begin() would + * equal end().) + */ + bool + empty() const { return begin() == end(); } + + /** + * @brief Attempt to preallocate enough memory for specified number of + * elements. + * @param n Number of elements required. + * @throw std::length_error If @a n exceeds @c max_size(). + * + * This function attempts to reserve enough memory for the + * %vector to hold the specified number of elements. If the + * number requested is more than max_size(), length_error is + * thrown. + * + * The advantage of this function is that if optimal code is a + * necessity and the user can determine the number of elements + * that will be required, the user can reserve the memory in + * %advance, and thus prevent a possible reallocation of memory + * and copying of %vector data. + */ + void + reserve(size_type __n); + + // element access + /** + * @brief Subscript access to the data contained in the %vector. + * @param n The index of the element for which data should be accessed. + * @return Read/write reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + reference + operator[](size_type __n) { return *(begin() + __n); } + + /** + * @brief Subscript access to the data contained in the %vector. + * @param n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + const_reference + operator[](size_type __n) const { return *(begin() + __n); } + + protected: + /// @if maint Safety check used only from at(). @endif + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range("vector [] access out of range"); + } + + public: + /** + * @brief Provides access to the data contained in the %vector. + * @param n The index of the element for which data should be + * accessed. + * @return Read/write reference to data. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is first + * checked that it is in the range of the vector. The function throws + * out_of_range if the check fails. + */ + reference + at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } + + /** + * @brief Provides access to the data contained in the %vector. + * @param n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter + * is first checked that it is in the range of the vector. The + * function throws out_of_range if the check fails. + */ + const_reference + at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } + + /** + * Returns a read/write reference to the data at the first + * element of the %vector. + */ + reference + front() { return *begin(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %vector. + */ + const_reference + front() const { return *begin(); } + + /** + * Returns a read/write reference to the data at the last element of the + * %vector. + */ + reference + back() { return *(end() - 1); } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %vector. + */ + const_reference + back() const { return *(end() - 1); } + + // [23.2.4.3] modifiers + /** + * @brief Add data to the end of the %vector. + * @param x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the end of the %vector and assigns the given data + * to it. Due to the nature of a %vector this operation can be + * done in constant time if the %vector has preallocated space + * available. + */ + void + push_back(const value_type& __x) + { + if (_M_finish != _M_end_of_storage) + { + _Construct(_M_finish, __x); + ++_M_finish; + } + else + _M_insert_aux(end(), __x); + } + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %vector by one. + * + * Note that no data is returned, and if the last element's data is + * needed, it should be retrieved before pop_back() is called. + */ + void + pop_back() + { + --_M_finish; + _Destroy(_M_finish); + } + + /** + * @brief Inserts given value into %vector before specified iterator. + * @param position An iterator into the %vector. + * @param x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before + * the specified location. Note that this kind of operation + * could be expensive for a %vector and if it is frequently + * used the user should consider using std::list. + */ + iterator + insert(iterator __position, const value_type& __x); + +#ifdef _GLIBCPP_DEPRECATED + /** + * @brief Inserts an element into the %vector. + * @param position An iterator into the %vector. + * @return An iterator that points to the inserted element. + * + * This function will insert a default-constructed element + * before the specified location. You should consider using + * insert(position,value_type()) instead. Note that this kind + * of operation could be expensive for a vector and if it is + * frequently used the user should consider using std::list. + * + * @note This was deprecated in 3.2 and will be removed in 3.4. + * You must define @c _GLIBCPP_DEPRECATED to make this visible + * in 3.2; see c++config.h. + */ + iterator + insert(iterator __position) + { return insert(__position, value_type()); } +#endif + + /** + * @brief Inserts a number of copies of given data into the %vector. + * @param position An iterator into the %vector. + * @param n Number of elements to be inserted. + * @param x Data to be inserted. + * + * This function will insert a specified number of copies of + * the given data before the location specified by @a position. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + void + insert(iterator __pos, size_type __n, const value_type& __x) + { _M_fill_insert(__pos, __n, __x); } + + /** + * @brief Inserts a range into the %vector. + * @param pos An iterator into the %vector. + * @param first An input iterator. + * @param last An input iterator. + * + * This function will insert copies of the data in the range + * [first,last) into the %vector before the location specified + * by @a pos. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + template<typename _InputIterator> + void + insert(iterator __pos, _InputIterator __first, _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename _Is_integer<_InputIterator>::_Integral _Integral; + _M_insert_dispatch(__pos, __first, __last, _Integral()); + } + + /** + * @brief Remove element at given position. + * @param position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %vector by one. + * + * Note This operation could be expensive and if it is + * frequently used the user should consider using std::list. + * The user is also cautioned that this function only erases + * the element, and that if the element is itself a pointer, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibilty. + */ + iterator + erase(iterator __position); + + /** + * @brief Remove a range of elements. + * @param first Iterator pointing to the first element to be erased. + * @param last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a last + * prior to erasing (or end()). + * + * This function will erase the elements in the range [first,last) and + * shorten the %vector accordingly. + * + * Note This operation could be expensive and if it is + * frequently used the user should consider using std::list. + * The user is also cautioned that this function only erases + * the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibilty. + */ + iterator + erase(iterator __first, iterator __last); + + /** + * @brief Swaps data with another %vector. + * @param x A %vector of the same element and allocator types. + * + * This exchanges the elements between two vectors in constant time. + * (Three pointers, so it should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(v1,v2) will feed to this function. + */ + void + swap(vector& __x) + { + std::swap(_M_start, __x._M_start); + std::swap(_M_finish, __x._M_finish); + std::swap(_M_end_of_storage, __x._M_end_of_storage); + } + + /** + * Erases all the elements. Note that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibilty. + */ + void + clear() { erase(begin(), end()); } + + protected: + /** + * @if maint + * Memory expansion handler. Uses the member allocation function to + * obtain @a n bytes of memory, and then copies [first,last) into it. + * @endif + */ + template<typename _ForwardIterator> + pointer + _M_allocate_and_copy(size_type __n, + _ForwardIterator __first, _ForwardIterator __last) + { + pointer __result = _M_allocate(__n); + try + { + uninitialized_copy(__first, __last, __result); + return __result; + } + catch(...) + { + _M_deallocate(__result, __n); + __throw_exception_again; + } + } + + + // Internal constructor functions follow. + + // Called by the range constructor to implement [23.1.1]/9 + template<typename _Integer> + void + _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) + { + _M_start = _M_allocate(__n); + _M_end_of_storage = _M_start + __n; + _M_finish = uninitialized_fill_n(_M_start, __n, __value); + } + + // Called by the range constructor to implement [23.1.1]/9 + template<typename _InputIter> + void + _M_initialize_dispatch(_InputIter __first, _InputIter __last, + __false_type) + { + typedef typename iterator_traits<_InputIter>::iterator_category + _IterCategory; _M_range_initialize(__first, __last, _IterCategory()); } - - ~vector() - { _Destroy(_M_start, _M_finish); } - - vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x); - - /** - * @brief Attempt to preallocate enough memory for specified number of - * elements. - * @param n Number of elements required - * - * This function attempts to reserve enough memory for the vector to hold - * the specified number of elements. If the number requested is more than - * max_size() length_error is thrown. - * - * The advantage of this function is that if optimal code is a necessity - * and the user can determine the number of elements that will be required - * the user can reserve the memory and thus prevent a possible - * reallocation of memory and copy of vector data. - */ - void reserve(size_type __n) { - if (__n > this->max_size()) - __throw_length_error("vector::reserve"); - if (this->capacity() < __n) { - const size_type __old_size = size(); - pointer __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish); - _Destroy(_M_start, _M_finish); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __tmp; - _M_finish = __tmp + __old_size; - _M_end_of_storage = _M_start + __n; - } - } - - // assign(), a generalized assignment member function. Two - // versions: one that takes a count, and one that takes a range. - // The range version is a member template, so we dispatch on whether - // or not the type is an integer. - - /** - * @brief Assigns a given value or range to a vector. - * @param n Number of elements to be assigned. - * @param val Value to be assigned. - * - * This function can be used to assign a range to a vector or fill it - * with a specified number of copies of the given value. - * Note that the assignment completely changes the vector and that the - * resulting vector's size is the same as the number of elements assigned. - * Old data may be lost. - */ - void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); } - void _M_fill_assign(size_type __n, const _Tp& __val); - - template<class _InputIterator> - void - assign(_InputIterator __first, _InputIterator __last) - { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); - } - - template<class _Integer> - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign((size_type) __n, (_Tp) __val); } - - template<class _InputIter> - void - _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type) - { - typedef typename iterator_traits<_InputIter>::iterator_category _IterCategory; - _M_assign_aux(__first, __last, _IterCategory()); - } - - template <class _InputIterator> - void - _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template <class _ForwardIterator> - void - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - - /** - * Returns a read/write reference to the data at the first element of the - * vector. - */ - reference front() { return *begin(); } - - /** - * Returns a read-only (constant) reference to the data at the first - * element of the vector. - */ - const_reference front() const { return *begin(); } - - /** - * Returns a read/write reference to the data at the last element of the - * vector. - */ - reference back() { return *(end() - 1); } - - /** - * Returns a read-only (constant) reference to the data at the first - * element of the vector. - */ - const_reference back() const { return *(end() - 1); } - - /** - * @brief Add data to the end of the vector. - * @param x Data to be added. - * - * This is a typical stack operation. The function creates an element at - * the end of the vector and assigns the given data to it. - * Due to the nature of a vector this operation can be done in constant - * time if the vector has preallocated space available. - */ - void - push_back(const _Tp& __x) - { - if (_M_finish != _M_end_of_storage) { - _Construct(_M_finish, __x); - ++_M_finish; - } - else - _M_insert_aux(end(), __x); - } - + + // Called by the second initialize_dispatch above + template<typename _InputIterator> + void + _M_range_initialize(_InputIterator __first, + _InputIterator __last, input_iterator_tag) + { + for ( ; __first != __last; ++__first) + push_back(*__first); + } + + // Called by the second initialize_dispatch above + template<typename _ForwardIterator> + void + _M_range_initialize(_ForwardIterator __first, + _ForwardIterator __last, forward_iterator_tag) + { + size_type __n = distance(__first, __last); + _M_start = _M_allocate(__n); + _M_end_of_storage = _M_start + __n; + _M_finish = uninitialized_copy(__first, __last, _M_start); + } + + + // Internal assign functions follow. The *_aux functions do the actual + // assignment work for the range versions. + + // Called by the range assign to implement [23.1.1]/9 + template<typename _Integer> + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { + _M_fill_assign(static_cast<size_type>(__n), + static_cast<value_type>(__val)); + } + + // Called by the range assign to implement [23.1.1]/9 + template<typename _InputIter> + void + _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type) + { + typedef typename iterator_traits<_InputIter>::iterator_category + _IterCategory; + _M_assign_aux(__first, __last, _IterCategory()); + } + + // Called by the second assign_dispatch above + template<typename _InputIterator> + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + input_iterator_tag); + + // Called by the second assign_dispatch above + template<typename _ForwardIterator> + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + forward_iterator_tag); + + // Called by assign(n,t), and the range assign when it turns out + // to be the same thing. + void + _M_fill_assign(size_type __n, const value_type& __val); + + + // Internal insert functions follow. + + // Called by the range insert to implement [23.1.1]/9 + template<typename _Integer> + void + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + __true_type) + { + _M_fill_insert(__pos, static_cast<size_type>(__n), + static_cast<value_type>(__val)); + } + + // Called by the range insert to implement [23.1.1]/9 + template<typename _InputIterator> + void + _M_insert_dispatch(iterator __pos, _InputIterator __first, + _InputIterator __last, __false_type) + { + typedef typename iterator_traits<_InputIterator>::iterator_category + _IterCategory; + _M_range_insert(__pos, __first, __last, _IterCategory()); + } + + // Called by the second insert_dispatch above + template<typename _InputIterator> + void + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, input_iterator_tag); + + // Called by the second insert_dispatch above + template<typename _ForwardIterator> + void + _M_range_insert(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, forward_iterator_tag); + + // Called by insert(p,n,x), and the range insert when it turns out to be + // the same thing. + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + // Called by insert(p,x) + void + _M_insert_aux(iterator __position, const value_type& __x); + #ifdef _GLIBCPP_DEPRECATED - /** - * Add an element to the end of the vector. The element is - * default-constructed. - * - * @note You must define _GLIBCPP_DEPRECATED to make this visible; see - * c++config.h. - */ - void - push_back() - { - if (_M_finish != _M_end_of_storage) { - _Construct(_M_finish); - ++_M_finish; - } - else - _M_insert_aux(end()); - } + // Unused now (same situation as in deque) + void _M_insert_aux(iterator __position); #endif - - void - swap(vector<_Tp, _Alloc>& __x) - { - std::swap(_M_start, __x._M_start); - std::swap(_M_finish, __x._M_finish); - std::swap(_M_end_of_storage, __x._M_end_of_storage); - } - + }; + + /** - * @brief Inserts given value into vector at specified element. - * @param position An iterator that points to the element where data - * should be inserted. - * @param x Data to be inserted. - * @return An iterator that points to the inserted data. + * @brief Vector equality comparison. + * @param x A %vector. + * @param y A %vector of the same type as @a x. + * @return True iff the size and elements of the vectors are equal. * - * This function will insert the given value into the specified location. - * Note that this kind of operation could be expensive for a vector and if - * it is frequently used the user should consider using std::list. + * This is an equivalence relation. It is linear in the size of the + * vectors. Vectors are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. */ - iterator - insert(iterator __position, const _Tp& __x) - { - size_type __n = __position - begin(); - if (_M_finish != _M_end_of_storage && __position == end()) { - _Construct(_M_finish, __x); - ++_M_finish; - } - else - _M_insert_aux(iterator(__position), __x); - return begin() + __n; - } - - /** - * @brief Inserts an empty element into the vector. - * @param position An iterator that points to the element where empty - * element should be inserted. - * @param x Data to be inserted. - * @return An iterator that points to the inserted element. - * - * This function will insert an empty element into the specified location. - * Note that this kind of operation could be expensive for a vector and if - * it is frequently used the user should consider using std::list. - */ - iterator - insert(iterator __position) - { - size_type __n = __position - begin(); - if (_M_finish != _M_end_of_storage && __position == end()) { - _Construct(_M_finish); - ++_M_finish; - } - else - _M_insert_aux(iterator(__position)); - return begin() + __n; - } - - // Check whether it's an integral type. If so, it's not an iterator. - template<class _InputIterator> - void - insert(iterator __pos, _InputIterator __first, _InputIterator __last) - { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); - } - - template <class _Integer> - void - _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, __true_type) - { _M_fill_insert(__pos, static_cast<size_type>(__n), static_cast<_Tp>(__val)); } - - template<class _InputIterator> - void - _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type) - { - typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory; - _M_range_insert(__pos, __first, __last, _IterCategory()); + template<typename _Tp, typename _Alloc> + inline bool + operator==(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { + return __x.size() == __y.size() && + equal(__x.begin(), __x.end(), __y.begin()); } - - /** - * @brief Inserts a number of copies of given data into the vector. - * @param position An iterator that points to the element where data - * should be inserted. - * @param n Amount of elements to be inserted. - * @param x Data to be inserted. - * - * This function will insert a specified number of copies of the given data - * into the specified location. - * - * Note that this kind of operation could be expensive for a vector and if - * it is frequently used the user should consider using std::list. - */ - void insert (iterator __pos, size_type __n, const _Tp& __x) - { _M_fill_insert(__pos, __n, __x); } - - void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x); - + /** - * @brief Removes last element from vector. + * @brief Vector ordering relation. + * @param x A %vector. + * @param y A %vector of the same type as @a x. + * @return True iff @a x is lexographically less than @a y. * - * This is a typical stack operation. It allows us to shrink the vector by - * one. + * This is a total ordering relation. It is linear in the size of the + * vectors. The elements must be comparable with @c <. * - * Note that no data is returned and if last element's data is needed it - * should be retrieved before pop_back() is called. + * See std::lexographical_compare() for how the determination is made. */ - void pop_back() { - --_M_finish; - _Destroy(_M_finish); - } - - /** - * @brief Remove element at given position - * @param position Iterator pointing to element to be erased. - * @return Doc Me! (Iterator pointing to new element at old location?) - * - * This function will erase the element at the given position and thus - * shorten the vector by one. - * - * Note This operation could be expensive and if it is frequently used the - * user should consider using std::list. The user is also cautioned that - * this function only erases the element, and that if the element is itself - * a pointer, the pointed-to memory is not touched in any way. Managing - * the pointer is the user's responsibilty. - */ - iterator erase(iterator __position) { - if (__position + 1 != end()) - copy(__position + 1, end(), __position); - --_M_finish; - _Destroy(_M_finish); - return __position; - } - - /** - * @brief Remove a range of elements from a vector. - * @param first Iterator pointing to the first element to be erased. - * @param last Iterator pointing to the last element to be erased. - * @return Doc Me! (Iterator pointing to new element at old location?) - * - * This function will erase the elements in the given range and shorten the - * vector accordingly. - * - * Note This operation could be expensive and if it is frequently used the - * user should consider using std::list. The user is also cautioned that - * this function only erases the elements, and that if the elements - * themselves are pointers, the pointed-to memory is not touched in any - * way. Managing the pointer is the user's responsibilty. - */ - iterator erase(iterator __first, iterator __last) { - iterator __i(copy(__last, end(), __first)); - _Destroy(__i, end()); - _M_finish = _M_finish - (__last - __first); - return __first; - } - - /** - * @brief Resizes the vector to the specified number of elements. - * @param new_size Number of elements the vector should contain. - * @param x Data with which new elements should be populated. - * - * This function will resize the vector to the specified number of - * elements. If the number is smaller than the vector's current size the - * vector is truncated, otherwise the vector is extended and new elements - * are populated with given data. - */ - void resize(size_type __new_size, const _Tp& __x) { - if (__new_size < size()) - erase(begin() + __new_size, end()); - else - insert(end(), __new_size - size(), __x); - } - - /** - * @brief Resizes the vector to the specified number of elements. - * @param new_size Number of elements the vector should contain. - * - * This function will resize the vector to the specified number of - * elements. If the number is smaller than the vector's current size the - * vector is truncated, otherwise the vector is extended and new elements - * are left uninitialized. - */ - void resize(size_type __new_size) { resize(__new_size, _Tp()); } - - /** - * Erases all elements in vector. Note that this function only erases the - * elements, and that if the elements themselves are pointers, the - * pointed-to memory is not touched in any way. Managing the pointer is - * the user's responsibilty. - */ - void clear() { erase(begin(), end()); } - -protected: - - template <class _ForwardIterator> - pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first, - _ForwardIterator __last) - { - pointer __result = _M_allocate(__n); - try { - uninitialized_copy(__first, __last, __result); - return __result; - } - catch(...) - { - _M_deallocate(__result, __n); - __throw_exception_again; - } - } - - template <class _InputIterator> - void _M_range_initialize(_InputIterator __first, - _InputIterator __last, input_iterator_tag) - { - for ( ; __first != __last; ++__first) - push_back(*__first); - } - - // This function is only called by the constructor. - template <class _ForwardIterator> - void _M_range_initialize(_ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag) - { - size_type __n = distance(__first, __last); - _M_start = _M_allocate(__n); - _M_end_of_storage = _M_start + __n; - _M_finish = uninitialized_copy(__first, __last, _M_start); - } - - template <class _InputIterator> - void _M_range_insert(iterator __pos, - _InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template <class _ForwardIterator> - void _M_range_insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); -}; - -template <class _Tp, class _Alloc> -inline bool -operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) -{ - return __x.size() == __y.size() && - equal(__x.begin(), __x.end(), __y.begin()); -} - -template <class _Tp, class _Alloc> -inline bool -operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) -{ - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -template <class _Tp, class _Alloc> -inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) -{ - __x.swap(__y); -} - -template <class _Tp, class _Alloc> -inline bool -operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__x == __y); -} - -template <class _Tp, class _Alloc> -inline bool -operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return __y < __x; -} - -template <class _Tp, class _Alloc> -inline bool -operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__y < __x); -} - -template <class _Tp, class _Alloc> -inline bool -operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__x < __y); -} - -template <class _Tp, class _Alloc> -vector<_Tp,_Alloc>& -vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x) -{ - if (&__x != this) { - const size_type __xlen = __x.size(); - if (__xlen > capacity()) { - pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end()); - _Destroy(_M_start, _M_finish); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __tmp; - _M_end_of_storage = _M_start + __xlen; - } - else if (size() >= __xlen) { - iterator __i(copy(__x.begin(), __x.end(), begin())); - _Destroy(__i, end()); - } - else { - copy(__x.begin(), __x.begin() + size(), _M_start); - uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish); - } - _M_finish = _M_start + __xlen; - } - return *this; -} - -template <class _Tp, class _Alloc> -void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const value_type& __val) -{ - if (__n > capacity()) { - vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator()); - __tmp.swap(*this); - } - else if (__n > size()) { - fill(begin(), end(), __val); - _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val); - } - else - erase(fill_n(begin(), __n, __val), end()); -} - -template <class _Tp, class _Alloc> template <class _InputIter> -void vector<_Tp, _Alloc>::_M_assign_aux(_InputIter __first, _InputIter __last, - input_iterator_tag) { - iterator __cur(begin()); - for ( ; __first != __last && __cur != end(); ++__cur, ++__first) - *__cur = *__first; - if (__first == __last) - erase(__cur, end()); - else - insert(end(), __first, __last); -} - -template <class _Tp, class _Alloc> template <class _ForwardIter> -void -vector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last, - forward_iterator_tag) { - size_type __len = distance(__first, __last); - - if (__len > capacity()) { - pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); - _Destroy(_M_start, _M_finish); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __tmp; - _M_end_of_storage = _M_finish = _M_start + __len; - } - else if (size() >= __len) { - iterator __new_finish(copy(__first, __last, _M_start)); - _Destroy(__new_finish, end()); - _M_finish = __new_finish.base(); - } - else { - _ForwardIter __mid = __first; - advance(__mid, size()); - copy(__first, __mid, _M_start); - _M_finish = uninitialized_copy(__mid, __last, _M_finish); - } -} - -template <class _Tp, class _Alloc> -void -vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x) -{ - if (_M_finish != _M_end_of_storage) { - _Construct(_M_finish, *(_M_finish - 1)); - ++_M_finish; - _Tp __x_copy = __x; - copy_backward(__position, iterator(_M_finish - 2), iterator(_M_finish- 1)); - *__position = __x_copy; - } - else { - const size_type __old_size = size(); - const size_type __len = __old_size != 0 ? 2 * __old_size : 1; - iterator __new_start(_M_allocate(__len)); - iterator __new_finish(__new_start); - try { - __new_finish = uninitialized_copy(iterator(_M_start), __position, - __new_start); - _Construct(__new_finish.base(), __x); - ++__new_finish; - __new_finish = uninitialized_copy(__position, iterator(_M_finish), - __new_finish); - } - catch(...) - { - _Destroy(__new_start,__new_finish); - _M_deallocate(__new_start.base(),__len); - __throw_exception_again; - } - _Destroy(begin(), end()); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __new_start.base(); - _M_finish = __new_finish.base(); - _M_end_of_storage = __new_start.base() + __len; - } -} - -template <class _Tp, class _Alloc> -void -vector<_Tp, _Alloc>::_M_insert_aux(iterator __position) -{ - if (_M_finish != _M_end_of_storage) { - _Construct(_M_finish, *(_M_finish - 1)); - ++_M_finish; - copy_backward(__position, iterator(_M_finish - 2), - iterator(_M_finish - 1)); - *__position = _Tp(); - } - else { - const size_type __old_size = size(); - const size_type __len = __old_size != 0 ? 2 * __old_size : 1; - pointer __new_start = _M_allocate(__len); - pointer __new_finish = __new_start; - try { - __new_finish = uninitialized_copy(iterator(_M_start), __position, - __new_start); - _Construct(__new_finish); - ++__new_finish; - __new_finish = uninitialized_copy(__position, iterator(_M_finish), - __new_finish); - } - catch(...) - { - _Destroy(__new_start,__new_finish); - _M_deallocate(__new_start,__len); - __throw_exception_again; - } - _Destroy(begin(), end()); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __new_start; - _M_finish = __new_finish; - _M_end_of_storage = __new_start + __len; - } -} - -template <class _Tp, class _Alloc> -void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n, - const _Tp& __x) -{ - if (__n != 0) { - if (size_type(_M_end_of_storage - _M_finish) >= __n) { - _Tp __x_copy = __x; - const size_type __elems_after = end() - __position; - iterator __old_finish(_M_finish); - if (__elems_after > __n) { - uninitialized_copy(_M_finish - __n, _M_finish, _M_finish); - _M_finish += __n; - copy_backward(__position, __old_finish - __n, __old_finish); - fill(__position, __position + __n, __x_copy); - } - else { - uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy); - _M_finish += __n - __elems_after; - uninitialized_copy(__position, __old_finish, _M_finish); - _M_finish += __elems_after; - fill(__position, __old_finish, __x_copy); - } - } - else { - const size_type __old_size = size(); - const size_type __len = __old_size + max(__old_size, __n); - iterator __new_start(_M_allocate(__len)); - iterator __new_finish(__new_start); - try { - __new_finish = uninitialized_copy(begin(), __position, __new_start); - __new_finish = uninitialized_fill_n(__new_finish, __n, __x); - __new_finish - = uninitialized_copy(__position, end(), __new_finish); - } - catch(...) - { - _Destroy(__new_start,__new_finish); - _M_deallocate(__new_start.base(),__len); - __throw_exception_again; - } - _Destroy(_M_start, _M_finish); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __new_start.base(); - _M_finish = __new_finish.base(); - _M_end_of_storage = __new_start.base() + __len; - } - } -} - -template <class _Tp, class _Alloc> template <class _InputIterator> -void -vector<_Tp, _Alloc>::_M_range_insert(iterator __pos, - _InputIterator __first, - _InputIterator __last, - input_iterator_tag) -{ - for ( ; __first != __last; ++__first) { - __pos = insert(__pos, *__first); - ++__pos; - } -} - -template <class _Tp, class _Alloc> template <class _ForwardIterator> -void -vector<_Tp, _Alloc>::_M_range_insert(iterator __position, - _ForwardIterator __first, - _ForwardIterator __last, - forward_iterator_tag) -{ - if (__first != __last) { - size_type __n = distance(__first, __last); - if (size_type(_M_end_of_storage - _M_finish) >= __n) { - const size_type __elems_after = end() - __position; - iterator __old_finish(_M_finish); - if (__elems_after > __n) { - uninitialized_copy(_M_finish - __n, _M_finish, _M_finish); - _M_finish += __n; - copy_backward(__position, __old_finish - __n, __old_finish); - copy(__first, __last, __position); - } - else { - _ForwardIterator __mid = __first; - advance(__mid, __elems_after); - uninitialized_copy(__mid, __last, _M_finish); - _M_finish += __n - __elems_after; - uninitialized_copy(__position, __old_finish, _M_finish); - _M_finish += __elems_after; - copy(__first, __mid, __position); - } - } - else { - const size_type __old_size = size(); - const size_type __len = __old_size + max(__old_size, __n); - iterator __new_start(_M_allocate(__len)); - iterator __new_finish(__new_start); - try { - __new_finish = uninitialized_copy(iterator(_M_start), - __position, __new_start); - __new_finish = uninitialized_copy(__first, __last, __new_finish); - __new_finish - = uninitialized_copy(__position, iterator(_M_finish), __new_finish); - } - catch(...) - { - _Destroy(__new_start,__new_finish); - _M_deallocate(__new_start.base(), __len); - __throw_exception_again; - } - _Destroy(_M_start, _M_finish); - _M_deallocate(_M_start, _M_end_of_storage - _M_start); - _M_start = __new_start.base(); - _M_finish = __new_finish.base(); - _M_end_of_storage = __new_start.base() + __len; + template<typename _Tp, typename _Alloc> + inline bool + operator<(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { + return lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } - } -} - + + /// Based on operator== + template<typename _Tp, typename _Alloc> + inline bool + operator!=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template<typename _Tp, typename _Alloc> + inline bool + operator>(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template<typename _Tp, typename _Alloc> + inline bool + operator<=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template<typename _Tp, typename _Alloc> + inline bool + operator>=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) + { return !(__x < __y); } + + /// See std::vector::swap(). + template<typename _Tp, typename _Alloc> + inline void + swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y) + { __x.swap(__y); } } // namespace std #endif /* __GLIBCPP_INTERNAL_VECTOR_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/bits/streambuf.tcc b/contrib/libstdc++/include/bits/streambuf.tcc index 5f57df583a7b..be858621b85b 100644 --- a/contrib/libstdc++/include/bits/streambuf.tcc +++ b/contrib/libstdc++/include/bits/streambuf.tcc @@ -1,6 +1,6 @@ // Stream buffer classes -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -67,8 +67,7 @@ namespace std { int_type __ret; bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur; - bool __testne = _M_in_cur && !traits_type::eq(__c, this->gptr()[-1]); - if (!__testpos || __testne) + if (!__testpos || !traits_type::eq(__c, this->gptr()[-1])) __ret = this->pbackfail(traits_type::to_int_type(__c)); else { @@ -199,54 +198,46 @@ namespace std basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout) { - typedef typename _Traits::int_type int_type; - - streamsize __ret = 0; - streamsize __bufsize = __sbin->in_avail(); - streamsize __xtrct; - bool __testput = __sbout->_M_mode & ios_base::out; - try - { - while (__testput && __bufsize != -1) - { - if (__bufsize != 0 && __sbin->gptr() != NULL - && __sbin->gptr() + __bufsize <= __sbin->egptr()) - { - __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize); - __ret += __xtrct; - __sbin->_M_in_cur_move(__xtrct); - if (__xtrct != __bufsize) - break; - } - else - { - size_t __size = - __sbin->_M_buf_size_opt > 0 ? __sbin->_M_buf_size_opt : 1; - _CharT* __buf = - static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __size)); - streamsize __charsread = __sbin->sgetn(__buf, __size); - __xtrct = __sbout->sputn(__buf, __charsread); - __ret += __xtrct; - if (__xtrct != __charsread) - break; - } - if (_Traits::eq_int_type(__sbin->sgetc(), _Traits::eof())) - break; - __bufsize = __sbin->in_avail(); - } - } - catch(exception& __fail) - { - __ios.setstate(ios_base::failbit); - if ((__ios.exceptions() & ios_base::failbit) != 0) - __throw_exception_again; - } - return __ret; - } + streamsize __ret = 0; + try + { + typename _Traits::int_type __c = __sbin->sgetc(); + while (!_Traits::eq_int_type(__c, _Traits::eof())) + { + const size_t __n = __sbin->_M_in_end - __sbin->_M_in_cur; + if (__n > 1) + { + const size_t __wrote = __sbout->sputn(__sbin->_M_in_cur, + __n); + __sbin->_M_in_cur_move(__wrote); + __ret += __wrote; + if (__wrote < __n) + break; + __c = __sbin->underflow(); + } + else + { + __c = __sbout->sputc(_Traits::to_char_type(__c)); + if (_Traits::eq_int_type(__c, _Traits::eof())) + break; + ++__ret; + __c = __sbin->snextc(); + } + } + } + catch(exception& __fail) + { + __ios.setstate(ios_base::failbit); + if ((__ios.exceptions() & ios_base::failbit) != 0) + __throw_exception_again; + } + return __ret; + } // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template class basic_streambuf<char>; extern template streamsize @@ -260,6 +251,7 @@ namespace std __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*); #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/streambuf_iterator.h b/contrib/libstdc++/include/bits/streambuf_iterator.h index 152df9c6e4b9..d482aba82560 100644 --- a/contrib/libstdc++/include/bits/streambuf_iterator.h +++ b/contrib/libstdc++/include/bits/streambuf_iterator.h @@ -1,6 +1,6 @@ // Streambuf iterators -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -28,8 +28,6 @@ // 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. - /** @file streambuf_iterator.h * This is an internal header file, included by other library headers. * You should not attempt to use it directly. @@ -40,6 +38,10 @@ #pragma GCC system_header +#include <streambuf> + +// NB: Should specialize copy, find algorithms for streambuf iterators. + namespace std { // 24.5.3 Template class istreambuf_iterator @@ -166,7 +168,6 @@ namespace std bool _M_failed; public: - inline ostreambuf_iterator(ostream_type& __s) throw () : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } @@ -174,7 +175,13 @@ namespace std : _M_sbuf(__s), _M_failed(!_M_sbuf) { } ostreambuf_iterator& - operator=(_CharT __c); + operator=(_CharT __c) + { + if (!_M_failed && + _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) + _M_failed = true; + return *this; + } ostreambuf_iterator& operator*() throw() @@ -191,16 +198,15 @@ namespace std bool failed() const throw() { return _M_failed; } - }; - 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; - } + ostreambuf_iterator& + _M_put(const _CharT* __ws, streamsize __len) + { + if (__builtin_expect(!_M_failed, true) && + __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false)) + _M_failed = true; + return *this; + } + }; } // namespace std #endif diff --git a/contrib/libstdc++/include/bits/valarray_array.h b/contrib/libstdc++/include/bits/valarray_array.h index 48dd2aa4d835..c880478aa417 100644 --- a/contrib/libstdc++/include/bits/valarray_array.h +++ b/contrib/libstdc++/include/bits/valarray_array.h @@ -603,16 +603,16 @@ _Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \ } \ } - _DEFINE_ARRAY_FUNCTION(+, plus) - _DEFINE_ARRAY_FUNCTION(-, minus) - _DEFINE_ARRAY_FUNCTION(*, multiplies) - _DEFINE_ARRAY_FUNCTION(/, divides) - _DEFINE_ARRAY_FUNCTION(%, modulus) - _DEFINE_ARRAY_FUNCTION(^, xor) - _DEFINE_ARRAY_FUNCTION(|, or) - _DEFINE_ARRAY_FUNCTION(&, and) - _DEFINE_ARRAY_FUNCTION(<<, shift_left) - _DEFINE_ARRAY_FUNCTION(>>, shift_right) + _DEFINE_ARRAY_FUNCTION(+, __plus) + _DEFINE_ARRAY_FUNCTION(-, __minus) + _DEFINE_ARRAY_FUNCTION(*, __multiplies) + _DEFINE_ARRAY_FUNCTION(/, __divides) + _DEFINE_ARRAY_FUNCTION(%, __modulus) + _DEFINE_ARRAY_FUNCTION(^, __bitwise_xor) + _DEFINE_ARRAY_FUNCTION(|, __bitwise_or) + _DEFINE_ARRAY_FUNCTION(&, __bitwise_and) + _DEFINE_ARRAY_FUNCTION(<<, __shift_left) + _DEFINE_ARRAY_FUNCTION(>>, __shift_right) #undef _DEFINE_VALARRAY_FUNCTION diff --git a/contrib/libstdc++/include/bits/valarray_meta.h b/contrib/libstdc++/include/bits/valarray_meta.h index f2926c090353..29a2dac2af49 100644 --- a/contrib/libstdc++/include/bits/valarray_meta.h +++ b/contrib/libstdc++/include/bits/valarray_meta.h @@ -41,469 +41,601 @@ namespace std { + // + // Implementing a loosened valarray return value is tricky. + // First we need to meet 26.3.1/3: we should not add more than + // two levels of template nesting. Therefore we resort to template + // template to "flatten" loosened return value types. + // At some point we use partial specialization to remove one level + // template nesting due to _Expr<> + // + + // This class is NOT defined. It doesn't need to. + template<typename _Tp1, typename _Tp2> class _Constant; + + // Implementations of unary functions applied to valarray<>s. + // I use hard-coded object functions here instead of a generic + // approach like pointers to function: + // 1) correctness: some functions take references, others values. + // we can't deduce the correct type afterwards. + // 2) efficiency -- object functions can be easily inlined + // 3) be Koenig-lookup-friendly + + struct __abs + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return abs(__t); } + }; - // - // Implementing a loosened valarray return value is tricky. - // First we need to meet 26.3.1/3: we should not add more than - // two levels of template nesting. Therefore we resort to template - // template to "flatten" loosened return value types. - // At some point we use partial specialization to remove one level - // template nesting due to _Expr<> - // - + struct __cos + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return cos(__t); } + }; - // This class is NOT defined. It doesn't need to. - template<typename _Tp1, typename _Tp2> class _Constant; + struct __acos + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return acos(__t); } + }; - // - // Unary function application closure. - // - template<class _Dom> class _UnFunBase { - public: - typedef typename _Dom::value_type value_type; - typedef value_type _Vt; - - _UnFunBase (const _Dom& __e, _Vt __f(_Vt)) - : _M_expr(__e), _M_func(__f) {} - - _Vt operator[] (size_t __i) const { return _M_func(_M_expr[__i]); } - size_t size () const { return _M_expr.size(); } - - private: - const _Dom& _M_expr; - _Vt (*_M_func)(_Vt); - }; + struct __cosh + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return cosh(__t); } + }; - template<template<class, class> class _Meta, class _Dom> - class _UnFunClos; - - template<class _Dom> - struct _UnFunClos<_Expr,_Dom> : _UnFunBase<_Dom> { - typedef _UnFunBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _UnFunClos (const _Dom& __e, value_type __f(value_type)) - : _Base (__e, __f) {} - }; - + struct __sin + { template<typename _Tp> - struct _UnFunClos<_ValArray,_Tp> : _UnFunBase<valarray<_Tp> > { - typedef _UnFunBase<valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _UnFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp)) - : _Base (__v, __f) {} - }; + _Tp operator()(const _Tp& __t) const { return sin(__t); } + }; - // - // Binary function application closure. - // - template<template<class, class> class _Meta1, - template<class, class> class Meta2, - class _Dom1, class _Dom2> class _BinFunClos; - - template<class _Dom1, class _Dom2> class _BinFunBase { - public: - typedef typename _Dom1::value_type value_type; - typedef value_type _Vt; + struct __asin + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return asin(__t); } + }; - _BinFunBase (const _Dom1& __e1, const _Dom2& __e2, - _Vt __f (_Vt, _Vt)) - : _M_expr1 (__e1), _M_expr2 (__e2), _M_func (__f) {} + struct __sinh + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return sinh(__t); } + }; - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1[__i], _M_expr2[__i]); } - size_t size () const { return _M_expr1.size (); } + struct __tan + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return tan(__t); } + }; - private: - const _Dom1& _M_expr1; - const _Dom2& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; + struct __atan + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return atan(__t); } + }; - template<class _Dom> class _BinFunBase1 { - public: - typedef typename _Dom::value_type value_type ; - typedef value_type _Vt; + struct __tanh + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return tanh(__t); } + }; - _BinFunBase1 (const _Vt& __c, const _Dom& __e, _Vt __f(_Vt, _Vt)) - : _M_expr1 (__c), _M_expr2 (__e), _M_func (__f) {} + struct __exp + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return exp(__t); } + }; - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1, _M_expr2[__i]); } - size_t size () const { return _M_expr2.size (); } + struct __log + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return log(__t); } + }; - private: - const _Vt& _M_expr1; - const _Dom& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; + struct __log10 + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return log10(__t); } + }; - template<class _Dom> class _BinFunBase2 { - public: - typedef typename _Dom::value_type value_type; - typedef value_type _Vt; + struct __sqrt + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return sqrt(__t); } + }; - _BinFunBase2 (const _Dom& __e, const _Vt& __c, _Vt __f(_Vt, _Vt)) - : _M_expr1 (__e), _M_expr2 (__c), _M_func (__f) {} + // In the past, we used to tailor operator applications semantics + // to the specialization of standard function objects (i.e. plus<>, etc.) + // That is incorrect. Therefore we provide our own surrogates. - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1[__i], _M_expr2); } - size_t size () const { return _M_expr1.size (); } + struct __unary_plus + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return +__t; } + }; - private: - const _Dom& _M_expr1; - const _Vt& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; + struct __negate + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return -__t; } + }; - template<class _Dom1, class _Dom2> - struct _BinFunClos<_Expr,_Expr,_Dom1,_Dom2> : _BinFunBase<_Dom1,_Dom2> { - typedef _BinFunBase<_Dom1,_Dom2> _Base; - typedef typename _Base::value_type value_type; - typedef value_type _Tp; + struct __bitwise_not + { + template<typename _Tp> + _Tp operator()(const _Tp& __t) const { return ~__t; } + }; - _BinFunClos (const _Dom1& __e1, const _Dom2& __e2, - _Tp __f(_Tp, _Tp)) - : _Base (__e1, __e2, __f) {} - }; + struct __plus + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + struct __minus + { template<typename _Tp> - struct _BinFunClos<_ValArray,_ValArray,_Tp,_Tp> - : _BinFunBase<valarray<_Tp>, valarray<_Tp> > { - typedef _BinFunBase<valarray<_Tp>, valarray<_Tp> > _Base; - typedef _Tp value_type; + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; - _BinFunClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __w, __f) {} - }; - - template<class _Dom> - struct _BinFunClos<_Expr,_ValArray,_Dom,typename _Dom::value_type> - : _BinFunBase<_Dom,valarray<typename _Dom::value_type> > { - typedef typename _Dom::value_type _Tp; - typedef _BinFunBase<_Dom,valarray<_Tp> > _Base; - typedef _Tp value_type; + struct __multiplies + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; - _BinFunClos (const _Dom& __e, const valarray<_Tp>& __v, - _Tp __f(_Tp, _Tp)) - : _Base (__e, __v, __f) {} - }; + struct __divides + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; - template<class _Dom> - struct _BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom> - : _BinFunBase<valarray<typename _Dom::value_type>,_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _BinFunBase<_Dom,valarray<_Tp> > _Base; - typedef _Tp value_type; + struct __modulus + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + struct __bitwise_xor + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + struct __bitwise_and + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + struct __bitwise_or + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + struct __shift_left + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x << __y; } + }; + + struct __shift_right + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x >> __y; } + }; + + struct __logical_and + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + struct __logical_or + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + struct __logical_not + { + template<typename _Tp> + bool operator()(const _Tp& __x) const { return !__x; } + }; + + struct __equal_to + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + struct __not_equal_to + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; - _BinFunClos (const valarray<_Tp>& __v, const _Dom& __e, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __e, __f) {} + struct __less + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + struct __greater + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + struct __less_equal + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + struct __greater_equal + { + template<typename _Tp> + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + // The few binary functions we miss. + struct __atan2 + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return atan2(__x, __y); } + }; + + struct __pow + { + template<typename _Tp> + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return pow(__x, __y); } + }; + + + // We need these bits in order to recover the return type of + // some functions/operators now that we're no longer using + // function templates. + template<typename, typename _Tp> + struct __fun + { + typedef _Tp result_type; }; - template<class _Dom> - struct _BinFunClos<_Expr,_Constant,_Dom,typename _Dom::value_type> - : _BinFunBase2<_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _Tp value_type; - typedef _BinFunBase2<_Dom> _Base; + // several specializations for relational operators. + template<typename _Tp> + struct __fun<__logical_not, _Tp> + { + typedef bool result_type; + }; - _BinFunClos (const _Dom& __e, const _Tp& __t, _Tp __f (_Tp, _Tp)) - : _Base (__e, __t, __f) {} + template<typename _Tp> + struct __fun<__logical_and, _Tp> + { + typedef bool result_type; }; - template<class _Dom> - struct _BinFunClos<_Constant,_Expr,_Dom,typename _Dom::value_type> - : _BinFunBase1<_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _Tp value_type; - typedef _BinFunBase1<_Dom> _Base; + template<typename _Tp> + struct __fun<__logical_or, _Tp> + { + typedef bool result_type; + }; - _BinFunClos (const _Tp& __t, const _Dom& __e, _Tp __f (_Tp, _Tp)) - : _Base (__t, __e, __f) {} + template<typename _Tp> + struct __fun<__less, _Tp> + { + typedef bool result_type; }; - template<typename _Tp> - struct _BinFunClos<_ValArray,_Constant,_Tp,_Tp> - : _BinFunBase2<valarray<_Tp> > { - typedef _BinFunBase2<valarray<_Tp> > _Base; - typedef _Tp value_type; + template<typename _Tp> + struct __fun<__greater, _Tp> + { + typedef bool result_type; + }; - _BinFunClos (const valarray<_Tp>& __v, const _Tp& __t, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __t, __f) {} + template<typename _Tp> + struct __fun<__less_equal, _Tp> + { + typedef bool result_type; }; - template<typename _Tp> - struct _BinFunClos<_Constant,_ValArray,_Tp,_Tp> - : _BinFunBase1<valarray<_Tp> > { - typedef _BinFunBase1<valarray<_Tp> > _Base; - typedef _Tp value_type; + template<typename _Tp> + struct __fun<__greater_equal, _Tp> + { + typedef bool result_type; + }; + + template<typename _Tp> + struct __fun<__equal_to, _Tp> + { + typedef bool result_type; + }; - _BinFunClos (const _Tp& __t, const valarray<_Tp>& __v, - _Tp __f (_Tp, _Tp)) - : _Base (__t, __v, __f) {} + template<typename _Tp> + struct __fun<__not_equal_to, _Tp> + { + typedef bool result_type; }; // // Apply function taking a value/const reference closure // - template<typename _Dom, typename _Arg> class _FunBase { + template<typename _Dom, typename _Arg> + class _FunBase + { public: - typedef typename _Dom::value_type value_type; + typedef typename _Dom::value_type value_type; + + _FunBase(const _Dom& __e, value_type __f(_Arg)) + : _M_expr(__e), _M_func(__f) {} - _FunBase (const _Dom& __e, value_type __f(_Arg)) - : _M_expr (__e), _M_func (__f) {} + value_type operator[](size_t __i) const + { return _M_func (_M_expr[__i]); } - value_type operator[] (size_t __i) const - { return _M_func (_M_expr[__i]); } - size_t size() const { return _M_expr.size ();} + size_t size() const { return _M_expr.size ();} private: const _Dom& _M_expr; value_type (*_M_func)(_Arg); }; - template<class _Dom> - struct _ValFunClos<_Expr,_Dom> - : _FunBase<_Dom, typename _Dom::value_type> { - typedef _FunBase<_Dom, typename _Dom::value_type> _Base; - typedef typename _Base::value_type value_type; - typedef value_type _Tp; + template<class _Dom> + struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type> + { + typedef _FunBase<_Dom, typename _Dom::value_type> _Base; + typedef typename _Base::value_type value_type; + typedef value_type _Tp; - _ValFunClos (const _Dom& __e, _Tp __f (_Tp)) : _Base (__e, __f) {} + _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {} }; - template<typename _Tp> - struct _ValFunClos<_ValArray,_Tp> - : _FunBase<valarray<_Tp>, _Tp> { - typedef _FunBase<valarray<_Tp>, _Tp> _Base; - typedef _Tp value_type; - - _ValFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp)) - : _Base (__v, __f) {} + template<typename _Tp> + struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp> + { + typedef _FunBase<valarray<_Tp>, _Tp> _Base; + typedef _Tp value_type; + + _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {} }; - template<class _Dom> + template<class _Dom> struct _RefFunClos<_Expr,_Dom> : - _FunBase<_Dom, const typename _Dom::value_type&> { - typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base; - typedef typename _Base::value_type value_type; - typedef value_type _Tp; - - _RefFunClos (const _Dom& __e, _Tp __f (const _Tp&)) - : _Base (__e, __f) {} + _FunBase<_Dom, const typename _Dom::value_type&> + { + typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base; + typedef typename _Base::value_type value_type; + typedef value_type _Tp; + + _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&)) + : _Base(__e, __f) {} }; - template<typename _Tp> - struct _RefFunClos<_ValArray,_Tp> - : _FunBase<valarray<_Tp>, const _Tp&> { - typedef _FunBase<valarray<_Tp>, const _Tp&> _Base; - typedef _Tp value_type; - - _RefFunClos (const valarray<_Tp>& __v, _Tp __f(const _Tp&)) - : _Base (__v, __f) {} + template<typename _Tp> + struct _RefFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, const _Tp&> + { + typedef _FunBase<valarray<_Tp>, const _Tp&> _Base; + typedef _Tp value_type; + + _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&)) + : _Base(__v, __f) {} }; - // - // Unary expression closure. - // + // + // Unary expression closure. + // - template<template<class> class _Oper, typename _Arg> - class _UnBase { + template<class _Oper, class _Arg> + class _UnBase + { public: - typedef _Oper<typename _Arg::value_type> _Op; - typedef typename _Op::result_type value_type; + typedef typename _Arg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _UnBase(const _Arg& __e) : _M_expr(__e) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr[__i]); } - _UnBase (const _Arg& __e) : _M_expr(__e) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr.size (); } + size_t size() const { return _M_expr.size(); } private: - const _Arg& _M_expr; + const _Arg& _M_expr; }; - template<template<class> class _Oper, typename _Arg> - inline typename _UnBase<_Oper, _Arg>::value_type - _UnBase<_Oper, _Arg>::operator[] (size_t __i) const - { return _Op() (_M_expr[__i]); } - - template<template<class> class _Oper, class _Dom> - struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> { - typedef _Dom _Arg; - typedef _UnBase<_Oper, _Dom> _Base; - typedef typename _Base::value_type value_type; - - _UnClos (const _Arg& __e) : _Base(__e) {} + template<class _Oper, class _Dom> + struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> + { + typedef _Dom _Arg; + typedef _UnBase<_Oper, _Dom> _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} }; - template<template<class> class _Oper, typename _Tp> - struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > { - typedef valarray<_Tp> _Arg; - typedef _UnBase<_Oper, valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _UnClos (const _Arg& __e) : _Base(__e) {} + template<class _Oper, typename _Tp> + struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > + { + typedef valarray<_Tp> _Arg; + typedef _UnBase<_Oper, valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} }; - // - // Binary expression closure. - // + // + // Binary expression closure. + // - template<template<class> class _Oper, - typename _FirstArg, typename _SecondArg> - class _BinBase { + template<class _Oper, class _FirstArg, class _SecondArg> + class _BinBase + { public: - typedef _Oper<typename _FirstArg::value_type> _Op; - typedef typename _Op::result_type value_type; + typedef typename _FirstArg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; - _BinBase (const _FirstArg& __e1, const _SecondArg& __e2) - : _M_expr1 (__e1), _M_expr2 (__e2) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr1.size (); } + _BinBase(const _FirstArg& __e1, const _SecondArg& __e2) + : _M_expr1(__e1), _M_expr2(__e2) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1[__i], _M_expr2[__i]); } + + size_t size() const { return _M_expr1.size(); } private: - const _FirstArg& _M_expr1; - const _SecondArg& _M_expr2; + const _FirstArg& _M_expr1; + const _SecondArg& _M_expr2; }; - template<template<class> class _Oper, - typename _FirstArg, typename _SecondArg> - inline typename _BinBase<_Oper,_FirstArg,_SecondArg>::value_type - _BinBase<_Oper,_FirstArg,_SecondArg>::operator[] (size_t __i) const - { return _Op() (_M_expr1[__i], _M_expr2[__i]); } - - template<template<class> class _Oper, class _Clos> - class _BinBase2 { + template<class _Oper, class _Clos> + class _BinBase2 + { public: - typedef typename _Clos::value_type _Vt; - typedef _Oper<_Vt> _Op; - typedef typename _Op::result_type value_type; + typedef typename _Clos::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; - _BinBase2 (const _Clos& __e, const _Vt& __t) - : _M_expr1 (__e), _M_expr2 (__t) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr1.size (); } + _BinBase2(const _Clos& __e, const _Vt& __t) + : _M_expr1(__e), _M_expr2(__t) {} - private: - const _Clos& _M_expr1; - const _Vt& _M_expr2; - }; + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1[__i], _M_expr2); } - template<template<class> class _Oper, class _Clos> - inline typename _BinBase2<_Oper,_Clos>::value_type - _BinBase2<_Oper,_Clos>::operator[] (size_t __i) const - { return _Op() (_M_expr1[__i], _M_expr2); } + size_t size() const { return _M_expr1.size(); } + private: + const _Clos& _M_expr1; + const _Vt& _M_expr2; + }; - template<template<class> class _Oper, class _Clos> - class _BinBase1 { + template<class _Oper, class _Clos> + class _BinBase1 + { public: - typedef typename _Clos::value_type _Vt; - typedef _Oper<_Vt> _Op; - typedef typename _Op::result_type value_type; + typedef typename _Clos::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _BinBase1(const _Vt& __t, const _Clos& __e) + : _M_expr1(__t), _M_expr2(__e) {} - _BinBase1 (const _Vt& __t, const _Clos& __e) - : _M_expr1 (__t), _M_expr2 (__e) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr2.size (); } + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1, _M_expr2[__i]); } + + size_t size() const { return _M_expr2.size(); } private: - const _Vt& _M_expr1; - const _Clos& _M_expr2; + const _Vt& _M_expr1; + const _Clos& _M_expr2; }; - - template<template<class> class _Oper, class _Clos> - inline typename - _BinBase1<_Oper,_Clos>::value_type - _BinBase1<_Oper,_Clos>:: operator[] (size_t __i) const - { return _Op() (_M_expr1, _M_expr2[__i]); } - - template<template<class> class _Oper, class _Dom1, class _Dom2> - struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2> - : _BinBase<_Oper,_Dom1,_Dom2> { - typedef _BinBase<_Oper,_Dom1,_Dom2> _Base; - typedef typename _Base::value_type value_type; + template<class _Oper, class _Dom1, class _Dom2> + struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2> + : _BinBase<_Oper,_Dom1,_Dom2> + { + typedef _BinBase<_Oper,_Dom1,_Dom2> _Base; + typedef typename _Base::value_type value_type; - _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {} + _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {} }; - template<template<class> class _Oper, typename _Tp> + template<class _Oper, typename _Tp> struct _BinClos<_Oper,_ValArray,_ValArray,_Tp,_Tp> - : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > { - typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base; - typedef _Tp value_type; + : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > + { + typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base; + typedef _Tp value_type; - _BinClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w) - : _Base (__v, __w) {} + _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w) + : _Base(__v, __w) {} }; - template<template<class> class _Oper, class _Dom> - struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type> - : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> > { - typedef typename _Dom::value_type _Tp; - typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2) - : _Base (__e1, __e2) {} + template<class _Oper, class _Dom> + struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type> + : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> > + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2) + : _Base(__e1, __e2) {} }; - template<template<class> class _Oper, class _Dom> + template<class _Oper, class _Dom> struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom> - : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base; - typedef typename _Base::value_type value_type; - - _BinClos (const valarray<_Tp>& __e1, const _Dom& __e2) - : _Base (__e1, __e2) {} + : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2) + : _Base(__e1, __e2) {} }; - template<template<class> class _Oper, class _Dom> + template<class _Oper, class _Dom> struct _BinClos<_Oper,_Expr,_Constant,_Dom,typename _Dom::value_type> - : _BinBase2<_Oper,_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _BinBase2<_Oper,_Dom> _Base; - typedef typename _Base::value_type value_type; - - _BinClos (const _Dom& __e1, const _Tp& __e2) : _Base (__e1, __e2) {} + : _BinBase2<_Oper,_Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase2<_Oper,_Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {} }; - template<template<class> class _Oper, class _Dom> + template<class _Oper, class _Dom> struct _BinClos<_Oper,_Constant,_Expr,typename _Dom::value_type,_Dom> - : _BinBase1<_Oper,_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _BinBase1<_Oper,_Dom> _Base; - typedef typename _Base::value_type value_type; - - _BinClos (const _Tp& __e1, const _Dom& __e2) : _Base (__e1, __e2) {} + : _BinBase1<_Oper,_Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase1<_Oper,_Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {} }; - template<template<class> class _Oper, typename _Tp> + template<class _Oper, typename _Tp> struct _BinClos<_Oper,_ValArray,_Constant,_Tp,_Tp> - : _BinBase2<_Oper,valarray<_Tp> > { - typedef _BinBase2<_Oper,valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _BinClos (const valarray<_Tp>& __v, const _Tp& __t) - : _Base (__v, __t) {} + : _BinBase2<_Oper,valarray<_Tp> > + { + typedef _BinBase2<_Oper,valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {} }; - template<template<class> class _Oper, typename _Tp> + template<class _Oper, typename _Tp> struct _BinClos<_Oper,_Constant,_ValArray,_Tp,_Tp> - : _BinBase1<_Oper,valarray<_Tp> > { - typedef _BinBase1<_Oper,valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _BinClos (const _Tp& __t, const valarray<_Tp>& __v) - : _Base (__t, __v) {} + : _BinBase1<_Oper,valarray<_Tp> > + { + typedef _BinBase1<_Oper,valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {} }; @@ -643,317 +775,261 @@ namespace std : _Base (__a, __i) {} }; - // - // class _Expr - // - template<class _Clos, typename _Tp> class _Expr { + // + // class _Expr + // + template<class _Clos, typename _Tp> + class _Expr + { public: - typedef _Tp value_type; + typedef _Tp value_type; + + _Expr(const _Clos&); + + const _Clos& operator()() const; - _Expr (const _Clos&); - - const _Clos& operator() () const; - - value_type operator[] (size_t) const; - valarray<value_type> operator[] (slice) const; - valarray<value_type> operator[] (const gslice&) const; - valarray<value_type> operator[] (const valarray<bool>&) const; - valarray<value_type> operator[] (const valarray<size_t>&) const; + value_type operator[](size_t) const; + valarray<value_type> operator[](slice) const; + valarray<value_type> operator[](const gslice&) const; + valarray<value_type> operator[](const valarray<bool>&) const; + valarray<value_type> operator[](const valarray<size_t>&) const; - _Expr<_UnClos<_Unary_plus,std::_Expr,_Clos>, value_type> - operator+ () const; + _Expr<_UnClos<__unary_plus,std::_Expr,_Clos>, value_type> + operator+() const; - _Expr<_UnClos<negate,std::_Expr,_Clos>, value_type> - operator- () const; + _Expr<_UnClos<__negate,std::_Expr,_Clos>, value_type> + operator-() const; - _Expr<_UnClos<_Bitwise_not,std::_Expr,_Clos>, value_type> - operator~ () const; + _Expr<_UnClos<__bitwise_not,std::_Expr,_Clos>, value_type> + operator~() const; - _Expr<_UnClos<logical_not,std::_Expr,_Clos>, bool> - operator! () const; + _Expr<_UnClos<__logical_not,std::_Expr,_Clos>, bool> + operator!() const; - size_t size () const; - value_type sum () const; + size_t size() const; + value_type sum() const; - valarray<value_type> shift (int) const; - valarray<value_type> cshift (int) const; + valarray<value_type> shift(int) const; + valarray<value_type> cshift(int) const; value_type min() const; value_type max() const; - valarray<value_type> apply(value_type (*) (const value_type&)) const; - valarray<value_type> apply(value_type (*) (value_type)) const; + valarray<value_type> apply(value_type (*)(const value_type&)) const; + valarray<value_type> apply(value_type (*)(value_type)) const; private: - const _Clos _M_closure; + const _Clos _M_closure; }; - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline - _Expr<_Clos,_Tp>::_Expr (const _Clos& __c) : _M_closure(__c) {} + _Expr<_Clos,_Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline const _Clos& - _Expr<_Clos,_Tp>::operator() () const + _Expr<_Clos,_Tp>::operator()() const { return _M_closure; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline _Tp - _Expr<_Clos,_Tp>::operator[] (size_t __i) const + _Expr<_Clos,_Tp>::operator[](size_t __i) const { return _M_closure[__i]; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (slice __s) const + _Expr<_Clos,_Tp>::operator[](slice __s) const { return _M_closure[__s]; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const gslice& __gs) const + _Expr<_Clos,_Tp>::operator[](const gslice& __gs) const { return _M_closure[__gs]; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray<bool>& __m) const + _Expr<_Clos,_Tp>::operator[](const valarray<bool>& __m) const { return _M_closure[__m]; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray<size_t>& __i) const + _Expr<_Clos,_Tp>::operator[](const valarray<size_t>& __i) const { return _M_closure[__i]; } - template<class _Clos, typename _Tp> + template<class _Clos, typename _Tp> inline size_t - _Expr<_Clos,_Tp>::size () const { return _M_closure.size (); } + _Expr<_Clos,_Tp>::size() const { return _M_closure.size (); } template<class _Clos, typename _Tp> - inline valarray<_Tp> - _Expr<_Clos, _Tp>::shift(int __n) const - { return valarray<_Tp>(_M_closure).shift(__n); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::shift(int __n) const + { return valarray<_Tp>(_M_closure).shift(__n); } template<class _Clos, typename _Tp> - inline valarray<_Tp> - _Expr<_Clos, _Tp>::cshift(int __n) const - { return valarray<_Tp>(_M_closure).cshift(__n); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::cshift(int __n) const + { return valarray<_Tp>(_M_closure).cshift(__n); } template<class _Clos, typename _Tp> - inline valarray<_Tp> - _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const - { return valarray<_Tp>(_M_closure).apply(__f); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const + { return valarray<_Tp>(_M_closure).apply(__f); } template<class _Clos, typename _Tp> - inline valarray<_Tp> - _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const - { return valarray<_Tp>(_M_closure).apply(__f); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const + { return valarray<_Tp>(_M_closure).apply(__f); } - // XXX: replace this with a more robust summation algorithm. - template<class _Clos, typename _Tp> + // XXX: replace this with a more robust summation algorithm. + template<class _Clos, typename _Tp> inline _Tp - _Expr<_Clos,_Tp>::sum () const + _Expr<_Clos,_Tp>::sum() const { - size_t __n = _M_closure.size(); - if (__n == 0) return _Tp(); - else { - _Tp __s = _M_closure[--__n]; - while (__n != 0) __s += _M_closure[--__n]; - return __s; + size_t __n = _M_closure.size(); + if (__n == 0) + return _Tp(); + else + { + _Tp __s = _M_closure[--__n]; + while (__n != 0) + __s += _M_closure[--__n]; + return __s; } } template<class _Clos, typename _Tp> - inline _Tp - _Expr<_Clos, _Tp>::min() const - { return __valarray_min(_M_closure); } + inline _Tp + _Expr<_Clos, _Tp>::min() const + { return __valarray_min(_M_closure); } template<class _Clos, typename _Tp> - inline _Tp - _Expr<_Clos, _Tp>::max() const - { return __valarray_max(_M_closure); } + inline _Tp + _Expr<_Clos, _Tp>::max() const + { return __valarray_max(_M_closure); } - template<class _Dom, typename _Tp> - inline _Expr<_UnClos<logical_not,_Expr,_Dom>, bool> - _Expr<_Dom,_Tp>::operator! () const + template<class _Dom, typename _Tp> + inline _Expr<_UnClos<__logical_not,_Expr,_Dom>, bool> + _Expr<_Dom,_Tp>::operator!() const { - typedef _UnClos<logical_not,std::_Expr,_Dom> _Closure; - return _Expr<_Closure,_Tp> (_Closure(this->_M_closure)); + typedef _UnClos<__logical_not,std::_Expr,_Dom> _Closure; + return _Expr<_Closure,_Tp>(_Closure(this->_M_closure)); } -#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ -template<class _Dom, typename _Tp> \ -inline _Expr<_UnClos<_Name,std::_Expr,_Dom>,_Tp> \ -_Expr<_Dom,_Tp>::operator _Op () const \ -{ \ - typedef _UnClos<_Name,std::_Expr,_Dom> _Closure; \ - return _Expr<_Closure,_Tp> (_Closure (this->_M_closure)); \ -} +#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ + template<class _Dom, typename _Tp> \ + inline _Expr<_UnClos<_Name,std::_Expr,_Dom>,_Tp> \ + _Expr<_Dom,_Tp>::operator _Op() const \ + { \ + typedef _UnClos<_Name,std::_Expr,_Dom> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(this->_M_closure)); \ + } - _DEFINE_EXPR_UNARY_OPERATOR(+, _Unary_plus) - _DEFINE_EXPR_UNARY_OPERATOR(-, negate) - _DEFINE_EXPR_UNARY_OPERATOR(~, _Bitwise_not) + _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_EXPR_UNARY_OPERATOR(-, __negate) + _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not) #undef _DEFINE_EXPR_UNARY_OPERATOR #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ -template<class _Dom1, class _Dom2> \ -inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \ - typename _Name<typename _Dom1::value_type>::result_type> \ -operator _Op (const _Expr<_Dom1,typename _Dom1::value_type>& __v, \ - const _Expr<_Dom2,typename _Dom2::value_type>& __w) \ -{ \ + template<class _Dom1, class _Dom2> \ + inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \ + typename __fun<_Name, typename _Dom1::value_type>::result_type>\ + operator _Op(const _Expr<_Dom1,typename _Dom1::value_type>& __v, \ + const _Expr<_Dom2,typename _Dom2::value_type>& __w) \ + { \ typedef typename _Dom1::value_type _Arg; \ - typedef typename _Name<_Arg>::result_type _Value; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__v (), __w ())); \ -} \ + return _Expr<_Closure,_Value>(_Closure(__v(), __w())); \ + } \ \ template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>, \ - typename _Name<typename _Dom::value_type>::result_type> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __v, \ - const typename _Dom::value_type& __t) \ +inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>,\ + typename __fun<_Name, typename _Dom::value_type>::result_type>\ +operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __v, \ + const typename _Dom::value_type& __t) \ { \ - typedef typename _Dom::value_type _Arg; \ - typedef typename _Name<_Arg>::result_type _Value; \ - typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__v (), __t)); \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \ + return _Expr<_Closure,_Value>(_Closure(__v(), __t)); \ } \ \ template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Name<typename _Dom::value_type>::result_type> \ -operator _Op (const typename _Dom::value_type& __t, \ - const _Expr<_Dom,typename _Dom::value_type>& __v) \ +inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>,\ + typename __fun<_Name, typename _Dom::value_type>::result_type>\ +operator _Op(const typename _Dom::value_type& __t, \ + const _Expr<_Dom,typename _Dom::value_type>& __v) \ { \ - typedef typename _Dom::value_type _Arg; \ - typedef typename _Name<_Arg>::result_type _Value; \ - typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__t, __v ())); \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \ + return _Expr<_Closure,_Value>(_Closure(__t, __v())); \ } \ \ template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \ - typename _Name<typename _Dom::value_type>::result_type> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \ - const valarray<typename _Dom::value_type>& __v) \ +inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>,\ + typename __fun<_Name, typename _Dom::value_type>::result_type>\ +operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \ + const valarray<typename _Dom::value_type>& __v) \ { \ - typedef typename _Dom::value_type _Arg; \ - typedef typename _Name<_Arg>::result_type _Value; \ - typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Arg> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__e (), __v)); \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Arg> _Closure; \ + return _Expr<_Closure,_Value>(_Closure(__e(), __v)); \ } \ \ template<class _Dom> \ -inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Name<typename _Dom::value_type>::result_type> \ -operator _Op (const valarray<typename _Dom::value_type>& __v, \ - const _Expr<_Dom,typename _Dom::value_type>& __e) \ +inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>,\ + typename __fun<_Name, typename _Dom::value_type>::result_type>\ +operator _Op(const valarray<typename _Dom::value_type>& __v, \ + const _Expr<_Dom,typename _Dom::value_type>& __e) \ { \ - typedef typename _Dom::value_type _Tp; \ - typedef typename _Name<_Tp>::result_type _Value; \ - typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__v, __e ())); \ + typedef typename _Dom::value_type _Tp; \ + typedef typename __fun<_Name, _Tp>::result_type _Value; \ + typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \ + return _Expr<_Closure,_Value> (_Closure (__v, __e ())); \ } - _DEFINE_EXPR_BINARY_OPERATOR(+, plus) - _DEFINE_EXPR_BINARY_OPERATOR(-, minus) - _DEFINE_EXPR_BINARY_OPERATOR(*, multiplies) - _DEFINE_EXPR_BINARY_OPERATOR(/, divides) - _DEFINE_EXPR_BINARY_OPERATOR(%, modulus) - _DEFINE_EXPR_BINARY_OPERATOR(^, _Bitwise_xor) - _DEFINE_EXPR_BINARY_OPERATOR(&, _Bitwise_and) - _DEFINE_EXPR_BINARY_OPERATOR(|, _Bitwise_or) - _DEFINE_EXPR_BINARY_OPERATOR(<<, _Shift_left) - _DEFINE_EXPR_BINARY_OPERATOR(>>, _Shift_right) + _DEFINE_EXPR_BINARY_OPERATOR(+, __plus) + _DEFINE_EXPR_BINARY_OPERATOR(-, __minus) + _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies) + _DEFINE_EXPR_BINARY_OPERATOR(/, __divides) + _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus) + _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor) + _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and) + _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or) + _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left) + _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right) + _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and) + _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or) + _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to) + _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to) + _DEFINE_EXPR_BINARY_OPERATOR(<, __less) + _DEFINE_EXPR_BINARY_OPERATOR(>, __greater) + _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal) + _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal) #undef _DEFINE_EXPR_BINARY_OPERATOR - -#define _DEFINE_EXPR_RELATIONAL_OPERATOR(_Op, _Name) \ -template<class _Dom1, class _Dom2> \ -inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, bool> \ -operator _Op (const _Expr<_Dom1,typename _Dom1::value_type>& __v, \ - const _Expr<_Dom2,typename _Dom2::value_type>& __w) \ -{ \ - typedef typename _Dom1::value_type _Arg; \ - typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__v (), __w ())); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>, \ - bool> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __v, \ - const typename _Dom::value_type& __t) \ -{ \ - typedef typename _Dom::value_type _Arg; \ - typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__v (), __t)); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>, \ - bool> \ -operator _Op (const typename _Dom::value_type& __t, \ - const _Expr<_Dom,typename _Dom::value_type>& __v) \ -{ \ - typedef typename _Dom::value_type _Arg; \ - typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__t, __v ())); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \ - bool> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \ - const valarray<typename _Dom::value_type>& __v) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Tp> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__e (), __v)); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - bool> \ -operator _Op (const valarray<typename _Dom::value_type>& __v, \ - const _Expr<_Dom,typename _Dom::value_type>& __e) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__v, __e ())); \ -} - - _DEFINE_EXPR_RELATIONAL_OPERATOR(&&, logical_and) - _DEFINE_EXPR_RELATIONAL_OPERATOR(||, logical_or) - _DEFINE_EXPR_RELATIONAL_OPERATOR(==, equal_to) - _DEFINE_EXPR_RELATIONAL_OPERATOR(!=, not_equal_to) - _DEFINE_EXPR_RELATIONAL_OPERATOR(<, less) - _DEFINE_EXPR_RELATIONAL_OPERATOR(>, greater) - _DEFINE_EXPR_RELATIONAL_OPERATOR(<=, less_equal) - _DEFINE_EXPR_RELATIONAL_OPERATOR(>=, greater_equal) - -#undef _DEFINE_EXPR_RELATIONAL_OPERATOR - - - -#define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \ -template<class _Dom> \ -inline _Expr<_UnFunClos<_Expr,_Dom>,typename _Dom::value_type> \ -_Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _UnFunClos<_Expr,_Dom> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__e(), (_Tp(*)(_Tp))(&_Name))); \ -} \ - \ -template<typename _Tp> \ -inline _Expr<_UnFunClos<_ValArray,_Tp>,_Tp> \ -_Name(const valarray<_Tp>& __v) \ -{ \ - typedef _UnFunClos<_ValArray,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> (_Closure (__v, (_Tp(*)(_Tp))(&_Name))); \ -} +#define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \ + template<class _Dom> \ + inline _Expr<_UnClos<__##_Name,_Expr,_Dom>,typename _Dom::value_type>\ + _Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _UnClos<__##_Name,_Expr,_Dom> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__e())); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_UnClos<__##_Name,_ValArray,_Tp>,_Tp> \ + _Name(const valarray<_Tp>& __v) \ + { \ + typedef _UnClos<__##_Name,_ValArray,_Tp> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__v)); \ + } _DEFINE_EXPR_UNARY_FUNCTION(abs) _DEFINE_EXPR_UNARY_FUNCTION(cos) @@ -972,93 +1048,89 @@ _Name(const valarray<_Tp>& __v) \ #undef _DEFINE_EXPR_UNARY_FUNCTION - -#define _DEFINE_EXPR_BINARY_FUNCTION(_Name) \ -template<class _Dom1, class _Dom2> \ -inline _Expr<_BinFunClos<_Expr,_Expr,_Dom1,_Dom2>,typename _Dom1::value_type>\ -_Name (const _Expr<_Dom1,typename _Dom1::value_type>& __e1, \ - const _Expr<_Dom2,typename _Dom2::value_type>& __e2) \ -{ \ - typedef typename _Dom1::value_type _Tp; \ - typedef _BinFunClos<_Expr,_Expr,_Dom1,_Dom2> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__e1 (), __e2 (), (_Tp(*)(_Tp, _Tp))(&_Name))); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinFunClos<_Expr,_ValArray,_Dom,typename _Dom::value_type>, \ - typename _Dom::value_type> \ -_Name (const _Expr<_Dom,typename _Dom::value_type>& __e, \ - const valarray<typename _Dom::value_type>& __v) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinFunClos<_Expr,_ValArray,_Dom,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__e (), __v, (_Tp(*)(_Tp, _Tp))(&_Name))); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Dom::value_type> \ -_Name (const valarray<typename _Dom::valarray>& __v, \ - const _Expr<_Dom,typename _Dom::value_type>& __e) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinFunClos<_ValArray,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__v, __e (), (_Tp(*)(_Tp, _Tp))(&_Name))); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinFunClos<_Expr,_Constant,_Dom,typename _Dom::value_type>, \ - typename _Dom::value_type> \ -_Name (const _Expr<_Dom, typename _Dom::value_type>& __e, \ - const typename _Dom::value_type& __t) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinFunClos<_Expr,_Constant,_Dom,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__e (), __t, (_Tp(*)(_Tp, _Tp))(&_Name))); \ -} \ - \ -template<class _Dom> \ -inline _Expr<_BinFunClos<_Constant,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Dom::value_type> \ -_Name (const typename _Dom::value_type& __t, \ - const _Expr<_Dom,typename _Dom::value_type>& __e) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinFunClos<_Constant,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__t, __e (), (_Tp(*)(_Tp, _Tp))(&_Name))); \ -} \ - \ -template<typename _Tp> \ -inline _Expr<_BinFunClos<_ValArray,_ValArray,_Tp,_Tp>, _Tp> \ -_Name (const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ -{ \ - typedef _BinFunClos<_ValArray,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__v, __w, (_Tp(*)(_Tp,_Tp))(&_Name))); \ -} \ - \ -template<typename _Tp> \ -inline _Expr<_BinFunClos<_ValArray,_Constant,_Tp,_Tp>,_Tp> \ -_Name (const valarray<_Tp>& __v, const _Tp& __t) \ -{ \ - typedef _BinFunClos<_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__v, __t, (_Tp(*)(_Tp,_Tp))(&_Name))); \ -} \ - \ -template<typename _Tp> \ -inline _Expr<_BinFunClos<_Constant,_ValArray,_Tp,_Tp>,_Tp> \ -_Name (const _Tp& __t, const valarray<_Tp>& __v) \ -{ \ - typedef _BinFunClos<_Constant,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp> \ - (_Closure (__t, __v, (_Tp(*)(_Tp,_Tp))(&_Name))); \ -} +#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \ + template<class _Dom1, class _Dom2> \ + inline _Expr<_BinClos<__##_Fun,_Expr,_Expr,_Dom1,_Dom2>, \ + typename _Dom1::value_type> \ + _Fun(const _Expr<_Dom1,typename _Dom1::value_type>& __e1, \ + const _Expr<_Dom2,typename _Dom2::value_type>& __e2) \ + { \ + typedef typename _Dom1::value_type _Tp; \ + typedef _BinClos<__##_Fun,_Expr,_Expr,_Dom1,_Dom2> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__e1(), __e2())); \ + } \ + \ + template<class _Dom> \ + inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom, \ + typename _Dom::value_type>, \ + typename _Dom::value_type> \ + _Fun(const _Expr<_Dom,typename _Dom::value_type>& __e, \ + const valarray<typename _Dom::value_type>& __v) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure;\ + return _Expr<_Closure,_Tp>(_Closure(__e(), __v)); \ + } \ + \ + template<class _Dom> \ + inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \ + typename _Dom::value_type,_Dom>, \ + typename _Dom::value_type> \ + _Fun(const valarray<typename _Dom::valarray>& __v, \ + const _Expr<_Dom,typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<__##_Fun,_ValArray,_Expr,_Tp,_Dom> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__v, __e())); \ + } \ + \ + template<class _Dom> \ + inline _Expr<_BinClos<__##_Fun,_Expr,_Constant,_Dom, \ + typename _Dom::value_type>, \ + typename _Dom::value_type> \ + _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ + const typename _Dom::value_type& __t) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<__##_Fun,_Expr,_Constant,_Dom,_Tp> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__e(), __t)); \ + } \ + \ + template<class _Dom> \ + inline _Expr<_BinClos<__##_Fun,_Constant,_Expr, \ + typename _Dom::value_type,_Dom>, \ + typename _Dom::value_type> \ + _Fun(const typename _Dom::value_type& __t, \ + const _Expr<_Dom,typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<__##_Fun, _Constant,_Expr,_Tp,_Dom> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__t, __e())); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \ + _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ + { \ + typedef _BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__v, __w)); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp>,_Tp> \ + _Fun(const valarray<_Tp>& __v, const _Tp& __t) \ + { \ + typedef _BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__v, __t)); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp>,_Tp> \ + _Fun(const _Tp& __t, const valarray<_Tp>& __v) \ + { \ + typedef _BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp> _Closure; \ + return _Expr<_Closure,_Tp>(_Closure(__t, __v)); \ + } _DEFINE_EXPR_BINARY_FUNCTION(atan2) _DEFINE_EXPR_BINARY_FUNCTION(pow) diff --git a/contrib/libstdc++/include/bits/vector.tcc b/contrib/libstdc++/include/bits/vector.tcc new file mode 100644 index 000000000000..da5cf7edf832 --- /dev/null +++ b/contrib/libstdc++/include/bits/vector.tcc @@ -0,0 +1,437 @@ +// Vector implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001, 2002 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. + +/* + * + * 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. + */ + +/** @file vector.tcc + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +#ifndef __GLIBCPP_INTERNAL_VECTOR_TCC +#define __GLIBCPP_INTERNAL_VECTOR_TCC + +namespace std +{ + template<typename _Tp, typename _Alloc> + void + vector<_Tp,_Alloc>:: + reserve(size_type __n) + { + if (__n > this->max_size()) + __throw_length_error("vector::reserve"); + if (this->capacity() < __n) + { + const size_type __old_size = size(); + pointer __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish); + _Destroy(_M_start, _M_finish); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __tmp; + _M_finish = __tmp + __old_size; + _M_end_of_storage = _M_start + __n; + } + } + + template<typename _Tp, typename _Alloc> + typename vector<_Tp,_Alloc>::iterator + vector<_Tp,_Alloc>:: + insert(iterator __position, const value_type& __x) + { + size_type __n = __position - begin(); + if (_M_finish != _M_end_of_storage && __position == end()) + { + _Construct(_M_finish, __x); + ++_M_finish; + } + else + _M_insert_aux(__position, __x); + return begin() + __n; + } + + template<typename _Tp, typename _Alloc> + typename vector<_Tp,_Alloc>::iterator + vector<_Tp,_Alloc>:: + erase(iterator __position) + { + if (__position + 1 != end()) + copy(__position + 1, end(), __position); + --_M_finish; + _Destroy(_M_finish); + return __position; + } + + template<typename _Tp, typename _Alloc> + typename vector<_Tp,_Alloc>::iterator + vector<_Tp,_Alloc>:: + erase(iterator __first, iterator __last) + { + iterator __i(copy(__last, end(), __first)); + _Destroy(__i, end()); + _M_finish = _M_finish - (__last - __first); + return __first; + } + + template<typename _Tp, typename _Alloc> + vector<_Tp,_Alloc>& + vector<_Tp,_Alloc>:: + operator=(const vector<_Tp,_Alloc>& __x) + { + if (&__x != this) + { + const size_type __xlen = __x.size(); + if (__xlen > capacity()) + { + pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end()); + _Destroy(_M_start, _M_finish); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __tmp; + _M_end_of_storage = _M_start + __xlen; + } + else if (size() >= __xlen) + { + iterator __i(copy(__x.begin(), __x.end(), begin())); + _Destroy(__i, end()); + } + else + { + copy(__x.begin(), __x.begin() + size(), _M_start); + uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish); + } + _M_finish = _M_start + __xlen; + } + return *this; + } + + template<typename _Tp, typename _Alloc> + void + vector<_Tp,_Alloc>:: + _M_fill_assign(size_t __n, const value_type& __val) + { + if (__n > capacity()) + { + vector __tmp(__n, __val, get_allocator()); + __tmp.swap(*this); + } + else if (__n > size()) + { + fill(begin(), end(), __val); + _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val); + } + else + erase(fill_n(begin(), __n, __val), end()); + } + + template<typename _Tp, typename _Alloc> template<typename _InputIter> + void + vector<_Tp,_Alloc>:: + _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag) + { + iterator __cur(begin()); + for ( ; __first != __last && __cur != end(); ++__cur, ++__first) + *__cur = *__first; + if (__first == __last) + erase(__cur, end()); + else + insert(end(), __first, __last); + } + + template<typename _Tp, typename _Alloc> template<typename _ForwardIter> + void + vector<_Tp,_Alloc>:: + _M_assign_aux(_ForwardIter __first, _ForwardIter __last, + forward_iterator_tag) + { + size_type __len = distance(__first, __last); + + if (__len > capacity()) + { + pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); + _Destroy(_M_start, _M_finish); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __tmp; + _M_end_of_storage = _M_finish = _M_start + __len; + } + else if (size() >= __len) + { + iterator __new_finish(copy(__first, __last, _M_start)); + _Destroy(__new_finish, end()); + _M_finish = __new_finish.base(); + } + else + { + _ForwardIter __mid = __first; + advance(__mid, size()); + copy(__first, __mid, _M_start); + _M_finish = uninitialized_copy(__mid, __last, _M_finish); + } + } + + template<typename _Tp, typename _Alloc> + void + vector<_Tp,_Alloc>:: + _M_insert_aux(iterator __position, const _Tp& __x) + { + if (_M_finish != _M_end_of_storage) + { + _Construct(_M_finish, *(_M_finish - 1)); + ++_M_finish; + _Tp __x_copy = __x; + copy_backward(__position, iterator(_M_finish-2), iterator(_M_finish-1)); + *__position = __x_copy; + } + else + { + const size_type __old_size = size(); + const size_type __len = __old_size != 0 ? 2 * __old_size : 1; + iterator __new_start(_M_allocate(__len)); + iterator __new_finish(__new_start); + try + { + __new_finish = uninitialized_copy(iterator(_M_start), __position, + __new_start); + _Construct(__new_finish.base(), __x); + ++__new_finish; + __new_finish = uninitialized_copy(__position, iterator(_M_finish), + __new_finish); + } + catch(...) + { + _Destroy(__new_start,__new_finish); + _M_deallocate(__new_start.base(),__len); + __throw_exception_again; + } + _Destroy(begin(), end()); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __new_start.base(); + _M_finish = __new_finish.base(); + _M_end_of_storage = __new_start.base() + __len; + } + } + + #ifdef _GLIBCPP_DEPRECATED + template<typename _Tp, typename _Alloc> + void + vector<_Tp,_Alloc>:: + _M_insert_aux(iterator __position) + { + if (_M_finish != _M_end_of_storage) + { + _Construct(_M_finish, *(_M_finish - 1)); + ++_M_finish; + copy_backward(__position, iterator(_M_finish - 2), + iterator(_M_finish - 1)); + *__position = value_type(); + } + else + { + const size_type __old_size = size(); + const size_type __len = __old_size != 0 ? 2 * __old_size : 1; + pointer __new_start = _M_allocate(__len); + pointer __new_finish = __new_start; + try + { + __new_finish = uninitialized_copy(iterator(_M_start), __position, + __new_start); + _Construct(__new_finish); + ++__new_finish; + __new_finish = uninitialized_copy(__position, iterator(_M_finish), + __new_finish); + } + catch(...) + { + _Destroy(__new_start,__new_finish); + _M_deallocate(__new_start,__len); + __throw_exception_again; + } + _Destroy(begin(), end()); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __new_start; + _M_finish = __new_finish; + _M_end_of_storage = __new_start + __len; + } + } + #endif + + template<typename _Tp, typename _Alloc> + void + vector<_Tp,_Alloc>:: + _M_fill_insert(iterator __position, size_type __n, const value_type& __x) + { + if (__n != 0) + { + if (size_type(_M_end_of_storage - _M_finish) >= __n) + { + value_type __x_copy = __x; + const size_type __elems_after = end() - __position; + iterator __old_finish(_M_finish); + if (__elems_after > __n) + { + uninitialized_copy(_M_finish - __n, _M_finish, _M_finish); + _M_finish += __n; + copy_backward(__position, __old_finish - __n, __old_finish); + fill(__position, __position + __n, __x_copy); + } + else + { + uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy); + _M_finish += __n - __elems_after; + uninitialized_copy(__position, __old_finish, _M_finish); + _M_finish += __elems_after; + fill(__position, __old_finish, __x_copy); + } + } + else + { + const size_type __old_size = size(); + const size_type __len = __old_size + max(__old_size, __n); + iterator __new_start(_M_allocate(__len)); + iterator __new_finish(__new_start); + try + { + __new_finish = uninitialized_copy(begin(), __position, + __new_start); + __new_finish = uninitialized_fill_n(__new_finish, __n, __x); + __new_finish = uninitialized_copy(__position, end(), + __new_finish); + } + catch(...) + { + _Destroy(__new_start,__new_finish); + _M_deallocate(__new_start.base(),__len); + __throw_exception_again; + } + _Destroy(_M_start, _M_finish); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __new_start.base(); + _M_finish = __new_finish.base(); + _M_end_of_storage = __new_start.base() + __len; + } + } + } + + template<typename _Tp, typename _Alloc> template<typename _InputIterator> + void + vector<_Tp,_Alloc>:: + _M_range_insert(iterator __pos, + _InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + for ( ; __first != __last; ++__first) + { + __pos = insert(__pos, *__first); + ++__pos; + } + } + + template<typename _Tp, typename _Alloc> template<typename _ForwardIterator> + void + vector<_Tp,_Alloc>:: + _M_range_insert(iterator __position,_ForwardIterator __first, + _ForwardIterator __last, forward_iterator_tag) + { + if (__first != __last) + { + size_type __n = distance(__first, __last); + if (size_type(_M_end_of_storage - _M_finish) >= __n) + { + const size_type __elems_after = end() - __position; + iterator __old_finish(_M_finish); + if (__elems_after > __n) + { + uninitialized_copy(_M_finish - __n, _M_finish, _M_finish); + _M_finish += __n; + copy_backward(__position, __old_finish - __n, __old_finish); + copy(__first, __last, __position); + } + else + { + _ForwardIterator __mid = __first; + advance(__mid, __elems_after); + uninitialized_copy(__mid, __last, _M_finish); + _M_finish += __n - __elems_after; + uninitialized_copy(__position, __old_finish, _M_finish); + _M_finish += __elems_after; + copy(__first, __mid, __position); + } + } + else + { + const size_type __old_size = size(); + const size_type __len = __old_size + max(__old_size, __n); + iterator __new_start(_M_allocate(__len)); + iterator __new_finish(__new_start); + try + { + __new_finish = uninitialized_copy(iterator(_M_start), + __position, __new_start); + __new_finish = uninitialized_copy(__first, __last, __new_finish); + __new_finish = uninitialized_copy(__position, iterator(_M_finish), + __new_finish); + } + catch(...) + { + _Destroy(__new_start,__new_finish); + _M_deallocate(__new_start.base(), __len); + __throw_exception_again; + } + _Destroy(_M_start, _M_finish); + _M_deallocate(_M_start, _M_end_of_storage - _M_start); + _M_start = __new_start.base(); + _M_finish = __new_finish.base(); + _M_end_of_storage = __new_start.base() + __len; + } + } + } +} // namespace std + +#endif /* __GLIBCPP_INTERNAL_VECTOR_TCC */ diff --git a/contrib/libstdc++/include/c_std/std_cmath.h b/contrib/libstdc++/include/c_std/std_cmath.h index b2f65c82d674..1264c4dba69a 100644 --- a/contrib/libstdc++/include/c_std/std_cmath.h +++ b/contrib/libstdc++/include/c_std/std_cmath.h @@ -1,6 +1,6 @@ // -*- C++ -*- C forwarding header. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -76,6 +76,91 @@ #undef tan #undef tanh +// ...and in the darkness bind them... +namespace __gnu_cxx +{ + namespace __c99_binding + { +#if _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \ + _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC + extern "C" float (acosf)(float); + extern "C" float (asinf)(float); + extern "C" float (atanf)(float); + extern "C" float (atan2f)(float, float); + extern "C" float (ceilf)(float); + extern "C" float (coshf)(float); + extern "C" float (expf)(float); + extern "C" float (floorf)(float); + extern "C" float (fmodf)(float, float); + extern "C" float (frexpf)(float, int*); + extern "C" float (ldexpf)(float, int); + extern "C" float (logf)(float); + extern "C" float (log10f)(float); + extern "C" float (modff)(float, float*); + extern "C" float (powf)(float, float); + extern "C" float (sinhf)(float); + extern "C" float (tanf)(float); + extern "C" float (tanhf)(float); +#endif +#if !_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC +#if _GLIBCPP_HAVE_ACOSF + using ::acosf; +#endif +#if _GLIBCPP_HAVE_ASINF + using ::asinf; +#endif +#if _GLIBCPP_HAVE_ATANF + using ::atanf; +#endif +#if _GLIBCPP_HAVE_ATAN2F + using ::atan2f; +#endif +#if _GLIBCPP_HAVE_CEILF + using ::ceilf; +#endif +#if _GLIBCPP_HAVE_COSHF + using ::coshf; +#endif +#if _GLIBCPP_HAVE_EXPF + using ::expf; +#endif +#if _GLIBCPP_HAVE_FLOORF + using ::floorf; +#endif +#if _GLIBCPP_HAVE_FMODF + using ::fmodf; +#endif +#if _GLIBCPP_HAVE_FREXPF + using ::frexpf; +#endif +#if _GLIBCPP_HAVE_LDEXPF + using ::ldexpf; +#endif +#if _GLIBCPP_HAVE_LOGF + using ::logf; +#endif +#if _GLIBCPP_HAVE_LOG10F + using ::log10f; +#endif +#if _GLIBCPP_HAVE_MODFF + using ::modff; +#endif +#if _GLIBCPP_HAVE_POWF + using ::powf; +#endif +#if _GLIBCPP_HAVE_SINHF + using ::sinhf; +#endif +#if _GLIBCPP_HAVE_TANF + using ::tanf; +#endif +#if _GLIBCPP_HAVE_TANHF + using ::tanhf; +#endif +#endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */ + } +} + namespace std { // Forward declaration of a helper function. This really should be @@ -96,7 +181,7 @@ namespace std #if _GLIBCPP_HAVE_ACOSF inline float - acos(float __x) { return ::acosf(__x); } + acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); } #else inline float acos(float __x) { return ::acos(static_cast<double>(__x)); } @@ -116,7 +201,7 @@ namespace std #if _GLIBCPP_HAVE_ASINF inline float - asin(float __x) { return ::asinf(__x); } + asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); } #else inline float asin(float __x) { return ::asin(static_cast<double>(__x)); } @@ -134,7 +219,7 @@ namespace std #if _GLIBCPP_HAVE_ATANF inline float - atan(float __x) { return ::atanf(__x); } + atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); } #else inline float atan(float __x) { return ::atan(static_cast<double>(__x)); } @@ -152,7 +237,7 @@ namespace std #if _GLIBCPP_HAVE_ATAN2F inline float - atan2(float __y, float __x) { return ::atan2f(__y, __x); } + atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); } #else inline float atan2(float __y, float __x) @@ -172,7 +257,7 @@ namespace std #if _GLIBCPP_HAVE_CEILF inline float - ceil(float __x) { return ::ceilf(__x); } + ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); } #else inline float ceil(float __x) { return ::ceil(static_cast<double>(__x)); } @@ -200,7 +285,7 @@ namespace std #if _GLIBCPP_HAVE_COSHF inline float - cosh(float __x) { return ::coshf(__x); } + cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); } #else inline float cosh(float __x) { return ::cosh(static_cast<double>(__x)); } @@ -218,7 +303,7 @@ namespace std #if _GLIBCPP_HAVE_EXPF inline float - exp(float __x) { return ::expf(__x); } + exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); } #else inline float exp(float __x) { return ::exp(static_cast<double>(__x)); } @@ -246,7 +331,7 @@ namespace std #if _GLIBCPP_HAVE_FLOORF inline float - floor(float __x) { return ::floorf(__x); } + floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); } #else inline float floor(float __x) { return ::floor(static_cast<double>(__x)); } @@ -264,7 +349,7 @@ namespace std #if _GLIBCPP_HAVE_FMODF inline float - fmod(float __x, float __y) { return ::fmodf(__x, __y); } + fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); } #else inline float fmod(float __x, float __y) @@ -284,7 +369,7 @@ namespace std #if _GLIBCPP_HAVE_FREXPF inline float - frexp(float __x, int* __exp) { return ::frexpf(__x, __exp); } + frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); } #else inline float frexp(float __x, int* __exp) { return ::frexp(__x, __exp); } @@ -303,7 +388,7 @@ namespace std #if _GLIBCPP_HAVE_LDEXPF inline float - ldexp(float __x, int __exp) { return ::ldexpf(__x, __exp); } + ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); } #else inline float ldexp(float __x, int __exp) @@ -323,7 +408,7 @@ namespace std #if _GLIBCPP_HAVE_LOGF inline float - log(float __x) { return ::logf(__x); } + log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); } #else inline float log(float __x) { return ::log(static_cast<double>(__x)); } @@ -341,7 +426,7 @@ namespace std #if _GLIBCPP_HAVE_LOG10F inline float - log10(float __x) { return ::log10f(__x); } + log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); } #else inline float log10(float __x) { return ::log10(static_cast<double>(__x)); } @@ -359,7 +444,7 @@ namespace std #if _GLIBCPP_HAVE_MODFF inline float - modf(float __x, float* __iptr) { return ::modff(__x, __iptr); } + modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); } #else inline float modf(float __x, float* __iptr) @@ -398,7 +483,7 @@ namespace std #if _GLIBCPP_HAVE_POWF inline float - pow(float __x, float __y) { return ::powf(__x, __y); } + pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); } #else inline float pow(float __x, float __y) @@ -440,7 +525,7 @@ namespace std #if _GLIBCPP_HAVE_SINHF inline float - sinh(float __x) { return ::sinhf(__x); } + sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); } #else inline float sinh(float __x) { return ::sinh(static_cast<double>(__x)); } @@ -468,7 +553,7 @@ namespace std #if _GLIBCPP_HAVE_TANF inline float - tan(float __x) { return ::tanf(__x); } + tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); } #else inline float tan(float __x) { return ::tan(static_cast<double>(__x)); } @@ -486,7 +571,7 @@ namespace std #if _GLIBCPP_HAVE_TANHF inline float - tanh(float __x) { return ::tanhf(__x); } + tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); } #else inline float tanh(float __x) { return ::tanh(static_cast<double>(__x)); } @@ -503,6 +588,7 @@ namespace std #if _GLIBCPP_USE_C99 +#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC // These are possible macros imported from C99-land. For strict // conformance, remove possible C99-injected names from the global // namespace, and sequester them in the __gnu_cxx extension namespace. @@ -561,6 +647,7 @@ namespace __gnu_cxx __capture_isunordered(_Tp __f1, _Tp __f2) { return isunordered(__f1, __f2); } } +#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */ #endif #undef fpclassify @@ -577,6 +664,7 @@ namespace __gnu_cxx #undef isunordered #if _GLIBCPP_USE_C99 +#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC namespace __gnu_cxx { template<typename _Tp> @@ -647,6 +735,7 @@ namespace std using __gnu_cxx::islessgreater; using __gnu_cxx::isunordered; } +#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */ #endif #ifdef _GLIBCPP_NO_TEMPLATE_EXPORT diff --git a/contrib/libstdc++/include/c_std/std_cstdio.h b/contrib/libstdc++/include/c_std/std_cstdio.h index 6fb8c79fb3d7..3b4a68567396 100644 --- a/contrib/libstdc++/include/c_std/std_cstdio.h +++ b/contrib/libstdc++/include/c_std/std_cstdio.h @@ -1,6 +1,6 @@ // -*- C++ -*- forwarding header. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -152,11 +152,24 @@ namespace std namespace __gnu_cxx { +#if _GLIBCPP_USE_C99_CHECK || _GLIBCPP_USE_C99_DYNAMIC + extern "C" int + (snprintf)(char * restrict, size_t, const char * restrict, ...); + extern "C" int + (vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list); + extern "C" int (vscanf)(const char * restrict, __gnuc_va_list); + extern "C" int + (vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list); + extern "C" int + (vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list); +#endif +#if !_GLIBCPP_USE_C99_DYNAMIC using ::snprintf; using ::vfscanf; using ::vscanf; using ::vsnprintf; using ::vsscanf; +#endif } namespace std diff --git a/contrib/libstdc++/include/c_std/std_cstdlib.h b/contrib/libstdc++/include/c_std/std_cstdlib.h index 70fc8d3452e4..e1436be1d7a1 100644 --- a/contrib/libstdc++/include/c_std/std_cstdlib.h +++ b/contrib/libstdc++/include/c_std/std_cstdlib.h @@ -1,6 +1,6 @@ // -*- C++ -*- forwarding header. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -135,8 +135,15 @@ namespace std namespace __gnu_cxx { +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC using ::lldiv_t; +#endif +#if _GLIBCPP_USE_C99_CHECK || _GLIBCPP_USE_C99_DYNAMIC + extern "C" void (_Exit)(int); +#endif +#if !_GLIBCPP_USE_C99_DYNAMIC using ::_Exit; +#endif inline long long abs(long long __x) { return __x >= 0 ? __x : -__x; } @@ -144,6 +151,7 @@ namespace __gnu_cxx inline long long llabs(long long __x) { return __x >= 0 ? __x : -__x; } +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC inline lldiv_t div(long long __n, long long __d) { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } @@ -151,22 +159,36 @@ namespace __gnu_cxx inline lldiv_t lldiv(long long __n, long long __d) { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } +#endif +#if _GLIBCPP_USE_C99_LONG_LONG_CHECK || _GLIBCPP_USE_C99_LONG_LONG_DYNAMIC + extern "C" long long int (atoll)(const char *); + extern "C" long long int + (strtoll)(const char * restrict, char ** restrict, int); + extern "C" unsigned long long int + (strtoull)(const char * restrict, char ** restrict, int); +#endif +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC using ::atoll; - using ::strtof; using ::strtoll; using ::strtoull; +#endif + using ::strtof; using ::strtold; } namespace std { +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC using __gnu_cxx::lldiv_t; +#endif using __gnu_cxx::_Exit; using __gnu_cxx::abs; using __gnu_cxx::llabs; +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC using __gnu_cxx::div; using __gnu_cxx::lldiv; +#endif using __gnu_cxx::atoll; using __gnu_cxx::strtof; using __gnu_cxx::strtoll; diff --git a/contrib/libstdc++/include/c_std/std_cwchar.h b/contrib/libstdc++/include/c_std/std_cwchar.h index f67f00610f50..8b33c52282f1 100644 --- a/contrib/libstdc++/include/c_std/std_cwchar.h +++ b/contrib/libstdc++/include/c_std/std_cwchar.h @@ -1,6 +1,6 @@ // -*- C++ -*- forwarding header. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -225,9 +225,23 @@ namespace std namespace __gnu_cxx { +#if _GLIBCPP_USE_C99_CHECK || _GLIBCPP_USE_C99_DYNAMIC + extern "C" long double + (wcstold)(const wchar_t * restrict, wchar_t ** restrict); +#endif +#if !_GLIBCPP_USE_C99_DYNAMIC using ::wcstold; +#endif +#if _GLIBCPP_USE_C99_LONG_LONG_CHECK || _GLIBCPP_USE_C99_LONG_LONG_DYNAMIC + extern "C" long long int + (wcstoll)(const wchar_t * restrict, wchar_t ** restrict, int); + extern "C" unsigned long long int + (wcstoull)(const wchar_t * restrict, wchar_t ** restrict, int); +#endif +#if !_GLIBCPP_USE_C99_LONG_LONG_DYNAMIC using ::wcstoll; using ::wcstoull; +#endif } namespace std diff --git a/contrib/libstdc++/include/ext/stdio_filebuf.h b/contrib/libstdc++/include/ext/stdio_filebuf.h index 59ab41a03e55..4c6bf90a7c41 100644 --- a/contrib/libstdc++/include/ext/stdio_filebuf.h +++ b/contrib/libstdc++/include/ext/stdio_filebuf.h @@ -58,6 +58,7 @@ namespace __gnu_cxx typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; + typedef std::size_t size_t; protected: // Stack-based buffer for unbuffered input. @@ -75,7 +76,7 @@ namespace __gnu_cxx * file will be closed when the stdio_filebuf is closed/destroyed. */ stdio_filebuf(int __fd, std::ios_base::openmode __mode, bool __del, - int_type __size); + size_t __size); /** * @param f An open @c FILE*. @@ -88,7 +89,7 @@ namespace __gnu_cxx * stdio_filebuf is closed/destroyed. */ stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, - int_type __size = static_cast<int_type>(BUFSIZ)); + size_t __size = static_cast<size_t>(BUFSIZ)); /** * Possibly closes the external data stream, in the case of the file @@ -117,7 +118,7 @@ namespace __gnu_cxx template<typename _CharT, typename _Traits> stdio_filebuf<_CharT, _Traits>:: stdio_filebuf(int __fd, std::ios_base::openmode __mode, bool __del, - int_type __size) + size_t __size) { _M_file.sys_open(__fd, __mode, __del); if (this->is_open()) @@ -125,7 +126,7 @@ namespace __gnu_cxx _M_mode = __mode; if (__size > 0 && __size < 4) { - // Specify unbuffered. + // Specify not to use an allocated buffer. _M_buf = _M_unbuf; _M_buf_size = __size; _M_buf_size_opt = 0; @@ -142,7 +143,7 @@ namespace __gnu_cxx template<typename _CharT, typename _Traits> stdio_filebuf<_CharT, _Traits>:: stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, - int_type __size) + size_t __size) { _M_file.sys_open(__f, __mode); if (this->is_open()) @@ -150,7 +151,7 @@ namespace __gnu_cxx _M_mode = __mode; if (__size > 0 && __size < 4) { - // Specify unbuffered. + // Specify not to use an allocated buffer. _M_buf = _M_unbuf; _M_buf_size = __size; _M_buf_size_opt = 0; diff --git a/contrib/libstdc++/include/ext/stl_hashtable.h b/contrib/libstdc++/include/ext/stl_hashtable.h index 2bc8a2fcec0a..b41c821f6035 100644 --- a/contrib/libstdc++/include/ext/stl_hashtable.h +++ b/contrib/libstdc++/include/ext/stl_hashtable.h @@ -65,13 +65,10 @@ // Hashtable class, used to implement the hashed associative containers // hash_set, hash_map, hash_multiset, and hash_multimap. -#include <bits/stl_algobase.h> -#include <bits/stl_alloc.h> -#include <bits/stl_construct.h> +#include <vector> +#include <iterator> #include <bits/stl_algo.h> -#include <bits/stl_uninitialized.h> #include <bits/stl_function.h> -#include <bits/stl_vector.h> #include <ext/stl_hash_fun.h> namespace __gnu_cxx diff --git a/contrib/libstdc++/include/std/std_bitset.h b/contrib/libstdc++/include/std/std_bitset.h index fe60b01f347c..ebe16504d188 100644 --- a/contrib/libstdc++/include/std/std_bitset.h +++ b/contrib/libstdc++/include/std/std_bitset.h @@ -219,7 +219,7 @@ namespace std void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) { - if (__shift != 0) + if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD; const size_t __offset = __shift % _GLIBCPP_BITSET_BITS_PER_WORD; @@ -244,7 +244,7 @@ namespace std void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) { - if (__shift != 0) + if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD; const size_t __offset = __shift % _GLIBCPP_BITSET_BITS_PER_WORD; @@ -570,6 +570,7 @@ namespace std struct _Sanitize<0> { static void _S_do_sanitize(unsigned long) { } }; + /** * @brief The %bitset class represents a @e fixed-size sequence of bits. * @@ -578,17 +579,19 @@ namespace std * (Note that %bitset does @e not meet the formal requirements of a * <a href="tables.html#65">container</a>. Mainly, it lacks iterators.) * - * The template argument, @a _Nb, may be any nonzero number of type - * size_t. + * The template argument, @a Nb, may be any non-negative number, + * specifying the number of bits (e.g., "0", "12", "1024*1024"). * - * A %bitset of size N has N % (sizeof(unsigned long) * CHAR_BIT) unused - * bits. (They are the high-order bits in the highest word.) It is - * a class invariant that those unused bits are always zero. + * In the general unoptimized case, storage is allocated in word-sized + * blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B + * words will be used for storage. B - Nb%B bits are unused. (They are + * the high-order bits in the highest word.) It is a class invariant + * that those unused bits are always zero. * * If you think of %bitset as "a simple array of bits," be aware that * your mental picture is reversed: a %bitset behaves the same way as * bits in integers do, with the bit at index 0 in the "least significant - * / right-hand" position, and the bit at index N-1 in the "most + * / right-hand" position, and the bit at index Nb-1 in the "most * significant / left-hand" position. Thus, unlike other containers, a * %bitset's index "counts from right to left," to put it very loosely. * @@ -619,6 +622,7 @@ namespace std * @endcode * * Also see http://gcc.gnu.org/onlinedocs/libstdc++/ext/sgiexts.html#ch23 + * for a description of extensions. * * @if maint * Most of the actual code isn't contained in %bitset<> itself, but in the @@ -805,16 +809,26 @@ namespace std bitset<_Nb>& operator<<=(size_t __pos) { - this->_M_do_left_shift(__pos); - this->_M_do_sanitize(); + if (__builtin_expect(__pos < _Nb, 1)) + { + this->_M_do_left_shift(__pos); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); return *this; } bitset<_Nb>& operator>>=(size_t __pos) { - this->_M_do_right_shift(__pos); - this->_M_do_sanitize(); + if (__builtin_expect(__pos < _Nb, 1)) + { + this->_M_do_right_shift(__pos); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); return *this; } //@} @@ -1183,6 +1197,7 @@ namespace std typename basic_istream<_CharT, _Traits>::sentry __sentry(__is); if (__sentry) { + ios_base::iostate __state = ios_base::goodbit; basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf(); for (size_t __i = 0; __i < _Nb; ++__i) { @@ -1191,7 +1206,7 @@ namespace std typename _Traits::int_type __c1 = __buf->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { - __is.setstate(ios_base::eofbit); + __state |= ios_base::eofbit; break; } else @@ -1201,19 +1216,21 @@ namespace std if (__c == '0' || __c == '1') __tmp.push_back(__c); - else if (_Traits::eq_int_type(__buf->sputbackc(__c2), - __eof)) + else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) { - __is.setstate(ios_base::failbit); + __state |= ios_base::failbit; break; } } } if (__tmp.empty() && !_Nb) - __is.setstate(ios_base::failbit); + __state |= ios_base::failbit; else __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb); + + if (__state != ios_base::goodbit) + __is.setstate(__state); // may throw an exception } return __is; diff --git a/contrib/libstdc++/include/std/std_complex.h b/contrib/libstdc++/include/std/std_complex.h index bcfcedde8e9a..252070b13895 100644 --- a/contrib/libstdc++/include/std/std_complex.h +++ b/contrib/libstdc++/include/std/std_complex.h @@ -390,7 +390,7 @@ namespace std __s.flags(__os.flags()); __s.imbue(__os.getloc()); __s.precision(__os.precision()); - __s << '(' << __x.real() << "," << __x.imag() << ')'; + __s << '(' << __x.real() << ',' << __x.imag() << ')'; return __os << __s.str(); } @@ -456,7 +456,7 @@ namespace std inline _Tp norm(const complex<_Tp>& __z) { - return _Norm_helper<__is_floating<_Tp>::_M_type>::_S_do_it(__z); + return _Norm_helper<__is_floating<_Tp>::_M_type && !_GLIBCPP_FAST_MATH>::_S_do_it(__z); } template<typename _Tp> @@ -565,24 +565,30 @@ namespace std } template<typename _Tp> - inline complex<_Tp> + complex<_Tp> pow(const complex<_Tp>& __x, const _Tp& __y) { - return exp(__y * log(__x)); + if (__x.imag() == _Tp()) + return pow(__x.real(), __y); + + complex<_Tp> __t = log(__x); + return polar(exp(__y * __t.real()), __y * __t.imag()); } template<typename _Tp> inline complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) { - return exp(__y * log(__x)); + return __x == _Tp() ? _Tp() : exp(__y * log(__x)); } template<typename _Tp> inline complex<_Tp> pow(const _Tp& __x, const complex<_Tp>& __y) { - return exp(__y * log(__x)); + return __x == _Tp() + ? _Tp() + : polar(pow(__x, __y.real()), __y.imag() * log(__x)); } // 26.2.3 complex specializations diff --git a/contrib/libstdc++/include/std/std_deque.h b/contrib/libstdc++/include/std/std_deque.h index 0fca0d1a3d49..921c25fa4931 100644 --- a/contrib/libstdc++/include/std/std_deque.h +++ b/contrib/libstdc++/include/std/std_deque.h @@ -70,8 +70,9 @@ #include <bits/stl_uninitialized.h> #include <bits/stl_deque.h> +#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT +# include <bits/deque.tcc> +#endif + #endif /* _CPP_DEQUE */ -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/std/std_fstream.h b/contrib/libstdc++/include/std/std_fstream.h index 838b99dc08bd..bcbbb971946a 100644 --- a/contrib/libstdc++/include/std/std_fstream.h +++ b/contrib/libstdc++/include/std/std_fstream.h @@ -50,6 +50,15 @@ namespace std { + // [27.8.1.1] template class basic_filebuf + /** + * @brief The actual work of input and output (for files). + * + * This class associates both its input and output sequence with an + * external disk file, and maintains a joint file position for both + * sequences. Many of its sematics are described in terms of similar + * behavior in the Standard C Library's @c FILE streams. + */ template<typename _CharT, typename _Traits> class basic_filebuf : public basic_streambuf<_CharT, _Traits> { @@ -61,30 +70,55 @@ namespace std typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; - // Non-standard Types: + //@{ + /** + * @if maint + * @doctodo + * @endif + */ typedef basic_streambuf<char_type, traits_type> __streambuf_type; typedef basic_filebuf<char_type, traits_type> __filebuf_type; typedef __basic_file<char> __file_type; typedef typename traits_type::state_type __state_type; typedef codecvt<char_type, char, __state_type> __codecvt_type; - typedef typename __codecvt_type::result __res_type; typedef ctype<char_type> __ctype_type; + //@} friend class ios_base; // For sync_with_stdio. protected: // Data Members: // MT lock inherited from libio or other low-level io library. + /** + * @if maint + * @doctodo + * @endif + */ __c_lock _M_lock; // External buffer. + /** + * @if maint + * @doctodo + * @endif + */ __file_type _M_file; // Current and beginning state type for codecvt. + /** + * @if maint + * @doctodo + * @endif + */ __state_type _M_state_cur; __state_type _M_state_beg; // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. + /** + * @if maint + * @doctodo + * @endif + */ bool _M_buf_allocated; // XXX Needed? @@ -92,12 +126,26 @@ namespace std // The position in the buffer corresponding to the external file // pointer. + /** + * @if maint + * @doctodo + * @endif + */ char_type* _M_filepos; public: // Constructors/destructor: + /** + * @brief Does not open any files. + * + * The default constructor initializes the parent class using its + * own default ctor. + */ basic_filebuf(); + /** + * @brief The destructor closes the file first. + */ virtual ~basic_filebuf() { @@ -106,23 +154,61 @@ namespace std } // Members: + /** + * @brief Returns true if the external file is open. + */ bool - is_open() const { return _M_file.is_open(); } + is_open() const throw() { return _M_file.is_open(); } + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * @return @c this on success, NULL on failure + * + * If a file is already open, this function immediately fails. + * Otherwise it tries to open the file named @a s using the flags + * given in @a mode. + * + * [Table 92 gives the relation between openmode combinations and the + * equivalent fopen() flags, but the table has not been copied yet.] + */ __filebuf_type* open(const char* __s, ios_base::openmode __mode); + /** + * @brief Closes the currently associated file. + * @return @c this on success, NULL on failure + * + * If no file is currently open, this function immediately fails. + * + * If a "put buffer area" exists, @c overflow(eof) is called to flush + * all the characters. The file is then closed. + * + * If any operations fail, this function also fails. + */ __filebuf_type* - close(); + close() throw(); protected: + /** + * @if maint + * @doctodo + * @endif + */ void _M_allocate_internal_buffer(); + /** + * @if maint + * @doctodo + * @endif + */ void - _M_destroy_internal_buffer(); + _M_destroy_internal_buffer() throw(); - // Overridden virtual functions: + // [27.8.1.4] overridden virtual functions + // [documentation is inherited] virtual streamsize showmanyc(); @@ -137,15 +223,23 @@ namespace std // the underflow() case in order to maintain synchronization. So // instead of calling underflow() from uflow(), we create a common // subroutine to do the real work. + /** + * @if maint + * @doctodo + * @endif + */ int_type _M_underflow_common(bool __bump); + // [documentation is inherited] virtual int_type underflow(); + // [documentation is inherited] virtual int_type uflow(); + // [documentation is inherited] virtual int_type pbackfail(int_type __c = _Traits::eof()); @@ -157,6 +251,8 @@ namespace std // this in actuality be a helper function that checks for the // eccentricities of this implementation, and then call // overflow() if indeed the buffer is full. + + // [documentation is inherited] virtual int_type overflow(int_type __c = _Traits::eof()); @@ -167,28 +263,54 @@ namespace std // character c. // 27.5.2.4.5 // Consume some sequence of the characters in the pending sequence. + /** + * @if maint + * @doctodo + * @endif + */ int_type _M_really_overflow(int_type __c = _Traits::eof()); // Convert internal byte sequence to external, char-based // sequence via codecvt. + /** + * @if maint + * @doctodo + * @endif + */ void _M_convert_to_external(char_type*, streamsize, streamsize&, streamsize&); + /** + * @brief Manipulates the buffer. + * @param s Pointer to a buffer area. + * @param n Size of @a s. + * @return @c this + * + * If no file has been opened, and both @a s and @a n are zero, then + * the stream becomes unbuffered. Otherwise, @c s is used as a + * buffer; see + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 + * for more. + */ virtual __streambuf_type* setbuf(char_type* __s, streamsize __n); + // [documentation is inherited] virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); + // [documentation is inherited] virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode = ios_base::in | ios_base::out); + // [documentation is inherited] virtual int sync() { + int __ret = 0; bool __testput = _M_out_cur && _M_out_beg < _M_out_end; // Make sure that the internal buffer resyncs its idea of @@ -197,19 +319,26 @@ namespace std { // Need to restore current position after the write. off_type __off = _M_out_cur - _M_out_end; - _M_really_overflow(); // _M_file.sync() will be called within - if (__off) + + // _M_file.sync() will be called within + if (traits_type::eq_int_type(_M_really_overflow(), + traits_type::eof())) + __ret = -1; + else if (__off) _M_file.seekoff(__off, ios_base::cur); } else _M_file.sync(); + _M_last_overflowed = false; - return 0; + return __ret; } + // [documentation is inherited] virtual void imbue(const locale& __loc); + // [documentation is inherited] virtual streamsize xsgetn(char_type* __s, streamsize __n) { @@ -231,6 +360,7 @@ namespace std return __ret; } + // [documentation is inherited] virtual streamsize xsputn(const char_type* __s, streamsize __n) { @@ -238,6 +368,11 @@ namespace std return __streambuf_type::xsputn(__s, __n); } + /** + * @if maint + * @doctodo + * @endif + */ void _M_output_unshift(); @@ -248,6 +383,11 @@ namespace std // internal buffer does not truly reflect the contents of the // external buffer. At this point, for whatever reason, it is in // an indeterminate state. + /** + * @if maint + * @doctodo + * @endif + */ void _M_set_indeterminate(void) { @@ -258,6 +398,11 @@ namespace std _M_filepos = _M_buf; } + /** + * @if maint + * @doctodo + * @endif + */ void _M_set_determinate(off_type __off) { @@ -270,6 +415,11 @@ namespace std _M_filepos = _M_buf + __off; } + /** + * @if maint + * @doctodo + * @endif + */ bool _M_is_indeterminate(void) { @@ -286,7 +436,7 @@ namespace std } }; - // Explicit specializations. + // Explicit specialization declarations, defined in src/fstream.cc. template<> basic_filebuf<char>::int_type basic_filebuf<char>::_M_underflow_common(bool __bump); @@ -299,19 +449,24 @@ namespace std // Generic definitions. template <typename _CharT, typename _Traits> - basic_filebuf<_CharT, _Traits>::int_type + typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::underflow() { return _M_underflow_common(false); } template <typename _CharT, typename _Traits> - basic_filebuf<_CharT, _Traits>::int_type + typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::uflow() { return _M_underflow_common(true); } - // 27.8.1.5 Template class basic_ifstream + // [27.8.1.5] Template class basic_ifstream /** - * Derivation of general input streams, specific to files. + * @brief Controlling input for files. + * + * This class supports reading from named files, using the inherited + * functions from std::basic_istream. To control the associated + * sequence, an instance of std::basic_filebuf is used, which this page + * refers to as @c sb. */ template<typename _CharT, typename _Traits> class basic_ifstream : public basic_istream<_CharT, _Traits> @@ -329,20 +484,33 @@ namespace std typedef basic_istream<char_type, traits_type> __istream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __filebuf_type _M_filebuf; public: - // Constructors/Destructors: - /** Default constructor. Create an input file stream. */ + // Constructors/Destructors: + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ basic_ifstream() : __istream_type(NULL), _M_filebuf() { this->init(&_M_filebuf); } /** - * @brief Create an input file stream. - * @param s Null terminated string specifying filename. + * @brief Create an input file stream. + * @param s Null terminated string specifying the filename. * @param mode Open file in specified mode (see std::ios_base). * + * @c ios_base::in is automatically included in @a mode. + * * Tip: When using std::string to hold the filename, you must use * .c_str() before passing it to this constructor. */ @@ -354,21 +522,44 @@ namespace std this->open(__s, __mode); } + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ ~basic_ifstream() { } // Members: /** - * @brief Get a pointer to the file stream's buffer. - * @return Pointer to basic_filebuf. + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). */ __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } + /** + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() + */ bool is_open() { return _M_filebuf.is_open(); } + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|in). If that function + * fails, @c failbit is set in the stream's error state. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ void open(const char* __s, ios_base::openmode __mode = ios_base::in) { @@ -376,7 +567,12 @@ namespace std this->setstate(ios_base::failbit); } - /** Close the file. */ + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ void close() { @@ -386,9 +582,14 @@ namespace std }; - // 27.8.1.8 Template class basic_ofstream + // [27.8.1.8] Template class basic_ofstream /** - * Derivation of general output streams, specific to files. + * @brief Controlling output for files. + * + * This class supports reading from named files, using the inherited + * functions from std::basic_ostream. To control the associated + * sequence, an instance of std::basic_filebuf is used, which this page + * refers to as @c sb. */ template<typename _CharT, typename _Traits> class basic_ofstream : public basic_ostream<_CharT,_Traits> @@ -406,20 +607,34 @@ namespace std typedef basic_ostream<char_type, traits_type> __ostream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __filebuf_type _M_filebuf; public: // Constructors: - /** Default constructor for output file_stream. */ + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ basic_ofstream() : __ostream_type(NULL), _M_filebuf() { this->init(&_M_filebuf); } /** - * @brief Create an output stream. - * @param s Null terminated string specifying filename. + * @brief Create an output file stream. + * @param s Null terminated string specifying the filename. * @param mode Open file in specified mode (see std::ios_base). * + * @c ios_base::out|ios_base::trunc is automatically included in + * @a mode. + * * Tip: When using std::string to hold the filename, you must use * .c_str() before passing it to this constructor. */ @@ -432,29 +647,40 @@ namespace std this->open(__s, __mode); } + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ ~basic_ofstream() { } // Members: /** - * @brief Get a pointer to the file stream's buffer. - * @return Pointer to basic_filebuf. + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). */ __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } /** - * @brief Query to see if file stream is open. - * @return True if stream is open. + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() */ bool is_open() { return _M_filebuf.is_open(); } /** - * @brief Specify a file to open for output. - * @param s Null terminated string specifying filename. - * @param mode Mode in which to open file (see std::ios_base). + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that + * function fails, @c failbit is set in the stream's error state. * * Tip: When using std::string to hold the filename, you must use * .c_str() before passing it to this constructor. @@ -467,7 +693,12 @@ namespace std this->setstate(ios_base::failbit); } - /** Close the file stream. */ + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ void close() { @@ -477,9 +708,14 @@ namespace std }; - // 27.8.1.11 Template class basic_fstream + // [27.8.1.11] Template class basic_fstream /** - * Derivation of general input/output streams, specific to files. + * @brief Controlling intput and output for files. + * + * This class supports reading from and writing to named files, using + * the inherited functions from std::basic_iostream. To control the + * associated sequence, an instance of std::basic_filebuf is used, which + * this page refers to as @c sb. */ template<typename _CharT, typename _Traits> class basic_fstream : public basic_iostream<_CharT, _Traits> @@ -498,18 +734,29 @@ namespace std typedef basic_iostream<char_type, traits_type> __iostream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __filebuf_type _M_filebuf; public: // Constructors/destructor: - /** Default constructor. Create a file stream. */ + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ basic_fstream() : __iostream_type(NULL), _M_filebuf() { this->init(&_M_filebuf); } /** - * @brief Create an input/output stream. - * @param s Null terminated string specifying filename. + * @brief Create an input/output file stream. + * @param s Null terminated string specifying the filename. * @param mode Open file in specified mode (see std::ios_base). * * Tip: When using std::string to hold the filename, you must use @@ -524,29 +771,40 @@ namespace std this->open(__s, __mode); } + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ ~basic_fstream() { } // Members: /** - * @brief Get a pointer to the file stream's buffer. - * @return Pointer to basic_filebuf. + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). */ __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } /** - * @brief Query to see if file stream is open. - * @return True if stream is open. + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() */ bool is_open() { return _M_filebuf.is_open(); } /** - * @brief Specify a file to open for input and/or output. - * @param s Null terminated string specifying filename. - * @param mode Mode in which to open file (see std::ios_base). + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode). If that + * function fails, @c failbit is set in the stream's error state. * * Tip: When using std::string to hold the filename, you must use * .c_str() before passing it to this constructor. @@ -559,7 +817,12 @@ namespace std setstate(ios_base::failbit); } - /** Close the file stream. */ + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ void close() { diff --git a/contrib/libstdc++/include/std/std_iomanip.h b/contrib/libstdc++/include/std/std_iomanip.h index 23237ce210d6..490d5ac1cfba 100644 --- a/contrib/libstdc++/include/std/std_iomanip.h +++ b/contrib/libstdc++/include/std/std_iomanip.h @@ -1,6 +1,7 @@ // Standard stream manipulators -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003 +// 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 @@ -47,8 +48,18 @@ namespace std { + // [27.6.3] standard manipulators + // Also see DR 183. + struct _Resetiosflags { ios_base::fmtflags _M_mask; }; + /** + * @brief Manipulator for @c setf. + * @param mask A format flags mask. + * + * Sent to a stream object, this manipulator resets the specified flags, + * via @e stream.setf(0,mask). + */ inline _Resetiosflags resetiosflags(ios_base::fmtflags __mask) { @@ -76,6 +87,13 @@ namespace std struct _Setiosflags { ios_base::fmtflags _M_mask; }; + /** + * @brief Manipulator for @c setf. + * @param mask A format flags mask. + * + * Sent to a stream object, this manipulator sets the format flags + * to @a mask. + */ inline _Setiosflags setiosflags(ios_base::fmtflags __mask) { @@ -103,6 +121,14 @@ namespace std struct _Setbase { int _M_base; }; + /** + * @brief Manipulator for @c setf. + * @param base A numeric base. + * + * Sent to a stream object, this manipulator changes the + * @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base + * is 8, 10, or 16, accordingly, and to 0 if @a base is any other value. + */ inline _Setbase setbase(int __base) { @@ -137,6 +163,13 @@ namespace std template<typename _CharT> struct _Setfill { _CharT _M_c; }; + /** + * @brief Manipulator for @c fill. + * @param c The new fill character. + * + * Sent to a stream object, this manipulator calls @c fill(c) for that + * object. + */ template<typename _CharT> inline _Setfill<_CharT> setfill(_CharT __c) @@ -165,6 +198,13 @@ namespace std struct _Setprecision { int _M_n; }; + /** + * @brief Manipulator for @c precision. + * @param n The new precision. + * + * Sent to a stream object, this manipulator calls @c precision(n) for + * that object. + */ inline _Setprecision setprecision(int __n) { @@ -192,6 +232,13 @@ namespace std struct _Setw { int _M_n; }; + /** + * @brief Manipulator for @c width. + * @param n The new width. + * + * Sent to a stream object, this manipulator calls @c width(n) for + * that object. + */ inline _Setw setw(int __n) { @@ -219,6 +266,7 @@ namespace std // Inhibit implicit instantiations for required instantiations, // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. +#if _GLIBCPP_EXTERN_TEMPLATE extern template ostream& operator<<(ostream&, _Setfill<char>); extern template ostream& operator<<(ostream&, _Setiosflags); extern template ostream& operator<<(ostream&, _Resetiosflags); @@ -246,6 +294,7 @@ namespace std extern template wistream& operator>>(wistream&, _Setprecision); extern template wistream& operator>>(wistream&, _Setw); #endif +#endif } // namespace std #endif diff --git a/contrib/libstdc++/include/std/std_iosfwd.h b/contrib/libstdc++/include/std/std_iosfwd.h index 797f4936dc8a..55b0e0b19fa7 100644 --- a/contrib/libstdc++/include/std/std_iosfwd.h +++ b/contrib/libstdc++/include/std/std_iosfwd.h @@ -1,6 +1,7 @@ // Forwarding declarations -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003 +// 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 @@ -42,7 +43,9 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <bits/stringfwd.h> // For string forward declarations. +#include <bits/c++locale.h> +#include <cctype> // For isspace, etc. +#include <bits/stringfwd.h> // For string forward declarations. #include <bits/fpos.h> #include <bits/functexcept.h> @@ -102,35 +105,64 @@ namespace std class ios_base; #endif - typedef basic_ios<char> ios; - typedef basic_streambuf<char> streambuf; - typedef basic_istream<char> istream; - typedef basic_ostream<char> ostream; - typedef basic_iostream<char> iostream; - typedef basic_stringbuf<char> stringbuf; - typedef basic_istringstream<char> istringstream; - typedef basic_ostringstream<char> ostringstream; - typedef basic_stringstream<char> stringstream; - typedef basic_filebuf<char> filebuf; - typedef basic_ifstream<char> ifstream; - typedef basic_ofstream<char> ofstream; - typedef basic_fstream<char> fstream; + /** + * @defgroup s27_2_iosfwd I/O Forward Declarations + * + * Nearly all of the I/O classes are parameterized on the type of + * characters they read and write. (The major exception is ios_base at + * the top of the hierarchy.) This is a change from pre-Standard + * streams, which were not templates. + * + * For ease of use and compatibility, all of the basic_* I/O-related + * classes are given typedef names for both of the builtin character + * widths (wide and narrow). The typedefs are the same as the + * pre-Standard names, for example: + * + * @code + * typedef basic_ifstream<char> ifstream; + * @endcode + * + * Because properly forward-declaring these classes can be difficult, you + * should not do it yourself. Instead, include the <iosfwd> + * header, which contains only declarations of all the I/O classes as + * well as the typedefs. Trying to forward-declare the typedefs + * themselves (e.g., "class ostream;") is not valid ISO C++. + * + * For more specific declarations, see + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#10 + * + * @{ + */ + typedef basic_ios<char> ios; ///< @isiosfwd + typedef basic_streambuf<char> streambuf; ///< @isiosfwd + typedef basic_istream<char> istream; ///< @isiosfwd + typedef basic_ostream<char> ostream; ///< @isiosfwd + typedef basic_iostream<char> iostream; ///< @isiosfwd + typedef basic_stringbuf<char> stringbuf; ///< @isiosfwd + typedef basic_istringstream<char> istringstream; ///< @isiosfwd + typedef basic_ostringstream<char> ostringstream; ///< @isiosfwd + typedef basic_stringstream<char> stringstream; ///< @isiosfwd + typedef basic_filebuf<char> filebuf; ///< @isiosfwd + typedef basic_ifstream<char> ifstream; ///< @isiosfwd + typedef basic_ofstream<char> ofstream; ///< @isiosfwd + typedef basic_fstream<char> fstream; ///< @isiosfwd #ifdef _GLIBCPP_USE_WCHAR_T - typedef basic_ios<wchar_t> wios; - typedef basic_streambuf<wchar_t> wstreambuf; - typedef basic_istream<wchar_t> wistream; - typedef basic_ostream<wchar_t> wostream; - typedef basic_iostream<wchar_t> wiostream; - typedef basic_stringbuf<wchar_t> wstringbuf; - typedef basic_istringstream<wchar_t> wistringstream; - typedef basic_ostringstream<wchar_t> wostringstream; - typedef basic_stringstream<wchar_t> wstringstream; - typedef basic_filebuf<wchar_t> wfilebuf; - typedef basic_ifstream<wchar_t> wifstream; - typedef basic_ofstream<wchar_t> wofstream; - typedef basic_fstream<wchar_t> wfstream; + typedef basic_ios<wchar_t> wios; ///< @isiosfwd + typedef basic_streambuf<wchar_t> wstreambuf; ///< @isiosfwd + typedef basic_istream<wchar_t> wistream; ///< @isiosfwd + typedef basic_ostream<wchar_t> wostream; ///< @isiosfwd + typedef basic_iostream<wchar_t> wiostream; ///< @isiosfwd + typedef basic_stringbuf<wchar_t> wstringbuf; ///< @isiosfwd + typedef basic_istringstream<wchar_t> wistringstream; ///< @isiosfwd + typedef basic_ostringstream<wchar_t> wostringstream; ///< @isiosfwd + typedef basic_stringstream<wchar_t> wstringstream; ///< @isiosfwd + typedef basic_filebuf<wchar_t> wfilebuf; ///< @isiosfwd + typedef basic_ifstream<wchar_t> wifstream; ///< @isiosfwd + typedef basic_ofstream<wchar_t> wofstream; ///< @isiosfwd + typedef basic_fstream<wchar_t> wfstream; ///< @isiosfwd #endif + /** @} */ } // namespace std #endif diff --git a/contrib/libstdc++/include/std/std_iostream.h b/contrib/libstdc++/include/std/std_iostream.h index d0736b835132..d70949377df1 100644 --- a/contrib/libstdc++/include/std/std_iostream.h +++ b/contrib/libstdc++/include/std/std_iostream.h @@ -47,17 +47,31 @@ namespace std { - extern istream cin; - extern ostream cout; - extern ostream cerr; - extern ostream clog; + /** + * @name Standard Stream Objects + * + * The <iostream> header declares the eight <em>standard stream + * objects</em>. For other declarations, see + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#10 and the + * @link s27_2_iosfwd I/O forward declarations @endlink + * + * They are required by default to cooperate with the global C library's + * @c FILE streams, and to be available during program startup and + * termination. For more information, see the HOWTO linked to above. + */ + //@{ + extern istream cin; ///< Linked to standard input + extern ostream cout; ///< Linked to standard output + extern ostream cerr; ///< Linked to standard error (unbuffered) + extern ostream clog; ///< Linked to standard error (buffered) #ifdef _GLIBCPP_USE_WCHAR_T - extern wistream wcin; - extern wostream wcout; - extern wostream wcerr; - extern wostream wclog; + extern wistream wcin; ///< Linked to standard input + extern wostream wcout; ///< Linked to standard output + extern wostream wcerr; ///< Linked to standard error (unbuffered) + extern wostream wclog; ///< Linked to standard error (buffered) #endif + //@} // For construction of filebuffers for cout, cin, cerr, clog et. al. static ios_base::Init __ioinit; diff --git a/contrib/libstdc++/include/std/std_istream.h b/contrib/libstdc++/include/std/std_istream.h index 8aa9123ed5c5..da9c7db18838 100644 --- a/contrib/libstdc++/include/std/std_istream.h +++ b/contrib/libstdc++/include/std/std_istream.h @@ -46,7 +46,14 @@ namespace std { - // 27.6.1.1 Template class basic_istream + // [27.6.1.1] Template class basic_istream + /** + * @brief Controlling input. + * + * This is the base class for all input streams. It provides text + * formatting of all builtin types, and communicates with any class + * derived from basic_streambuf to do the actual input. + */ template<typename _CharT, typename _Traits> class basic_istream : virtual public basic_ios<_CharT, _Traits> { @@ -66,12 +73,33 @@ namespace std typedef num_get<_CharT, __istreambuf_iter> __numget_type; typedef ctype<_CharT> __ctype_type; + template<typename _CharT2, typename _Traits2> + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&); + + template<typename _CharT2, typename _Traits2> + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); + protected: // Data Members: + /** + * @if maint + * The number of characters extracted in the previous unformatted + * function; see gcount(). + * @endif + */ streamsize _M_gcount; public: - // 27.6.1.1.1 Constructor/destructor: + // [27.6.1.1.1] constructor/destructor + /** + * @brief Base constructor. + * + * This ctor is almost never called by the user directly, rather from + * derived classes' initialization lists, which pass a pointer to + * their own stream buffer. + */ explicit basic_istream(__streambuf_type* __sb) { @@ -79,16 +107,29 @@ namespace std _M_gcount = streamsize(0); } + /** + * @brief Base destructor. + * + * This does very little apart from providing a virtual base dtor. + */ virtual ~basic_istream() { _M_gcount = streamsize(0); } - // 27.6.1.1.2 Prefix/suffix: + // [27.6.1.1.2] prefix/suffix class sentry; friend class sentry; - // 27.6.1.2 Formatted input: - // 27.6.1.2.3 basic_istream::operator>> + // [27.6.1.2] formatted input + // [27.6.1.2.3] basic_istream::operator>> + //@{ + /** + * @brief Interface for manipulators. + * + * Manuipulators such as @c std::ws and @c std::dec use these + * functions in constructs like "std::cin >> std::ws". For more + * information, see the iomanip header. + */ __istream_type& operator>>(__istream_type& (*__pf)(__istream_type&)); @@ -97,8 +138,36 @@ namespace std __istream_type& operator>>(ios_base& (*__pf)(ios_base&)); + //@} - // 27.6.1.2.2 Arithmetic Extractors + // [27.6.1.2.2] arithmetic extractors + /** + * @name Arithmetic Extractors + * + * All the @c operator>> functions (aka <em>formatted input + * functions</em>) have some common behavior. Each starts by + * constructing a temporary object of type std::basic_istream::sentry + * with the second argument (noskipws) set to false. This has several + * effects, concluding with the setting of a status flag; see the + * sentry documentation for more. + * + * If the sentry status is good, the function tries to extract + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during extraction, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Basic arithmetic extractors + * @param A variable of builtin type. + * @return @c *this if successful + * + * These functions use the stream's current locale (specifically, the + * @c num_get facet) to parse the input data. + */ __istream_type& operator>>(bool& __n); @@ -140,92 +209,431 @@ namespace std __istream_type& operator>>(void*& __p); + /** + * @brief Extracting into another streambuf. + * @param sb A pointer to a streambuf + * + * This function behaves like one of the basic arithmetic extractors, + * in that it also constructs a sentry onject and has the same error + * handling behavior. + * + * If @a sb is NULL, the stream will set failbit in its error state. + * + * Characters are extracted from this stream and inserted into the + * @a sb streambuf until one of the following occurs: + * + * - the input stream reaches end-of-file, + * - insertion into the output buffer fails (in this case, the + * character that would have been inserted is not extracted), or + * - an exception occurs (and in this case is caught) + * + * If the function inserts no characters, failbit is set. + */ __istream_type& operator>>(__streambuf_type* __sb); + //@} - // 27.6.1.3 Unformatted input: + // [27.6.1.3] unformatted input + /** + * @brief Character counting + * @return The number of characters extracted by the previous + * unformatted input function dispatched for this stream. + */ inline streamsize - gcount(void) const + gcount() const { return _M_gcount; } + /** + * @name Unformatted Input Functions + * + * All the unformatted input functions have some common behavior. + * Each starts by constructing a temporary object of type + * std::basic_istream::sentry with the second argument (noskipws) + * set to true. This has several effects, concluding with the + * setting of a status flag; see the sentry documentation for more. + * + * If the sentry status is good, the function tries to extract + * whatever data is appropriate for the type of the argument. + * + * The number of characters extracted is stored for later retrieval + * by gcount(). + * + * If an exception is thrown during extraction, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Simple extraction. + * @return A character, or eof(). + * + * Tries to extract a character. If none are available, sets failbit + * and returns traits::eof(). + */ int_type - get(void); - + get(); + + /** + * @brief Simple extraction. + * @param c The character in which to store data. + * @return *this + * + * Tries to extract a character and store it in @a c. If none are + * available, sets failbit and returns traits::eof(). + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ __istream_type& get(char_type& __c); + /** + * @brief Simple multiple-character extraction. + * @param s Pointer to an array. + * @param n Maximum number of characters to store in @a s. + * @param delim A "stop" character. + * @return *this + * + * Characters are extracted and stored into @a s until one of the + * following happens: + * + * - @c n-1 characters are stored + * - the input sequence reaches EOF + * - the next character equals @a delim, in which case the character + * is not extracted + * + * If no characters are stored, failbit is set in the stream's error + * state. + * + * In any case, a null character is stored into the next location in + * the array. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ __istream_type& get(char_type* __s, streamsize __n, char_type __delim); + /** + * @brief Simple multiple-character extraction. + * @param s Pointer to an array. + * @param n Maximum number of characters to store in @a s. + * @return *this + * + * Returns @c get(s,n,widen('\n')). + */ inline __istream_type& get(char_type* __s, streamsize __n) { return this->get(__s, __n, this->widen('\n')); } + /** + * @brief Extraction into another streambuf. + * @param sb A streambuf in which to store data. + * @param delim A "stop" character. + * @return *this + * + * Characters are extracted and inserted into @a sb until one of the + * following happens: + * + * - the input sequence reaches EOF + * - insertion into the output buffer fails (in this case, the + * character that would have been inserted is not extracted) + * - the next character equals @a delim (in this case, the character + * is not extracted) + * - an exception occurs (and in this case is caught) + * + * If no characters are stored, failbit is set in the stream's error + * state. + */ __istream_type& get(__streambuf_type& __sb, char_type __delim); + /** + * @brief Extraction into another streambuf. + * @param sb A streambuf in which to store data. + * @return *this + * + * Returns @c get(sb,widen('\n')). + */ inline __istream_type& get(__streambuf_type& __sb) { return this->get(__sb, this->widen('\n')); } + /** + * @brief String extraction. + * @param s A character array in which to store the data. + * @param n Maximum number of characters to extract. + * @param delim A "stop" character. + * @return *this + * + * Extracts and stores characters into @a s until one of the + * following happens. Note that these criteria are required to be + * tested in the order listed here, to allow an input line to exactly + * fill the @a s array without setting failbit. + * + * -# the input sequence reaches end-of-file, in which case eofbit + * is set in the stream error state + * -# the next character equals @c delim, in which case the character + * is extracted (and therefore counted in @c gcount()) but not stored + * -# @c n-1 characters are stored, in which case failbit is set + * in the stream error state + * + * If no characters are extracted, failbit is set. (An empty line of + * input should therefore not cause failbit to be set.) + * + * In any case, a null character is stored in the next location in + * the array. + */ __istream_type& getline(char_type* __s, streamsize __n, char_type __delim); + /** + * @brief String extraction. + * @param s A character array in which to store the data. + * @param n Maximum number of characters to extract. + * @return *this + * + * Returns @c getline(s,n,widen('\n')). + */ inline __istream_type& getline(char_type* __s, streamsize __n) { return this->getline(__s, __n, this->widen('\n')); } + /** + * @brief Discarding characters + * @param n Number of characters to discard. + * @param delim A "stop" character. + * @return *this + * + * Extracts characters and throws them away until one of the + * following happens: + * - if @a n @c != @c std::numeric_limits<int>::max(), @a n + * characters are extracted + * - the input sequence reaches end-of-file + * - the next character equals @a delim (in this case, the character + * is extracted); note that this condition will never occur if + * @a delim equals @c traits::eof(). + */ __istream_type& ignore(streamsize __n = 1, int_type __delim = traits_type::eof()); + /** + * @brief Looking ahead in the stream + * @return The next character, or eof(). + * + * If, after constructing the sentry object, @c good() is false, + * returns @c traits::eof(). Otherwise reads but does not extract + * the next input character. + */ int_type - peek(void); + peek(); + /** + * @brief Extraction without delimiters. + * @param s A character array. + * @param n Maximum number of characters to store. + * @return *this + * + * If the stream state is @c good(), extracts characters and stores + * them into @a s until one of the following happens: + * - @a n characters are stored + * - the input sequence reaches end-of-file, in which case the error + * state is set to @c failbit|eofbit. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ __istream_type& read(char_type* __s, streamsize __n); + /** + * @brief Extraction until the buffer is exhausted, but no more. + * @param s A character array. + * @param n Maximum number of characters to store. + * @return The number of characters extracted. + * + * Extracts characters and stores them into @a s depending on the + * number of characters remaining in the streambuf's buffer, + * @c rdbuf()->in_avail(), called @c A here: + * - if @c A @c == @c -1, sets eofbit and extracts no characters + * - if @c A @c == @c 0, extracts no characters + * - if @c A @c > @c 0, extracts @c min(A,n) + * + * The goal is to empty the current buffer, and to not request any + * more from the external input sequence controlled by the streambuf. + */ streamsize readsome(char_type* __s, streamsize __n); + /** + * @brief Unextracting a single character. + * @param c The character to push back into the input stream. + * @return *this + * + * If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c). + * + * If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in + * the error state. + * + * @note Since no characters are extracted, the next call to + * @c gcount() will return 0, as required by DR 60. + */ __istream_type& putback(char_type __c); + /** + * @brief Unextracting the previous character. + * @return *this + * + * If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c). + * + * If @c rdbuf() is null or if @c sungetc() fails, sets badbit in + * the error state. + * + * @note Since no characters are extracted, the next call to + * @c gcount() will return 0, as required by DR 60. + */ __istream_type& - unget(void); - + unget(); + + /** + * @brief Synchronizing the stream buffer. + * @return 0 on success, -1 on failure + * + * If @c rdbuf() is a null pointer, returns -1. + * + * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, + * sets badbit and returns -1. + * + * Otherwise, returns 0. + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). + */ int - sync(void); - + sync(); + + /** + * @brief Getting the current read position. + * @return A file position object. + * + * If @c fail() is not false, returns @c pos_type(-1) to indicate + * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in). + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). + */ pos_type - tellg(void); - + tellg(); + + /** + * @brief Changing the current read position. + * @param pos A file position object. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If + * that function fails, sets failbit. + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). + */ __istream_type& seekg(pos_type); + /** + * @brief Changing the current read position. + * @param off A file offset object. + * @param dir The direction in which to seek. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). + * If that function fails, sets failbit. + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). + */ __istream_type& seekg(off_type, ios_base::seekdir); + //@} }; + /** + * @brief Performs setup work for input streams. + * + * Objects of this class are created before all of the standard + * extractors are run. It is responsible for "exception-safe prefix and + * suffix operations," although only prefix actions are currently required + * by the standard. Additional actions may be added by the + * implementation, and we list them in + * http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/howto.html#5 + * under [27.6] notes. + */ template<typename _CharT, typename _Traits> class basic_istream<_CharT, _Traits>::sentry { public: + /// Easy access to dependant types. typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::__ctype_type __ctype_type; typedef typename _Traits::int_type __int_type; + /** + * @brief The constructor performs all the work. + * @param is The input stream to guard. + * @param noskipws Whether to consume whitespace or not. + * + * If the stream state is good (@a is.good() is true), then the + * following actions are performed, otherwise the sentry state is + * false ("not okay") and failbit is set in the stream state. + * + * The sentry's preparatory actions are: + * + * -# if the stream is tied to an output stream, @c is.tie()->flush() + * is called to synchronize the output sequence + * -# if @a noskipws is false, and @c ios_base::skipws is set in + * @c is.flags(), the sentry extracts and discards whitespace + * characters from the stream. The currently imbued locale is + * used to determine whether each character is whitespace. + * + * If the stream state is still good, then the sentry state becomes + * true ("okay"). + */ explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); + /** + * @brief Quick status checking. + * @return The sentry state. + * + * For ease of use, sentries may be converted to booleans. The + * return value is that of the sentry state (true == okay). + */ operator bool() { return _M_ok; } private: bool _M_ok; }; - // 27.6.1.2.3 Character extraction templates + // [27.6.1.2.3] character extraction templates + //@{ + /** + * @brief Character extractors + * @param in An input stream. + * @param c A character reference. + * @return in + * + * Behaves like one of the formatted arithmetic extractors described in + * std::basic_istream. After constructing a sentry object with good + * status, this function extracts a character (if one is available) and + * stores it in @a c. Otherwise, sets failbit in the input stream. + */ template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); @@ -239,7 +647,34 @@ namespace std basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& __in, signed char& __c) { return (__in >> reinterpret_cast<char&>(__c)); } - + //@} + + //@{ + /** + * @brief Character string extractors + * @param in An input stream. + * @param s A pointer to a character array. + * @return in + * + * Behaves like one of the formatted arithmetic extractors described in + * std::basic_istream. After constructing a sentry object with good + * status, this function extracts up to @c n characters and stores them + * into the array starting at @a s. @c n is defined as: + * + * - if @c width() is greater than zero, @c n is width() + * - otherwise @c n is "the number of elements of the largest array of + * @c char_type that can store a terminating @c eos." [27.6.1.2.3]/6 + * + * Characters are extracted and stored until one of the following happens: + * - @c n-1 characters are stored + * - EOF is reached + * - the next character is whitespace according to the current locale + * - the next character is a null byte (i.e., @c charT() ) + * + * @c width(0) is then called for the input stream. + * + * If no characters are extracted, sets failbit. + */ template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); @@ -253,8 +688,15 @@ namespace std basic_istream<char,_Traits>& operator>>(basic_istream<char,_Traits>& __in, signed char* __s) { return (__in >> reinterpret_cast<char*>(__s)); } + //@} // 27.6.1.5 Template class basic_iostream + /** + * @brief Merging istream and ostream capabilities. + * + * This class multiply inherits from the input and output stream classes + * simply to provide a single interface. + */ template<typename _CharT, typename _Traits> class basic_iostream : public basic_istream<_CharT, _Traits>, @@ -275,16 +717,45 @@ namespace std typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_ostream<_CharT, _Traits> __ostream_type; + /** + * @brief Constructor does nothing. + * + * Both of the parent classes are initialized with the same + * streambuf pointer passed to this constructor. + */ explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) : __istream_type(__sb), __ostream_type(__sb) { } + /** + * @brief Destructor does nothing. + */ virtual ~basic_iostream() { } }; - // 27.6.1.4 Standard basic_istream manipulators + // [27.6.1.4] standard basic_istream manipulators + /** + * @brief Quick and easy way to eat whitespace + * + * This manipulator extracts whitespace characters, stopping when the + * next character is non-whitespace, or when the input sequence is empty. + * If the sequence is empty, @c eofbit is set in the stream, but not + * @c failbit. + * + * The current locale is used to distinguish whitespace characters. + * + * Example: + * @code + * MyClass mc; + * + * std::cin >> std::ws >> mc; + * @endcode + * will skip leading whitespace before calling operator>> on cin and your + * object. Note that the same effect can be achieved by creating a + * std::basic_istream::sentry inside your definition of operator>>. + */ template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __is); diff --git a/contrib/libstdc++/include/std/std_limits.h b/contrib/libstdc++/include/std/std_limits.h index 5f70ddab8e39..9be69477958f 100644 --- a/contrib/libstdc++/include/std/std_limits.h +++ b/contrib/libstdc++/include/std/std_limits.h @@ -45,7 +45,6 @@ #pragma GCC system_header -#include <bits/cpu_limits.h> #include <bits/c++config.h> // @@ -64,13 +63,13 @@ // double (1) // long double (1) // -// GNU C++ undertstands (where supported by the host C-library) +// GNU C++ undertstands (where supported by the host C-library) // * integer // long long, unsigned long long (2) // // which brings us to 15 fundamental arithmetic data types in GNU C++. // -// +// // Since a numeric_limits<> is a bit tricky to get right, we rely on // an interface composed of macros which should be defined in config/os // or config/cpu when they differ from the generic (read arbitrary) @@ -80,813 +79,77 @@ // These values can be overridden in the target configuration file. // The default values are appropriate for many 32-bit targets. -#ifndef __glibcpp_char_bits -#define __glibcpp_char_bits 8 -#endif -#ifdef __CHAR_UNSIGNED__ -#define __glibcpp_plain_char_is_signed false -#else -#define __glibcpp_plain_char_is_signed true -#endif -#ifndef __glibcpp_short_bits -#define __glibcpp_short_bits 16 -#endif -#ifndef __glibcpp_int_bits -#define __glibcpp_int_bits 32 -#endif -#ifndef __glibcpp_long_bits -#define __glibcpp_long_bits 32 -#endif -#ifndef __glibcpp_wchar_t_bits -#define __glibcpp_wchar_t_bits 32 -#endif -#ifndef __glibcpp_wchar_t_is_signed -#define __glibcpp_wchar_t_is_signed true -#endif -#ifndef __glibcpp_long_long_bits -#define __glibcpp_long_long_bits 64 -#endif -#ifndef __glibcpp_float_bits -#define __glibcpp_float_bits 32 -#endif -#ifndef __glibcpp_double_bits -#define __glibcpp_double_bits 64 -#endif -#ifndef __glibcpp_long_double_bits -#define __glibcpp_long_double_bits 128 -#endif - -#ifndef __glibcpp_char_traps -#define __glibcpp_char_traps true -#endif -#ifndef __glibcpp_short_traps -#define __glibcpp_short_traps true -#endif -#ifndef __glibcpp_int_traps -#define __glibcpp_int_traps true -#endif -#ifndef __glibcpp_long_traps -#define __glibcpp_long_traps true -#endif -#ifndef __glibcpp_wchar_t_traps -#define __glibcpp_wchar_t_traps true -#endif -#ifndef __glibcpp_long_long_traps -#define __glibcpp_long_long_traps true -#endif - -// You should not need to define any macros below this point, unless -// you have a machine with non-standard bit-widths. - -// These values are the minimums and maximums for standard data types -// of common widths. - -#define __glibcpp_s8_max 127 -#define __glibcpp_s8_min (-__glibcpp_s8_max - 1) -#define __glibcpp_s8_digits 7 -#define __glibcpp_s8_digits10 2 -#define __glibcpp_u8_min 0U -#define __glibcpp_u8_max (__glibcpp_s8_max * 2 + 1) -#define __glibcpp_u8_digits 8 -#define __glibcpp_u8_digits10 2 -#define __glibcpp_s16_max 32767 -#define __glibcpp_s16_min (-__glibcpp_s16_max - 1) -#define __glibcpp_s16_digits 15 -#define __glibcpp_s16_digits10 4 -#define __glibcpp_u16_min 0U -#define __glibcpp_u16_max (__glibcpp_s16_max * 2 + 1) -#define __glibcpp_u16_digits 16 -#define __glibcpp_u16_digits10 4 -#define __glibcpp_s32_max 2147483647L -#define __glibcpp_s32_min (-__glibcpp_s32_max - 1) -#define __glibcpp_s32_digits 31 -#define __glibcpp_s32_digits10 9 -#define __glibcpp_u32_min 0UL -#define __glibcpp_u32_max (__glibcpp_s32_max * 2U + 1) -#define __glibcpp_u32_digits 32 -#define __glibcpp_u32_digits10 9 -#define __glibcpp_s64_max 9223372036854775807LL -#define __glibcpp_s64_min (-__glibcpp_s64_max - 1) -#define __glibcpp_s64_digits 63 -#define __glibcpp_s64_digits10 18 -#define __glibcpp_u64_min 0ULL -#define __glibcpp_u64_max (__glibcpp_s64_max * 2ULL + 1) -#define __glibcpp_u64_digits 64 -#define __glibcpp_u64_digits10 19 - -#define __glibcpp_f32_min 1.17549435e-38F -#define __glibcpp_f32_max 3.40282347e+38F -#define __glibcpp_f32_digits 24 -#define __glibcpp_f32_digits10 6 -#define __glibcpp_f32_radix 2 -#define __glibcpp_f32_epsilon 1.19209290e-07F -#define __glibcpp_f32_round_error 1.0F -#define __glibcpp_f32_min_exponent -125 -#define __glibcpp_f32_min_exponent10 -37 -#define __glibcpp_f32_max_exponent 128 -#define __glibcpp_f32_max_exponent10 38 -#define __glibcpp_f64_min 2.2250738585072014e-308 -#define __glibcpp_f64_max 1.7976931348623157e+308 -#define __glibcpp_f64_digits 53 -#define __glibcpp_f64_digits10 15 -#define __glibcpp_f64_radix 2 -#define __glibcpp_f64_epsilon 2.2204460492503131e-16 -#define __glibcpp_f64_round_error 1.0 -#define __glibcpp_f64_min_exponent -1021 -#define __glibcpp_f64_min_exponent10 -307 -#define __glibcpp_f64_max_exponent 1024 -#define __glibcpp_f64_max_exponent10 308 -#define __glibcpp_f80_min 3.36210314311209350626e-4932L -#define __glibcpp_f80_max 1.18973149535723176502e+4932L -#define __glibcpp_f80_digits 64 -#define __glibcpp_f80_digits10 18 -#define __glibcpp_f80_radix 2 -#define __glibcpp_f80_epsilon 1.08420217248550443401e-19L -#define __glibcpp_f80_round_error 1.0L -#define __glibcpp_f80_min_exponent -16381 -#define __glibcpp_f80_min_exponent10 -4931 -#define __glibcpp_f80_max_exponent 16384 -#define __glibcpp_f80_max_exponent10 4932 -#define __glibcpp_f96_min 1.68105157155604675313e-4932L -#define __glibcpp_f96_max 1.18973149535723176502e+4932L -#define __glibcpp_f96_digits 64 -#define __glibcpp_f96_digits10 18 -#define __glibcpp_f96_radix 2 -#define __glibcpp_f96_epsilon 1.08420217248550443401e-19L -#define __glibcpp_f96_round_error 1.0L -#define __glibcpp_f96_min_exponent -16382 -#define __glibcpp_f96_min_exponent10 -4931 -#define __glibcpp_f96_max_exponent 16384 -#define __glibcpp_f96_max_exponent10 4932 -#define __glibcpp_f128_min 3.362103143112093506262677817321752603E-4932L -#define __glibcpp_f128_max 1.189731495357231765085759326628007016E+4932L -#define __glibcpp_f128_digits 113 -#define __glibcpp_f128_digits10 33 -#define __glibcpp_f128_radix 2 -#define __glibcpp_f128_epsilon 1.925929944387235853055977942584927319E-34L -#define __glibcpp_f128_round_error 1.0L -#define __glibcpp_f128_min_exponent -16381 -#define __glibcpp_f128_min_exponent10 -4931 -#define __glibcpp_f128_max_exponent 16384 -#define __glibcpp_f128_max_exponent10 4932 - -// bool-specific hooks: -// __glibcpp_bool_digits __glibcpp_int_traps __glibcpp_long_traps - -#ifndef __glibcpp_bool_digits -#define __glibcpp_bool_digits 1 -#endif - -// char. - -#define __glibcpp_plain_char_traps true -#define __glibcpp_signed_char_traps true -#define __glibcpp_unsigned_char_traps true -#ifndef __glibcpp_char_is_modulo -#define __glibcpp_char_is_modulo true -#endif -#ifndef __glibcpp_signed_char_is_modulo -#define __glibcpp_signed_char_is_modulo true -#endif -#if __glibcpp_char_bits == 8 -#define __glibcpp_signed_char_min __glibcpp_s8_min -#define __glibcpp_signed_char_max __glibcpp_s8_max -#define __glibcpp_signed_char_digits __glibcpp_s8_digits -#define __glibcpp_signed_char_digits10 __glibcpp_s8_digits10 -#define __glibcpp_unsigned_char_min __glibcpp_u8_min -#define __glibcpp_unsigned_char_max __glibcpp_u8_max -#define __glibcpp_unsigned_char_digits __glibcpp_u8_digits -#define __glibcpp_unsigned_char_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_char_bits == 16 -#define __glibcpp_signed_char_min __glibcpp_s16_min -#define __glibcpp_signed_char_max __glibcpp_s16_max -#define __glibcpp_signed_char_digits __glibcpp_s16_digits -#define __glibcpp_signed_char_digits10 __glibcpp_s16_digits10 -#define __glibcpp_unsigned_char_min __glibcpp_u16_min -#define __glibcpp_unsigned_char_max __glibcpp_u16_max -#define __glibcpp_unsigned_char_digits __glibcpp_u16_digits -#define __glibcpp_unsigned_char_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_char_bits == 32 -#define __glibcpp_signed_char_min (signed char)__glibcpp_s32_min -#define __glibcpp_signed_char_max (signed char)__glibcpp_s32_max -#define __glibcpp_signed_char_digits __glibcpp_s32_digits -#define __glibcpp_signed_char_digits10 __glibcpp_s32_digits10 -#define __glibcpp_unsigned_char_min (unsigned char)__glibcpp_u32_min -#define __glibcpp_unsigned_char_max (unsigned char)__glibcpp_u32_max -#define __glibcpp_unsigned_char_digits __glibcpp_u32_digits -#define __glibcpp_unsigned_char_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_char_bits == 64 -#define __glibcpp_signed_char_min (signed char)__glibcpp_s64_min -#define __glibcpp_signed_char_max (signed char)__glibcpp_s64_max -#define __glibcpp_signed_char_digits __glibcpp_s64_digits -#define __glibcpp_signed_char_digits10 __glibcpp_s64_digits10 -#define __glibcpp_unsigned_char_min (unsigned char)__glibcpp_u64_min -#define __glibcpp_unsigned_char_max (unsigned char)__glibcpp_u64_max -#define __glibcpp_unsigned_char_digits __glibcpp_u64_digits -#define __glibcpp_unsigned_char_digits10 __glibcpp_u64_digits10 -#else -// You must define these macros in the configuration file. -#endif - -#if __glibcpp_plain_char_is_signed -#define __glibcpp_char_min (char)__glibcpp_signed_char_min -#define __glibcpp_char_max (char)__glibcpp_signed_char_max -#define __glibcpp_char_digits __glibcpp_signed_char_digits -#define __glibcpp_char_digits10 __glibcpp_signed_char_digits10 -#else -#define __glibcpp_char_min (char)__glibcpp_unsigned_char_min -#define __glibcpp_char_max (char)__glibcpp_unsigned_char_max -#define __glibcpp_char_digits __glibcpp_unsigned_char_digits -#define __glibcpp_char_digits10 __glibcpp_unsigned_char_digits10 -#endif - -// short - -#define __glibcpp_signed_short_traps true -#define __glibcpp_unsigned_short_traps true -#ifndef __glibcpp_signed_short_is_modulo -#define __glibcpp_signed_short_is_modulo true -#endif -#if __glibcpp_short_bits == 8 -#define __glibcpp_signed_short_min __glibcpp_s8_min -#define __glibcpp_signed_short_max __glibcpp_s8_max -#define __glibcpp_signed_short_digits __glibcpp_s8_digits -#define __glibcpp_signed_short_digits10 __glibcpp_s8_digits10 -#define __glibcpp_unsigned_short_min __glibcpp_u8_min -#define __glibcpp_unsigned_short_max __glibcpp_u8_max -#define __glibcpp_unsigned_short_digits __glibcpp_u8_digits -#define __glibcpp_unsigned_short_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_short_bits == 16 -#define __glibcpp_signed_short_min __glibcpp_s16_min -#define __glibcpp_signed_short_max __glibcpp_s16_max -#define __glibcpp_signed_short_digits __glibcpp_s16_digits -#define __glibcpp_signed_short_digits10 __glibcpp_s16_digits10 -#define __glibcpp_unsigned_short_min __glibcpp_u16_min -#define __glibcpp_unsigned_short_max __glibcpp_u16_max -#define __glibcpp_unsigned_short_digits __glibcpp_u16_digits -#define __glibcpp_unsigned_short_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_short_bits == 32 -#define __glibcpp_signed_short_min (short)__glibcpp_s32_min -#define __glibcpp_signed_short_max (short)__glibcpp_s32_max -#define __glibcpp_signed_short_digits __glibcpp_s32_digits -#define __glibcpp_signed_short_digits10 __glibcpp_s32_digits10 -#define __glibcpp_unsigned_short_min (unsigned short)__glibcpp_u32_min -#define __glibcpp_unsigned_short_max (unsigned short)__glibcpp_u32_max -#define __glibcpp_unsigned_short_digits __glibcpp_u32_digits -#define __glibcpp_unsigned_short_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_short_bits == 64 -#define __glibcpp_signed_short_min (short)__glibcpp_s64_min -#define __glibcpp_signed_short_max (short)__glibcpp_s64_max -#define __glibcpp_signed_short_digits __glibcpp_s64_digits -#define __glibcpp_signed_short_digits10 __glibcpp_s64_digits10 -#define __glibcpp_unsigned_short_min (unsigned short)__glibcpp_u64_min -#define __glibcpp_unsigned_short_max (unsigned short)__glibcpp_u64_max -#define __glibcpp_unsigned_short_digits __glibcpp_u64_digits -#define __glibcpp_unsigned_short_digits10 __glibcpp_u64_digits10 -#else -// You must define these macros in the configuration file. -#endif - -// int - -#define __glibcpp_signed_int_traps true -#define __glibcpp_unsigned_int_traps true -#ifndef __glibcpp_signed_int_is_modulo -#define __glibcpp_signed_int_is_modulo true -#endif -#if __glibcpp_int_bits == 8 -#define __glibcpp_signed_int_min __glibcpp_s8_min -#define __glibcpp_signed_int_max __glibcpp_s8_max -#define __glibcpp_signed_int_digits __glibcpp_s8_digits -#define __glibcpp_signed_int_digits10 __glibcpp_s8_digits10 -#define __glibcpp_unsigned_int_min __glibcpp_u8_min -#define __glibcpp_unsigned_int_max __glibcpp_u8_max -#define __glibcpp_unsigned_int_digits __glibcpp_u8_digits -#define __glibcpp_unsigned_int_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_int_bits == 16 -#define __glibcpp_signed_int_min __glibcpp_s16_min -#define __glibcpp_signed_int_max __glibcpp_s16_max -#define __glibcpp_signed_int_digits __glibcpp_s16_digits -#define __glibcpp_signed_int_digits10 __glibcpp_s16_digits10 -#define __glibcpp_unsigned_int_min __glibcpp_u16_min -#define __glibcpp_unsigned_int_max __glibcpp_u16_max -#define __glibcpp_unsigned_int_digits __glibcpp_u16_digits -#define __glibcpp_unsigned_int_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_int_bits == 32 -#define __glibcpp_signed_int_min (int)__glibcpp_s32_min -#define __glibcpp_signed_int_max (int)__glibcpp_s32_max -#define __glibcpp_signed_int_digits __glibcpp_s32_digits -#define __glibcpp_signed_int_digits10 __glibcpp_s32_digits10 -#define __glibcpp_unsigned_int_min (unsigned)__glibcpp_u32_min -#define __glibcpp_unsigned_int_max (unsigned)__glibcpp_u32_max -#define __glibcpp_unsigned_int_digits __glibcpp_u32_digits -#define __glibcpp_unsigned_int_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_int_bits == 64 -#define __glibcpp_signed_int_min (int)__glibcpp_s64_min -#define __glibcpp_signed_int_max (int)__glibcpp_s64_max -#define __glibcpp_signed_int_digits __glibcpp_s64_digits -#define __glibcpp_signed_int_digits10 __glibcpp_s64_digits10 -#define __glibcpp_unsigned_int_min (unsigned)__glibcpp_u64_min -#define __glibcpp_unsigned_int_max (unsigned)__glibcpp_u64_max -#define __glibcpp_unsigned_int_digits __glibcpp_u64_digits -#define __glibcpp_unsigned_int_digits10 __glibcpp_u64_digits10 -#else -// You must define these macros in the configuration file. -#endif - -// long - -#define __glibcpp_signed_long_traps true -#define __glibcpp_unsigned_long_traps true -#ifndef __glibcpp_signed_long_is_modulo -#define __glibcpp_signed_long_is_modulo true -#endif -#if __glibcpp_long_bits == 8 -#define __glibcpp_signed_long_min __glibcpp_s8_min -#define __glibcpp_signed_long_max __glibcpp_s8_max -#define __glibcpp_signed_long_digits __glibcpp_s8_digits -#define __glibcpp_signed_long_digits10 __glibcpp_s8_digits10 -#define __glibcpp_unsigned_long_min __glibcpp_u8_min -#define __glibcpp_unsigned_long_max __glibcpp_u8_max -#define __glibcpp_unsigned_long_digits __glibcpp_u8_digits -#define __glibcpp_unsigned_long_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_long_bits == 16 -#define __glibcpp_signed_long_min __glibcpp_s16_min -#define __glibcpp_signed_long_max __glibcpp_s16_max -#define __glibcpp_signed_long_digits __glibcpp_s16_digits -#define __glibcpp_signed_long_digits10 __glibcpp_s16_digits10 -#define __glibcpp_unsigned_long_min __glibcpp_u16_min -#define __glibcpp_unsigned_long_max __glibcpp_u16_max -#define __glibcpp_unsigned_long_digits __glibcpp_u16_digits -#define __glibcpp_unsigned_long_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_long_bits == 32 -#define __glibcpp_signed_long_min __glibcpp_s32_min -#define __glibcpp_signed_long_max __glibcpp_s32_max -#define __glibcpp_signed_long_digits __glibcpp_s32_digits -#define __glibcpp_signed_long_digits10 __glibcpp_s32_digits10 -#define __glibcpp_unsigned_long_min __glibcpp_u32_min -#define __glibcpp_unsigned_long_max __glibcpp_u32_max -#define __glibcpp_unsigned_long_digits __glibcpp_u32_digits -#define __glibcpp_unsigned_long_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_long_bits == 64 -#define __glibcpp_signed_long_min (long)__glibcpp_s64_min -#define __glibcpp_signed_long_max (long)__glibcpp_s64_max -#define __glibcpp_signed_long_digits __glibcpp_s64_digits -#define __glibcpp_signed_long_digits10 __glibcpp_s64_digits10 -#define __glibcpp_unsigned_long_min (unsigned long)__glibcpp_u64_min -#define __glibcpp_unsigned_long_max (unsigned long)__glibcpp_u64_max -#define __glibcpp_unsigned_long_digits __glibcpp_u64_digits -#define __glibcpp_unsigned_long_digits10 __glibcpp_u64_digits10 -#else -// You must define these macros in the configuration file. -#endif - -// long long - -#define __glibcpp_signed_long_long_traps true -#define __glibcpp_signed_long_long_traps true -#ifndef __glibcpp_signed_long_long_is_modulo -#define __glibcpp_signed_long_long_is_modulo true -#endif -#if __glibcpp_long_long_bits == 8 -#define __glibcpp_signed_long_long_min __glibcpp_s8_min -#define __glibcpp_signed_long_long_max __glibcpp_s8_max -#define __glibcpp_signed_long_long_digits __glibcpp_s8_digits -#define __glibcpp_signed_long_long_digits10 __glibcpp_s8_digits10 -#define __glibcpp_unsigned_long_long_min __glibcpp_u8_min -#define __glibcpp_unsigned_long_long_max __glibcpp_u8_max -#define __glibcpp_unsigned_long_long_digits __glibcpp_u8_digits -#define __glibcpp_unsigned_long_long_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_long_long_bits == 16 -#define __glibcpp_signed_long_long_min __glibcpp_s16_min -#define __glibcpp_signed_long_long_max __glibcpp_s16_max -#define __glibcpp_signed_long_long_digits __glibcpp_s16_digits -#define __glibcpp_signed_long_long_digits10 __glibcpp_s16_digits10 -#define __glibcpp_unsigned_long_long_min __glibcpp_u16_min -#define __glibcpp_unsigned_long_long_max __glibcpp_u16_max -#define __glibcpp_unsigned_long_long_digits __glibcpp_u16_digits -#define __glibcpp_unsigned_long_long_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_long_long_bits == 32 -#define __glibcpp_signed_long_long_min __glibcpp_s32_min -#define __glibcpp_signed_long_long_max __glibcpp_s32_max -#define __glibcpp_signed_long_long_digits __glibcpp_s32_digits -#define __glibcpp_signed_long_long_digits10 __glibcpp_s32_digits10 -#define __glibcpp_unsigned_long_long_min __glibcpp_u32_min -#define __glibcpp_unsigned_long_long_max __glibcpp_u32_max -#define __glibcpp_unsigned_long_long_digits __glibcpp_u32_digits -#define __glibcpp_unsigned_long_long_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_long_long_bits == 64 -#define __glibcpp_signed_long_long_min __glibcpp_s64_min -#define __glibcpp_signed_long_long_max __glibcpp_s64_max -#define __glibcpp_signed_long_long_digits __glibcpp_s64_digits -#define __glibcpp_signed_long_long_digits10 __glibcpp_s64_digits10 -#define __glibcpp_signed_long_long_traps true -#define __glibcpp_unsigned_long_long_min __glibcpp_u64_min -#define __glibcpp_unsigned_long_long_max __glibcpp_u64_max -#define __glibcpp_unsigned_long_long_digits __glibcpp_u64_digits -#define __glibcpp_unsigned_long_long_digits10 __glibcpp_u64_digits10 -#define __glibcpp_unsigned_long_long_traps true -#else -// You must define these macros in the configuration file. -#endif - -// wchar_t - -#define __glibcpp_wchar_t_traps true -#ifndef __glibcpp_wchar_t_is_modulo -#define __glibcpp_wchar_t_is_modulo true -#endif -#if __glibcpp_wchar_t_is_signed -#if __glibcpp_wchar_t_bits == 8 -#define __glibcpp_wchar_t_min __glibcpp_s8_min -#define __glibcpp_wchar_t_max __glibcpp_s8_max -#define __glibcpp_wchar_t_digits __glibcpp_s8_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_s8_digits10 -#elif __glibcpp_wchar_t_bits == 16 -#define __glibcpp_wchar_t_min __glibcpp_s16_min -#define __glibcpp_wchar_t_max __glibcpp_s16_max -#define __glibcpp_wchar_t_digits __glibcpp_s16_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_s16_digits10 -#elif __glibcpp_wchar_t_bits == 32 -#define __glibcpp_wchar_t_min (wchar_t)__glibcpp_s32_min -#define __glibcpp_wchar_t_max (wchar_t)__glibcpp_s32_max -#define __glibcpp_wchar_t_digits __glibcpp_s32_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_s32_digits10 -#elif __glibcpp_wchar_t_bits == 64 -#define __glibcpp_wchar_t_min (wchar_t)__glibcpp_s64_min -#define __glibcpp_wchar_t_max (wchar_t)__glibcpp_s64_max -#define __glibcpp_wchar_t_digits __glibcpp_s64_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_s64_digits10 -#else -// You must define these macros in the configuration file. -#endif -#else -#if __glibcpp_wchar_t_bits == 8 -#define __glibcpp_wchar_t_min __glibcpp_u8_min -#define __glibcpp_wchar_t_max __glibcpp_u8_max -#define __glibcpp_wchar_t_digits __glibcpp_u8_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_u8_digits10 -#elif __glibcpp_wchar_t_bits == 16 -#define __glibcpp_wchar_t_min __glibcpp_u16_min -#define __glibcpp_wchar_t_max __glibcpp_u16_max -#define __glibcpp_wchar_t_digits __glibcpp_u16_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_u16_digits10 -#elif __glibcpp_wchar_t_bits == 32 -#define __glibcpp_wchar_t_min (wchar_t)__glibcpp_u32_min -#define __glibcpp_wchar_t_max (wchar_t)__glibcpp_u32_max -#define __glibcpp_wchar_t_digits __glibcpp_u32_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_u32_digits10 -#elif __glibcpp_wchar_t_bits == 64 -#define __glibcpp_wchar_t_min (wchar_t)__glibcpp_u64_min -#define __glibcpp_wchar_t_max (wchar_t)__glibcpp_u64_max -#define __glibcpp_wchar_t_digits __glibcpp_u64_digits -#define __glibcpp_wchar_t_digits10 __glibcpp_u64_digits10 -#else -// You must define these macros in the configuration file. -#endif +// GCC only intrinsicly supports modulo integral types. The only remaining +// integral exceptional values is division by zero. Only targets that do not +// signal division by zero in some "hard to ignore" way should use false. +#ifndef __glibcpp_integral_traps +# define __glibcpp_integral_traps true #endif // float // -#if __glibcpp_float_bits == 32 -#define __glibcpp_float_min __glibcpp_f32_min -#define __glibcpp_float_max __glibcpp_f32_max -#define __glibcpp_float_digits __glibcpp_f32_digits -#define __glibcpp_float_digits10 __glibcpp_f32_digits10 -#define __glibcpp_float_radix __glibcpp_f32_radix -#define __glibcpp_float_epsilon __glibcpp_f32_epsilon -#define __glibcpp_float_round_error __glibcpp_f32_round_error -#define __glibcpp_float_min_exponent __glibcpp_f32_min_exponent -#define __glibcpp_float_min_exponent10 __glibcpp_f32_min_exponent10 -#define __glibcpp_float_max_exponent __glibcpp_f32_max_exponent -#define __glibcpp_float_max_exponent10 __glibcpp_f32_max_exponent10 -#elif __glibcpp_float_bits == 64 -#define __glibcpp_float_min __glibcpp_f64_min -#define __glibcpp_float_max __glibcpp_f64_max -#define __glibcpp_float_digits __glibcpp_f64_digits -#define __glibcpp_float_digits10 __glibcpp_f64_digits10 -#define __glibcpp_float_radix __glibcpp_f64_radix -#define __glibcpp_float_epsilon __glibcpp_f64_epsilon -#define __glibcpp_float_round_error __glibcpp_f64_round_error -#define __glibcpp_float_min_exponent __glibcpp_f64_min_exponent -#define __glibcpp_float_min_exponent10 __glibcpp_f64_min_exponent10 -#define __glibcpp_float_max_exponent __glibcpp_f64_max_exponent -#define __glibcpp_float_max_exponent10 __glibcpp_f64_max_exponent10 -#elif __glibcpp_float_bits == 80 -#define __glibcpp_float_min __glibcpp_f80_min -#define __glibcpp_float_max __glibcpp_f80_max -#define __glibcpp_float_digits __glibcpp_f80_digits -#define __glibcpp_float_digits10 __glibcpp_f80_digits10 -#define __glibcpp_float_radix __glibcpp_f80_radix -#define __glibcpp_float_epsilon __glibcpp_f80_epsilon -#define __glibcpp_float_round_error __glibcpp_f80_round_error -#define __glibcpp_float_min_exponent __glibcpp_f80_min_exponent -#define __glibcpp_float_min_exponent10 __glibcpp_f80_min_exponent10 -#define __glibcpp_float_max_exponent __glibcpp_f80_max_exponent -#define __glibcpp_float_max_exponent10 __glibcpp_f80_max_exponent10 -#else -// You must define these macros in the configuration file. -#endif - -// FIXME: These are just stubs and inkorrect - -#ifndef __glibcpp_float_has_infinity -#define __glibcpp_float_has_infinity false -#endif - -#ifndef __glibcpp_float_has_quiet_NaN -#define __glibcpp_float_has_quiet_NaN false -#endif - -#ifndef __glibcpp_float_has_signaling_NaN -#define __glibcpp_float_has_signaling_NaN false -#endif - -#ifndef __glibcpp_float_has_denorm -#define __glibcpp_float_has_denorm denorm_absent -#endif +// Default values. Should be overriden in configuration files if necessary. #ifndef __glibcpp_float_has_denorm_loss -#define __glibcpp_float_has_denorm_loss false -#endif - -#ifndef __glibcpp_float_infinity -#define __glibcpp_float_infinity 0.0F -#endif - -#ifndef __glibcpp_float_quiet_NaN -#define __glibcpp_float_quiet_NaN 0.0F -#endif - -#ifndef __glibcpp_float_signaling_NaN -#define __glibcpp_float_signaling_NaN 0.0F -#endif - -#ifndef __glibcpp_float_denorm_min -#define __glibcpp_float_denorm_min 0.0F +# define __glibcpp_float_has_denorm_loss false #endif - -#ifndef __glibcpp_float_is_iec559 -#define __glibcpp_float_is_iec559 false -#endif - -#ifndef __glibcpp_float_is_bounded -#define __glibcpp_float_is_bounded true -#endif - -#ifndef __glibcpp_float_is_modulo -#define __glibcpp_float_is_modulo false -#endif - #ifndef __glibcpp_float_traps -#define __glibcpp_float_traps false +# define __glibcpp_float_traps false #endif - #ifndef __glibcpp_float_tinyness_before -#define __glibcpp_float_tinyness_before false -#endif - -#ifndef __glibcpp_float_round_style -#define __glibcpp_float_round_style round_toward_zero +# define __glibcpp_float_tinyness_before false #endif // double -#if __glibcpp_double_bits == 32 -#define __glibcpp_double_min __glibcpp_f32_min -#define __glibcpp_double_max __glibcpp_f32_max -#define __glibcpp_double_digits __glibcpp_f32_digits -#define __glibcpp_double_digits10 __glibcpp_f32_digits10 -#define __glibcpp_double_radix __glibcpp_f32_radix -#define __glibcpp_double_epsilon __glibcpp_f32_epsilon -#define __glibcpp_double_round_error __glibcpp_f32_round_error -#define __glibcpp_double_min_exponent __glibcpp_f32_min_exponent -#define __glibcpp_double_min_exponent10 __glibcpp_f32_min_exponent10 -#define __glibcpp_double_max_exponent __glibcpp_f32_max_exponent -#define __glibcpp_double_max_exponent10 __glibcpp_f32_max_exponent10 -#elif __glibcpp_double_bits == 64 -#define __glibcpp_double_min __glibcpp_f64_min -#define __glibcpp_double_max __glibcpp_f64_max -#define __glibcpp_double_digits __glibcpp_f64_digits -#define __glibcpp_double_digits10 __glibcpp_f64_digits10 -#define __glibcpp_double_radix __glibcpp_f64_radix -#define __glibcpp_double_epsilon __glibcpp_f64_epsilon -#define __glibcpp_double_round_error __glibcpp_f64_round_error -#define __glibcpp_double_min_exponent __glibcpp_f64_min_exponent -#define __glibcpp_double_min_exponent10 __glibcpp_f64_min_exponent10 -#define __glibcpp_double_max_exponent __glibcpp_f64_max_exponent -#define __glibcpp_double_max_exponent10 __glibcpp_f64_max_exponent10 -#elif __glibcpp_double_bits == 80 -#define __glibcpp_double_min __glibcpp_f80_min -#define __glibcpp_double_max __glibcpp_f80_max -#define __glibcpp_double_digits __glibcpp_f80_digits -#define __glibcpp_double_digits10 __glibcpp_f80_digits10 -#define __glibcpp_double_radix __glibcpp_f80_radix -#define __glibcpp_double_epsilon __glibcpp_f80_epsilon -#define __glibcpp_double_round_error __glibcpp_f80_round_error -#define __glibcpp_double_min_exponent __glibcpp_f80_min_exponent -#define __glibcpp_double_min_exponent10 __glibcpp_f80_min_exponent10 -#define __glibcpp_double_max_exponent __glibcpp_f80_max_exponent -#define __glibcpp_double_max_exponent10 __glibcpp_f80_max_exponent10 -#else -// You must define these macros in the configuration file. -#endif - -// FIXME: These are just stubs and inkorrect - -#ifndef __glibcpp_double_has_infinity -#define __glibcpp_double_has_infinity false -#endif - -#ifndef __glibcpp_double_has_quiet_NaN -#define __glibcpp_double_has_quiet_NaN false -#endif - -#ifndef __glibcpp_double_has_signaling_NaN -#define __glibcpp_double_has_signaling_NaN false -#endif - -#ifndef __glibcpp_double_has_denorm -#define __glibcpp_double_has_denorm denorm_absent -#endif +// Default values. Should be overriden in configuration files if necessary. #ifndef __glibcpp_double_has_denorm_loss -#define __glibcpp_double_has_denorm_loss false -#endif - -#ifndef __glibcpp_double_infinity -#define __glibcpp_double_infinity 0.0 +# define __glibcpp_double_has_denorm_loss false #endif - -#ifndef __glibcpp_double_quiet_NaN -#define __glibcpp_double_quiet_NaN 0.0 -#endif - -#ifndef __glibcpp_double_signaling_NaN -#define __glibcpp_double_signaling_NaN 0.0 -#endif - -#ifndef __glibcpp_double_denorm_min -#define __glibcpp_double_denorm_min 0.0 -#endif - -#ifndef __glibcpp_double_is_iec559 -#define __glibcpp_double_is_iec559 false -#endif - -#ifndef __glibcpp_double_is_bounded -#define __glibcpp_double_is_bounded true -#endif - -#ifndef __glibcpp_double_is_modulo -#define __glibcpp_double_is_modulo false -#endif - #ifndef __glibcpp_double_traps -#define __glibcpp_double_traps false +# define __glibcpp_double_traps false #endif - #ifndef __glibcpp_double_tinyness_before -#define __glibcpp_double_tinyness_before false -#endif - -#ifndef __glibcpp_double_round_style -#define __glibcpp_double_round_style round_toward_zero +# define __glibcpp_double_tinyness_before false #endif // long double -#if __glibcpp_long_double_bits == 32 -#define __glibcpp_long_double_min __glibcpp_f32_min -#define __glibcpp_long_double_max __glibcpp_f32_max -#define __glibcpp_long_double_digits __glibcpp_f32_digits -#define __glibcpp_long_double_digits10 __glibcpp_f32_digits10 -#define __glibcpp_long_double_radix __glibcpp_f32_radix -#define __glibcpp_long_double_epsilon __glibcpp_f32_epsilon -#define __glibcpp_long_double_round_error __glibcpp_f32_round_error -#define __glibcpp_long_double_min_exponent __glibcpp_f32_min_exponent -#define __glibcpp_long_double_min_exponent10 __glibcpp_f32_min_exponent10 -#define __glibcpp_long_double_max_exponent __glibcpp_f32_max_exponent -#define __glibcpp_long_double_max_exponent10 __glibcpp_f32_max_exponent10 -#elif __glibcpp_long_double_bits == 64 -#define __glibcpp_long_double_min __glibcpp_f64_min -#define __glibcpp_long_double_max __glibcpp_f64_max -#define __glibcpp_long_double_digits __glibcpp_f64_digits -#define __glibcpp_long_double_digits10 __glibcpp_f64_digits10 -#define __glibcpp_long_double_radix __glibcpp_f64_radix -#define __glibcpp_long_double_epsilon __glibcpp_f64_epsilon -#define __glibcpp_long_double_round_error __glibcpp_f64_round_error -#define __glibcpp_long_double_min_exponent __glibcpp_f64_min_exponent -#define __glibcpp_long_double_min_exponent10 __glibcpp_f64_min_exponent10 -#define __glibcpp_long_double_max_exponent __glibcpp_f64_max_exponent -#define __glibcpp_long_double_max_exponent10 __glibcpp_f64_max_exponent10 -#elif __glibcpp_long_double_bits == 80 -#define __glibcpp_long_double_min __glibcpp_f80_min -#define __glibcpp_long_double_max __glibcpp_f80_max -#define __glibcpp_long_double_digits __glibcpp_f80_digits -#define __glibcpp_long_double_digits10 __glibcpp_f80_digits10 -#define __glibcpp_long_double_radix __glibcpp_f80_radix -#define __glibcpp_long_double_epsilon __glibcpp_f80_epsilon -#define __glibcpp_long_double_round_error __glibcpp_f80_round_error -#define __glibcpp_long_double_min_exponent __glibcpp_f80_min_exponent -#define __glibcpp_long_double_min_exponent10 __glibcpp_f80_min_exponent10 -#define __glibcpp_long_double_max_exponent __glibcpp_f80_max_exponent -#define __glibcpp_long_double_max_exponent10 __glibcpp_f80_max_exponent10 -#elif __glibcpp_long_double_bits == 96 -#define __glibcpp_long_double_min __glibcpp_f96_min -#define __glibcpp_long_double_max __glibcpp_f96_max -#define __glibcpp_long_double_digits __glibcpp_f96_digits -#define __glibcpp_long_double_digits10 __glibcpp_f96_digits10 -#define __glibcpp_long_double_radix __glibcpp_f96_radix -#define __glibcpp_long_double_epsilon __glibcpp_f96_epsilon -#define __glibcpp_long_double_round_error __glibcpp_f96_round_error -#define __glibcpp_long_double_min_exponent __glibcpp_f96_min_exponent -#define __glibcpp_long_double_min_exponent10 __glibcpp_f96_min_exponent10 -#define __glibcpp_long_double_max_exponent __glibcpp_f96_max_exponent -#define __glibcpp_long_double_max_exponent10 __glibcpp_f96_max_exponent10 -#elif __glibcpp_long_double_bits == 128 -#define __glibcpp_long_double_min __glibcpp_f128_min -#define __glibcpp_long_double_max __glibcpp_f128_max -#define __glibcpp_long_double_digits __glibcpp_f128_digits -#define __glibcpp_long_double_digits10 __glibcpp_f128_digits10 -#define __glibcpp_long_double_radix __glibcpp_f128_radix -#define __glibcpp_long_double_epsilon __glibcpp_f128_epsilon -#define __glibcpp_long_double_round_error __glibcpp_f128_round_error -#define __glibcpp_long_double_min_exponent __glibcpp_f128_min_exponent -#define __glibcpp_long_double_min_exponent10 __glibcpp_f128_min_exponent10 -#define __glibcpp_long_double_max_exponent __glibcpp_f128_max_exponent -#define __glibcpp_long_double_max_exponent10 __glibcpp_f128_max_exponent10 -#else -// You must define these macros in the configuration file. -#endif - -// FIXME: These are just stubs and inkorrect - -#ifndef __glibcpp_long_double_has_infinity -#define __glibcpp_long_double_has_infinity false -#endif - -#ifndef __glibcpp_long_double_has_quiet_NaN -#define __glibcpp_long_double_has_quiet_NaN false -#endif - -#ifndef __glibcpp_long_double_has_signaling_NaN -#define __glibcpp_long_double_has_signaling_NaN false -#endif - -#ifndef __glibcpp_long_double_has_denorm -#define __glibcpp_long_double_has_denorm denorm_absent -#endif +// Default values. Should be overriden in configuration files if necessary. #ifndef __glibcpp_long_double_has_denorm_loss -#define __glibcpp_long_double_has_denorm_loss false -#endif - -#ifndef __glibcpp_long_double_infinity -#define __glibcpp_long_double_infinity 0.0L +# define __glibcpp_long_double_has_denorm_loss false #endif - -#ifndef __glibcpp_long_double_quiet_NaN -#define __glibcpp_long_double_quiet_NaN 0.0L -#endif - -#ifndef __glibcpp_long_double_signaling_NaN -#define __glibcpp_long_double_signaling_NaN 0.0L +#ifndef __glibcpp_long_double_traps +# define __glibcpp_long_double_traps false #endif - -#ifndef __glibcpp_long_double_denorm_min -#define __glibcpp_long_double_denorm_min 0.0L +#ifndef __glibcpp_long_double_tinyness_before +# define __glibcpp_long_double_tinyness_before false #endif -#ifndef __glibcpp_long_double_is_iec559 -#define __glibcpp_long_double_is_iec559 false -#endif +// You should not need to define any macros below this point. -#ifndef __glibcpp_long_double_is_bounded -#define __glibcpp_long_double_is_bounded true -#endif +#define __glibcpp_signed(T) ((T)(-1) < 0) -#ifndef __glibcpp_long_double_is_modulo -#define __glibcpp_long_double_is_modulo false -#endif +#define __glibcpp_min(T) \ + (__glibcpp_signed (T) ? (T)1 << __glibcpp_digits (T) : (T)0) -#ifndef __glibcpp_long_double_traps -#define __glibcpp_long_double_traps false -#endif +#define __glibcpp_max(T) \ + (__glibcpp_signed (T) ? ((T)1 << __glibcpp_digits (T)) - 1 : ~(T)0) -#ifndef __glibcpp_long_double_tinyness_before -#define __glibcpp_long_double_tinyness_before false -#endif +#define __glibcpp_digits(T) \ + (sizeof(T) * __CHAR_BIT__ - __glibcpp_signed (T)) -#ifndef __glibcpp_long_double_round_style -#define __glibcpp_long_double_round_style round_toward_zero -#endif +// The fraction 643/2136 approximates log10(2) to 7 significant digits. +#define __glibcpp_digits10(T) \ + (__glibcpp_digits (T) * 643 / 2136) namespace std { - enum float_round_style + enum float_round_style { round_indeterminate = -1, round_toward_zero = 0, @@ -895,7 +158,7 @@ namespace std round_toward_neg_infinity = 3 }; - enum float_denorm_style + enum float_denorm_style { denorm_indeterminate = -1, denorm_absent = 0, @@ -920,7 +183,7 @@ namespace std static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; - + static const bool has_infinity = false; static const bool has_quiet_NaN = false; static const bool has_signaling_NaN = false; @@ -936,8 +199,8 @@ namespace std static const float_round_style round_style = round_toward_zero; }; - template<typename _Tp> - struct numeric_limits : public __numeric_limits_base + template<typename _Tp> + struct numeric_limits : public __numeric_limits_base { static _Tp min() throw() { return static_cast<_Tp>(0); } static _Tp max() throw() { return static_cast<_Tp>(0); } @@ -950,7 +213,7 @@ namespace std }; // Now there follow 15 explicit specializations. Yes, 15. Make sure - // you get the count right. + // you get the count right. template<> struct numeric_limits<bool> { @@ -958,11 +221,10 @@ namespace std static bool min() throw() { return false; } - static bool max() throw() { return true; } - static const int digits = __glibcpp_bool_digits; + static const int digits = 1; static const int digits10 = 0; static const bool is_signed = false; static const bool is_integer = true; @@ -1000,34 +262,31 @@ namespace std // It is not clear what it means for a boolean type to trap. // This is a DR on the LWG issue list. Here, I use integer // promotion semantics. - static const bool traps = __glibcpp_signed_int_traps - || __glibcpp_signed_long_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_bool_digits - template<> struct numeric_limits<char> { static const bool is_specialized = true; static char min() throw() - { return __glibcpp_char_min; } + { return __glibcpp_min(char); } static char max() throw() - { return __glibcpp_char_max; } + { return __glibcpp_max(char); } - static const int digits = __glibcpp_char_digits; - static const int digits10 = __glibcpp_char_digits10; - static const bool is_signed = __glibcpp_plain_char_is_signed; + static const int digits = __glibcpp_digits (char); + static const int digits10 = __glibcpp_digits10 (char); + static const bool is_signed = __glibcpp_signed (char); static const bool is_integer = true; static const bool is_exact = true; static const int radix = 2; static char epsilon() throw() - { return char(); } + { return 0; } static char round_error() throw() - { return char(); } + { return 0; } static const int min_exponent = 0; static const int min_exponent10 = 0; @@ -1051,35 +310,25 @@ namespace std static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_char_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_char_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_char_min -#undef __glibcpp_char_max -#undef __glibcpp_char_digits -#undef __glibcpp_char_digits10 -#undef __glibcpp_char_is_signed -#undef __glibcpp_char_is_modulo -#undef __glibcpp_char_traps - - - template<> struct numeric_limits<signed char> { static const bool is_specialized = true; static signed char min() throw() - { return __glibcpp_signed_char_min; } + { return -__SCHAR_MAX__ - 1; } static signed char max() throw() - { return __glibcpp_signed_char_max; } + { return __SCHAR_MAX__; } - static const int digits = __glibcpp_signed_char_digits; - static const int digits10 = __glibcpp_signed_char_digits10; + static const int digits = __glibcpp_digits (signed char); + static const int digits10 = __glibcpp_digits10 (signed char); static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1111,20 +360,13 @@ namespace std static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_signed_char_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_signed_char_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_signed_char_min -#undef __glibcpp_signed_char_max -#undef __glibcpp_signed_char_digits -#undef __glibcpp_signed_char_digits10 -#undef __glibcpp_signed_char_is_modulo -#undef __glibcpp_signed_char_traps - template<> struct numeric_limits<unsigned char> { @@ -1133,10 +375,10 @@ namespace std static unsigned char min() throw() { return 0; } static unsigned char max() throw() - { return __glibcpp_unsigned_char_max; } + { return __SCHAR_MAX__ * 2U + 1; } - static const int digits = __glibcpp_unsigned_char_digits; - static const int digits10 = __glibcpp_unsigned_char_digits10; + static const int digits = __glibcpp_digits (unsigned char); + static const int digits10 = __glibcpp_digits10 (unsigned char); static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1170,29 +412,24 @@ namespace std static const bool is_bounded = true; static const bool is_modulo = true; - static const bool traps = __glibcpp_unsigned_char_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_unsigned_char_max -#undef __glibcpp_unsigned_char_digits -#undef __glibcpp_unsigned_char_digits10 -#undef __glibcpp_unsigned_char_traps - template<> struct numeric_limits<wchar_t> { static const bool is_specialized = true; static wchar_t min() throw() - { return __glibcpp_wchar_t_min; } + { return __glibcpp_min (wchar_t); } static wchar_t max() throw() - { return __glibcpp_wchar_t_max; } + { return __glibcpp_max (wchar_t); } - static const int digits = __glibcpp_wchar_t_digits; - static const int digits10 = __glibcpp_wchar_t_digits10; - static const bool is_signed = __glibcpp_wchar_t_is_signed; + static const int digits = __glibcpp_digits (wchar_t); + static const int digits10 = __glibcpp_digits10 (wchar_t); + static const bool is_signed = __glibcpp_signed (wchar_t); static const bool is_integer = true; static const bool is_exact = true; static const int radix = 2; @@ -1223,33 +460,25 @@ namespace std static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_wchar_t_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_wchar_t_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_wchar_t_min -#undef __glibcpp_wchar_t_max -#undef __glibcpp_wchar_t_digits -#undef __glibcpp_wchar_t_digits10 -#undef __glibcpp_wchar_t_is_signed -#undef __glibcpp_wchar_t_is_modulo -#undef __glibcpp_wchar_t_traps - template<> struct numeric_limits<short> { static const bool is_specialized = true; static short min() throw() - { return __glibcpp_signed_short_min; } + { return -__SHRT_MAX__ - 1; } static short max() throw() - { return __glibcpp_signed_short_max; } + { return __SHRT_MAX__; } - static const int digits = __glibcpp_signed_short_digits; - static const int digits10 = __glibcpp_signed_short_digits10; + static const int digits = __glibcpp_digits (short); + static const int digits10 = __glibcpp_digits10 (short); static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1279,22 +508,15 @@ namespace std static short denorm_min() throw() { return short(); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_signed_short_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_signed_short_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_signed_short_min -#undef __glibcpp_signed_short_max -#undef __glibcpp_signed_short_digits -#undef __glibcpp_signed_short_digits10 -#undef __glibcpp_signed_short_is_modulo -#undef __glibcpp_signed_short_traps - template<> struct numeric_limits<unsigned short> { @@ -1303,10 +525,10 @@ namespace std static unsigned short min() throw() { return 0; } static unsigned short max() throw() - { return __glibcpp_unsigned_short_max; } + { return __SHRT_MAX__ * 2U + 1; } - static const int digits = __glibcpp_unsigned_short_digits; - static const int digits10 = __glibcpp_unsigned_short_digits10; + static const int digits = __glibcpp_digits (unsigned short); + static const int digits10 = __glibcpp_digits10 (unsigned short); static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1336,32 +558,27 @@ namespace std static unsigned short denorm_min() throw() { return static_cast<unsigned short>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = true; - static const bool traps = __glibcpp_unsigned_short_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_unsigned_short_max -#undef __glibcpp_unsigned_short_digits -#undef __glibcpp_unsigned_short_digits10 -#undef __glibcpp_unsigned_short_traps - template<> struct numeric_limits<int> { static const bool is_specialized = true; static int min() throw() - { return __glibcpp_signed_int_min; } + { return -__INT_MAX__ - 1; } static int max() throw() - { return __glibcpp_signed_int_max; } + { return __INT_MAX__; } - static const int digits = __glibcpp_signed_int_digits; - static const int digits10 = __glibcpp_signed_int_digits10; + static const int digits = __glibcpp_digits (int); + static const int digits10 = __glibcpp_digits10 (int); static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1391,22 +608,15 @@ namespace std static int denorm_min() throw() { return static_cast<int>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_signed_int_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_signed_int_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_signed_int_min -#undef __glibcpp_signed_int_max -#undef __glibcpp_signed_int_digits -#undef __glibcpp_signed_int_digits10 -#undef __glibcpp_signed_int_is_modulo -#undef __glibcpp_signed_int_traps - template<> struct numeric_limits<unsigned int> { @@ -1414,11 +624,11 @@ namespace std static unsigned int min() throw() { return 0; } - static unsigned int max() throw() - { return __glibcpp_unsigned_int_max; } + static unsigned int max() throw() + { return __INT_MAX__ * 2U + 1; } - static const int digits = __glibcpp_unsigned_int_digits; - static const int digits10 = __glibcpp_unsigned_int_digits10; + static const int digits = __glibcpp_digits (unsigned int); + static const int digits10 = __glibcpp_digits10 (unsigned int); static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1448,32 +658,27 @@ namespace std static unsigned int denorm_min() throw() { return static_cast<unsigned int>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = true; - static const bool traps = __glibcpp_unsigned_int_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_unsigned_int_max -#undef __glibcpp_unsigned_int_digits -#undef __glibcpp_unsigned_int_digits10 -#undef __glibcpp_unsigned_int_traps - template<> struct numeric_limits<long> { static const bool is_specialized = true; static long min() throw() - { return __glibcpp_signed_long_min; } + { return -__LONG_MAX__ - 1; } static long max() throw() - { return __glibcpp_signed_long_max; } + { return __LONG_MAX__; } - static const int digits = __glibcpp_signed_long_digits; - static const int digits10 = __glibcpp_signed_long_digits10; + static const int digits = __glibcpp_digits (long); + static const int digits10 = __glibcpp_digits10 (long); static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1503,22 +708,15 @@ namespace std static long denorm_min() throw() { return static_cast<long>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_signed_long_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_signed_long_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_signed_long_min -#undef __glibcpp_signed_long_max -#undef __glibcpp_signed_long_digits -#undef __glibcpp_signed_long_digits10 -#undef __glibcpp_signed_long_is_modulo -#undef __glibcpp_signed_long_traps - template<> struct numeric_limits<unsigned long> { @@ -1527,10 +725,10 @@ namespace std static unsigned long min() throw() { return 0; } static unsigned long max() throw() - { return __glibcpp_unsigned_long_max; } + { return __LONG_MAX__ * 2UL + 1; } - static const int digits = __glibcpp_unsigned_long_digits; - static const int digits10 = __glibcpp_unsigned_long_digits10; + static const int digits = __glibcpp_digits (unsigned long); + static const int digits10 = __glibcpp_digits10 (unsigned long); static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1560,32 +758,27 @@ namespace std static unsigned long denorm_min() throw() { return static_cast<unsigned long>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = true; - static const bool traps = __glibcpp_unsigned_long_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_unsigned_long_max -#undef __glibcpp_unsigned_long_digits -#undef __glibcpp_unsigned_long_digits10 -#undef __glibcpp_unsigned_long_traps - template<> struct numeric_limits<long long> { static const bool is_specialized = true; - + static long long min() throw() - { return __glibcpp_signed_long_long_min; } + { return -__LONG_LONG_MAX__ - 1; } static long long max() throw() - { return __glibcpp_signed_long_long_max; } - - static const int digits = __glibcpp_signed_long_long_digits; - static const int digits10 = __glibcpp_signed_long_long_digits10; + { return __LONG_LONG_MAX__; } + + static const int digits = __glibcpp_digits (long long); + static const int digits10 = __glibcpp_digits10 (long long); static const bool is_signed = true; static const bool is_integer = true; static const bool is_exact = true; @@ -1594,18 +787,18 @@ namespace std { return 0; } static long long round_error() throw() { return 0; } - + static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; - + static const bool has_infinity = false; static const bool has_quiet_NaN = false; static const bool has_signaling_NaN = false; static const float_denorm_style has_denorm = denorm_absent; static const bool has_denorm_loss = false; - + static long long infinity() throw() { return static_cast<long long>(0); } static long long quiet_NaN() throw() @@ -1614,23 +807,16 @@ namespace std { return static_cast<long long>(0); } static long long denorm_min() throw() { return static_cast<long long>(0); } - - static const bool is_iec559 = true; + + static const bool is_iec559 = false; static const bool is_bounded = true; - static const bool is_modulo = __glibcpp_signed_long_long_is_modulo; + static const bool is_modulo = true; - static const bool traps = __glibcpp_signed_long_long_traps; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_signed_long_long_min -#undef __glibcpp_signed_long_long_max -#undef __glibcpp_signed_long_long_digits -#undef __glibcpp_signed_long_long_digits10 -#undef __glibcpp_signed_long_long_is_modulo -#undef __glibcpp_signed_long_long_traps - template<> struct numeric_limits<unsigned long long> { @@ -1639,10 +825,10 @@ namespace std static unsigned long long min() throw() { return 0; } static unsigned long long max() throw() - { return __glibcpp_unsigned_long_long_max; } + { return __LONG_LONG_MAX__ * 2ULL + 1; } - static const int digits = __glibcpp_unsigned_long_long_digits; - static const int digits10 = __glibcpp_unsigned_long_long_digits10; + static const int digits = __glibcpp_digits (unsigned long long); + static const int digits10 = __glibcpp_digits10 (unsigned long long); static const bool is_signed = false; static const bool is_integer = true; static const bool is_exact = true; @@ -1672,95 +858,72 @@ namespace std static unsigned long long denorm_min() throw() { return static_cast<unsigned long long>(0); } - static const bool is_iec559 = true; + static const bool is_iec559 = false; static const bool is_bounded = true; static const bool is_modulo = true; - static const bool traps = true; + static const bool traps = __glibcpp_integral_traps; static const bool tinyness_before = false; static const float_round_style round_style = round_toward_zero; }; -#undef __glibcpp_unsigned_long_long_max -#undef __glibcpp_unsigned_long_long_digits -#undef __glibcpp_unsigned_long_long_digits10 -#undef __glibcpp_unsigned_long_long_traps - template<> struct numeric_limits<float> { static const bool is_specialized = true; static float min() throw() - { return __glibcpp_float_min; } + { return __FLT_MIN__; } static float max() throw() - { return __glibcpp_float_max; } + { return __FLT_MAX__; } - static const int digits = __glibcpp_float_digits; - static const int digits10 = __glibcpp_float_digits10; + static const int digits = __FLT_MANT_DIG__; + static const int digits10 = __FLT_DIG__; static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; - static const int radix = __glibcpp_float_radix; + static const int radix = __FLT_RADIX__; static float epsilon() throw() - { return __glibcpp_float_epsilon; } + { return __FLT_EPSILON__; } static float round_error() throw() - { return __glibcpp_float_round_error; } - - static const int min_exponent = __glibcpp_float_min_exponent; - static const int min_exponent10 = __glibcpp_float_min_exponent10; - static const int max_exponent = __glibcpp_float_max_exponent; - static const int max_exponent10 = __glibcpp_float_max_exponent10; - - static const bool has_infinity = __glibcpp_float_has_infinity; - static const bool has_quiet_NaN = __glibcpp_float_has_quiet_NaN; - static const bool has_signaling_NaN = __glibcpp_float_has_signaling_NaN; - static const float_denorm_style has_denorm = __glibcpp_float_has_denorm; + { return 0.5F; } + + static const int min_exponent = __FLT_MIN_EXP__; + static const int min_exponent10 = __FLT_MIN_10_EXP__; + static const int max_exponent = __FLT_MAX_EXP__; + static const int max_exponent10 = __FLT_MAX_10_EXP__; + + static const bool has_infinity + = __builtin_huge_valf () / 2 == __builtin_huge_valf (); + static const bool has_quiet_NaN + = __builtin_nanf ("") != __builtin_nanf (""); + static const bool has_signaling_NaN = has_quiet_NaN; + static const float_denorm_style has_denorm + = __FLT_DENORM_MIN__ ? denorm_present : denorm_absent; static const bool has_denorm_loss = __glibcpp_float_has_denorm_loss; static float infinity() throw() - { return __glibcpp_float_infinity; } + { return __builtin_huge_valf (); } static float quiet_NaN() throw() - { return __glibcpp_float_quiet_NaN; } + { return __builtin_nanf (""); } static float signaling_NaN() throw() - { return __glibcpp_float_signaling_NaN; } + { return __builtin_nansf (""); } static float denorm_min() throw() - { return __glibcpp_float_denorm_min; } + { return __FLT_DENORM_MIN__; } - static const bool is_iec559 = __glibcpp_float_is_iec559; - static const bool is_bounded = __glibcpp_float_is_bounded; - static const bool is_modulo = __glibcpp_float_is_modulo; + static const bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static const bool is_bounded = true; + static const bool is_modulo = false; static const bool traps = __glibcpp_float_traps; static const bool tinyness_before = __glibcpp_float_tinyness_before; - static const float_round_style round_style = __glibcpp_float_round_style; + static const float_round_style round_style = round_to_nearest; }; -#undef __glibcpp_float_min -#undef __glibcpp_float_max -#undef __glibcpp_float_digits -#undef __glibcpp_float_digits10 -#undef __glibcpp_float_radix -#undef __glibcpp_float_round_error -#undef __glibcpp_float_min_exponent -#undef __glibcpp_float_min_exponent10 -#undef __glibcpp_float_max_exponent -#undef __glibcpp_float_max_exponent10 -#undef __glibcpp_float_has_infinity -#undef __glibcpp_float_has_quiet_NaN -#undef __glibcpp_float_has_signaling_NaN -#undef __glibcpp_float_has_denorm #undef __glibcpp_float_has_denorm_loss -#undef __glibcpp_float_infinity -#undef __glibcpp_float_quiet_NaN -#undef __glibcpp_float_signaling_NaN -#undef __glibcpp_float_denorm_min -#undef __glibcpp_float_is_iec559 -#undef __glibcpp_float_is_bounded -#undef __glibcpp_float_is_modulo #undef __glibcpp_float_traps #undef __glibcpp_float_tinyness_before -#undef __glibcpp_float_round_style template<> struct numeric_limits<double> @@ -1768,159 +931,123 @@ namespace std static const bool is_specialized = true; static double min() throw() - { return __glibcpp_double_min; } + { return __DBL_MIN__; } static double max() throw() - { return __glibcpp_double_max; } + { return __DBL_MAX__; } - static const int digits = __glibcpp_double_digits; - static const int digits10 = __glibcpp_double_digits10; + static const int digits = __DBL_MANT_DIG__; + static const int digits10 = __DBL_DIG__; static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; - static const int radix = __glibcpp_double_radix; + static const int radix = __FLT_RADIX__; static double epsilon() throw() - { return __glibcpp_double_epsilon; } + { return __DBL_EPSILON__; } static double round_error() throw() - { return __glibcpp_double_round_error; } - - static const int min_exponent = __glibcpp_double_min_exponent; - static const int min_exponent10 = __glibcpp_double_min_exponent10; - static const int max_exponent = __glibcpp_double_max_exponent; - static const int max_exponent10 = __glibcpp_double_max_exponent10; - - static const bool has_infinity = __glibcpp_double_has_infinity; - static const bool has_quiet_NaN = __glibcpp_double_has_quiet_NaN; - static const bool has_signaling_NaN = __glibcpp_double_has_signaling_NaN; - static const float_denorm_style has_denorm = - __glibcpp_double_has_denorm; + { return 0.5; } + + static const int min_exponent = __DBL_MIN_EXP__; + static const int min_exponent10 = __DBL_MIN_10_EXP__; + static const int max_exponent = __DBL_MAX_EXP__; + static const int max_exponent10 = __DBL_MAX_10_EXP__; + + static const bool has_infinity + = __builtin_huge_val () / 2 == __builtin_huge_val (); + static const bool has_quiet_NaN + = __builtin_nan ("") != __builtin_nan (""); + static const bool has_signaling_NaN = has_quiet_NaN; + static const float_denorm_style has_denorm + = __DBL_DENORM_MIN__ ? denorm_present : denorm_absent; static const bool has_denorm_loss = __glibcpp_double_has_denorm_loss; static double infinity() throw() - { return __glibcpp_double_infinity; } + { return __builtin_huge_val(); } static double quiet_NaN() throw() - { return __glibcpp_double_quiet_NaN; } + { return __builtin_nan (""); } static double signaling_NaN() throw() - { return __glibcpp_double_signaling_NaN; } + { return __builtin_nans (""); } static double denorm_min() throw() - { return __glibcpp_double_denorm_min; } + { return __DBL_DENORM_MIN__; } - static const bool is_iec559 = __glibcpp_double_is_iec559; - static const bool is_bounded = __glibcpp_double_is_bounded; - static const bool is_modulo = __glibcpp_double_is_modulo; + static const bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static const bool is_bounded = true; + static const bool is_modulo = false; static const bool traps = __glibcpp_double_traps; static const bool tinyness_before = __glibcpp_double_tinyness_before; - static const float_round_style round_style = - __glibcpp_double_round_style; + static const float_round_style round_style = round_to_nearest; }; -#undef __glibcpp_double_min -#undef __glibcpp_double_max -#undef __glibcpp_double_digits -#undef __glibcpp_double_digits10 -#undef __glibcpp_double_radix -#undef __glibcpp_double_round_error -#undef __glibcpp_double_min_exponent -#undef __glibcpp_double_min_exponent10 -#undef __glibcpp_double_max_exponent -#undef __glibcpp_double_max_exponent10 -#undef __glibcpp_double_has_infinity -#undef __glibcpp_double_has_quiet_NaN -#undef __glibcpp_double_has_signaling_NaN -#undef __glibcpp_double_has_denorm #undef __glibcpp_double_has_denorm_loss -#undef __glibcpp_double_infinity -#undef __glibcpp_double_quiet_NaN -#undef __glibcpp_double_signaling_NaN -#undef __glibcpp_double_denorm_min -#undef __glibcpp_double_is_iec559 -#undef __glibcpp_double_is_bounded -#undef __glibcpp_double_is_modulo #undef __glibcpp_double_traps #undef __glibcpp_double_tinyness_before -#undef __glibcpp_double_round_style - - + template<> struct numeric_limits<long double> { static const bool is_specialized = true; static long double min() throw() - { return __glibcpp_long_double_min; } + { return __LDBL_MIN__; } static long double max() throw() - { return __glibcpp_long_double_max; } + { return __LDBL_MAX__; } - static const int digits = __glibcpp_long_double_digits; - static const int digits10 = __glibcpp_long_double_digits10; + static const int digits = __LDBL_MANT_DIG__; + static const int digits10 = __LDBL_DIG__; static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; - static const int radix = __glibcpp_long_double_radix; + static const int radix = __FLT_RADIX__; static long double epsilon() throw() - { return __glibcpp_long_double_epsilon; } + { return __LDBL_EPSILON__; } static long double round_error() throw() - { return __glibcpp_long_double_round_error; } - - static const int min_exponent = __glibcpp_long_double_min_exponent; - static const int min_exponent10 = __glibcpp_long_double_min_exponent10; - static const int max_exponent = __glibcpp_long_double_max_exponent; - static const int max_exponent10 = __glibcpp_long_double_max_exponent10; - - static const bool has_infinity = __glibcpp_long_double_has_infinity; - static const bool has_quiet_NaN = __glibcpp_long_double_has_quiet_NaN; - static const bool has_signaling_NaN = - __glibcpp_long_double_has_signaling_NaN; - static const float_denorm_style has_denorm = - __glibcpp_long_double_has_denorm; - static const bool has_denorm_loss = - __glibcpp_long_double_has_denorm_loss; + { return 0.5L; } + + static const int min_exponent = __LDBL_MIN_EXP__; + static const int min_exponent10 = __LDBL_MIN_10_EXP__; + static const int max_exponent = __LDBL_MAX_EXP__; + static const int max_exponent10 = __LDBL_MAX_10_EXP__; + + static const bool has_infinity + = __builtin_huge_vall () / 2 == __builtin_huge_vall (); + static const bool has_quiet_NaN + = __builtin_nanl ("") != __builtin_nanl (""); + static const bool has_signaling_NaN = has_quiet_NaN; + static const float_denorm_style has_denorm + = __LDBL_DENORM_MIN__ ? denorm_present : denorm_absent; + static const bool has_denorm_loss + = __glibcpp_long_double_has_denorm_loss; static long double infinity() throw() - { return __glibcpp_long_double_infinity; } + { return __builtin_huge_vall (); } static long double quiet_NaN() throw() - { return __glibcpp_long_double_quiet_NaN; } + { return __builtin_nanl (""); } static long double signaling_NaN() throw() - { return __glibcpp_long_double_signaling_NaN; } + { return __builtin_nansl (""); } static long double denorm_min() throw() - { return __glibcpp_long_double_denorm_min; } + { return __LDBL_DENORM_MIN__; } - static const bool is_iec559 = __glibcpp_long_double_is_iec559; - static const bool is_bounded = __glibcpp_long_double_is_bounded; - static const bool is_modulo = __glibcpp_long_double_is_modulo; + static const bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static const bool is_bounded = true; + static const bool is_modulo = false; - static const bool traps = __glibcpp_long_double_traps; + static const bool traps = __glibcpp_long_double_traps; static const bool tinyness_before = __glibcpp_long_double_tinyness_before; - static const float_round_style round_style = - __glibcpp_long_double_round_style; + static const float_round_style round_style = round_to_nearest; }; -#undef __glibcpp_long_double_min -#undef __glibcpp_long_double_max -#undef __glibcpp_long_double_digits -#undef __glibcpp_long_double_digits10 -#undef __glibcpp_long_double_radix -#undef __glibcpp_long_double_round_error -#undef __glibcpp_long_double_min_exponent -#undef __glibcpp_long_double_min_exponent10 -#undef __glibcpp_long_double_max_exponent -#undef __glibcpp_long_double_max_exponent10 -#undef __glibcpp_long_double_has_infinity -#undef __glibcpp_long_double_has_quiet_NaN -#undef __glibcpp_long_double_has_signaling_NaN -#undef __glibcpp_long_double_has_denorm #undef __glibcpp_long_double_has_denorm_loss -#undef __glibcpp_long_double_infinity -#undef __glibcpp_long_double_quiet_NaN -#undef __glibcpp_long_double_signaling_NaN -#undef __glibcpp_long_double_denorm_min -#undef __glibcpp_long_double_is_iec559 -#undef __glibcpp_long_double_is_bounded -#undef __glibcpp_long_double_is_modulo #undef __glibcpp_long_double_traps #undef __glibcpp_long_double_tinyness_before -#undef __glibcpp_long_double_round_style - + } // namespace std +#undef __glibcpp_signed +#undef __glibcpp_min +#undef __glibcpp_max +#undef __glibcpp_digits +#undef __glibcpp_digits10 + #endif // _CPP_NUMERIC_LIMITS diff --git a/contrib/libstdc++/include/std/std_list.h b/contrib/libstdc++/include/std/std_list.h index f32553be1f44..84523ad8e4fa 100644 --- a/contrib/libstdc++/include/std/std_list.h +++ b/contrib/libstdc++/include/std/std_list.h @@ -70,8 +70,9 @@ #include <bits/stl_uninitialized.h> #include <bits/stl_list.h> +#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT +# include <bits/list.tcc> +#endif + #endif /* _CPP_LIST */ -// Local Variables: -// mode:C++ -// End: diff --git a/contrib/libstdc++/include/std/std_locale.h b/contrib/libstdc++/include/std/std_locale.h index 9c46b96bc2f1..29602560766c 100644 --- a/contrib/libstdc++/include/std/std_locale.h +++ b/contrib/libstdc++/include/std/std_locale.h @@ -1,6 +1,6 @@ // Locale support -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2002, 2003 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 @@ -42,11 +42,8 @@ #pragma GCC system_header #include <bits/localefwd.h> +#include <bits/locale_classes.h> #include <bits/locale_facets.h> #include <bits/locale_facets.tcc> #endif - -// Local Variables: -// mode:c++ -// End: diff --git a/contrib/libstdc++/include/std/std_memory.h b/contrib/libstdc++/include/std/std_memory.h index 5850eb2a0075..47c3ede8995d 100644 --- a/contrib/libstdc++/include/std/std_memory.h +++ b/contrib/libstdc++/include/std/std_memory.h @@ -58,314 +58,301 @@ #include <bits/stl_uninitialized.h> #include <bits/stl_raw_storage_iter.h> -// Since this entire file is within namespace std, there's no reason to -// waste two spaces along the left column. Thus the leading indentation is -// slightly violated from here on. namespace std { -/** - * @if maint - * This is a helper function. The unused second parameter exists to - * permit the real get_temporary_buffer to use template parameter deduction. - * - * XXX This should perhaps use the pool. - * @endif -*/ -template <typename _Tp> -pair<_Tp*, ptrdiff_t> -__get_temporary_buffer(ptrdiff_t __len, _Tp*) -{ - if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp))) - __len = INT_MAX / sizeof(_Tp); - - while (__len > 0) { - _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp)); - if (__tmp != 0) - return pair<_Tp*, ptrdiff_t>(__tmp, __len); - __len /= 2; - } - - return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0); -} - -/** - * @brief This is a mostly-useless wrapper around malloc(). - * @param len The number of objects of type Tp. - * @return See full description. - * - * Reinventing the wheel, but this time with prettier spokes! - * - * This function tries to obtain storage for @c len adjacent Tp objects. - * The objects themselves are not constructed, of course. A pair<> is - * returned containing "the buffer s address and capacity (in the units of - * sizeof(Tp)), or a pair of 0 values if no storage can be obtained." - * Note that the capacity obtained may be less than that requested if the - * memory is unavailable; you should compare len with the .second return - * value. -*/ -template<typename _Tp> - inline pair<_Tp*,ptrdiff_t> - get_temporary_buffer(ptrdiff_t __len) - { - return __get_temporary_buffer(__len, (_Tp*) 0); - } - -/** - * @brief The companion to get_temporary_buffer(). - * @param p A buffer previously allocated by get_temporary_buffer. - * @return None. - * - * Frees the memory pointed to by p. - */ -template<typename _Tp> - void - return_temporary_buffer(_Tp* __p) - { - std::free(__p); - } - - -/** - * A wrapper class to provide auto_ptr with reference semantics. For - * example, an auto_ptr can be assigned (or constructed from) the result of - * a function which returns an auto_ptr by value. - * - * All the auto_ptr_ref stuff should happen behind the scenes. -*/ -template<typename _Tp1> - struct auto_ptr_ref -{ - _Tp1* _M_ptr; - - explicit - auto_ptr_ref(_Tp1* __p) - : _M_ptr(__p) {} -}; - - -/** - * @brief A simple smart pointer providing strict ownership semantics. - * - * The Standard says: - * <pre> - * An @c auto_ptr owns the object it holds a pointer to. Copying an - * @c auto_ptr copies the pointer and transfers ownership to the destination. - * If more than one @c auto_ptr owns the same object at the same time the - * behavior of the program is undefined. - * - * The uses of @c auto_ptr include providing temporary exception-safety for - * dynamically allocated memory, passing ownership of dynamically allocated - * memory to a function, and returning dynamically allocated memory from a - * function. @c auto_ptr does not meet the CopyConstructible and Assignable - * requirements for Standard Library <a href="tables.html#65">container</a> - * elements and thus instantiating a Standard Library container with an - * @c auto_ptr results in undefined behavior. - * </pre> - * Quoted from [20.4.5]/3. - * - * Good examples of what can and cannot be done with auto_ptr can be found - * in the libstdc++ testsuite. - * - * @if maint - * _GLIBCPP_RESOLVE_LIB_DEFECTS - * 127. auto_ptr<> conversion issues - * These resolutions have all been incorporated. - * @endif -*/ -template<typename _Tp> - class auto_ptr -{ -private: - _Tp* _M_ptr; - -public: - /// The pointed-to type. - typedef _Tp element_type; - /** - * @brief An %auto_ptr is usually constructed from a raw pointer. - * @param p A pointer (defaults to NULL). - * - * This object now @e owns the object pointed to by @a p. - */ - explicit - auto_ptr(element_type* __p = 0) throw() - : _M_ptr(__p) { } - - /** - * @brief An %auto_ptr can be constructed from another %auto_ptr. - * @param a Another %auto_ptr of the same type. - * - * This object now @e owns the object previously owned by @a a, which has - * given up ownsership. - */ - auto_ptr(auto_ptr& __a) throw() - : _M_ptr(__a.release()) { } - - /** - * @brief An %auto_ptr can be constructed from another %auto_ptr. - * @param a Another %auto_ptr of a different but related type. - * - * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. - * - * This object now @e owns the object previously owned by @a a, which has - * given up ownsership. - */ - template<typename _Tp1> - auto_ptr(auto_ptr<_Tp1>& __a) throw() - : _M_ptr(__a.release()) { } - - /** - * @brief %auto_ptr assignment operator. - * @param a Another %auto_ptr of the same type. + * @if maint + * This is a helper function. The unused second parameter exists to + * permit the real get_temporary_buffer to use template parameter deduction. * - * This object now @e owns the object previously owned by @a a, which has - * given up ownsership. The object that this one @e used to own and - * track has been deleted. - */ - auto_ptr& - operator=(auto_ptr& __a) throw() + * XXX This should perhaps use the pool. + * @endif + */ + template<typename _Tp> + pair<_Tp*, ptrdiff_t> + __get_temporary_buffer(ptrdiff_t __len, _Tp*) { - reset(__a.release()); - return *this; + if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp))) + __len = INT_MAX / sizeof(_Tp); + + while (__len > 0) + { + _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp)); + if (__tmp != 0) + return pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len /= 2; + } + return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0); } /** - * @brief %auto_ptr assignment operator. - * @param a Another %auto_ptr of a different but related type. + * @brief This is a mostly-useless wrapper around malloc(). + * @param len The number of objects of type Tp. + * @return See full description. * - * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. + * Reinventing the wheel, but this time with prettier spokes! * - * This object now @e owns the object previously owned by @a a, which has - * given up ownsership. The object that this one @e used to own and - * track has been deleted. - */ - template <typename _Tp1> - auto_ptr& - operator=(auto_ptr<_Tp1>& __a) throw() - { - reset(__a.release()); - return *this; - } + * This function tries to obtain storage for @c len adjacent Tp objects. + * The objects themselves are not constructed, of course. A pair<> is + * returned containing "the buffer s address and capacity (in the units of + * sizeof(Tp)), or a pair of 0 values if no storage can be obtained." + * Note that the capacity obtained may be less than that requested if the + * memory is unavailable; you should compare len with the .second return + * value. + */ + template<typename _Tp> + inline pair<_Tp*,ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) + { return __get_temporary_buffer(__len, (_Tp*) 0); } /** - * When the %auto_ptr goes out of scope, the object it owns is deleted. - * If it no longer owns anything (i.e., @c get() is @c NULL), then this - * has no effect. + * @brief The companion to get_temporary_buffer(). + * @param p A buffer previously allocated by get_temporary_buffer. + * @return None. * - * @if maint - * The C++ standard says there is supposed to be an empty throw - * specification here, but omitting it is standard conforming. Its - * presence can be detected only if _Tp::~_Tp() throws, but this is - * prohibited. [17.4.3.6]/2 - * @end maint - */ - ~auto_ptr() { delete _M_ptr; } + * Frees the memory pointed to by p. + */ + template<typename _Tp> + void + return_temporary_buffer(_Tp* __p) + { std::free(__p); } /** - * @brief Smart pointer dereferencing. + * A wrapper class to provide auto_ptr with reference semantics. For + * example, an auto_ptr can be assigned (or constructed from) the result of + * a function which returns an auto_ptr by value. * - * If this %auto_ptr no longer owns anything, then this operation will - * crash. (For a smart pointer, "no longer owns anything" is the same as - * being a null pointer, and you know what happens when you dereference - * one of those...) - */ - element_type& - operator*() const throw() { return *_M_ptr; } + * All the auto_ptr_ref stuff should happen behind the scenes. + */ + template<typename _Tp1> + struct auto_ptr_ref + { + _Tp1* _M_ptr; + + explicit + auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } + }; - /** - * @brief Smart pointer dereferencing. - * - * This returns the pointer itself, which the language then will - * automatically cause to be dereferenced. - */ - element_type* - operator->() const throw() { return _M_ptr; } /** - * @brief Bypassing the smart pointer. - * @return The raw pointer being managed. + * @brief A simple smart pointer providing strict ownership semantics. * - * You can get a copy of the pointer that this object owns, for - * situations such as passing to a function which only accepts a raw - * pointer. + * The Standard says: + * <pre> + * An @c auto_ptr owns the object it holds a pointer to. Copying an + * @c auto_ptr copies the pointer and transfers ownership to the destination. + * If more than one @c auto_ptr owns the same object at the same time the + * behavior of the program is undefined. * - * @note This %auto_ptr still owns the memory. - */ - element_type* - get() const throw() { return _M_ptr; } - - /** - * @brief Bypassing the smart pointer. - * @return The raw pointer being managed. + * The uses of @c auto_ptr include providing temporary exception-safety for + * dynamically allocated memory, passing ownership of dynamically allocated + * memory to a function, and returning dynamically allocated memory from a + * function. @c auto_ptr does not meet the CopyConstructible and Assignable + * requirements for Standard Library <a href="tables.html#65">container</a> + * elements and thus instantiating a Standard Library container with an + * @c auto_ptr results in undefined behavior. + * </pre> + * Quoted from [20.4.5]/3. * - * You can get a copy of the pointer that this object owns, for - * situations such as passing to a function which only accepts a raw - * pointer. + * Good examples of what can and cannot be done with auto_ptr can be found + * in the libstdc++ testsuite. * - * @note This %auto_ptr no longer owns the memory. When this object - * goes out of scope, nothing will happen. - */ - element_type* - release() throw() - { - element_type* __tmp = _M_ptr; - _M_ptr = 0; - return __tmp; - } - - /** - * @brief Forcibly deletes the managed object. - * @param p A pointer (defaults to NULL). - * - * This object now @e owns the object pointed to by @a p. The previous - * object has been deleted. - */ - void - reset(element_type* __p = 0) throw() - { - if (__p != _M_ptr) - { - delete _M_ptr; - _M_ptr = __p; - } - } - - /** @{ - * @brief Automatic conversions - * - * These operations convert an %auto_ptr into and from an auto_ptr_ref - * automatically as needed. This allows constructs such as - * @code - * auto_ptr<Derived> func_returning_auto_ptr(.....); - * ... - * auto_ptr<Base> ptr = func_returning_auto_ptr(.....); - * @endcode - */ - auto_ptr(auto_ptr_ref<element_type> __ref) throw() - : _M_ptr(__ref._M_ptr) {} - - auto_ptr& - operator=(auto_ptr_ref<element_type> __ref) throw() + * @if maint + * _GLIBCPP_RESOLVE_LIB_DEFECTS + * 127. auto_ptr<> conversion issues + * These resolutions have all been incorporated. + * @endif + */ + template<typename _Tp> + class auto_ptr { - if (__ref._M_ptr != this->get()) + private: + _Tp* _M_ptr; + + public: + /// The pointed-to type. + typedef _Tp element_type; + + /** + * @brief An %auto_ptr is usually constructed from a raw pointer. + * @param p A pointer (defaults to NULL). + * + * This object now @e owns the object pointed to by @a p. + */ + explicit + auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } + + /** + * @brief An %auto_ptr can be constructed from another %auto_ptr. + * @param a Another %auto_ptr of the same type. + * + * This object now @e owns the object previously owned by @a a, + * which has given up ownsership. + */ + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } + + /** + * @brief An %auto_ptr can be constructed from another %auto_ptr. + * @param a Another %auto_ptr of a different but related type. + * + * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. + * + * This object now @e owns the object previously owned by @a a, + * which has given up ownsership. + */ + template<typename _Tp1> + auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } + + /** + * @brief %auto_ptr assignment operator. + * @param a Another %auto_ptr of the same type. + * + * This object now @e owns the object previously owned by @a a, + * which has given up ownsership. The object that this one @e + * used to own and track has been deleted. + */ + auto_ptr& + operator=(auto_ptr& __a) throw() + { + reset(__a.release()); + return *this; + } + + /** + * @brief %auto_ptr assignment operator. + * @param a Another %auto_ptr of a different but related type. + * + * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. + * + * This object now @e owns the object previously owned by @a a, + * which has given up ownsership. The object that this one @e + * used to own and track has been deleted. + */ + template<typename _Tp1> + auto_ptr& + operator=(auto_ptr<_Tp1>& __a) throw() { - delete _M_ptr; - _M_ptr = __ref._M_ptr; - } - return *this; - } - - template<typename _Tp1> - operator auto_ptr_ref<_Tp1>() throw() - { return auto_ptr_ref<_Tp1>(this->release()); } - - template<typename _Tp1> - operator auto_ptr<_Tp1>() throw() - { return auto_ptr<_Tp1>(this->release()); } - /** @} */ -}; - + reset(__a.release()); + return *this; + } + + /** + * When the %auto_ptr goes out of scope, the object it owns is deleted. + * If it no longer owns anything (i.e., @c get() is @c NULL), then this + * has no effect. + * + * @if maint + * The C++ standard says there is supposed to be an empty throw + * specification here, but omitting it is standard conforming. Its + * presence can be detected only if _Tp::~_Tp() throws, but this is + * prohibited. [17.4.3.6]/2 + * @end maint + */ + ~auto_ptr() { delete _M_ptr; } + + /** + * @brief Smart pointer dereferencing. + * + * If this %auto_ptr no longer owns anything, then this + * operation will crash. (For a smart pointer, "no longer owns + * anything" is the same as being a null pointer, and you know + * what happens when you dereference one of those...) + */ + element_type& + operator*() const throw() { return *_M_ptr; } + + /** + * @brief Smart pointer dereferencing. + * + * This returns the pointer itself, which the language then will + * automatically cause to be dereferenced. + */ + element_type* + operator->() const throw() { return _M_ptr; } + + /** + * @brief Bypassing the smart pointer. + * @return The raw pointer being managed. + * + * You can get a copy of the pointer that this object owns, for + * situations such as passing to a function which only accepts a raw + * pointer. + * + * @note This %auto_ptr still owns the memory. + */ + element_type* + get() const throw() { return _M_ptr; } + + /** + * @brief Bypassing the smart pointer. + * @return The raw pointer being managed. + * + * You can get a copy of the pointer that this object owns, for + * situations such as passing to a function which only accepts a raw + * pointer. + * + * @note This %auto_ptr no longer owns the memory. When this object + * goes out of scope, nothing will happen. + */ + element_type* + release() throw() + { + element_type* __tmp = _M_ptr; + _M_ptr = 0; + return __tmp; + } + + /** + * @brief Forcibly deletes the managed object. + * @param p A pointer (defaults to NULL). + * + * This object now @e owns the object pointed to by @a p. The previous + * object has been deleted. + */ + void + reset(element_type* __p = 0) throw() + { + if (__p != _M_ptr) + { + delete _M_ptr; + _M_ptr = __p; + } + } + + /** @{ + * @brief Automatic conversions + * + * These operations convert an %auto_ptr into and from an auto_ptr_ref + * automatically as needed. This allows constructs such as + * @code + * auto_ptr<Derived> func_returning_auto_ptr(.....); + * ... + * auto_ptr<Base> ptr = func_returning_auto_ptr(.....); + * @endcode + */ + auto_ptr(auto_ptr_ref<element_type> __ref) throw() + : _M_ptr(__ref._M_ptr) { } + + auto_ptr& + operator=(auto_ptr_ref<element_type> __ref) throw() + { + if (__ref._M_ptr != this->get()) + { + delete _M_ptr; + _M_ptr = __ref._M_ptr; + } + return *this; + } + + template<typename _Tp1> + operator auto_ptr_ref<_Tp1>() throw() + { return auto_ptr_ref<_Tp1>(this->release()); } + + template<typename _Tp1> + operator auto_ptr<_Tp1>() throw() + { return auto_ptr<_Tp1>(this->release()); } + /** @} */ + }; } // namespace std -#endif /* _CPP_MEMORY */ +#endif diff --git a/contrib/libstdc++/include/std/std_ostream.h b/contrib/libstdc++/include/std/std_ostream.h index eff4bb5119f3..82f8a2864bc6 100644 --- a/contrib/libstdc++/include/std/std_ostream.h +++ b/contrib/libstdc++/include/std/std_ostream.h @@ -46,7 +46,14 @@ namespace std { - // 27.6.2.1 Template class basic_ostream + // [27.6.2.1] Template class basic_ostream + /** + * @brief Controlling output. + * + * This is the base class for all output streams. It provides text + * formatting of all builtin types, and communicates with any class + * derived from basic_streambuf to do the actual output. + */ template<typename _CharT, typename _Traits> class basic_ostream : virtual public basic_ios<_CharT, _Traits> { @@ -66,20 +73,60 @@ namespace std typedef num_put<_CharT, __ostreambuf_iter> __numput_type; typedef ctype<_CharT> __ctype_type; - // 27.6.2.2 Constructor/destructor: + template<typename _CharT2, typename _Traits2> + friend basic_ostream<_CharT2, _Traits2>& + operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2); + + template<typename _Traits2> + friend basic_ostream<char, _Traits2>& + operator<<(basic_ostream<char, _Traits2>&, char); + + template<typename _CharT2, typename _Traits2> + friend basic_ostream<_CharT2, _Traits2>& + operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*); + + template<typename _Traits2> + friend basic_ostream<char, _Traits2>& + operator<<(basic_ostream<char, _Traits2>&, const char*); + + template<typename _CharT2, typename _Traits2> + friend basic_ostream<_CharT2, _Traits2>& + operator<<(basic_ostream<_CharT2, _Traits2>&, const char*); + + // [27.6.2.2] constructor/destructor + /** + * @brief Base constructor. + * + * This ctor is almost never called by the user directly, rather from + * derived classes' initialization lists, which pass a pointer to + * their own stream buffer. + */ explicit basic_ostream(__streambuf_type* __sb) { this->init(__sb); } + /** + * @brief Base destructor. + * + * This does very little apart from providing a virtual base dtor. + */ virtual ~basic_ostream() { } - // 27.6.2.3 Prefix/suffix: + // [27.6.2.3] prefix/suffix class sentry; friend class sentry; - // 27.6.2.5 Formatted output: - // 27.6.2.5.3 basic_ostream::operator<< + // [27.6.2.5] formatted output + // [27.6.2.5.3] basic_ostream::operator<< + //@{ + /** + * @brief Interface for manipulators. + * + * Manuipulators such as @c std::endl and @c std::hex use these + * functions in constructs like "std::cout << std::endl". For more + * information, see the iomanip header. + */ __ostream_type& operator<<(__ostream_type& (*__pf)(__ostream_type&)); @@ -88,8 +135,35 @@ namespace std __ostream_type& operator<<(ios_base& (*__pf) (ios_base&)); - - // 27.6.2.5.2 Arithmetic Inserters + //@} + + // [27.6.2.5.2] arithmetic inserters + /** + * @name Arithmetic Inserters + * + * All the @c operator<< functions (aka <em>formatted output + * functions</em>) have some common behavior. Each starts by + * constructing a temporary object of type std::basic_ostream::sentry. + * This can have several effects, concluding with the setting of a + * status flag; see the sentry documentation for more. + * + * If the sentry status is good, the function tries to generate + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during insertion, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Basic arithmetic inserters + * @param A variable of builtin type. + * @return @c *this if successful + * + * These functions use the stream's current locale (specifically, the + * @c num_get facet) to perform numeric formatting. + */ __ostream_type& operator<<(long __n); @@ -150,31 +224,140 @@ namespace std __ostream_type& operator<<(const void* __p); + /** + * @brief Extracting from another streambuf. + * @param sb A pointer to a streambuf + * + * This function behaves like one of the basic arithmetic extractors, + * in that it also constructs a sentry onject and has the same error + * handling behavior. + * + * If @a sb is NULL, the stream will set failbit in its error state. + * + * Characters are extracted from @a sb and inserted into @c *this + * until one of the following occurs: + * + * - the input stream reaches end-of-file, + * - insertion into the output sequence fails (in this case, the + * character that would have been inserted is not extracted), or + * - an exception occurs while getting a character from @a sb, which + * sets failbit in the error state + * + * If the function inserts no characters, failbit is set. + */ __ostream_type& operator<<(__streambuf_type* __sb); - - // Unformatted output: + //@} + + // [27.6.2.6] unformatted output functions + /** + * @name Unformatted Output Functions + * + * All the unformatted output functions have some common behavior. + * Each starts by constructing a temporary object of type + * std::basic_ostream::sentry. This has several effects, concluding + * with the setting of a status flag; see the sentry documentation + * for more. + * + * If the sentry status is good, the function tries to generate + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during insertion, ios_base::badbit + * will be turned on in the stream's error state. If badbit is on in + * the stream's exceptions mask, the exception will be rethrown + * without completing its actions. + */ + //@{ + /** + * @brief Simple insertion. + * @param c The character to insert. + * @return *this + * + * Tries to insert @a c. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ __ostream_type& put(char_type __c); + /** + * @brief Character string insertion. + * @param s The array to insert. + * @param n Maximum number of characters to insert. + * @return *this + * + * Characters are copied from @a s and inserted into the stream until + * one of the following happens: + * + * - @a n characters are inserted + * - inserting into the output sequence fails (in this case, badbit + * will be set in the stream's error state) + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ __ostream_type& write(const char_type* __s, streamsize __n); - + //@} + + /** + * @brief Synchronizing the stream buffer. + * @return *this + * + * If @c rdbuf() is a null pointer, changes nothing. + * + * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, + * sets badbit. + */ __ostream_type& flush(); - // Seeks: + // [27.6.2.4] seek members + /** + * @brief Getting the current write position. + * @return A file position object. + * + * If @c fail() is not false, returns @c pos_type(-1) to indicate + * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out). + */ pos_type tellp(); + /** + * @brief Changing the current write position. + * @param pos A file position object. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If + * that function fails, sets failbit. + */ __ostream_type& seekp(pos_type); - __ostream_type& + /** + * @brief Changing the current write position. + * @param off A file offset object. + * @param dir The direction in which to seek. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). + * If that function fails, sets failbit. + */ + __ostream_type& seekp(off_type, ios_base::seekdir); }; - // 27.6.2.3 Class basic_ostream::sentry + /** + * @brief Performs setup work for output streams. + * + * Objects of this class are created before all of the standard + * inserters are run. It is responsible for "exception-safe prefix and + * suffix operations." Additional actions may be added by the + * implementation, and we list them in + * http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/howto.html#5 + * under [27.6] notes. + */ template <typename _CharT, typename _Traits> class basic_ostream<_CharT, _Traits>::sentry { @@ -183,9 +366,27 @@ namespace std basic_ostream<_CharT,_Traits>& _M_os; public: + /** + * @brief The constructor performs preparatory work. + * @param os The output stream to guard. + * + * If the stream state is good (@a os.good() is true), then if the + * stream is tied to another output stream, @c is.tie()->flush() + * is called to synchronize the output sequences. + * + * If the stream state is still good, then the sentry state becomes + * true ("okay"). + */ explicit sentry(basic_ostream<_CharT,_Traits>& __os); + /** + * @brief Possibly flushes the stream. + * + * If @c ios_base::unitbuf is set in @c os.flags(), and + * @c std::uncaught_exception() is true, the sentry destructor calls + * @c flush() on the output stream. + */ ~sentry() { // XXX MT @@ -197,10 +398,34 @@ namespace std } } + /** + * @brief Quick status checking. + * @return The sentry state. + * + * For ease of use, sentries may be converted to booleans. The + * return value is that of the sentry state (true == okay). + */ operator bool() { return _M_ok; } }; + // [27.6.2.5.4] character insertion templates + //@{ + /** + * @brief Character inserters + * @param out An output stream. + * @param c A character. + * @return out + * + * Behaves like one of the formatted arithmetic inserters described in + * std::basic_ostream. After constructing a sentry object with good + * status, this function inserts a single character and any required + * padding (as determined by [22.2.2.2.2]). @c out.width(0) is then + * called. + * + * If @a c is of type @c char and the character type of the stream is not + * @c char, the character is widened before insertion. + */ template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c); @@ -225,7 +450,22 @@ namespace std basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c) { return (__out << static_cast<char>(__c)); } + //@} + //@{ + /** + * @brief String inserters + * @param out An output stream. + * @param s A character string. + * @return out + * @pre @a s must be a non-NULL pointer + * + * Behaves like one of the formatted arithmetic inserters described in + * std::basic_ostream. After constructing a sentry object with good + * status, this function inserts @c traits::length(s) characters starting + * at @a s, widened if necessary, followed by any required padding (as + * determined by [22.2.2.2.2]). @c out.width(0) is then called. + */ template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s); @@ -249,18 +489,38 @@ namespace std basic_ostream<char, _Traits> & operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s) { return (__out << reinterpret_cast<const char*>(__s)); } - - // 27.6.2.7 Standard basic_ostream manipulators + //@} + + // [27.6.2.7] standard basic_ostream manipulators + /** + * @brief Write a newline and flush the stream. + * + * This manipulator is often mistakenly used when a simple newline is + * desired, leading to poor buffering performance. See + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for more + * on this subject. + */ template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) { return flush(__os.put(__os.widen('\n'))); } + /** + * @brief Write a null character into the output sequence. + * + * "Null character" is @c CharT() by definition. For CharT of @c char, + * this correctly writes the ASCII @c NUL character string terminator. + */ template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) { return __os.put(_CharT()); } + /** + * @brief Flushes the output stream. + * + * This manipulator simply calls the stream's @c flush() member function. + */ template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) diff --git a/contrib/libstdc++/include/std/std_queue.h b/contrib/libstdc++/include/std/std_queue.h index 6be35516d659..60636e6f0dd8 100644 --- a/contrib/libstdc++/include/std/std_queue.h +++ b/contrib/libstdc++/include/std/std_queue.h @@ -74,8 +74,9 @@ #include <bits/stl_function.h> #include <bits/stl_queue.h> -#endif /* _CPP_QUEUE */ +#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT +# include <bits/deque.tcc> +# include <bits/vector.tcc> +#endif -// Local Variables: -// mode:C++ -// End: +#endif /* _CPP_QUEUE */ diff --git a/contrib/libstdc++/include/std/std_sstream.h b/contrib/libstdc++/include/std/std_sstream.h index 6ee750531485..0940e60f52e7 100644 --- a/contrib/libstdc++/include/std/std_sstream.h +++ b/contrib/libstdc++/include/std/std_sstream.h @@ -1,6 +1,6 @@ // String based streams -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2002 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2002, 2003 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 @@ -46,6 +46,18 @@ namespace std { + // [27.7.1] template class basic_stringbuf + /** + * @brief The actual work of input and output (for std::string). + * + * This class associates either or both of its input and output sequences + * with a sequence of characters, which can be initialized from, or made + * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) + * + * For this class, open modes (of type @c ios_base::openmode) have + * @c in set if the input sequence can be read, and @c out set if the + * output sequence can be written. + */ template<typename _CharT, typename _Traits, typename _Alloc> class basic_stringbuf : public basic_streambuf<_CharT, _Traits> { @@ -61,22 +73,48 @@ namespace std typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; - // Non-standard Types: + //@{ + /** + * @if maint + * @doctodo + * @endif + */ typedef basic_streambuf<char_type, traits_type> __streambuf_type; typedef basic_string<char_type, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; + //@} protected: // Data Members: + /** + * @if maint + * @doctodo + * @endif + */ __string_type _M_string; public: // Constructors: + /** + * @brief Starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * The default constructor initializes the parent class using its + * own default ctor. + */ explicit basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) : __streambuf_type(), _M_string() { _M_stringbuf_init(__mode); } + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * This constructor initializes the parent class using its + * own default ctor. + */ explicit basic_stringbuf(const __string_type& __str, ios_base::openmode __mode = ios_base::in | ios_base::out) @@ -84,6 +122,14 @@ namespace std { _M_stringbuf_init(__mode); } // Get and set: + /** + * @brief Copying out the string buffer. + * @return A copy of one of the underlying sequences. + * + * "If the buffer is only created in input mode, the underlying + * character sequence is equal to the input sequence; otherwise, it + * is equal to the output sequence." [27.7.1.2]/1 + */ __string_type str() const { @@ -94,7 +140,7 @@ namespace std // _M_string, and may not be the correct size of the // current stringbuf internal buffer. __size_type __len = _M_string.size(); - if (_M_out_cur > _M_out_beg) + if (_M_out_end > _M_out_beg) __len = max(__size_type(_M_out_end - _M_out_beg), __len); return __string_type(_M_out_beg, _M_out_beg + __len); } @@ -102,6 +148,13 @@ namespace std return _M_string; } + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Deallocates any previous stored sequence, then copies @a s to + * use as a new one. + */ void str(const __string_type& __s) { @@ -112,6 +165,11 @@ namespace std protected: // Common initialization code for both ctors goes here. + /** + * @if maint + * @doctodo + * @endif + */ void _M_stringbuf_init(ios_base::openmode __mode) { @@ -135,6 +193,7 @@ namespace std } // Overridden virtual functions: + // [documentation is inherited] virtual int_type underflow() { @@ -144,12 +203,25 @@ namespace std return traits_type::eof(); } + // [documentation is inherited] virtual int_type pbackfail(int_type __c = traits_type::eof()); + // [documentation is inherited] virtual int_type overflow(int_type __c = traits_type::eof()); + /** + * @brief Manipulates the buffer. + * @param s Pointer to a buffer area. + * @param n Size of @a s. + * @return @c this + * + * If no buffer has already been created, and both @a s and @a n are + * non-zero, then @c s is used as a buffer; see + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 + * for more. + */ virtual __streambuf_type* setbuf(char_type* __s, streamsize __n) { @@ -161,10 +233,12 @@ namespace std return this; } + // [documentation is inherited] virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); + // [documentation is inherited] virtual pos_type seekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out); @@ -175,6 +249,11 @@ namespace std // Assumes: contents of _M_string and internal buffer match exactly. // __i == _M_in_cur - _M_in_beg // __o == _M_out_cur - _M_out_beg + /** + * @if maint + * @doctodo + * @endif + */ virtual int _M_really_sync(__size_type __i, __size_type __o) { @@ -196,7 +275,15 @@ namespace std }; - // 27.7.2 Template class basic_istringstream + // [27.7.2] Template class basic_istringstream + /** + * @brief Controlling input for std::string. + * + * This class supports reading from objects of type std::basic_string, + * using the inherited functions from std::basic_istream. To control + * the associated sequence, an instance of std::basic_stringbuf is used, + * which this page refers to as @c sb. + */ template<typename _CharT, typename _Traits, typename _Alloc> class basic_istringstream : public basic_istream<_CharT, _Traits> { @@ -218,40 +305,104 @@ namespace std typedef basic_istream<char_type, traits_type> __istream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __stringbuf_type _M_stringbuf; public: // Constructors: + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::in is automatically included in @a mode. + * + * Initializes @c sb using @c mode|in, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_istringstream(ios_base::openmode __mode = ios_base::in) : __istream_type(NULL), _M_stringbuf(__mode | ios_base::in) { this->init(&_M_stringbuf); } + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::in is automatically included in @a mode. + * + * Initializes @c sb using @a str and @c mode|in, and passes @c &sb + * to the base class initializer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_istringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::in) : __istream_type(NULL), _M_stringbuf(__str, __mode | ios_base::in) { this->init(&_M_stringbuf); } + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ ~basic_istringstream() { } // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ __string_type str() const { return _M_stringbuf.str(); } + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; - // 27.7.3 Template class basic_ostringstream + // [27.7.3] Template class basic_ostringstream + /** + * @brief Controlling output for std::string. + * + * This class supports writing to objects of type std::basic_string, + * using the inherited functions from std::basic_ostream. To control + * the associated sequence, an instance of std::basic_stringbuf is used, + * which this page refers to as @c sb. + */ template <typename _CharT, typename _Traits, typename _Alloc> class basic_ostringstream : public basic_ostream<_CharT, _Traits> { @@ -273,40 +424,104 @@ namespace std typedef basic_ostream<char_type, traits_type> __ostream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __stringbuf_type _M_stringbuf; public: - // Constructors/destructor: + // Constructors/destructor: + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::out is automatically included in @a mode. + * + * Initializes @c sb using @c mode|out, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_ostringstream(ios_base::openmode __mode = ios_base::out) : __ostream_type(NULL), _M_stringbuf(__mode | ios_base::out) { this->init(&_M_stringbuf); } + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::out is automatically included in @a mode. + * + * Initializes @c sb using @a str and @c mode|out, and passes @c &sb + * to the base class initializer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_ostringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::out) : __ostream_type(NULL), _M_stringbuf(__str, __mode | ios_base::out) { this->init(&_M_stringbuf); } + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ ~basic_ostringstream() { } // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ __string_type str() const { return _M_stringbuf.str(); } + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; - // 27.7.4 Template class basic_stringstream + // [27.7.4] Template class basic_stringstream + /** + * @brief Controlling input and output for std::string. + * + * This class supports reading from and writing to objects of type + * std::basic_string, using the inherited functions from + * std::basic_iostream. To control the associated sequence, an instance + * of std::basic_stringbuf is used, which this page refers to as @c sb. + */ template <typename _CharT, typename _Traits, typename _Alloc> class basic_stringstream : public basic_iostream<_CharT, _Traits> { @@ -328,33 +543,85 @@ namespace std typedef basic_iostream<char_type, traits_type> __iostream_type; private: + /** + * @if maint + * @doctodo + * @endif + */ __stringbuf_type _M_stringbuf; public: // Constructors/destructors + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * Initializes @c sb using @c mode, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(NULL), _M_stringbuf(__m) { this->init(&_M_stringbuf); } + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * Initializes @c sb using @a str and @c mode, and passes @c &sb + * to the base class initializer. + * + * @if maint + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + * @endif + */ explicit basic_stringstream(const __string_type& __str, ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(NULL), _M_stringbuf(__str, __m) { this->init(&_M_stringbuf); } + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ ~basic_stringstream() { } // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ __string_type str() const { return _M_stringbuf.str(); } + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } diff --git a/contrib/libstdc++/include/std/std_stack.h b/contrib/libstdc++/include/std/std_stack.h index e517c42b6ab6..ddae7e78fc68 100644 --- a/contrib/libstdc++/include/std/std_stack.h +++ b/contrib/libstdc++/include/std/std_stack.h @@ -70,8 +70,8 @@ #include <bits/stl_deque.h> #include <bits/stl_stack.h> -#endif /* _CPP_STACK */ +#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT +# include <bits/deque.tcc> +#endif -// Local Variables: -// mode:C++ -// End: +#endif /* _CPP_STACK */ diff --git a/contrib/libstdc++/include/std/std_streambuf.h b/contrib/libstdc++/include/std/std_streambuf.h index db36ed3d75dc..a1958c1a8e7c 100644 --- a/contrib/libstdc++/include/std/std_streambuf.h +++ b/contrib/libstdc++/include/std/std_streambuf.h @@ -50,28 +50,104 @@ namespace std { + /** + * @if maint + * Does stuff. + * @endif + */ template<typename _CharT, typename _Traits> streamsize __copy_streambufs(basic_ios<_CharT, _Traits>& _ios, basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout); - // 27.5.2 Template class basic_streambuf<_CharT, _Traits> + /** + * @brief The actual work of input and output (interface). + * + * This is a base class. Derived stream buffers each control a + * pair of character sequences: one for input, and one for output. + * + * Section [27.5.1] of the standard describes the requirements and + * behavior of stream buffer classes. That section (three paragraphs) + * is reproduced here, for simplicity and accuracy. + * + * -# Stream buffers can impose various constraints on the sequences + * they control. Some constraints are: + * - The controlled input sequence can be not readable. + * - The controlled output sequence can be not writable. + * - The controlled sequences can be associated with the contents of + * other representations for character sequences, such as external + * files. + * - The controlled sequences can support operations @e directly to or + * from associated sequences. + * - The controlled sequences can impose limitations on how the + * program can read characters from a sequence, write characters to + * a sequence, put characters back into an input sequence, or alter + * the stream position. + * . + * -# Each sequence is characterized by three pointers which, if non-null, + * all point into the same @c charT array object. The array object + * represents, at any moment, a (sub)sequence of characters from the + * sequence. Operations performed on a sequence alter the values + * stored in these pointers, perform reads and writes directly to or + * from associated sequences, and alter "the stream position" and + * conversion state as needed to maintain this subsequence relationship. + * The three pointers are: + * - the <em>beginning pointer</em>, or lowest element address in the + * array (called @e xbeg here); + * - the <em>next pointer</em>, or next element address that is a + * current candidate for reading or writing (called @e xnext here); + * - the <em>end pointer</em>, or first element address beyond the + * end of the array (called @e xend here). + * . + * -# The following semantic constraints shall always apply for any set + * of three pointers for a sequence, using the pointer names given + * immediately above: + * - If @e xnext is not a null pointer, then @e xbeg and @e xend shall + * also be non-null pointers into the same @c charT array, as + * described above; otherwise, @e xbeg and @e xend shall also be null. + * - If @e xnext is not a null pointer and @e xnext < @e xend for an + * output sequence, then a <em>write position</em> is available. + * In this case, @e *xnext shall be assignable as the next element + * to write (to put, or to store a character value, into the sequence). + * - If @e xnext is not a null pointer and @e xbeg < @e xnext for an + * input sequence, then a <em>putback position</em> is available. + * In this case, @e xnext[-1] shall have a defined value and is the + * next (preceding) element to store a character that is put back + * into the input sequence. + * - If @e xnext is not a null pointer and @e xnext< @e xend for an + * input sequence, then a <em>read position</em> is available. + * In this case, @e *xnext shall have a defined value and is the + * next element to read (to get, or to obtain a character value, + * from the sequence). + */ template<typename _CharT, typename _Traits> class basic_streambuf { public: - // Types: + //@{ + /** + * These are standard types. They permit a standardized way of + * referring to names of (or names dependant on) the template + * parameters, which are specific to the implementation. + */ typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; - - // Non-standard Types: + //@} + + //@{ + /** + * @if maint + * These are non-standard types. + * @endif + */ typedef ctype<char_type> __ctype_type; typedef basic_streambuf<char_type, traits_type> __streambuf_type; typedef typename traits_type::state_type __state_type; + //@} friend class basic_ios<char_type, traits_type>; friend class basic_istream<char_type, traits_type>; @@ -84,56 +160,100 @@ namespace std __streambuf_type* __sbin,__streambuf_type* __sbout); protected: - // Pointer to the beginning of internally-allocated - // space. Filebuf manually allocates/deallocates this, whereas - // stringstreams attempt to use the built-in intelligence of the - // string class. If you are managing memory, set this. If not, - // leave it NULL. + /** + * @if maint + * Pointer to the beginning of internally-allocated space. Filebuf + * manually allocates/deallocates this, whereas stringstreams attempt + * to use the built-in intelligence of the string class. If you are + * managing memory, set this. If not, leave it NULL. + * @endif + */ char_type* _M_buf; - // Actual size of allocated internal buffer, in bytes. + /** + * @if maint + * Actual size of allocated internal buffer, in bytes. + * @endif + */ size_t _M_buf_size; - // Optimal or preferred size of internal buffer, in bytes. + /** + * @if maint + * Optimal or preferred size of internal buffer, in bytes. + * @endif + */ size_t _M_buf_size_opt; - // True iff _M_in_* and _M_out_* buffers should always point to - // the same place. True for fstreams, false for sstreams. + /** + * @if maint + * True iff _M_in_* and _M_out_* buffers should always point to + * the same place. True for fstreams, false for sstreams. + * @endif + */ bool _M_buf_unified; - // This is based on _IO_FILE, just reordered to be more - // consistent, and is intended to be the most minimal abstraction - // for an internal buffer. - // get == input == read - // put == output == write + //@{ + /** + * @if maint + * This is based on _IO_FILE, just reordered to be more consistent, + * and is intended to be the most minimal abstraction for an + * internal buffer. + * - get == input == read + * - put == output == write + * @endif + */ char_type* _M_in_beg; // Start of get area. char_type* _M_in_cur; // Current read area. char_type* _M_in_end; // End of get area. char_type* _M_out_beg; // Start of put area. char_type* _M_out_cur; // Current put area. char_type* _M_out_end; // End of put area. + //@} - // Place to stash in || out || in | out settings for current streambuf. + /** + * @if maint + * Place to stash in || out || in | out settings for current streambuf. + * @endif + */ ios_base::openmode _M_mode; - // Current locale setting. + /** + * @if maint + * Current locale setting. + * @endif + */ locale _M_buf_locale; - // True iff locale is initialized. + /** + * @if maint + * True iff locale is initialized. + * @endif + */ bool _M_buf_locale_init; - // Necessary bits for putback buffer management. Only used in - // the basic_filebuf class, as necessary for the standard - // requirements. The only basic_streambuf member function that - // needs access to these data members is in_avail... - // NB: pbacks of over one character are not currently supported. + //@{ + /** + * @if maint + * Necessary bits for putback buffer management. Only used in + * the basic_filebuf class, as necessary for the standard + * requirements. The only basic_streambuf member function that + * needs access to these data members is in_avail... + * + * @note pbacks of over one character are not currently supported. + * @endif + */ static const size_t _S_pback_size = 1; char_type _M_pback[_S_pback_size]; char_type* _M_pback_cur_save; char_type* _M_pback_end_save; bool _M_pback_init; + //@} - // Yet unused. + /** + * @if maint + * Yet unused. + * @endif + */ fpos<__state_type> _M_pos; // Initializes pback buffers, and moves normal buffers to safety. @@ -158,7 +278,7 @@ namespace std // Assumptions: // The pback buffer has only moved forward. void - _M_pback_destroy() + _M_pback_destroy() throw() { if (_M_pback_init) { @@ -236,6 +356,7 @@ namespace std } public: + /// Destructor deallocates no buffer space. virtual ~basic_streambuf() { @@ -245,7 +366,14 @@ namespace std _M_mode = ios_base::openmode(0); } - // Locales: + // [27.5.2.2.1] locales + /** + * @brief Entry point for imbue(). + * @param loc The new locale. + * @return The previous locale. + * + * Calls the derived imbue(loc). + */ locale pubimbue(const locale &__loc) { @@ -254,11 +382,27 @@ namespace std return __tmp; } + /** + * @brief Locale access. + * @return The current locale in effect. + * + * If pubimbue(loc) has been called, then the most recent @c loc + * is returned. Otherwise the global locale in effect at the time + * of construction is returned. + */ locale getloc() const { return _M_buf_locale; } - // Buffer and positioning: + // [27.5.2.2.2] buffer management and positioning + //@{ + /** + * @brief Entry points for derived buffer functions. + * + * The public versions of @c pubfoo dispatch to the protected + * derived @c foo member functions, passing the arguments (if any) + * and returning the result unchanged. + */ __streambuf_type* pubsetbuf(char_type* __s, streamsize __n) { return this->setbuf(__s, __n); } @@ -275,9 +419,17 @@ namespace std int pubsync() { return this->sync(); } - - // Get and put areas: - // Get area: + //@} + + // [27.5.2.2.3] get area + /** + * @brief Looking ahead into the stream. + * @return The number of characters available. + * + * If a read position is available, returns the number of characters + * available for reading before the buffer must be refilled. + * Otherwise returns the derived @c showmanyc(). + */ streamsize in_avail() { @@ -298,6 +450,13 @@ namespace std return __ret; } + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * Calls @c sbumpc(), and if that function returns + * @c traits::eof(), so does this function. Otherwise, @c sgetc(). + */ int_type snextc() { @@ -306,9 +465,25 @@ namespace std ? __eof : this->sgetc()); } + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * If the input read position is available, returns that character + * and increments the read pointer, otherwise calls and returns + * @c uflow(). + */ int_type sbumpc(); + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * If the input read position is available, returns that character, + * otherwise calls and returns @c underflow(). Does not move the + * read position after fetching the character. + */ int_type sgetc() { @@ -320,26 +495,84 @@ namespace std return __ret; } + /** + * @brief Entry point for xsgetn. + * @param s A buffer area. + * @param n A count. + * + * Returns xsgetn(s,n). The effect is to fill @a s[0] through + * @a s[n-1] with characters from the input sequence, if possible. + */ streamsize sgetn(char_type* __s, streamsize __n) { return this->xsgetn(__s, __n); } - // Putback: + // [27.5.2.2.4] putback + /** + * @brief Pushing characters back into the input stream. + * @param c The character to push back. + * @return The previous character, if possible. + * + * Similar to sungetc(), but @a c is pushed onto the stream instead + * of "the previous character". If successful, the next character + * fetched from the input stream will be @a c. + */ int_type sputbackc(char_type __c); + /** + * @brief Moving backwards in the input stream. + * @return The previous character, if possible. + * + * If a putback position is available, this function decrements the + * input pointer and returns that character. Otherwise, calls and + * returns pbackfail(). The effect is to "unget" the last character + * "gotten". + */ int_type sungetc(); - // Put area: + // [27.5.2.2.5] put area + /** + * @brief Entry point for all single-character output functions. + * @param c A character to output. + * @return @a c, if possible. + * + * One of two public output functions. + * + * If a write position is available for the output sequence (i.e., + * the buffer is not full), stores @a c in that position, increments + * the position, and returns @c traits::to_int_type(c). If a write + * position is not available, returns @c overflow(c). + */ int_type sputc(char_type __c); + /** + * @brief Entry point for all single-character output functions. + * @param s A buffer read area. + * @param n A count. + * + * One of two public output functions. + * + * + * Returns xsputn(s,n). The effect is to write @a s[0] through + * @a s[n-1] to the output sequence, if possible. + */ streamsize sputn(const char_type* __s, streamsize __n) { return this->xsputn(__s, __n); } protected: + /** + * @brief Base constructor. + * + * Only called from derived constructors, and sets up all the + * buffer data to zero, including the pointers described in the + * basic_streambuf class description. Note that, as a result, + * - the class starts with no read nor write positions available, + * - this is not an error + */ basic_streambuf() : _M_buf(NULL), _M_buf_size(0), _M_buf_size_opt(BUFSIZ), _M_buf_unified(false), _M_in_beg(0), _M_in_cur(0), _M_in_end(0), @@ -349,7 +582,18 @@ namespace std _M_pback_init(false) { } - // Get area: + // [27.5.2.3.1] get area access + //@{ + /** + * @brief Access to the get area. + * + * These functions are only available to other protected functions, + * including derived classes. + * + * - eback() returns the beginning pointer for the input sequence + * - gptr() returns the next pointer for the input sequence + * - egptr() returns the end pointer for the input sequence + */ char_type* eback() const { return _M_in_beg; } @@ -358,10 +602,25 @@ namespace std char_type* egptr() const { return _M_in_end; } - + //@} + + /** + * @brief Moving the read position. + * @param n The delta by which to move. + * + * This just advances the read position without returning any data. + */ void gbump(int __n) { _M_in_cur += __n; } + /** + * @brief Setting the three read area pointers. + * @param gbeg A pointer. + * @param gnext A pointer. + * @param gend A pointer. + * @post @a gbeg == @c eback(), @a gnext == @c gptr(), and + * @a gend == @c egptr() + */ void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) { @@ -372,7 +631,18 @@ namespace std _M_mode = _M_mode | ios_base::in; } - // Put area: + // [27.5.2.3.2] put area access + //@{ + /** + * @brief Access to the put area. + * + * These functions are only available to other protected functions, + * including derived classes. + * + * - pbase() returns the beginning pointer for the output sequence + * - pptr() returns the next pointer for the output sequence + * - epptr() returns the end pointer for the output sequence + */ char_type* pbase() const { return _M_out_beg; } @@ -381,10 +651,24 @@ namespace std char_type* epptr() const { return _M_out_end; } - + //@} + + /** + * @brief Moving the write position. + * @param n The delta by which to move. + * + * This just advances the write position without returning any data. + */ void pbump(int __n) { _M_out_cur += __n; } + /** + * @brief Setting the three write area pointers. + * @param pbeg A pointer. + * @param pend A pointer. + * @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and + * @a pend == @c epptr() + */ void setp(char_type* __pbeg, char_type* __pend) { @@ -394,8 +678,19 @@ namespace std _M_mode = _M_mode | ios_base::out; } - // Virtual functions: - // Locales: + // [27.5.2.4] virtual functions + // [27.5.2.4.1] locales + /** + * @brief Changes translations. + * @param loc A new locale. + * + * Translations done during I/O which depend on the current locale + * are changed by this call. The standard adds, "Between invocations + * of this function a class derived from streambuf can safely cache + * results of calls to locale functions and to members of facets + * so obtained." This function simply stores the new locale for use + * by derived classes. + */ virtual void imbue(const locale& __loc) { @@ -403,35 +698,126 @@ namespace std _M_buf_locale = __loc; } - // Buffer management and positioning: + // [27.5.2.4.2] buffer management and positioning + /** + * @brief Maniuplates the buffer. + * + * Each derived class provides its own appropriate behavior. See + * the next-to-last paragraph of + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for + * more on this function. + * + * @note Base class version does nothing, returns @c this. + */ virtual basic_streambuf<char_type,_Traits>* setbuf(char_type*, streamsize) { return this; } + /** + * @brief Alters the stream positions. + * + * Each derived class provides its own appropriate behavior. + * @note Base class version does nothing, returns a @c pos_type + * that represents an invalid stream position. + */ virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } + /** + * @brief Alters the stream positions. + * + * Each derived class provides its own appropriate behavior. + * @note Base class version does nothing, returns a @c pos_type + * that represents an invalid stream position. + */ virtual pos_type seekpos(pos_type, ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } + /** + * @brief Synchronizes the buffer arrays with the controlled sequences. + * @return -1 on failure. + * + * Each derived class provides its own appropriate behavior, + * including the definition of "failure". + * @note Base class version does nothing, returns zero. + */ virtual int sync() { return 0; } - // Get area: + // [27.5.2.4.3] get area + /** + * @brief Investigating the data available. + * @return An estimate of the number of characters available in the + * input sequence, or -1. + * + * "If it returns a positive value, then successive calls to + * @c underflow() will not return @c traits::eof() until at least that + * number of characters have been supplied. If @c showmanyc() + * returns -1, then calls to @c underflow() or @c uflow() will fail." + * [27.5.2.4.3]/1 + * + * @note Base class version does nothing, returns zero. + * @note The standard adds that "the intention is not only that the + * calls [to underflow or uflow] will not return @c eof() but + * that they will return "immediately". + * @note The standard adds that "the morphemes of @c showmanyc are + * "es-how-many-see", not "show-manic". + */ virtual streamsize showmanyc() { return 0; } + /** + * @brief Multiple character extraction. + * @param s A buffer area. + * @param n Maximum number of characters to assign. + * @return The number of characters assigned. + * + * Fills @a s[0] through @a s[n-1] with characters from the input + * sequence, as if by @c sbumpc(). Stops when either @a n characters + * have been copied, or when @c traits::eof() would be copied. + * + * It is expected that derived classes provide a more efficient + * implementation by overriding this definition. + */ virtual streamsize xsgetn(char_type* __s, streamsize __n); + /** + * @brief Fetches more data from the controlled sequence. + * @return The first character from the <em>pending sequence</em>. + * + * Informally, this function is called when the input buffer is + * exhausted (or does not exist, as buffering need not actually be + * done). If a buffer exists, it is "refilled". In either case, the + * next available character is returned, or @c traits::eof() to + * indicate a null pending sequence. + * + * For a formal definiton of the pending sequence, see a good text + * such as Langer & Kreft, or [27.5.2.4.3]/7-14. + * + * A functioning input streambuf can be created by overriding only + * this function (no buffer area will be used). For an example, see + * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#6 + * + * @note Base class version does nothing, returns eof(). + */ virtual int_type underflow() { return traits_type::eof(); } + /** + * @brief Fetches more data from the controlled sequence. + * @return The first character from the <em>pending sequence</em>. + * + * Informally, this function does the same thing as @c underflow(), + * and in fact is required to call that function. It also returns + * the new character, like @c underflow() does. However, this + * function also moves the read position forward by one. + */ virtual int_type uflow() { @@ -448,21 +834,78 @@ namespace std return __ret; } - // Putback: + // [27.5.2.4.4] putback + /** + * @brief Tries to back up the input sequence. + * @param c The character to be inserted back into the sequence. + * @return eof() on failure, "some other value" on success + * @post The constraints of @c gptr(), @c eback(), and @c pptr() + * are the same as for @c underflow(). + * + * @note Base class version does nothing, returns eof(). + */ virtual int_type pbackfail(int_type /* __c */ = traits_type::eof()) { return traits_type::eof(); } // Put area: + /** + * @brief Multiple character insertion. + * @param s A buffer area. + * @param n Maximum number of characters to write. + * @return The number of characters written. + * + * Writes @a s[0] through @a s[n-1] to the output sequence, as if + * by @c sputc(). Stops when either @a n characters have been + * copied, or when @c sputc() would return @c traits::eof(). + * + * It is expected that derived classes provide a more efficient + * implementation by overriding this definition. + */ virtual streamsize xsputn(const char_type* __s, streamsize __n); + /** + * @brief Consumes data from the buffer; writes to the + * controlled sequence. + * @param c An additional character to consume. + * @return eof() to indicate failure, something else (usually + * @a c, or not_eof()) + * + * Informally, this function is called when the output buffer is full + * (or does not exist, as buffering need not actually be done). If a + * buffer exists, it is "consumed", with "some effect" on the + * controlled sequence. (Typically, the buffer is written out to the + * sequence verbatim.) In either case, the character @a c is also + * written out, if @a c is not @c eof(). + * + * For a formal definiton of this function, see a good text + * such as Langer & Kreft, or [27.5.2.4.5]/3-7. + * + * A functioning output streambuf can be created by overriding only + * this function (no buffer area will be used). + * + * @note Base class version does nothing, returns eof(). + */ virtual int_type overflow(int_type /* __c */ = traits_type::eof()) { return traits_type::eof(); } #ifdef _GLIBCPP_DEPRECATED + // Annex D.6 public: + /** + * @brief Tosses a character. + * + * Advances the read pointer, ignoring the character that would have + * been read. + * + * See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html + * + * @note This function has been deprecated by the standard. You + * must define @c _GLIBCPP_DEPRECATED to make this visible; see + * c++config.h. + */ void stossc() { diff --git a/contrib/libstdc++/include/std/std_valarray.h b/contrib/libstdc++/include/std/std_valarray.h index 3957d7f4b26f..b4de5dfec370 100644 --- a/contrib/libstdc++/include/std/std_valarray.h +++ b/contrib/libstdc++/include/std/std_valarray.h @@ -45,48 +45,47 @@ #include <cmath> #include <cstdlib> #include <numeric> -#include <functional> #include <algorithm> namespace std { - template<class _Clos, typename _Tp> class _Expr; + template<class _Clos, typename _Tp> + class _Expr; - template<typename _Tp1, typename _Tp2> class _ValArray; + template<typename _Tp1, typename _Tp2> + class _ValArray; - template<template<class> class _Oper, - template<class, class> class _Meta, class _Dom> struct _UnClos; + template<class _Oper, template<class, class> class _Meta, class _Dom> + struct _UnClos; - template<template<class> class _Oper, + template<class _Oper, template<class, class> class _Meta1, template<class, class> class _Meta2, - class _Dom1, class _Dom2> class _BinClos; + class _Dom1, class _Dom2> + class _BinClos; - template<template<class, class> class _Meta, class _Dom> class _SClos; + template<template<class, class> class _Meta, class _Dom> + class _SClos; - template<template<class, class> class _Meta, class _Dom> class _GClos; + template<template<class, class> class _Meta, class _Dom> + class _GClos; - template<template<class, class> class _Meta, class _Dom> class _IClos; + template<template<class, class> class _Meta, class _Dom> + class _IClos; - template<template<class, class> class _Meta, class _Dom> class _ValFunClos; - - template<template<class, class> class _Meta, class _Dom> class _RefFunClos; - - template<class _Tp> struct _Unary_plus; - template<class _Tp> struct _Bitwise_and; - template<class _Tp> struct _Bitwise_or; - template<class _Tp> struct _Bitwise_xor; - template<class _Tp> struct _Bitwise_not; - template<class _Tp> struct _Shift_left; - template<class _Tp> struct _Shift_right; + template<template<class, class> class _Meta, class _Dom> + class _ValFunClos; - template<class _Tp> class valarray; // An array of type _Tp - class slice; // BLAS-like slice out of an array - template<class _Tp> class slice_array; - class gslice; // generalized slice out of an array - template<class _Tp> class gslice_array; - template<class _Tp> class mask_array; // masked array - template<class _Tp> class indirect_array; // indirected array + template<template<class, class> class _Meta, class _Dom> + class _RefFunClos; + + template<class _Tp> class valarray; // An array of type _Tp + class slice; // BLAS-like slice out of an array + template<class _Tp> class slice_array; + class gslice; // generalized slice out of an array + template<class _Tp> class gslice_array; + template<class _Tp> class mask_array; // masked array + template<class _Tp> class indirect_array; // indirected array } // namespace std @@ -95,12 +94,19 @@ namespace std namespace std { - template<class _Tp> class valarray - { - public: + template<class _Tp> + class valarray + { + template<class _Op> + struct _UnaryOp + { + typedef typename __fun<_Op, _Tp>::result_type __rt; + typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; + }; + public: typedef _Tp value_type; - - // _lib.valarray.cons_ construct/destroy: + + // _lib.valarray.cons_ construct/destroy: valarray(); explicit valarray(size_t); valarray(const _Tp&, size_t); @@ -111,8 +117,8 @@ namespace std valarray(const mask_array<_Tp>&); valarray(const indirect_array<_Tp>&); template<class _Dom> - valarray(const _Expr<_Dom,_Tp>& __e); - ~valarray(); + valarray(const _Expr<_Dom,_Tp>& __e); + ~valarray(); // _lib.valarray.assign_ assignment: valarray<_Tp>& operator=(const valarray<_Tp>&); @@ -123,7 +129,7 @@ namespace std valarray<_Tp>& operator=(const indirect_array<_Tp>&); template<class _Dom> valarray<_Tp>& - operator= (const _Expr<_Dom,_Tp>&); + operator= (const _Expr<_Dom,_Tp>&); // _lib.valarray.access_ element access: // XXX: LWG to be resolved. @@ -137,67 +143,67 @@ namespace std valarray<_Tp> operator[](const valarray<bool>&) const; mask_array<_Tp> operator[](const valarray<bool>&); _Expr<_IClos<_ValArray, _Tp>, _Tp> - operator[](const valarray<size_t>&) const; + operator[](const valarray<size_t>&) const; indirect_array<_Tp> operator[](const valarray<size_t>&); // _lib.valarray.unary_ unary operators: - _Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const; - _Expr<_UnClos<negate,_ValArray,_Tp>,_Tp> operator- () const; - _Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const; - _Expr<_UnClos<logical_not,_ValArray,_Tp>,bool> operator! () const; - + typename _UnaryOp<__unary_plus>::_Rt operator+() const; + typename _UnaryOp<__negate>::_Rt operator-() const; + typename _UnaryOp<__bitwise_not>::_Rt operator~() const; + typename _UnaryOp<__logical_not>::_Rt operator!() const; + // _lib.valarray.cassign_ computed assignment: - valarray<_Tp>& operator*= (const _Tp&); - valarray<_Tp>& operator/= (const _Tp&); - valarray<_Tp>& operator%= (const _Tp&); - valarray<_Tp>& operator+= (const _Tp&); - valarray<_Tp>& operator-= (const _Tp&); - valarray<_Tp>& operator^= (const _Tp&); - valarray<_Tp>& operator&= (const _Tp&); - valarray<_Tp>& operator|= (const _Tp&); + valarray<_Tp>& operator*=(const _Tp&); + valarray<_Tp>& operator/=(const _Tp&); + valarray<_Tp>& operator%=(const _Tp&); + valarray<_Tp>& operator+=(const _Tp&); + valarray<_Tp>& operator-=(const _Tp&); + valarray<_Tp>& operator^=(const _Tp&); + valarray<_Tp>& operator&=(const _Tp&); + valarray<_Tp>& operator|=(const _Tp&); valarray<_Tp>& operator<<=(const _Tp&); valarray<_Tp>& operator>>=(const _Tp&); - valarray<_Tp>& operator*= (const valarray<_Tp>&); - valarray<_Tp>& operator/= (const valarray<_Tp>&); - valarray<_Tp>& operator%= (const valarray<_Tp>&); - valarray<_Tp>& operator+= (const valarray<_Tp>&); - valarray<_Tp>& operator-= (const valarray<_Tp>&); - valarray<_Tp>& operator^= (const valarray<_Tp>&); - valarray<_Tp>& operator|= (const valarray<_Tp>&); - valarray<_Tp>& operator&= (const valarray<_Tp>&); + valarray<_Tp>& operator*=(const valarray<_Tp>&); + valarray<_Tp>& operator/=(const valarray<_Tp>&); + valarray<_Tp>& operator%=(const valarray<_Tp>&); + valarray<_Tp>& operator+=(const valarray<_Tp>&); + valarray<_Tp>& operator-=(const valarray<_Tp>&); + valarray<_Tp>& operator^=(const valarray<_Tp>&); + valarray<_Tp>& operator|=(const valarray<_Tp>&); + valarray<_Tp>& operator&=(const valarray<_Tp>&); valarray<_Tp>& operator<<=(const valarray<_Tp>&); valarray<_Tp>& operator>>=(const valarray<_Tp>&); template<class _Dom> - valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator*=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator/=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator%=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator+=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator-=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator^=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator|=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); template<class _Dom> - valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&); + - // _lib.valarray.members_ member functions: size_t size() const; _Tp sum() const; _Tp min() const; _Tp max() const; -// // FIXME: Extension -// _Tp product () const; + // // FIXME: Extension + // _Tp product () const; valarray<_Tp> shift (int) const; valarray<_Tp> cshift(int) const; @@ -205,56 +211,25 @@ namespace std _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const; void resize(size_t __size, _Tp __c = _Tp()); - private: + private: size_t _M_size; _Tp* __restrict__ _M_data; - + friend class _Array<_Tp>; - }; - - - template<typename _Tp> struct _Unary_plus : unary_function<_Tp,_Tp> { - _Tp operator() (const _Tp& __t) const { return __t; } - }; - - template<typename _Tp> struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x & __y; } - }; - - template<typename _Tp> struct _Bitwise_or : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x | __y; } - }; - - template<typename _Tp> struct _Bitwise_xor : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x ^ __y; } - }; - - template<typename _Tp> struct _Bitwise_not : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __t) const { return ~__t; } - }; - - template<typename _Tp> struct _Shift_left : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x << __y; } - }; - - template<typename _Tp> struct _Shift_right : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x >> __y; } - }; - + }; template<typename _Tp> - inline const _Tp& - valarray<_Tp>::operator[] (size_t __i) const - { return _M_data[__i]; } + inline const _Tp& + valarray<_Tp>::operator[](size_t __i) const + { return _M_data[__i]; } template<typename _Tp> - inline _Tp& - valarray<_Tp>::operator[] (size_t __i) - { return _M_data[__i]; } + inline _Tp& + valarray<_Tp>::operator[](size_t __i) + { return _M_data[__i]; } } // std:: -#include <bits/slice.h> #include <bits/slice_array.h> #include <bits/gslice.h> #include <bits/gslice_array.h> @@ -264,214 +239,227 @@ namespace std namespace std { template<typename _Tp> - inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {} + inline + valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} template<typename _Tp> - inline valarray<_Tp>::valarray (size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_default_construct(_M_data, _M_data + __n); } + inline + valarray<_Tp>::valarray(size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_default_construct(_M_data, _M_data + __n); } template<typename _Tp> - inline valarray<_Tp>::valarray (const _Tp& __t, size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_fill_construct (_M_data, _M_data + __n, __t); } + inline + valarray<_Tp>::valarray(const _Tp& __t, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_fill_construct(_M_data, _M_data + __n, __t); } template<typename _Tp> - inline valarray<_Tp>::valarray (const _Tp* __restrict__ __p, size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_copy_construct (__p, __p + __n, _M_data); } + inline + valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_copy_construct(__p, __p + __n, _M_data); } template<typename _Tp> - inline valarray<_Tp>::valarray (const valarray<_Tp>& __v) - : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) - { __valarray_copy_construct (__v._M_data, __v._M_data + _M_size, _M_data); } + inline + valarray<_Tp>::valarray(const valarray<_Tp>& __v) + : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) + { __valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } template<typename _Tp> - inline valarray<_Tp>::valarray (const slice_array<_Tp>& __sa) - : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) - { - __valarray_copy - (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); - } + inline + valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) + : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) + { + __valarray_copy + (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); + } template<typename _Tp> - inline valarray<_Tp>::valarray (const gslice_array<_Tp>& __ga) - : _M_size(__ga._M_index.size()), - _M_data(__valarray_get_storage<_Tp>(_M_size)) - { - __valarray_copy - (__ga._M_array, _Array<size_t>(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) + : _M_size(__ga._M_index.size()), + _M_data(__valarray_get_storage<_Tp>(_M_size)) + { + __valarray_copy + (__ga._M_array, _Array<size_t>(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); + } template<typename _Tp> - inline valarray<_Tp>::valarray (const mask_array<_Tp>& __ma) - : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) - { - __valarray_copy - (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) + : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) + { + __valarray_copy + (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); + } template<typename _Tp> - inline valarray<_Tp>::valarray (const indirect_array<_Tp>& __ia) - : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) - { - __valarray_copy - (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) + : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) + { + __valarray_copy + (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); + } template<typename _Tp> template<class _Dom> - inline valarray<_Tp>::valarray (const _Expr<_Dom, _Tp>& __e) - : _M_size(__e.size ()), _M_data(__valarray_get_storage<_Tp>(_M_size)) - { __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); } + inline + valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) + : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) + { __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); } template<typename _Tp> - inline valarray<_Tp>::~valarray () - { + inline + valarray<_Tp>::~valarray() + { __valarray_destroy_elements(_M_data, _M_data + _M_size); __valarray_release_memory(_M_data); - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const valarray<_Tp>& __v) - { + inline valarray<_Tp>& + valarray<_Tp>::operator=(const valarray<_Tp>& __v) + { __valarray_copy(__v._M_data, _M_size, _M_data); return *this; - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Tp& __t) - { - __valarray_fill (_M_data, _M_size, __t); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Tp& __t) + { + __valarray_fill(_M_data, _M_size, __t); return *this; - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const slice_array<_Tp>& __sa) - { - __valarray_copy (__sa._M_array, __sa._M_sz, - __sa._M_stride, _Array<_Tp>(_M_data)); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) + { + __valarray_copy(__sa._M_array, __sa._M_sz, + __sa._M_stride, _Array<_Tp>(_M_data)); return *this; - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const gslice_array<_Tp>& __ga) - { - __valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) + { + __valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const mask_array<_Tp>& __ma) - { - __valarray_copy (__ma._M_array, __ma._M_mask, - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) + { + __valarray_copy(__ma._M_array, __ma._M_mask, + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template<typename _Tp> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const indirect_array<_Tp>& __ia) - { - __valarray_copy (__ia._M_array, __ia._M_index, - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) + { + __valarray_copy(__ia._M_array, __ia._M_index, + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template<typename _Tp> template<class _Dom> - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Expr<_Dom, _Tp>& __e) - { - __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); - return *this; - } + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) + { + __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); + return *this; + } template<typename _Tp> - inline _Expr<_SClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (slice __s) const - { + inline _Expr<_SClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](slice __s) const + { typedef _SClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure, _Tp> (_Closure (_Array<_Tp>(_M_data), __s)); - } + return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); + } template<typename _Tp> - inline slice_array<_Tp> - valarray<_Tp>::operator[] (slice __s) - { - return slice_array<_Tp> (_Array<_Tp>(_M_data), __s); - } + inline slice_array<_Tp> + valarray<_Tp>::operator[](slice __s) + { + return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); + } template<typename _Tp> - inline _Expr<_GClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (const gslice& __gs) const - { + inline _Expr<_GClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const gslice& __gs) const + { typedef _GClos<_ValArray,_Tp> _Closure; return _Expr<_Closure, _Tp> - (_Closure (_Array<_Tp>(_M_data), __gs._M_index->_M_index)); - } + (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); + } template<typename _Tp> - inline gslice_array<_Tp> - valarray<_Tp>::operator[] (const gslice& __gs) - { + inline gslice_array<_Tp> + valarray<_Tp>::operator[](const gslice& __gs) + { return gslice_array<_Tp> - (_Array<_Tp>(_M_data), __gs._M_index->_M_index); - } + (_Array<_Tp>(_M_data), __gs._M_index->_M_index); + } template<typename _Tp> - inline valarray<_Tp> - valarray<_Tp>::operator[] (const valarray<bool>& __m) const - { - size_t __s (0); - size_t __e (__m.size ()); + inline valarray<_Tp> + valarray<_Tp>::operator[](const valarray<bool>& __m) const + { + size_t __s = 0; + size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) - if (__m[__i]) ++__s; - return valarray<_Tp> (mask_array<_Tp> (_Array<_Tp>(_M_data), __s, - _Array<bool> (__m))); - } + if (__m[__i]) ++__s; + return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, + _Array<bool> (__m))); + } template<typename _Tp> - inline mask_array<_Tp> - valarray<_Tp>::operator[] (const valarray<bool>& __m) - { - size_t __s (0); - size_t __e (__m.size ()); + inline mask_array<_Tp> + valarray<_Tp>::operator[](const valarray<bool>& __m) + { + size_t __s = 0; + size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) - if (__m[__i]) ++__s; - return mask_array<_Tp> (_Array<_Tp>(_M_data), __s, _Array<bool> (__m)); - } + if (__m[__i]) ++__s; + return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m)); + } template<typename _Tp> - inline _Expr<_IClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (const valarray<size_t>& __i) const - { + inline _Expr<_IClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const valarray<size_t>& __i) const + { typedef _IClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure, _Tp> (_Closure (*this, __i)); - } + return _Expr<_Closure, _Tp>(_Closure(*this, __i)); + } template<typename _Tp> - inline indirect_array<_Tp> - valarray<_Tp>::operator[] (const valarray<size_t>& __i) - { - return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(), - _Array<size_t> (__i)); - } + inline indirect_array<_Tp> + valarray<_Tp>::operator[](const valarray<size_t>& __i) + { + return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), + _Array<size_t>(__i)); + } template<class _Tp> - inline size_t valarray<_Tp>::size () const { return _M_size; } + inline size_t + valarray<_Tp>::size() const + { return _M_size; } template<class _Tp> - inline _Tp - valarray<_Tp>::sum () const - { + inline _Tp + valarray<_Tp>::sum() const + { return __valarray_sum(_M_data, _M_data + _M_size); - } + } // template<typename _Tp> // inline _Tp @@ -530,209 +518,172 @@ namespace std } template <class _Tp> - inline void - valarray<_Tp>::resize (size_t __n, _Tp __c) - { - // This complication is so to make valarray<valarray<T> > work - // even though it is not required by the standard. Nobody should - // be saying valarray<valarray<T> > anyway. See the specs. - __valarray_destroy_elements(_M_data, _M_data + _M_size); - if (_M_size != __n) - { - __valarray_release_memory(_M_data); - _M_size = __n; - _M_data = __valarray_get_storage<_Tp>(__n); - } - __valarray_fill_construct(_M_data, _M_data + __n, __c); - } + inline void + valarray<_Tp>::resize (size_t __n, _Tp __c) + { + // This complication is so to make valarray<valarray<T> > work + // even though it is not required by the standard. Nobody should + // be saying valarray<valarray<T> > anyway. See the specs. + __valarray_destroy_elements(_M_data, _M_data + _M_size); + if (_M_size != __n) + { + __valarray_release_memory(_M_data); + _M_size = __n; + _M_data = __valarray_get_storage<_Tp>(__n); + } + __valarray_fill_construct(_M_data, _M_data + __n, __c); + } template<typename _Tp> - inline _Tp - valarray<_Tp>::min() const - { + inline _Tp + valarray<_Tp>::min() const + { return *min_element (_M_data, _M_data+_M_size); - } + } template<typename _Tp> - inline _Tp - valarray<_Tp>::max() const - { + inline _Tp + valarray<_Tp>::max() const + { return *max_element (_M_data, _M_data+_M_size); - } + } template<class _Tp> - inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> - valarray<_Tp>::apply (_Tp func (_Tp)) const - { + inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> + valarray<_Tp>::apply(_Tp func(_Tp)) const + { typedef _ValFunClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure,_Tp> (_Closure (*this, func)); - } + return _Expr<_Closure,_Tp>(_Closure(*this, func)); + } template<class _Tp> - inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> - valarray<_Tp>::apply (_Tp func (const _Tp &)) const - { + inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> + valarray<_Tp>::apply(_Tp func(const _Tp &)) const + { typedef _RefFunClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure,_Tp> (_Closure (*this, func)); - } + return _Expr<_Closure,_Tp>(_Closure(*this, func)); + } #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ template<typename _Tp> \ - inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \ + inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ valarray<_Tp>::operator _Op() const \ { \ - typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (*this)); \ + typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(*this)); \ } - _DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus) - _DEFINE_VALARRAY_UNARY_OPERATOR(-, negate) - _DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not) + _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate) + _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not) + _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not) #undef _DEFINE_VALARRAY_UNARY_OPERATOR - - template<typename _Tp> - inline _Expr<_UnClos<logical_not,_ValArray,_Tp>, bool> - valarray<_Tp>::operator!() const - { - typedef _UnClos<logical_not,_ValArray,_Tp> _Closure; - return _Expr<_Closure, bool> (_Closure (*this)); - } #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ template<class _Tp> \ - inline valarray<_Tp> & \ - valarray<_Tp>::operator _Op##= (const _Tp &__t) \ - { \ - _Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, __t); \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const _Tp &__t) \ + { \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \ return *this; \ - } \ + } \ \ template<class _Tp> \ - inline valarray<_Tp> & \ - valarray<_Tp>::operator _Op##= (const valarray<_Tp> &__v) \ - { \ - _Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, \ - _Array<_Tp>(__v._M_data)); \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \ + { \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \ + _Array<_Tp>(__v._M_data)); \ return *this; \ - } - -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, plus) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, minus) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, multiplies) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, divides) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, modulus) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, xor) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, and) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, or) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, shift_left) -_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, shift_right) + } + +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right) #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT - -} // std:: - - -namespace std -{ - #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ template<class _Tp> template<class _Dom> \ - inline valarray<_Tp> & \ - valarray<_Tp>::operator _Op##= (const _Expr<_Dom,_Tp> &__e) \ - { \ - _Array_augmented_##_Name (_Array<_Tp>(_M_data), __e, _M_size); \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) \ + { \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \ return *this; \ - } - -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, plus) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, minus) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, multiplies) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, divides) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, modulus) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, xor) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, and) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, or) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, shift_left) -_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, shift_right) + } + +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ template<typename _Tp> \ - inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \ - operator _Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \ - { \ + inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ + { \ typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (__v, __w)); \ - } \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \ + } \ \ template<typename _Tp> \ - inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,_Tp> \ - operator _Op (const valarray<_Tp> &__v, const _Tp &__t) \ + inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ { \ - typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (__v, __t)); \ + typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ } \ \ template<typename _Tp> \ - inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,_Tp> \ - operator _Op (const _Tp &__t, const valarray<_Tp> &__v) \ - { \ - typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (__t, __v)); \ - } - -_DEFINE_BINARY_OPERATOR(+, plus) -_DEFINE_BINARY_OPERATOR(-, minus) -_DEFINE_BINARY_OPERATOR(*, multiplies) -_DEFINE_BINARY_OPERATOR(/, divides) -_DEFINE_BINARY_OPERATOR(%, modulus) -_DEFINE_BINARY_OPERATOR(^, _Bitwise_xor) -_DEFINE_BINARY_OPERATOR(&, _Bitwise_and) -_DEFINE_BINARY_OPERATOR(|, _Bitwise_or) -_DEFINE_BINARY_OPERATOR(<<, _Shift_left) -_DEFINE_BINARY_OPERATOR(>>, _Shift_right) - -#undef _DEFINE_BINARY_OPERATOR - -#define _DEFINE_LOGICAL_OPERATOR(_Op, _Name) \ - template<typename _Tp> \ - inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>,bool> \ - operator _Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \ - { \ - typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, bool> (_Closure (__v, __w)); \ - } \ - \ - template<class _Tp> \ - inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,bool> \ - operator _Op (const valarray<_Tp> &__v, const _Tp &__t) \ + inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ { \ - typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, bool> (_Closure (__v, __t)); \ - } \ - \ - template<class _Tp> \ - inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,bool> \ - operator _Op (const _Tp &__t, const valarray<_Tp> &__v) \ - { \ - typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, bool> (_Closure (__t, __v)); \ - } - -_DEFINE_LOGICAL_OPERATOR(&&, logical_and) -_DEFINE_LOGICAL_OPERATOR(||, logical_or) -_DEFINE_LOGICAL_OPERATOR(==, equal_to) -_DEFINE_LOGICAL_OPERATOR(!=, not_equal_to) -_DEFINE_LOGICAL_OPERATOR(<, less) -_DEFINE_LOGICAL_OPERATOR(>, greater) -_DEFINE_LOGICAL_OPERATOR(<=, less_equal) -_DEFINE_LOGICAL_OPERATOR(>=, greater_equal) - -#undef _DEFINE_LOGICAL_OPERATOR + typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ + } + +_DEFINE_BINARY_OPERATOR(+, __plus) +_DEFINE_BINARY_OPERATOR(-, __minus) +_DEFINE_BINARY_OPERATOR(*, __multiplies) +_DEFINE_BINARY_OPERATOR(/, __divides) +_DEFINE_BINARY_OPERATOR(%, __modulus) +_DEFINE_BINARY_OPERATOR(^, __bitwise_xor) +_DEFINE_BINARY_OPERATOR(&, __bitwise_and) +_DEFINE_BINARY_OPERATOR(|, __bitwise_or) +_DEFINE_BINARY_OPERATOR(<<, __shift_left) +_DEFINE_BINARY_OPERATOR(>>, __shift_right) +_DEFINE_BINARY_OPERATOR(&&, __logical_and) +_DEFINE_BINARY_OPERATOR(||, __logical_or) +_DEFINE_BINARY_OPERATOR(==, __equal_to) +_DEFINE_BINARY_OPERATOR(!=, __not_equal_to) +_DEFINE_BINARY_OPERATOR(<, __less) +_DEFINE_BINARY_OPERATOR(>, __greater) +_DEFINE_BINARY_OPERATOR(<=, __less_equal) +_DEFINE_BINARY_OPERATOR(>=, __greater_equal) } // namespace std diff --git a/contrib/libstdc++/include/std/std_vector.h b/contrib/libstdc++/include/std/std_vector.h index 4120aa9e3be2..5738ef7ade89 100644 --- a/contrib/libstdc++/include/std/std_vector.h +++ b/contrib/libstdc++/include/std/std_vector.h @@ -71,8 +71,9 @@ #include <bits/stl_vector.h> #include <bits/stl_bvector.h> +#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT +# include <bits/vector.tcc> +#endif + #endif /* _CPP_VECTOR */ -// Local Variables: -// mode:C++ -// End: |