From 9fab27938873b3a2a44e44e2050c23ee98e67e58 Mon Sep 17 00:00:00 2001 From: Benjamin Kosnik Date: Thu, 5 Oct 2000 11:33:23 +0000 Subject: [PATCH] include: New directory. 2000-10-05 Benjamin Kosnik * include: New directory. * include/backward: New directory. * include/bits: New directory. * include/ext: New directory. * include/std: New directory. * include/*/*: Populate. * backwards: Move to include/backwards, delete. * bits: Move to include/bits, delete. * ext: Move to include/ext, delete. * std: Move to include/std, delete. * src/complex.cc: Adjust include of mathconf. * mkc++config (BASE_H): Add include. * src/Makefile.am: Support for topleve sources include directory. (INCLUDES): Add LIBMATH_INCLUDE. * src/Makefile.in: Regenerate. * math/Makefile.am (INCLUDES): Append /include. * math/Makefile.in: Regenerate. * libio/Makefile.am (INCLUDES): Add glibcpp_includedir. * libio/Makefile.in: Regenerate. From-SVN: r36724 --- libstdc++-v3/bits/basic_file.h | 340 --- libstdc++-v3/bits/basic_ios.h | 216 -- libstdc++-v3/bits/basic_ios.tcc | 142 - libstdc++-v3/bits/basic_string.h | 1038 ------- libstdc++-v3/bits/c++config | 72 - libstdc++-v3/bits/char_traits.h | 307 -- libstdc++-v3/bits/codecvt.h | 662 ----- libstdc++-v3/bits/concept_checks.h | 811 ------ libstdc++-v3/bits/container_concepts.h | 244 -- libstdc++-v3/bits/cpp_type_traits.h | 301 -- libstdc++-v3/bits/exception_support.h | 79 - libstdc++-v3/bits/fpos.h | 121 - libstdc++-v3/bits/fstream.tcc | 586 ---- libstdc++-v3/bits/generic_shadow.h | 59 - libstdc++-v3/bits/gslice.h | 117 - libstdc++-v3/bits/gslice_array.h | 169 -- libstdc++-v3/bits/indirect_array.h | 160 -- libstdc++-v3/bits/ios_base.h | 576 ---- libstdc++-v3/bits/istream.tcc | 1216 -------- libstdc++-v3/bits/limits_generic.h | 786 ------ libstdc++-v3/bits/locale_facets.h | 1733 ------------ libstdc++-v3/bits/locale_facets.tcc | 1277 --------- libstdc++-v3/bits/localefwd.h | 508 ---- libstdc++-v3/bits/mask_array.h | 160 -- libstdc++-v3/bits/ostream.tcc | 683 ----- libstdc++-v3/bits/pthread_allocimpl.h | 495 ---- libstdc++-v3/bits/sbuf_iter.h | 264 -- libstdc++-v3/bits/sequence_concepts.h | 204 -- libstdc++-v3/bits/slice.h | 77 - libstdc++-v3/bits/slice_array.h | 161 -- libstdc++-v3/bits/sstream.tcc | 220 -- libstdc++-v3/bits/std_algorithm.h | 40 - libstdc++-v3/bits/std_bitset.h | 1076 ------- libstdc++-v3/bits/std_cassert.h | 39 - libstdc++-v3/bits/std_cctype.h | 211 -- libstdc++-v3/bits/std_cerrno.h | 40 - libstdc++-v3/bits/std_cfloat.h | 47 - libstdc++-v3/bits/std_climits.h | 42 - libstdc++-v3/bits/std_clocale.h | 41 - libstdc++-v3/bits/std_cmath.h | 506 ---- libstdc++-v3/bits/std_complex.h | 961 ------- libstdc++-v3/bits/std_csetjmp.h | 40 - libstdc++-v3/bits/std_csignal.h | 40 - libstdc++-v3/bits/std_cstdarg.h | 40 - libstdc++-v3/bits/std_cstddef.h | 40 - libstdc++-v3/bits/std_cstdio.h | 61 - libstdc++-v3/bits/std_cstdlib.h | 54 - libstdc++-v3/bits/std_cstring.h | 44 - libstdc++-v3/bits/std_ctime.h | 40 - libstdc++-v3/bits/std_cwchar.h | 78 - libstdc++-v3/bits/std_cwctype.h | 160 -- libstdc++-v3/bits/std_deque.h | 41 - libstdc++-v3/bits/std_exception.h | 81 - libstdc++-v3/bits/std_fstream.h | 420 --- libstdc++-v3/bits/std_functional.h | 27 - libstdc++-v3/bits/std_iomanip.h | 219 -- libstdc++-v3/bits/std_ios.h | 52 - libstdc++-v3/bits/std_iosfwd.h | 157 -- libstdc++-v3/bits/std_iostream.h | 58 - libstdc++-v3/bits/std_istream.h | 307 -- libstdc++-v3/bits/std_iterator.h | 46 - libstdc++-v3/bits/std_list.h | 40 - libstdc++-v3/bits/std_locale.h | 46 - libstdc++-v3/bits/std_map.h | 40 - libstdc++-v3/bits/std_memory.h | 128 - libstdc++-v3/bits/std_new.h | 82 - libstdc++-v3/bits/std_numeric.h | 41 - libstdc++-v3/bits/std_ostream.h | 288 -- libstdc++-v3/bits/std_queue.h | 45 - libstdc++-v3/bits/std_set.h | 40 - libstdc++-v3/bits/std_sstream.h | 366 --- libstdc++-v3/bits/std_stack.h | 41 - libstdc++-v3/bits/std_stdexcept.h | 90 - libstdc++-v3/bits/std_streambuf.h | 528 ---- libstdc++-v3/bits/std_string.h | 63 - libstdc++-v3/bits/std_strstream.h | 159 -- libstdc++-v3/bits/std_typeinfo.h | 81 - libstdc++-v3/bits/std_utility.h | 38 - libstdc++-v3/bits/std_valarray.h | 728 ----- libstdc++-v3/bits/std_vector.h | 42 - libstdc++-v3/bits/stl_algo.h | 3297 ---------------------- libstdc++-v3/bits/stl_algobase.h | 756 ----- libstdc++-v3/bits/stl_alloc.h | 900 ------ libstdc++-v3/bits/stl_config.h | 568 ---- libstdc++-v3/bits/stl_construct.h | 124 - libstdc++-v3/bits/stl_deque.h | 1652 ----------- libstdc++-v3/bits/stl_function.h | 732 ----- libstdc++-v3/bits/stl_heap.h | 297 -- libstdc++-v3/bits/stl_iterator.h | 1086 ------- libstdc++-v3/bits/stl_iterator_base.h | 367 --- libstdc++-v3/bits/stl_list.h | 885 ------ libstdc++-v3/bits/stl_map.h | 282 -- libstdc++-v3/bits/stl_multimap.h | 282 -- libstdc++-v3/bits/stl_multiset.h | 274 -- libstdc++-v3/bits/stl_numeric.h | 255 -- libstdc++-v3/bits/stl_pair.h | 101 - libstdc++-v3/bits/stl_pthread_alloc.h | 31 - libstdc++-v3/bits/stl_queue.h | 242 -- libstdc++-v3/bits/stl_range_errors.h | 74 - libstdc++-v3/bits/stl_raw_storage_iter.h | 81 - libstdc++-v3/bits/stl_relops.h | 62 - libstdc++-v3/bits/stl_set.h | 268 -- libstdc++-v3/bits/stl_stack.h | 143 - libstdc++-v3/bits/stl_string_fwd.h | 46 - libstdc++-v3/bits/stl_tempbuf.h | 161 -- libstdc++-v3/bits/stl_threads.h | 379 --- libstdc++-v3/bits/stl_tree.h | 1370 --------- libstdc++-v3/bits/stl_uninitialized.h | 281 -- libstdc++-v3/bits/stl_vector.h | 879 ------ libstdc++-v3/bits/streambuf.tcc | 261 -- libstdc++-v3/bits/string.tcc | 856 ------ libstdc++-v3/bits/type_traits.h | 387 --- libstdc++-v3/bits/valarray_array.h | 575 ---- libstdc++-v3/bits/valarray_array.tcc | 161 -- libstdc++-v3/bits/valarray_meta.h | 1067 ------- libstdc++-v3/std/algorithm | 3 - libstdc++-v3/std/bitset | 3 - libstdc++-v3/std/cassert | 3 - libstdc++-v3/std/cctype | 3 - libstdc++-v3/std/cerrno | 3 - libstdc++-v3/std/cfloat | 3 - libstdc++-v3/std/ciso646 | 0 libstdc++-v3/std/climits | 3 - libstdc++-v3/std/clocale | 3 - libstdc++-v3/std/cmath | 3 - libstdc++-v3/std/complex | 3 - libstdc++-v3/std/csetjmp | 4 - libstdc++-v3/std/csignal | 4 - libstdc++-v3/std/cstdarg | 4 - libstdc++-v3/std/cstddef | 3 - libstdc++-v3/std/cstdio | 3 - libstdc++-v3/std/cstdlib | 3 - libstdc++-v3/std/cstring | 3 - libstdc++-v3/std/ctime | 3 - libstdc++-v3/std/cwchar | 3 - libstdc++-v3/std/cwctype | 3 - libstdc++-v3/std/deque | 3 - libstdc++-v3/std/exception | 3 - libstdc++-v3/std/fstream | 3 - libstdc++-v3/std/functional | 3 - libstdc++-v3/std/iomanip | 3 - libstdc++-v3/std/ios | 3 - libstdc++-v3/std/iosfwd | 3 - libstdc++-v3/std/iostream | 5 - libstdc++-v3/std/istream | 3 - libstdc++-v3/std/iterator | 3 - libstdc++-v3/std/limits | 3 - libstdc++-v3/std/list | 3 - libstdc++-v3/std/locale | 3 - libstdc++-v3/std/map | 3 - libstdc++-v3/std/memory | 3 - libstdc++-v3/std/new | 3 - libstdc++-v3/std/numeric | 3 - libstdc++-v3/std/ostream | 3 - libstdc++-v3/std/queue | 3 - libstdc++-v3/std/set | 3 - libstdc++-v3/std/sstream | 3 - libstdc++-v3/std/stack | 3 - libstdc++-v3/std/stdexcept | 3 - libstdc++-v3/std/streambuf | 3 - libstdc++-v3/std/string | 3 - libstdc++-v3/std/strstream | 3 - libstdc++-v3/std/typeinfo | 3 - libstdc++-v3/std/utility | 3 - libstdc++-v3/std/valarray | 3 - libstdc++-v3/std/vector | 3 - 166 files changed, 41015 deletions(-) delete mode 100644 libstdc++-v3/bits/basic_file.h delete mode 100644 libstdc++-v3/bits/basic_ios.h delete mode 100644 libstdc++-v3/bits/basic_ios.tcc delete mode 100644 libstdc++-v3/bits/basic_string.h delete mode 100644 libstdc++-v3/bits/c++config delete mode 100644 libstdc++-v3/bits/char_traits.h delete mode 100644 libstdc++-v3/bits/codecvt.h delete mode 100644 libstdc++-v3/bits/concept_checks.h delete mode 100644 libstdc++-v3/bits/container_concepts.h delete mode 100644 libstdc++-v3/bits/cpp_type_traits.h delete mode 100644 libstdc++-v3/bits/exception_support.h delete mode 100644 libstdc++-v3/bits/fpos.h delete mode 100644 libstdc++-v3/bits/fstream.tcc delete mode 100644 libstdc++-v3/bits/generic_shadow.h delete mode 100644 libstdc++-v3/bits/gslice.h delete mode 100644 libstdc++-v3/bits/gslice_array.h delete mode 100644 libstdc++-v3/bits/indirect_array.h delete mode 100644 libstdc++-v3/bits/ios_base.h delete mode 100644 libstdc++-v3/bits/istream.tcc delete mode 100644 libstdc++-v3/bits/limits_generic.h delete mode 100644 libstdc++-v3/bits/locale_facets.h delete mode 100644 libstdc++-v3/bits/locale_facets.tcc delete mode 100644 libstdc++-v3/bits/localefwd.h delete mode 100644 libstdc++-v3/bits/mask_array.h delete mode 100644 libstdc++-v3/bits/ostream.tcc delete mode 100644 libstdc++-v3/bits/pthread_allocimpl.h delete mode 100644 libstdc++-v3/bits/sbuf_iter.h delete mode 100644 libstdc++-v3/bits/sequence_concepts.h delete mode 100644 libstdc++-v3/bits/slice.h delete mode 100644 libstdc++-v3/bits/slice_array.h delete mode 100644 libstdc++-v3/bits/sstream.tcc delete mode 100644 libstdc++-v3/bits/std_algorithm.h delete mode 100644 libstdc++-v3/bits/std_bitset.h delete mode 100644 libstdc++-v3/bits/std_cassert.h delete mode 100644 libstdc++-v3/bits/std_cctype.h delete mode 100644 libstdc++-v3/bits/std_cerrno.h delete mode 100644 libstdc++-v3/bits/std_cfloat.h delete mode 100644 libstdc++-v3/bits/std_climits.h delete mode 100644 libstdc++-v3/bits/std_clocale.h delete mode 100644 libstdc++-v3/bits/std_cmath.h delete mode 100644 libstdc++-v3/bits/std_complex.h delete mode 100644 libstdc++-v3/bits/std_csetjmp.h delete mode 100644 libstdc++-v3/bits/std_csignal.h delete mode 100644 libstdc++-v3/bits/std_cstdarg.h delete mode 100644 libstdc++-v3/bits/std_cstddef.h delete mode 100644 libstdc++-v3/bits/std_cstdio.h delete mode 100644 libstdc++-v3/bits/std_cstdlib.h delete mode 100644 libstdc++-v3/bits/std_cstring.h delete mode 100644 libstdc++-v3/bits/std_ctime.h delete mode 100644 libstdc++-v3/bits/std_cwchar.h delete mode 100644 libstdc++-v3/bits/std_cwctype.h delete mode 100644 libstdc++-v3/bits/std_deque.h delete mode 100644 libstdc++-v3/bits/std_exception.h delete mode 100644 libstdc++-v3/bits/std_fstream.h delete mode 100644 libstdc++-v3/bits/std_functional.h delete mode 100644 libstdc++-v3/bits/std_iomanip.h delete mode 100644 libstdc++-v3/bits/std_ios.h delete mode 100644 libstdc++-v3/bits/std_iosfwd.h delete mode 100644 libstdc++-v3/bits/std_iostream.h delete mode 100644 libstdc++-v3/bits/std_istream.h delete mode 100644 libstdc++-v3/bits/std_iterator.h delete mode 100644 libstdc++-v3/bits/std_list.h delete mode 100644 libstdc++-v3/bits/std_locale.h delete mode 100644 libstdc++-v3/bits/std_map.h delete mode 100644 libstdc++-v3/bits/std_memory.h delete mode 100644 libstdc++-v3/bits/std_new.h delete mode 100644 libstdc++-v3/bits/std_numeric.h delete mode 100644 libstdc++-v3/bits/std_ostream.h delete mode 100644 libstdc++-v3/bits/std_queue.h delete mode 100644 libstdc++-v3/bits/std_set.h delete mode 100644 libstdc++-v3/bits/std_sstream.h delete mode 100644 libstdc++-v3/bits/std_stack.h delete mode 100644 libstdc++-v3/bits/std_stdexcept.h delete mode 100644 libstdc++-v3/bits/std_streambuf.h delete mode 100644 libstdc++-v3/bits/std_string.h delete mode 100644 libstdc++-v3/bits/std_strstream.h delete mode 100644 libstdc++-v3/bits/std_typeinfo.h delete mode 100644 libstdc++-v3/bits/std_utility.h delete mode 100644 libstdc++-v3/bits/std_valarray.h delete mode 100644 libstdc++-v3/bits/std_vector.h delete mode 100644 libstdc++-v3/bits/stl_algo.h delete mode 100644 libstdc++-v3/bits/stl_algobase.h delete mode 100644 libstdc++-v3/bits/stl_alloc.h delete mode 100644 libstdc++-v3/bits/stl_config.h delete mode 100644 libstdc++-v3/bits/stl_construct.h delete mode 100644 libstdc++-v3/bits/stl_deque.h delete mode 100644 libstdc++-v3/bits/stl_function.h delete mode 100644 libstdc++-v3/bits/stl_heap.h delete mode 100644 libstdc++-v3/bits/stl_iterator.h delete mode 100644 libstdc++-v3/bits/stl_iterator_base.h delete mode 100644 libstdc++-v3/bits/stl_list.h delete mode 100644 libstdc++-v3/bits/stl_map.h delete mode 100644 libstdc++-v3/bits/stl_multimap.h delete mode 100644 libstdc++-v3/bits/stl_multiset.h delete mode 100644 libstdc++-v3/bits/stl_numeric.h delete mode 100644 libstdc++-v3/bits/stl_pair.h delete mode 100644 libstdc++-v3/bits/stl_pthread_alloc.h delete mode 100644 libstdc++-v3/bits/stl_queue.h delete mode 100644 libstdc++-v3/bits/stl_range_errors.h delete mode 100644 libstdc++-v3/bits/stl_raw_storage_iter.h delete mode 100644 libstdc++-v3/bits/stl_relops.h delete mode 100644 libstdc++-v3/bits/stl_set.h delete mode 100644 libstdc++-v3/bits/stl_stack.h delete mode 100644 libstdc++-v3/bits/stl_string_fwd.h delete mode 100644 libstdc++-v3/bits/stl_tempbuf.h delete mode 100644 libstdc++-v3/bits/stl_threads.h delete mode 100644 libstdc++-v3/bits/stl_tree.h delete mode 100644 libstdc++-v3/bits/stl_uninitialized.h delete mode 100644 libstdc++-v3/bits/stl_vector.h delete mode 100644 libstdc++-v3/bits/streambuf.tcc delete mode 100644 libstdc++-v3/bits/string.tcc delete mode 100644 libstdc++-v3/bits/type_traits.h delete mode 100644 libstdc++-v3/bits/valarray_array.h delete mode 100644 libstdc++-v3/bits/valarray_array.tcc delete mode 100644 libstdc++-v3/bits/valarray_meta.h delete mode 100644 libstdc++-v3/std/algorithm delete mode 100644 libstdc++-v3/std/bitset delete mode 100644 libstdc++-v3/std/cassert delete mode 100644 libstdc++-v3/std/cctype delete mode 100644 libstdc++-v3/std/cerrno delete mode 100644 libstdc++-v3/std/cfloat delete mode 100644 libstdc++-v3/std/ciso646 delete mode 100644 libstdc++-v3/std/climits delete mode 100644 libstdc++-v3/std/clocale delete mode 100644 libstdc++-v3/std/cmath delete mode 100644 libstdc++-v3/std/complex delete mode 100644 libstdc++-v3/std/csetjmp delete mode 100644 libstdc++-v3/std/csignal delete mode 100644 libstdc++-v3/std/cstdarg delete mode 100644 libstdc++-v3/std/cstddef delete mode 100644 libstdc++-v3/std/cstdio delete mode 100644 libstdc++-v3/std/cstdlib delete mode 100644 libstdc++-v3/std/cstring delete mode 100644 libstdc++-v3/std/ctime delete mode 100644 libstdc++-v3/std/cwchar delete mode 100644 libstdc++-v3/std/cwctype delete mode 100644 libstdc++-v3/std/deque delete mode 100644 libstdc++-v3/std/exception delete mode 100644 libstdc++-v3/std/fstream delete mode 100644 libstdc++-v3/std/functional delete mode 100644 libstdc++-v3/std/iomanip delete mode 100644 libstdc++-v3/std/ios delete mode 100644 libstdc++-v3/std/iosfwd delete mode 100644 libstdc++-v3/std/iostream delete mode 100644 libstdc++-v3/std/istream delete mode 100644 libstdc++-v3/std/iterator delete mode 100644 libstdc++-v3/std/limits delete mode 100644 libstdc++-v3/std/list delete mode 100644 libstdc++-v3/std/locale delete mode 100644 libstdc++-v3/std/map delete mode 100644 libstdc++-v3/std/memory delete mode 100644 libstdc++-v3/std/new delete mode 100644 libstdc++-v3/std/numeric delete mode 100644 libstdc++-v3/std/ostream delete mode 100644 libstdc++-v3/std/queue delete mode 100644 libstdc++-v3/std/set delete mode 100644 libstdc++-v3/std/sstream delete mode 100644 libstdc++-v3/std/stack delete mode 100644 libstdc++-v3/std/stdexcept delete mode 100644 libstdc++-v3/std/streambuf delete mode 100644 libstdc++-v3/std/string delete mode 100644 libstdc++-v3/std/strstream delete mode 100644 libstdc++-v3/std/typeinfo delete mode 100644 libstdc++-v3/std/utility delete mode 100644 libstdc++-v3/std/valarray delete mode 100644 libstdc++-v3/std/vector diff --git a/libstdc++-v3/bits/basic_file.h b/libstdc++-v3/bits/basic_file.h deleted file mode 100644 index 3c8430b3264..00000000000 --- a/libstdc++-v3/bits/basic_file.h +++ /dev/null @@ -1,340 +0,0 @@ -// Wrapper of C-language FILE struct -*- C++ -*- - -// Copyright (C) 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.8 File-based streams -// - -#ifndef _CPP_BASIC_FILE -#define _CPP_BASIC_FILE 1 - -#include -#include - -namespace std { - - // Ulrich is going to make some detailed comment here, explaining - // all this unpleasantness, providing detailed performance analysis - // as to why we have to do all this lame vtable hacking instead of a - // sane, function-based approach. This verbage will provide a clear - // and detailed description of the whole object-layout, - // vtable-swapping, sordid history of this hack. - template - struct __basic_file_base: public __c_file_type - { - virtual - ~__basic_file_base() { }; - - virtual int - overflow(int __c = EOF) = 0; - - virtual int - underflow() = 0; - - virtual int - uflow() = 0; - - virtual int - pbackfail(int __c) = 0; - - virtual streamsize - xsputn(const _CharT* __s, streamsize __n) = 0; - - virtual streamsize - xsgetn(_CharT* __s, streamsize __n) = 0; - - virtual streamoff - seekoff(streamoff __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out) = 0; - - virtual streamoff - seekpos(streamoff __pos, - ios_base::openmode __mode = ios_base::in | ios_base::out) = 0; - - virtual streambuf* - setbuf(_CharT* __b, int __len) = 0; - - virtual int - sync() = 0; - - virtual int - doallocate() = 0; - - virtual streamsize - sys_read(_CharT* __s, streamsize __n) = 0; - - virtual streamsize - sys_write(const _CharT* __s, streamsize __n) = 0; - - virtual streamoff - sys_seek(streamoff __off, ios_base::seekdir __way) = 0; - - virtual int - sys_close() = 0; - - virtual int - sys_stat(void* __v) = 0; - - virtual int - showmanyc() = 0; - - virtual void - imbue(void* __v) = 0; - }; - - // Some of these member functions are based on libio/filebuf.cc. - // Also note that the order and number of virtual functions has to precisely - // match the order and number in the _IO_jump_t struct defined in libioP.h. - template -#if _GLIBCPP_BASIC_FILE_INHERITANCE - class __basic_file: public __basic_file_base<_CharT> -#else - class __basic_file -#endif - { -#if _GLIBCPP_BASIC_FILE_ENCAPSULATION - int _M_fileno; - __c_file_type* _M_cfile; -#endif - __c_wfile_type _M_wfile; - - public: - __basic_file(__c_lock* __lock = 0); - - void - _M_open_mode(ios_base::openmode __mode, int& __p_mode, int& __rw_mode); - - // Eqivalent to the normal fopen function. - __basic_file* - open(const char* __name, ios_base::openmode __mode, int __prot = 0664); - - // Used for opening the standard streams, cin, cout, cerr, clog, - // and their wide-stream equivalents. Instead of calling open, it - // just sets __c_file_type->_fileno and the respective _flags bits, and - // returns. - __basic_file* - sys_open(int __fd, ios_base::openmode __mode); - - __basic_file* - close(); - - bool - is_open(); - - // Needed by ios_base::sync_with_stdio. - int get_fileno(void); - - // NB: Must match FILE specific jump table starting here--this - // means all virtual functions starting with the dtor must match, - // slot by slot. For glibc-based dystems, this means the _IO_FILE - // as the FILE struct and _IO_jump_t as the jump table. - virtual - ~__basic_file(); // Takes the place of __finish. - - virtual int - overflow(int __c = EOF); - - virtual int - underflow(); - - virtual int - uflow(); - - virtual int - pbackfail(int __c); - - // A complex "write" function that sets all of __c_file_type's - // ponters and associated data members correctly and manages it's - // relation to the external byte sequence. - virtual streamsize - xsputn(const _CharT* __s, streamsize __n); - - // A complex "read" function that sets all of __c_file_type's - // ponters and associated data members correctly and manages it's - // relation to the external byte sequence. - virtual streamsize - xsgetn(_CharT* __s, streamsize __n); - - // A complex "seekoff" function that sets all of __c_file_type's - // ponters and associated data members correctly and manages it's - // relation to the external byte sequence. - virtual streamoff - seekoff(streamoff __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - // A complex "seekpos" function that sets all of __c_file_type's - // pointers and associated data members correctly and manages it's - // relation to the external byte sequence. - virtual streamoff - seekpos(streamoff __pos, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - virtual streambuf* - setbuf(_CharT* __b, int __len); - - virtual int - sync(); - - virtual int - doallocate(); - - // A simple read function for the external byte sequence, that - // does no mucking around with or setting of the pointers or flags - // in __c_file_type. - virtual streamsize - sys_read(_CharT* __s, streamsize __n); - - // A simple write function for the external byte sequence, that - // does no mucking around with or setting of the pointers or flags - // in __c_file_type. - virtual streamsize - sys_write(const _CharT* __s, streamsize __n); - - // A simple seek function for the external byte sequence, that - // does no mucking around with or setting of the pointers or flags - // in __c_file_type. - virtual streamoff - sys_seek(streamoff __off, ios_base::seekdir __way); - - virtual int - sys_close(); - - virtual int - sys_stat(void* __v); - - virtual int - showmanyc(); - - virtual void - imbue(void* __v); - }; - - // __basic_file specializations - template<> - __basic_file::__basic_file(__c_lock* __lock); - - template<> - int - __basic_file::overflow(int __c); - - template<> - int - __basic_file::underflow(); - - template<> - int - __basic_file::uflow(); - - template<> - int - __basic_file::pbackfail(int __c); - - template<> - streamsize - __basic_file::xsputn(const char* __s, streamsize __n); - - template<> - streamoff - __basic_file::seekoff(streamoff __off, ios_base::seekdir __way, - ios_base::openmode __mode); - - template<> - streamoff - __basic_file::seekpos(streamoff __pos, ios_base::openmode __mode); - - template<> - streambuf* - __basic_file::setbuf(char* __b, int __len); - - template<> - int - __basic_file::sync(); - - template<> - int - __basic_file::doallocate(); - - // __basic_file specializations -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - __basic_file::__basic_file(__c_lock* __lock); - - template<> - int - __basic_file::overflow(int __c); - - template<> - int - __basic_file::underflow(); - - template<> - int - __basic_file::uflow(); - - template<> - int - __basic_file::pbackfail(int __c); - - template<> - streamsize - __basic_file::xsputn(const wchar_t* __s, streamsize __n); - - template<> - streamoff - __basic_file::seekoff(streamoff __off, ios_base::seekdir __way, - ios_base::openmode __mode); - - template<> - streamoff - __basic_file::seekpos(streamoff __pos, ios_base::openmode __mode); - - template<> - streambuf* - __basic_file::setbuf(wchar_t* __b, int __len); - - template<> - int - __basic_file::sync(); - - template<> - int - __basic_file::doallocate(); -#endif - -} // namespace std - -#endif /* _CPP_BASIC_FILE */ - - - - - - - - diff --git a/libstdc++-v3/bits/basic_ios.h b/libstdc++-v3/bits/basic_ios.h deleted file mode 100644 index 7cac68b74c2..00000000000 --- a/libstdc++-v3/bits/basic_ios.h +++ /dev/null @@ -1,216 +0,0 @@ -// Iostreams base classes -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -#ifndef _CPP_BITS_BASICIOS_H -#define _CPP_BITS_BASICIOS_H 1 - -#include - -namespace std { - - // 27.4.5 Template class basic_ios - template - class basic_ios : public ios_base - { - public: - - // Types: - typedef _CharT char_type; - typedef typename _Traits::int_type int_type; - typedef typename _Traits::pos_type pos_type; - typedef typename _Traits::off_type off_type; - typedef _Traits traits_type; - - // Non-standard Types: - typedef ctype<_CharT> __ctype_type; - // From ostream - typedef ostreambuf_iterator<_CharT> __ostreambuf_iter; - typedef num_put<_CharT, __ostreambuf_iter> __numput_type; - typedef istreambuf_iterator<_CharT> __istreambuf_iter; - typedef num_get<_CharT, __istreambuf_iter> __numget_type; - - // Data members: - private: - basic_ostream<_CharT, _Traits>* _M_tie; - char_type _M_fill; - iostate _M_exception; - - protected: - basic_streambuf<_CharT, _Traits>* _M_streambuf; - iostate _M_streambuf_state; - - // Cached use_facet, which is based on the current locale info. - const __ctype_type* _M_ios_fctype; - // From ostream. - const __numput_type* _M_fnumput; - // From istream. - const __numget_type* _M_fnumget; - - public: - - inline const __ctype_type* - _M_get_fctype_ios(void) - { return _M_ios_fctype; } - - inline const __numget_type* - _M_get_fnumget(void) - { return _M_fnumget; } - - inline const __numput_type* - _M_get_fnumput(void) - { return _M_fnumput; } - - operator void*() const - { return this->fail() ? 0 : const_cast(this); } - - inline bool - operator!() const - { return this->fail(); } - - inline iostate - rdstate() const - { return _M_streambuf_state; } - - inline void - clear(iostate __state = goodbit) - { - if (this->rdbuf()) - _M_streambuf_state = __state; - else - _M_streambuf_state = __state | badbit; - if ((this->rdstate() & this->exceptions())) - throw failure("basic_ios::clear(iostate) caused exception"); - } - - inline void - setstate(iostate __state) - { this->clear(this->rdstate() | __state); } - - inline bool - good() const - { return this->rdstate() == 0; } - - inline bool - eof() const - { return (this->rdstate() & eofbit) != 0; } - - inline bool - fail() const - { return (this->rdstate() & (badbit | failbit)) != 0; } - - inline bool - bad() const - { return (this->rdstate() & badbit) != 0; } - - inline iostate - exceptions() const - { return _M_exception; } - - inline void - exceptions(iostate __except) - { - _M_exception = __except; - this->clear(_M_streambuf_state); - } - - // Constructor/destructor: - explicit - basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base() - { this->init(__sb); } - - virtual - ~basic_ios() { } - - // Members: - inline basic_ostream<_CharT, _Traits>* - tie() const - { return _M_tie; } - - inline basic_ostream<_CharT, _Traits>* - tie(basic_ostream<_CharT, _Traits>* __tiestr) - { - basic_ostream<_CharT, _Traits>* __old = _M_tie; - _M_tie = __tiestr; - return __old; - } - - inline basic_streambuf<_CharT, _Traits>* - rdbuf() const - { return _M_streambuf; } - - basic_streambuf<_CharT, _Traits>* - rdbuf(basic_streambuf<_CharT, _Traits>* __sb); - - basic_ios& - copyfmt(const basic_ios& __rhs); - - inline char_type - fill() const - { return _M_fill; } - - inline char_type - fill(char_type __ch) - { - char_type __old = _M_fill; - _M_fill = __ch; - return __old; - } - - // Locales: - locale - imbue(const locale& __loc); - - char - narrow(char_type __c, char __dfault) const; - - char_type - widen(char __c) const; - - protected: - // 27.4.5.1 basic_ios constructors - basic_ios() : ios_base() - { } - - void - init(basic_streambuf<_CharT, _Traits>* __sb); - }; - -} // namespace std - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -//#include -#endif - -#endif /* _CPP_BITS_BASICIOS_H */ - - - - - diff --git a/libstdc++-v3/bits/basic_ios.tcc b/libstdc++-v3/bits/basic_ios.tcc deleted file mode 100644 index 54d5efd19bc..00000000000 --- a/libstdc++-v3/bits/basic_ios.tcc +++ /dev/null @@ -1,142 +0,0 @@ -// basic_ios locale and locale-related member functions -*- C++ -*- - -// Copyright (C) 1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -#ifndef _CPP_BITS_BASICIOS_TCC -#define _CPP_BITS_BASICIOS_TCC 1 - -namespace std { - - template - basic_streambuf<_CharT, _Traits>* - basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) - { - basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; - _M_streambuf = __sb; - this->clear(); - return __old; - } - - template - basic_ios<_CharT, _Traits>& - basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) - { - // Per 27.1.1.1, do not call imbue, yet must trash all caches - // associated with imbue() - - // Alloc any new word array first, so if it fails we have "rollback". - _Words* __words = (__rhs._M_word_limit <= _S_local_words) ? - _M_word_array : new _Words[__rhs._M_word_limit]; - - // XXX This is the only reason _Callback_list was defined - // inline. The suspicion is that this increased compilation - // times dramatically for functions that use this member - // function (inserters_extractors, ios_manip_fmtflags). FIX ME, - // clean this stuff up. Callbacks are broken right now, anyway. - - // Bump refs before doing callbacks, for safety. - _Callback_list* __cb = __rhs._M_callbacks; - if (__cb) - __cb->_M_add_reference(); - _M_call_callbacks(erase_event); - if (_M_words != _M_word_array) - delete [] _M_words; - _M_dispose_callbacks(); - - _M_callbacks = __cb; // NB: Don't want any added during above. - for (int __i = 0; __i < __rhs._M_word_limit; ++__i) - __words[__i] = __rhs._M_words[__i]; - if (_M_words != _M_word_array) - delete [] _M_words; - _M_words = __words; - _M_word_limit = __rhs._M_word_limit; - - this->flags(__rhs.flags()); - this->width(__rhs.width()); - this->precision(__rhs.precision()); - this->tie(__rhs.tie()); - this->fill(__rhs.fill()); - // The next is required to be the last assignment. - this->exceptions(__rhs.exceptions()); - - _M_call_callbacks(copyfmt_event); - return *this; - } - - template - char - basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const - { return _M_ios_fctype->narrow(__c, __dfault); } - - template - _CharT - basic_ios<_CharT, _Traits>::widen(char __c) const - { return _M_ios_fctype->widen(__c); } - - // Locales: - template - locale - basic_ios<_CharT, _Traits>::imbue(const locale& __loc) - { - locale __old(this->getloc()); - ios_base::imbue(__loc); - _M_ios_fctype = &use_facet<__ctype_type>(__loc); - _M_fnumput = &use_facet<__numput_type>(__loc); - _M_fnumget = &use_facet<__numget_type>(__loc); - if (this->rdbuf() != 0) - this->rdbuf()->pubimbue(__loc); - return __old; - } - - template - void - basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) - { - // NB: This may be called more than once on the same object. - ios_base::_M_init(); - locale __loc = this->getloc(); - _M_ios_fctype = &use_facet<__ctype_type>(__loc); - // Should be filled in by ostream and istream, respectively. - _M_fnumput = &use_facet<__numput_type>(__loc); - _M_fnumget = &use_facet<__numget_type>(__loc); - _M_tie = 0; - _M_fill = this->widen(' '); - _M_exception = goodbit; - _M_streambuf = __sb; - iostate __state = __sb ? goodbit : badbit; - _M_streambuf_state = __state; - } - -} // namespace std - -#endif /* _CPP_BITS_BASICIOS_TCC */ - - - - - diff --git a/libstdc++-v3/bits/basic_string.h b/libstdc++-v3/bits/basic_string.h deleted file mode 100644 index 60795f7b72e..00000000000 --- a/libstdc++-v3/bits/basic_string.h +++ /dev/null @@ -1,1038 +0,0 @@ -// Components for manipulating sequences of characters -*- C++ -*- - -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 21 Strings library -// - -#ifndef _CPP_BITS_STRING_H -#define _CPP_BITS_STRING_H 1 - -#include -#include - -namespace std { - - // Documentation? What's that? - // Nathan Myers . - // - // A string looks like this: - // - // [_Rep] - // _M_length - // [basic_string] _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. - - // 21.3 Template class basic_string - template - class basic_string - { - // Types: - public: - typedef _Traits traits_type; - typedef typename _Traits::char_type value_type; - typedef _Alloc allocator_type; - typedef typename _Alloc::size_type size_type; - typedef typename _Alloc::difference_type difference_type; - typedef typename _Alloc::reference reference; - typedef typename _Alloc::const_reference const_reference; - typedef typename _Alloc::pointer pointer; - typedef typename _Alloc::const_pointer const_pointer; - typedef __normal_iterator iterator; - typedef __normal_iterator const_iterator; - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; - - private: - // _Rep: string representation - // Invariants: - // 1. String really contains _M_length + 1 characters; last is set - // to 0 only on call to c_str(). We avoid instantiating - // _CharT() where the interface does not require it. - // 2. _M_capacity >= _M_length - // Allocated memory is always _M_capacity + (1 * sizeof(_CharT)). - // 3. _M_references has three states: - // -1: leaked, one reference, no ref-copies allowed, non-const. - // 0: one reference, non-const. - // n>0: n + 1 references, operations require a lock, const. - // 4. All fields==0 is an empty string, given the extra storage - // beyond-the-end for a null terminator; thus, the shared - // empty string representation needs no constructor. - - struct _Rep - { - // Types: - typedef typename _Alloc::rebind::other _Raw_bytes_alloc; - - // (Public) Data members: - - // The maximum number of individual char_type elements of an - // individual string is determined by _S_max_size. This is the - // value that will be returned by max_size(). (Whereas npos - // 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: - // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT) - // Solving for m: - // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 - // In addition, this implementation quarters this ammount. - static size_type _S_max_size; - static _CharT _S_terminal; - - size_type _M_length; - size_type _M_capacity; - _Atomic_word _M_references; - - bool - _M_is_leaked() const - { return _M_references < 0; } - - bool - _M_is_shared() const - { return _M_references > 0; } - - void - _M_set_leaked() - { _M_references = -1; } - - void - _M_set_sharable() - { _M_references = 0; } - - _CharT* - _M_refdata() throw() - { return reinterpret_cast<_CharT*> (this + 1); } - - _CharT& - operator[](size_t __s) throw() - { return _M_refdata() [__s]; } - - _CharT* - _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) - { return (!_M_is_leaked() && __alloc1 == __alloc2) ? - _M_refcopy() : _M_clone(__alloc1); } - - // Create & Destroy - static _Rep* - _S_create(size_t, const _Alloc&); - - void - _M_dispose(const _Alloc& __a) - { - if (__exchange_and_add(&_M_references, -1) <= 0) - _M_destroy(__a); - } // XXX MT - - void - _M_destroy(const _Alloc&) throw(); - - _CharT* - _M_refcopy() throw() - { - __atomic_add(&_M_references, 1); - return _M_refdata(); - } // XXX MT - - _CharT* - _M_clone(const _Alloc&, size_type __res = 0); - -#if _GLIBCPP_ALLOC_CONTROL - // These function pointers allow you to modify the allocation - // policy used by the string classes. By default they expand by - // powers of two, but this may be excessive for space-critical - // applications. - - // Returns true if ALLOCATED is too much larger than LENGTH - static bool (*_S_excess_slop) (size_t __length, size_t __allocated); - - inline static bool - __default_excess(size_t, size_t); -#else - inline static bool - _S_excess_slop(size_t, size_t); -#endif - }; - - // Use empty-base optimization: http://www.cantrip.org/emptyopt.html - struct _Alloc_hider : _Alloc - { - _Alloc_hider(_CharT* __dat, const _Alloc& __a) - : _Alloc(__a), _M_p(__dat) { } - - _CharT* _M_p; // The actual data. - }; - - public: - // Data Members (public): - // NB: This is an unsigned type, and thus represents the maximum - // size that the allocator can hold. - static const size_type npos = static_cast(-1); - - private: - // Data Members (private): - mutable _Alloc_hider _M_dataplus; - - // The following storage is init'd to 0 by the linker, resulting - // (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 - { return _M_dataplus._M_p; } - - _CharT* - _M_data(_CharT* __p) - { return (_M_dataplus._M_p = __p); } - - _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 - _M_ibegin() const { return iterator(_M_data()); } - - iterator - _M_iend() const { return iterator(_M_data() + this->size()); } - - void - _M_leak() // for use in begin() & non-const op[] - { - if (!_M_rep()->_M_is_leaked()) - _M_leak_hard(); - } - - iterator - _M_check(size_type __pos) const - { - __OUTOFRANGE(__pos > this->size()); - return _M_ibegin() + __pos; - } - - // NB: _M_fold doesn't check for a bad __pos1 value. - 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); - } - - // _S_copy_chars is a separate template to permit specialization - // to optimize for the common case of pointers as iterators. - template - static void - _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) - { - for (; __k1 != __k2; ++__k1, ++__p) - traits_type::assign(*__p, *__k1); //these types are off - } - - static void - _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) - { _S_copy_chars(__p, __k1.base(), __k2.base()); } - - 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); } - - static void - _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) - { traits_type::copy(__p, __k1, __k2 - __k1); } - - void - _M_mutate(size_type __pos, size_type __len1, size_type __len2); - - void - _M_leak_hard(); - - static _Rep& - _S_empty_rep() - { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); } - - public: - // Construct/copy/destroy: - // NB: We overload ctors in some cases instead of using default - // arguments, per 17.4.4.4 para. 2 item 2. - - inline - basic_string(); - - explicit - basic_string(const _Alloc& __a); - - // NB: per LWG issue 42, semantics different from IS: - basic_string(const basic_string& __str); - basic_string(const basic_string& __str, size_type __pos, - size_type __n = npos); - basic_string(const basic_string& __str, size_type __pos, - size_type __n, const _Alloc& __a); - - basic_string(const _CharT* __s, size_type __n, - const _Alloc& __a = _Alloc()); - basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); - basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()); - - template - basic_string(_InputIterator __begin, _InputIterator __end, - const _Alloc& __a = _Alloc()); - - ~basic_string() - { _M_rep()->_M_dispose(this->get_allocator()); } - - basic_string& - operator=(const basic_string& __str) { return this->assign(__str); } - - basic_string& - operator=(const _CharT* __s) { return this->assign(__s); } - - basic_string& - operator=(_CharT __c) { return this->assign(1, __c); } - - // Iterators: - iterator - begin() - { - _M_leak(); - return iterator(_M_data()); - } - - const_iterator - begin() const - { return const_iterator(_M_data()); } - - iterator - end() - { - _M_leak(); - return iterator(_M_data() + this->size()); - } - - const_iterator - end() const - { return const_iterator(_M_data() + this->size()); } - - reverse_iterator - rbegin() - { return reverse_iterator(this->end()); } - - const_reverse_iterator - rbegin() const - { return const_reverse_iterator(this->end()); } - - reverse_iterator - rend() - { return reverse_iterator(this->begin()); } - - const_reverse_iterator - rend() const - { return const_reverse_iterator(this->begin()); } - - public: - // Capacity: - size_type - size() const { return _M_rep()->_M_length; } - - size_type - length() const { return _M_rep()->_M_length; } - - size_type - max_size() const { return _Rep::_S_max_size; } - - void - resize(size_type __n, _CharT __c); - - void - resize(size_type __n) { this->resize(__n, _CharT()); } - - size_type - capacity() const { return _M_rep()->_M_capacity; } - - void - reserve(size_type __res_arg = 0); - - void - clear() { _M_mutate(0, this->size(), 0); } - - bool - empty() const { return this->size() == 0; } - - // Element access: - const_reference - operator[] (size_type __pos) const - { return _M_data()[__pos]; } - - reference - operator[](size_type __pos) - { - _M_leak(); - return _M_data()[__pos]; - } - - const_reference - at(size_type __n) const - { - __OUTOFRANGE(__n >= this->size()); - return _M_data()[__n]; - } - - reference - at(size_type __n) - { - __OUTOFRANGE(__n >= size()); - _M_leak(); - return _M_data()[__n]; - } - - // Modifiers: - basic_string& - operator+=(const basic_string& __str) { return this->append(__str); } - - basic_string& - operator+=(const _CharT* __s) { return this->append(__s); } - - basic_string& - operator+=(_CharT __c) { return this->append(size_type(1), __c); } - - basic_string& - append(const basic_string& __str); - - basic_string& - append(const basic_string& __str, size_type __pos, size_type __n); - - basic_string& - append(const _CharT* __s, size_type __n); - - basic_string& - append(const _CharT* __s) - { return this->append(__s, traits_type::length(__s)); } - - basic_string& - append(size_type __n, _CharT __c); - - template - basic_string& - append(_InputIterator __first, _InputIterator __last) - { return this->replace(_M_iend(), _M_iend(), __first, __last); } - - void - push_back(_CharT __c) - { this->replace(_M_iend(), _M_iend(), 1, __c); } - - basic_string& - assign(const basic_string& __str); - - basic_string& - assign(const basic_string& __str, size_type __pos, size_type __n) - { - return this->assign(__str._M_check(__pos), __str._M_fold(__pos, __n)); - } - - basic_string& - assign(const _CharT* __s, size_type __n) - { return this->assign(__s, __s + __n); } - - basic_string& - assign(const _CharT* __s) - { return this->assign(__s, __s + traits_type::length(__s)); } - - basic_string& - assign(size_type __n, _CharT __c) - { return this->replace(_M_ibegin(), _M_iend(), __n, __c); } - - template - basic_string& - assign(_InputIterator __first, _InputIterator __last) - { return this->replace(_M_ibegin(), _M_iend(), __first, __last); } - - void - insert(iterator __p, size_type __n, _CharT __c) - { this->replace(__p, __p, __n, __c); } - - template - void insert(iterator __p, _InputIterator __beg, _InputIterator __end) - { this->replace(__p, __p, __beg, __end); } - - basic_string& - insert(size_type __pos1, const basic_string& __str) - { - iterator __p = _M_check(__pos1); - this->replace(__p, __p, __str._M_ibegin(), __str._M_iend()); - return *this; - } - - basic_string& - insert(size_type __pos1, const basic_string& __str, - size_type __pos2, size_type __n) - { - iterator __p = _M_check(__pos1); - this->replace(__p, __p, __str._M_check(__pos2), - __str._M_fold(__pos2, __n)); - return *this; - } - - basic_string& - insert(size_type __pos, const _CharT* __s, size_type __n) - { - iterator __p = _M_check(__pos); - this->replace(__p, __p, __s, __s + __n); - return *this; - } - - basic_string& - insert(size_type __pos, const _CharT* __s) - { return this->insert(__pos, __s, traits_type::length(__s)); } - - basic_string& - insert(size_type __pos, size_type __n, _CharT __c) - { - this->insert(_M_check(__pos), __n, __c); - return *this; - } - - 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; - } - - 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()); - } - - iterator - erase(iterator __position) - { - size_type __i = __position - _M_ibegin(); - this->replace(__position, __position + 1, _M_data(), _M_data()); - _M_rep()->_M_set_leaked(); - return _M_ibegin() + __i; - } - - iterator - erase(iterator __first, iterator __last) - { - size_type __i = __first - _M_ibegin(); - this->replace(__first, __last, _M_data(), _M_data()); - _M_rep()->_M_set_leaked(); - return _M_ibegin() + __i; - } - - basic_string& - replace(size_type __pos, size_type __n, const basic_string& __str) - { - return this->replace(_M_check(__pos), _M_fold(__pos, __n), - __str.begin(), __str.end()); - } - - basic_string& - replace(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2); - - basic_string& - replace(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2) - { - return this->replace(_M_check(__pos), _M_fold(__pos, __n1), - __s, __s + __n2); - } - - basic_string& - replace(size_type __pos, size_type __n1, const _CharT* __s) - { - return this->replace(_M_check(__pos), _M_fold(__pos, __n1), - __s, __s + traits_type::length(__s)); - } - - 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& - replace(iterator __i1, iterator __i2, const basic_string& __str) - { return this->replace(__i1, __i2, __str.begin(), __str.end()); } - - basic_string& - replace(iterator __i1, iterator __i2, - const _CharT* __s, size_type __n) - { return this->replace(__i1, __i2, __s, __s + __n); } - - basic_string& - replace(iterator __i1, iterator __i2, const _CharT* __s) - { return this->replace(__i1, __i2, __s, - __s + traits_type::length(__s)); } - - basic_string& - replace(iterator __i1, iterator __i2, size_type __n, _CharT __c); - - template - basic_string& - replace(iterator __i1, iterator __i2, - _InputIterator __k1, _InputIterator __k2) - { return _M_replace(__i1, __i2, __k1, __k2, - typename iterator_traits<_InputIterator>::iterator_category()); } - - private: - template - basic_string& - _M_replace(iterator __i1, iterator __i2, _InputIterator __k1, - _InputIterator __k2, input_iterator_tag); - - template - basic_string& - _M_replace(iterator __i1, iterator __i2, _FwdIterator __k1, - _FwdIterator __k2, forward_iterator_tag); - - // _S_construct_aux is used to implement the 21.3.1 para 15 which - // requires special behaviour if _InIter is an integral type - template - static _CharT* - _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a, - __false_type) - { - typedef typename iterator_traits<_InIter>::iterator_category _Tag; - return _S_construct(__beg, __end, __a, _Tag()); - } - - template - static _CharT* - _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a, - __true_type) - { - return _S_construct(static_cast(__beg), - static_cast(__end), __a); - } - - template - static _CharT* - _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a) - { - typedef typename _Is_integer<_InIter>::_Integral _Integral; - return _S_construct_aux(__beg, __end, __a, _Integral()); - } - - // For Input Iterators, used in istreambuf_iterators, etc. - template - 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 - static _CharT* - _S_construct(_FwdIter __end, _FwdIter __beg, const _Alloc& __a, - forward_iterator_tag); - - static _CharT* - _S_construct(size_type __req, _CharT __c, const _Alloc& __a); - - public: - - size_type - copy(_CharT* __s, size_type __n, size_type __pos = 0) const; - - void - swap(basic_string<_CharT, _Traits, _Alloc>& __s); - - // String operations: - const _CharT* - c_str() const - { - // MT: This assumes concurrent writes are OK. - size_type __n = this->size(); - traits_type::assign(_M_data()[__n], _Rep::_S_terminal); - return _M_data(); - } - - const _CharT* - data() const { return _M_data(); } - - allocator_type - get_allocator() const { return _M_dataplus; } - - size_type - find(const _CharT* __s, size_type __pos, size_type __n) const; - - size_type - find(const basic_string& __str, size_type __pos = 0) const - { return this->find(__str.data(), __pos, __str.size()); } - - size_type - find(const _CharT* __s, size_type __pos = 0) const - { return this->find(__s, __pos, traits_type::length(__s)); } - - size_type - find(_CharT __c, size_type __pos = 0) const; - - size_type - rfind(const basic_string& __str, size_type __pos = npos) const - { return this->rfind(__str.data(), __pos, __str.size()); } - - size_type - rfind(const _CharT* __s, size_type __pos, size_type __n) const; - - size_type - rfind(const _CharT* __s, size_type __pos = npos) const - { return this->rfind(__s, __pos, traits_type::length(__s)); } - - size_type - rfind(_CharT __c, size_type __pos = npos) const; - - 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 - find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; - - 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 - find_first_of(_CharT __c, size_type __pos = 0) const - { return this->find(__c, __pos); } - - 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 - find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; - - 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 - find_last_of(_CharT __c, size_type __pos = npos) const - { return this->rfind(__c, __pos); } - - 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 __n) const; - - 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 - find_first_not_of(_CharT __c, size_type __pos = 0) const; - - 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 __n) const; - 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 - find_last_not_of(_CharT __c, size_type __pos = npos) const; - - basic_string - substr(size_type __pos = 0, size_type __n = npos) const - { - __OUTOFRANGE(__pos > this->size()); - return basic_string(*this, __pos, __n); - } - - int - compare(const basic_string& __str) const - { - size_type __size = this->size(); - size_type __osize = __str.size(); - size_type __len = min(__size, __osize); - - int __r = traits_type::compare(_M_data(), __str.data(), __len); - if (!__r) - __r = __size - __osize; - return __r; - } - - int - compare(size_type __pos, size_type __n, const basic_string& __str) const; - - int - compare(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2) const; - - int - compare(const _CharT* __s) const; - - int - compare(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2 = npos) const; - - private: - static const _CharT* - _S_find(const _CharT* __beg, const _CharT* __end, _CharT __c); - }; - - - template - inline basic_string<_CharT, _Traits, _Alloc>:: - basic_string() - : _M_dataplus(_S_empty_rep()._M_refcopy(), _Alloc()) { } - - // operator+ - template - basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { - basic_string<_CharT, _Traits, _Alloc> __str(__lhs); - __str.append(__rhs); - return __str; - } - - template - basic_string<_CharT,_Traits,_Alloc> - operator+(const _CharT* __lhs, - const basic_string<_CharT,_Traits,_Alloc>& __rhs); - - template - basic_string<_CharT,_Traits,_Alloc> - operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); - - template - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { - basic_string<_CharT, _Traits, _Alloc> __str(__lhs); - __str.append(__rhs); - return __str; - } - - template - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) - { - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef typename __string_type::size_type __size_type; - __string_type __str(__lhs); - __str.append(__size_type(1), __rhs); - return __str; - } - - // operator == - template - inline bool - operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __lhs.compare(__rhs) == 0; } - - template - inline bool - operator==(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) == 0; } - - template - inline bool - operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) == 0; } - - // operator != - template - inline bool - operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) != 0; } - - template - inline bool - operator!=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) != 0; } - - template - inline bool - operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) != 0; } - - // operator < - template - inline bool - operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __lhs.compare(__rhs) < 0; } - - template - inline bool - operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) < 0; } - - template - inline bool - operator<(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) > 0; } - - // operator > - template - inline bool - operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __lhs.compare(__rhs) > 0; } - - template - inline bool - operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) > 0; } - - template - inline bool - operator>(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) < 0; } - - // operator <= - template - inline bool - operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __lhs.compare(__rhs) <= 0; } - - template - inline bool - operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) <= 0; } - - template - inline bool - operator<=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) >= 0; } - - // operator >= - template - inline bool - operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __lhs.compare(__rhs) >= 0; } - - template - inline bool - operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) >= 0; } - - template - inline bool - operator>=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) <= 0; } - - - template - inline void - swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, - basic_string<_CharT, _Traits, _Alloc>& __rhs) - { __lhs.swap(__rhs); } - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str); - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const basic_string<_CharT, _Traits, _Alloc>& __str); - - template - basic_istream<_CharT,_Traits>& - getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); - - template - inline basic_istream<_CharT,_Traits>& - getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str); - -} // namespace std - -#endif /* _CPP_BITS_STRING_H */ diff --git a/libstdc++-v3/bits/c++config b/libstdc++-v3/bits/c++config deleted file mode 100644 index 07667353a04..00000000000 --- a/libstdc++-v3/bits/c++config +++ /dev/null @@ -1,72 +0,0 @@ -// Predefined symbols and macros -*- C++ -*- - -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -#ifndef _CPP_CPPCONFIG -#define _CPP_CPPCONFIG 1 - -// The current version of the C++ library in compressed ISO date format. -#define __GLIBCPP__ 20000911 - -// By enabling this, all GNU extensions are enabled. -#define _GNU_SOURCE 1 - -// By enabling this, all ISO C99, ISO C9X functionality is enabled. -#define _ISOC99_SOURCE 1 - -// This flag controls the error handling in string, and perhaps other -// bits as time goes on: check out bits/basic_string.h for more -// info. It also helps alleviate the circular dependency between -// string and exception. -# define _GLIBCPP_USE_EXCEPTIONS 1 - -// This is necessary until Egcs supports separate template -// compilation. -#define _GLIBCPP_NO_TEMPLATE_EXPORT 1 - -// This is a hack around not having either pre-compiled headers or -// export compilation. If defined, the io, string, and valarray -// headers will include all the necessary bits. If not defined, the -// implementation optimizes the headers for the most commonly-used -// types. For the io library, this means that larger, out-of-line -// member functions are only declared, and definitions are not parsed -// by the compiler, but instead instantiated into the library binary. -//#define _GLIBCPP_FULLY_COMPLIANT_HEADERS 1 - -// To enable older, ARM-style iostreams and other anachronisms use this. -//#define _GLIBCPP_DEPRICATED 1 - -// Use corrected code from the committee library group's issues list. -# define _GLIBCPP_RESOLVE_LIB_DEFECTS 1 - - - - - - - diff --git a/libstdc++-v3/bits/char_traits.h b/libstdc++-v3/bits/char_traits.h deleted file mode 100644 index baab72293c3..00000000000 --- a/libstdc++-v3/bits/char_traits.h +++ /dev/null @@ -1,307 +0,0 @@ -// Character Traits for use by standard string and iostream -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 21 Strings library -// - -#ifndef _CPP_BITS_CHAR_TRAITS_H -#define _CPP_BITS_CHAR_TRAITS_H 1 - -#include // For mbstate_t. -#include // For memmove, memset, memchr -#include // For streamoff, streamsize - -namespace std { - - // Same as iosfwd -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Can't have self-recursive types for streampos. - // 21.1.3.1 char_traits sets size_type to streampos - // 27.4.1 - // And here, where streampos is typedefed to fpos - typedef fpos streampos; -# ifdef _GLIBCPP_USE_WCHAR_T - typedef fpos wstreampos; -# endif -#endif - - // 21.1.2 Basis for explicit _Traits specialization - // NB: That for any given actual character type this definition is - // probably wrong. - - template - struct char_traits - { - typedef _CharT char_type; - // Unsigned as wint_t in unsigned. - typedef unsigned long int_type; - typedef streampos pos_type; - typedef streamoff off_type; - typedef mbstate_t state_type; - - static void - assign(char_type& __c1, const char_type& __c2) - { __c1 = __c2; } - - static bool - eq(const char_type& __c1, const char_type& __c2) - { return __c1 == __c2; } - - static bool - lt(const char_type& __c1, const char_type& __c2) - { return __c1 < __c2; } - - static int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { - for (size_t __i = 0; __i < __n; ++__i) - if (!eq(__s1[__i], __s2[__i])) - return lt(__s1[__i], __s2[__i]) ? -1 : 1; - return 0; - } - - static size_t - length(const char_type* __s) - { - const char_type* __p = __s; - while (*__p) ++__p; - return (__p - __s); - } - - static const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { - for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p) - if (*__p == __a) return __p; - return 0; - } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { - for (char_type* __p = __s; __p < __s + __n; ++__p) - assign(*__p, __a); - return __s; - } - - static char_type - to_char_type(const int_type& __c) - { return char_type(__c); } - - static int_type - to_int_type(const char_type& __c) { return int_type(__c); } - - static bool - eq_int_type(const int_type& __c1, const int_type& __c2) - { return __c1 == __c2; } - - static state_type - _S_get_state(const pos_type& __pos) { return __pos.state(); } - - static int_type - eof() { return static_cast(-1); } - - static int_type - _S_eos() { return char_type(); } - - static int_type - not_eof(const int_type& __c) - { return eq_int_type(__c, eof()) ? int_type(0) : __c; } - }; - - // 21.1.4 char_traits specializations - template<> - struct char_traits - { - typedef char char_type; - typedef unsigned int int_type; - typedef streampos pos_type; - typedef streamoff off_type; - typedef mbstate_t state_type; - - static void - assign(char_type& __c1, const char_type& __c2) - { __c1 = __c2; } - - static bool - eq(const char_type& __c1, const char_type& __c2) - { return __c1 == __c2; } - - static bool - lt(const char_type& __c1, const char_type& __c2) - { return __c1 < __c2; } - - static int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { return memcmp(__s1, __s2, __n); } - - static size_t - length(const char_type* __s) - { return strlen(__s); } - - static const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { return static_cast(memchr(__s, __a, __n)); } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { return static_cast(memmove(__s1, __s2, __n)); } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { return static_cast(memcpy(__s1, __s2, __n)); } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { return static_cast(memset(__s, __a, __n)); } - - static char_type - to_char_type(const int_type& __c) - { return static_cast(__c); } - - // To keep both the byte 0xff and the eof symbol 0xffffffff - // from ending up as 0xffffffff. - static int_type - to_int_type(const char_type& __c) - { return static_cast(static_cast(__c)); } - - static bool - eq_int_type(const int_type& __c1, const int_type& __c2) - { return __c1 == __c2; } - - static state_type - _S_get_state(const pos_type& __pos) { return __pos.state(); } - - static int_type - eof() { return static_cast(EOF); } - - static int_type - _S_eos() { return char_type(); } - - static int_type - not_eof(const int_type& __c) - { return (__c == eof()) ? 0 : __c; } - }; - - -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - struct char_traits - { - typedef wchar_t char_type; - typedef wint_t int_type; - typedef wstreamoff off_type; - typedef wstreampos pos_type; - typedef mbstate_t state_type; - - static void - assign(char_type& __c1, const char_type& __c2) - { __c1 = __c2; } - - static bool - eq(const char_type& __c1, const char_type& __c2) - { return __c1 == __c2; } - - static bool - lt(const char_type& __c1, const char_type& __c2) - { return __c1 < __c2; } - - static int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { return wmemcmp(__s1, __s2, __n); } - - static size_t - length(const char_type* __s) - { return wcslen(__s); } - - static const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { return wmemchr(__s, __a, __n); } - - static char_type* - move(char_type* __s1, const char_type* __s2, int_type __n) - { return wmemmove(__s1, __s2, __n); } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { return wmemcpy(__s1, __s2, __n); } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { return wmemset(__s, __a, __n); } - - static char_type - to_char_type(const int_type& __c) { return char_type(__c); } - - static int_type - to_int_type(const char_type& __c) { return int_type(__c); } - - static bool - eq_int_type(const int_type& __c1, const int_type& __c2) - { return __c1 == __c2; } - - static state_type - _S_get_state(const pos_type& __pos) { return __pos.state(); } - - static int_type - eof() { return static_cast(WEOF); } - - static int_type - _S_eos() { return char_type(); } - - static int_type - not_eof(const int_type& __c) - { return eq_int_type(__c, eof()) ? 0 : __c; } - }; -#endif //_GLIBCPP_USE_WCHAR_T - - template - struct _Char_traits_match - { - _CharT _M_c; - _Char_traits_match(_CharT const& __c) : _M_c(__c) { } - - bool - operator()(_CharT const& __a) { return _Traits::eq(_M_c,__a); } - }; - -} // namespace std - - -#endif /* _CPP_BITS_CHAR_TRAITS_H */ - diff --git a/libstdc++-v3/bits/codecvt.h b/libstdc++-v3/bits/codecvt.h deleted file mode 100644 index 1306434a18c..00000000000 --- a/libstdc++-v3/bits/codecvt.h +++ /dev/null @@ -1,662 +0,0 @@ -// Locale support (codecvt) -*- C++ -*- - -// Copyright (C) 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 22.2.1.5 Template class codecvt -// - -// Warning: this file is not meant for user inclusion. Use . - -// Written by Benjamin Kosnik - -#ifndef _CPP_BITS_CODECVT_H -#define _CPP_BITS_CODECVT_H 1 - -#ifdef _GLIBCPP_USE_WCHAR_T -#include // For iconv, iconv_t -#include -#endif - -namespace std -{ - // XXX __enc_traits may need to move up the locale header hierarchy, - // depending on if ctype ends up using it. -#ifdef _GLIBCPP_USE_WCHAR_T - // Extensions to use icov for dealing with character encodings, - // including conversions and comparisons between various character - // sets. This object encapsulates data that may need to be shared between - // char_traits, codecvt and ctype. - class __enc_traits - { - public: - // Types: - // NB: A conversion descriptor subsumes and enhances the - // functionality of a simple state type such as mbstate_t. - typedef iconv_t __desc_type; - - protected: - // Data Members: - // Max size of charset encoding name - static const int _S_max_size = 32; - // Name of internal character set encoding. - char _M_intc_enc[_S_max_size]; - // Name of external character set encoding. - char _M_extc_enc[_S_max_size]; - - // Conversion descriptor between external encoding to internal encoding. - __desc_type _M_in_desc; - // Conversion descriptor between internal encoding to external encoding. - __desc_type _M_out_desc; - - public: - __enc_traits() : _M_in_desc(0), _M_out_desc(0) - { - // __intc_end = whatever we are using internally, which is - // UCS4 (linux) - // UCS2 == UNICODE (microsoft, java, aix, whatever...) - // XXX Currently don't know how to get this data from target system... - strcpy(_M_intc_enc, "UCS4"); - - // __extc_end = external codeset in current locale - strcpy(_M_extc_enc, nl_langinfo(CODESET)); - } - - __enc_traits(const char* __int, const char* __ext) - : _M_in_desc(0), _M_out_desc(0) - { - strncpy(_M_intc_enc, __int, _S_max_size); - strncpy(_M_extc_enc, __ext, _S_max_size); - } - - // 21.1.2 traits typedefs - // p4 - // typedef STATE_T state_type - // requires: state_type shall meet the requirements of - // CopyConstructible types (20.1.3) - __enc_traits(const __enc_traits& __obj) - { - strncpy(_M_intc_enc, __obj._M_intc_enc, _S_max_size); - strncpy(_M_extc_enc, __obj._M_extc_enc, _S_max_size); - } - - ~__enc_traits() - { - iconv_close(_M_in_desc); - iconv_close(_M_out_desc); - } - - // Initializes - void - _M_init() - { - _M_in_desc = iconv_open(_M_intc_enc, _M_extc_enc); - _M_out_desc = iconv_open(_M_extc_enc, _M_intc_enc); - if (_M_out_desc == iconv_t(-1) || _M_in_desc == iconv_t(-1)) - { - // XXX Extended error checking. - } - } - - bool - _M_good() - { - return _M_out_desc && _M_in_desc - && _M_out_desc != iconv_t(-1) && _M_in_desc != iconv_t(-1); - } - - const __desc_type* - _M_get_in_descriptor() - { return &_M_in_desc; } - - const __desc_type* - _M_get_out_descriptor() - { return &_M_out_desc; } - - const char* - _M_get_internal_enc() - { return _M_intc_enc; } - - const char* - _M_get_external_enc() - { return _M_extc_enc; } - }; -#endif //_GLIBCPP_USE_WCHAR_T - - - // 22.2.1.5 Template class codecvt - class codecvt_base - { - public: - enum result - { - ok, - partial, - error, - noconv - }; - }; - - // Template class __codecvt_abstract_base - // NB: An abstract base class that fills in the public inlines, so - // that the specializations don't have to re-copy the public - // interface. - template - class __codecvt_abstract_base - : public locale::facet, public codecvt_base - { - public: - // Types: - typedef codecvt_base::result result; - typedef _InternT intern_type; - typedef _ExternT extern_type; - typedef _StateT state_type; - - // 22.2.1.5.1 codecvt members - result - out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const - { - return this->do_out(__state, __from, __from_end, __from_next, - __to, __to_end, __to_next); - } - - result - unshift(state_type& __state, extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const - { return this->do_unshift(__state, __to,__to_end,__to_next); } - - result - in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const - { - return this->do_in(__state, __from, __from_end, __from_next, - __to, __to_end, __to_next); - } - - int - encoding() const throw() - { return this->do_encoding(); } - - bool - always_noconv() const throw() - { return this->do_always_noconv(); } - - int - length(const state_type& __state, const extern_type* __from, - const extern_type* __end, size_t __max) const - { return this->do_length(__state, __from, __end, __max); } - - int - max_length() const throw() - { return this->do_max_length(); } - - protected: - explicit - __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { } - - virtual - ~__codecvt_abstract_base() { } - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const = 0; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const = 0; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const = 0; - - virtual int - do_encoding() const throw() = 0; - - virtual bool - do_always_noconv() const throw() = 0; - - virtual int - do_length(const state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const = 0; - - virtual int - do_max_length() const throw() = 0; - }; - - // 22.2.1.5 Template class codecvt - // NB: Generic, mostly useless implementation. - template - class codecvt - : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> - { - public: - // Types: - typedef codecvt_base::result result; - typedef _InternT intern_type; - typedef _ExternT extern_type; - typedef _StateT state_type; - - // Data Members: - static locale::id id; - - explicit - codecvt(size_t __refs = 0) - : __codecvt_abstract_base<_InternT,_ExternT,_StateT> (__refs) { } - - protected: - virtual - ~codecvt() { } - }; - - template - locale::id codecvt<_InternT, _ExternT, _StateT>::id; - - // partial specialization - // This specialization takes advantage of iconv to provide code - // conversions between a large number of character encodings. - template - class codecvt<_InternT, _ExternT, __enc_traits> - : public __codecvt_abstract_base<_InternT, _ExternT, __enc_traits> - { - public: - // Types: - typedef codecvt_base::result result; - typedef _InternT intern_type; - typedef _ExternT extern_type; - typedef __enc_traits state_type; - typedef __enc_traits::__desc_type __desc_type; - typedef __enc_traits __enc_type; - - // Data Members: - static locale::id id; - - explicit - codecvt(size_t __refs = 0) - : __codecvt_abstract_base(__refs) - { } - - explicit - codecvt(__enc_type* __enc, size_t __refs = 0) - : __codecvt_abstract_base(__refs) - { } - - protected: - virtual - ~codecvt() { } - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual int - do_encoding() const throw(); - - virtual bool - do_always_noconv() const throw(); - - virtual int - do_length(const state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - - template - locale::id - codecvt<_InternT, _ExternT, __enc_traits>::id; - - template - codecvt_base::result - codecvt<_InternT, _ExternT, __enc_traits>:: - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const - { - result __ret = error; - if (__state._M_good()) - { - typedef state_type::__desc_type __desc_type; - const __desc_type* __desc = __state._M_get_out_descriptor(); - const size_t __fmultiple = sizeof(intern_type) / sizeof(char); - size_t __flen = __fmultiple * (__from_end - __from); - const size_t __tmultiple = sizeof(extern_type) / sizeof(char); - size_t __tlen = __tmultiple * (__to_end - __to); - - // Argument list for iconv specifies a byte sequence. Thus, - // all to/from arrays must be brutally casted to char*. - char* __cfrom = reinterpret_cast(const_cast(__from)); - char* __cto = reinterpret_cast(__to); - size_t __conv = iconv(*__desc, &__cfrom, &__flen, &__cto, &__tlen); - - if (__conv != size_t(-1)) - { - __from_next = reinterpret_cast(__cfrom); - __to_next = reinterpret_cast(__cto); - __ret = ok; - } - else - { - if (__flen < __from_end - __from) - { - __from_next = reinterpret_cast(__cfrom); - __to_next = reinterpret_cast(__cto); - __ret = partial; - } - else - __ret = error; - } - } - return __ret; - } - - template - codecvt_base::result - codecvt<_InternT, _ExternT, __enc_traits>:: - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const - { - result __ret = error; - if (__state._M_good()) - { - typedef state_type::__desc_type __desc_type; - const __desc_type* __desc = __state._M_get_in_descriptor(); - const size_t __tmultiple = sizeof(intern_type) / sizeof(char); - size_t __tlen = __tmultiple * (__to_end - __to); - - // Argument list for iconv specifies a byte sequence. Thus, - // all to/from arrays must be brutally casted to char*. - char* __cto = reinterpret_cast(__to); - size_t __conv = iconv(*__desc, NULL, NULL, &__cto, &__tlen); - - if (__conv != size_t(-1)) - { - __to_next = reinterpret_cast(__cto); - if (__tlen == __tmultiple * (__to_end - __to)) - __ret = noconv; - else if (__tlen == 0) - __ret = ok; - else - __ret = partial; - } - else - __ret = error; - } - return __ret; - } - - template - codecvt_base::result - codecvt<_InternT, _ExternT, __enc_traits>:: - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const - { - result __ret = error; - if (__state._M_good()) - { - typedef state_type::__desc_type __desc_type; - const __desc_type* __desc = __state._M_get_in_descriptor(); - const size_t __fmultiple = sizeof(extern_type) / sizeof(char); - size_t __flen = __fmultiple * (__from_end - __from); - const size_t __tmultiple = sizeof(intern_type) / sizeof(char); - size_t __tlen = __tmultiple * (__to_end - __to); - - // Argument list for iconv specifies a byte sequence. Thus, - // all to/from arrays must be brutally casted to char*. - char* __cfrom = reinterpret_cast(const_cast(__from)); - char* __cto = reinterpret_cast(__to); - size_t __conv = iconv(*__desc, &__cfrom, &__flen, &__cto, &__tlen); - - if (__conv != size_t(-1)) - { - __from_next = reinterpret_cast(__cfrom); - __to_next = reinterpret_cast(__cto); - __ret = ok; - } - else - { - if (__flen < __from_end - __from) - { - __from_next = reinterpret_cast(__cfrom); - __to_next = reinterpret_cast(__cto); - __ret = partial; - } - else - __ret = error; - } - } - return __ret; - } - - template - int - codecvt<_InternT, _ExternT, __enc_traits>:: - do_encoding() const throw() - { return 0; } - - template - bool - codecvt<_InternT, _ExternT, __enc_traits>:: - do_always_noconv() const throw() - { return false; } - - template - int - codecvt<_InternT, _ExternT, __enc_traits>:: - do_length(const state_type& __state, const extern_type* __from, - const extern_type* __end, size_t __max) const - { return min(__max, static_cast(__end - __from)); } - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 74. Garbled text for codecvt::do_max_length - template - int - codecvt<_InternT, _ExternT, __enc_traits>:: - do_max_length() const throw() - { return 1; } -#endif - - // codecvt required specialization - template<> - class codecvt - : public __codecvt_abstract_base - { - public: - // Types: - typedef char intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - // Data Members: - static locale::id id; - - explicit - codecvt(size_t __refs = 0); - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual int - do_encoding() const throw(); - - virtual bool - do_always_noconv() const throw(); - - virtual int - do_length(const state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - -#ifdef _GLIBCPP_USE_WCHAR_T - // codecvt required specialization - template<> - class codecvt - : public __codecvt_abstract_base - { - public: - // Types: - typedef wchar_t intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - // Data Members: - static locale::id id; - - explicit - codecvt(size_t __refs = 0); - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, - const extern_type* __from, const extern_type* __from_end, - const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual - int do_encoding() const throw(); - - virtual - bool do_always_noconv() const throw(); - - virtual - int do_length(const state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; -#endif //_GLIBCPP_USE_WCHAR_T - - // 22.2.1.6 Template class codecvt_byname - template - class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> - { - public: - explicit - codecvt_byname(const char*, size_t __refs = 0) - : codecvt<_InternT,_ExternT,_StateT> (__refs) { } - protected: - virtual - ~codecvt_byname() { } - }; - - template<> - class codecvt_byname - : public codecvt - { - public: - explicit - codecvt_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~codecvt_byname(); - }; - -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - class codecvt_byname - : public codecvt - { - public: - explicit - codecvt_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~codecvt_byname(); - }; -#endif - -} // namespace std - -#endif // _CPP_BITS_CODECVT_H - -// Local Variables: -// mode:c++ -// End: - diff --git a/libstdc++-v3/bits/concept_checks.h b/libstdc++-v3/bits/concept_checks.h deleted file mode 100644 index 4a0e2d55703..00000000000 --- a/libstdc++-v3/bits/concept_checks.h +++ /dev/null @@ -1,811 +0,0 @@ -/* - * Copyright (c) 1999 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef __CONCEPT_CHECKS_H -#define __CONCEPT_CHECKS_H - -/* - Use these macro like assertions, but they assert properties - on types (usually template arguments). In technical terms they - verify whether a type "models" a "concept". - - This set of requirements and the terminology used here is derived - from the book "Generic Programming and the STL" by Matt Austern - (Addison Wesley). For further information please consult that - book. The requirements also are intended to match the ANSI/ISO C++ - standard. - - This file covers the basic concepts and the iterator concepts. - There are several other files that provide the requirements - for the STL containers: - container_concepts.h - sequence_concepts.h - assoc_container_concepts.h - - Jeremy Siek, 1999 - - TO DO: - - some issues with regards to concept classification and mutability - including AssociativeContianer -> ForwardContainer - and SortedAssociativeContainer -> ReversibleContainer - - HashedAssociativeContainer - - Allocator - - Function Object Concepts - - */ - -#ifndef __STL_USE_CONCEPT_CHECKS - -// Some compilers lack the features that are necessary for concept checks. -// On those compilers we define the concept check macros to do nothing. -#define __STL_REQUIRES(__type_var, __concept) do {} while(0) -#define __STL_CLASS_REQUIRES(__type_var, __concept) \ - static int __##__type_var##_##__concept -#define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0) -#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0) -#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \ - static int __##__type_x##__type_y##_require_same_type -#define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0) -#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \ - static int __##__func##__ret##_generator_check -#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0) -#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \ - static int __##__func##__ret##__arg##_unary_function_check -#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \ - do {} while(0) -#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \ - static int __##__func##__ret##__first##__second##_binary_function_check -#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \ - do {} while(0) -#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \ - static int __##__opname##__ret##__first##__second##_require_binary_op - -#else /* __STL_USE_CONCEPT_CHECKS */ - -// This macro tests whether the template argument "__type_var" -// satisfies the requirements of "__concept". Here is a list of concepts -// that we know how to check: -// _Allocator -// _Assignable -// _DefaultConstructible -// _EqualityComparable -// _LessThanComparable -// _TrivialIterator -// _InputIterator -// _OutputIterator -// _ForwardIterator -// _BidirectionalIterator -// _RandomAccessIterator -// _Mutable_TrivialIterator -// _Mutable_ForwardIterator -// _Mutable_BidirectionalIterator -// _Mutable_RandomAccessIterator - -#define __STL_REQUIRES(__type_var, __concept) \ -do { \ - void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\ - ::__concept##_requirement_violation; __x = __x; } while (0) - -// Use this to check whether type X is convertible to type Y -#define __STL_CONVERTIBLE(__type_x, __type_y) \ -do { \ - void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \ - __type_y >::__type_X_is_not_convertible_to_type_Y; \ - __x = __x; } while (0) - -// Use this to test whether two template arguments are the same type -#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) \ -do { \ - void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \ - __type_y >::__type_X_not_same_as_type_Y; \ - __x = __x; } while (0) - - -// function object checks -#define __STL_GENERATOR_CHECK(__func, __ret) \ -do { \ - __ret (*__x)( __func&) = \ - _STL_GENERATOR_ERROR< \ - __func, __ret>::__generator_requirement_violation; \ - __x = __x; } while (0) - - -#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \ -do { \ - __ret (*__x)( __func&, const __arg& ) = \ - _STL_UNARY_FUNCTION_ERROR< \ - __func, __ret, __arg>::__unary_function_requirement_violation; \ - __x = __x; } while (0) - - -#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \ -do { \ - __ret (*__x)( __func&, const __first&, const __second& ) = \ - _STL_BINARY_FUNCTION_ERROR< \ - __func, __ret, __first, __second>::__binary_function_requirement_violation; \ - __x = __x; } while (0) - - -#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \ - do { \ - __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \ - __ret, __first, __second>::__binary_operator_requirement_violation; \ - __ret (*__y)( const __first&, const __second& ) = \ - _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \ - __const_binary_operator_requirement_violation; \ - __y = __y; __x = __x; } while (0) - - -#ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE - -#define __STL_CLASS_REQUIRES(__type_var, __concept) -#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) -#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) -#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) -#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) -#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) - -#else - -// Use this macro inside of template classes, where you would -// like to place requirements on the template arguments to the class -// Warning: do not pass pointers and such (e.g. T*) in as the __type_var, -// since the type_var is used to construct identifiers. Instead typedef -// the pointer type, then use the typedef name for the __type_var. -#define __STL_CLASS_REQUIRES(__type_var, __concept) \ - typedef void (* __func##__type_var##__concept)( __type_var ); \ - template <__func##__type_var##__concept _Tp1> \ - struct __dummy_struct_##__type_var##__concept { }; \ - static __dummy_struct_##__type_var##__concept< \ - __concept##_concept_specification< \ - __type_var>::__concept##_requirement_violation> \ - __dummy_ptr_##__type_var##__concept - - -#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \ - typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \ - __type_y ); \ - template < __func_##__type_x##__type_y##same_type _Tp1> \ - struct __dummy_struct_##__type_x##__type_y##_same_type { }; \ - static __dummy_struct_##__type_x##__type_y##_same_type< \ - _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \ - __dummy_ptr_##__type_x##__type_y##_same_type - - -#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \ - typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \ - template <__f_##__func##__ret##_generator _Tp1> \ - struct __dummy_struct_##__func##__ret##_generator { }; \ - static __dummy_struct_##__func##__ret##_generator< \ - _STL_GENERATOR_ERROR< \ - __func, __ret>::__generator_requirement_violation> \ - __dummy_ptr_##__func##__ret##_generator - - -#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \ - typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \ - const __arg& ); \ - template <__f_##__func##__ret##__arg##_unary_check _Tp1> \ - struct __dummy_struct_##__func##__ret##__arg##_unary_check { }; \ - static __dummy_struct_##__func##__ret##__arg##_unary_check< \ - _STL_UNARY_FUNCTION_ERROR< \ - __func, __ret, __arg>::__unary_function_requirement_violation> \ - __dummy_ptr_##__func##__ret##__arg##_unary_check - - -#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \ - typedef __ret (* __f_##__func##__ret##__first##__second##_binary_check)( __func&, const __first&,\ - const __second& ); \ - template <__f_##__func##__ret##__first##__second##_binary_check _Tp1> \ - struct __dummy_struct_##__func##__ret##__first##__second##_binary_check { }; \ - static __dummy_struct_##__func##__ret##__first##__second##_binary_check< \ - _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \ - __binary_function_requirement_violation> \ - __dummy_ptr_##__func##__ret##__first##__second##_binary_check - - -#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \ - typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op)(const __first&, \ - const __second& ); \ - template <__f_##__func##__ret##__first##__second##_binary_op _Tp1> \ - struct __dummy_struct_##__func##__ret##__first##__second##_binary_op { }; \ - static __dummy_struct_##__func##__ret##__first##__second##_binary_op< \ - _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \ - __binary_operator_requirement_violation> \ - __dummy_ptr_##__func##__ret##__first##__second##_binary_op - -#endif - -/* helper class for finding non-const version of a type. Need to have - something to assign to etc. when testing constant iterators. */ - -template -struct _Mutable_trait { - typedef _Tp _Type; -}; -template -struct _Mutable_trait { - typedef _Tp _Type; -}; - - -/* helper function for avoiding compiler warnings about unused variables */ -template -void __sink_unused_warning(_Type) { } - -template -struct _STL_CONVERT_ERROR { - static void - __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) { - _TypeY __y = __x; - __sink_unused_warning(__y); - } -}; - - -template struct __check_equal { }; - -template -struct _STL_SAME_TYPE_ERROR { - static void - __type_X_not_same_as_type_Y(_TypeX , _TypeY ) { - __check_equal<_TypeX> t1 = __check_equal<_TypeY>(); - } -}; - - -// Some Functon Object Checks - -template -struct _STL_GENERATOR_ERROR { - static _Ret __generator_requirement_violation(_Func& __f) { - return __f(); - } -}; - -template -struct _STL_GENERATOR_ERROR<_Func, void> { - static void __generator_requirement_violation(_Func& __f) { - __f(); - } -}; - - -template -struct _STL_UNARY_FUNCTION_ERROR { - static _Ret - __unary_function_requirement_violation(_Func& __f, - const _Arg& __arg) { - return __f(__arg); - } -}; - -template -struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> { - static void - __unary_function_requirement_violation(_Func& __f, - const _Arg& __arg) { - __f(__arg); - } -}; - -template -struct _STL_BINARY_FUNCTION_ERROR { - static _Ret - __binary_function_requirement_violation(_Func& __f, - const _First& __first, - const _Second& __second) { - return __f(__first, __second); - } -}; - -template -struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> { - static void - __binary_function_requirement_violation(_Func& __f, - const _First& __first, - const _Second& __second) { - __f(__first, __second); - } -}; - - -#define __STL_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \ -template \ -struct _STL_BINARY##_NAME##_ERROR { \ - static _Ret \ - __const_binary_operator_requirement_violation(const _First& __first, \ - const _Second& __second) { \ - return __first _OP __second; \ - } \ - static _Ret \ - __binary_operator_requirement_violation(_First& __first, \ - _Second& __second) { \ - return __first _OP __second; \ - } \ -} - -__STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL); -__STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL); -__STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN); -__STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL); -__STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN); -__STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL); -__STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS); -__STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES); -__STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE); -__STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT); -__STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD); -// ... - -// TODO, add unary operators (prefix and postfix) - -/* - The presence of this class is just to trick EDG into displaying - these error messages before any other errors. Without the - classes, the errors in the functions get reported after - other class errors deep inside the library. The name - choice just makes for an eye catching error message :) - */ -struct _STL_ERROR { - - template - static _Type - __default_constructor_requirement_violation(_Type) { - return _Type(); - } - template - static _Type - __assignment_operator_requirement_violation(_Type __a) { - __a = __a; - return __a; - } - template - static _Type - __copy_constructor_requirement_violation(_Type __a) { - _Type __c(__a); - return __c; - } - template - static _Type - __const_parameter_required_for_copy_constructor(_Type /* __a */, - const _Type& __b) { - _Type __c(__b); - return __c; - } - template - static _Type - __const_parameter_required_for_assignment_operator(_Type __a, - const _Type& __b) { - __a = __b; - return __a; - } - template - static _Type - __less_than_comparable_requirement_violation(_Type __a, _Type __b) { - if (__a < __b) return __a; - return __b; - } - template - static _Type - __equality_comparable_requirement_violation(_Type __a, _Type __b) { - if (__a == __b || __a != __b) return __a; - return __b; - } - template - static void - __dereference_operator_requirement_violation(_Iterator __i) { - __sink_unused_warning(*__i); - } - template - static void - __dereference_operator_and_assignment_requirement_violation(_Iterator __i) { - *__i = *__i; - } - template - static void - __preincrement_operator_requirement_violation(_Iterator __i) { - ++__i; - } - template - static void - __postincrement_operator_requirement_violation(_Iterator __i) { - __i++; - } - template - static void - __predecrement_operator_requirement_violation(_Iterator __i) { - --__i; - } - template - static void - __postdecrement_operator_requirement_violation(_Iterator __i) { - __i--; - } - template - static void - __postincrement_operator_and_assignment_requirement_violation(_Iterator __i, - _Type __t) { - *__i++ = __t; - } - template - static _Iterator - __iterator_addition_assignment_requirement_violation(_Iterator __i, - _Distance __n) { - __i += __n; - return __i; - } - template - static _Iterator - __iterator_addition_requirement_violation(_Iterator __i, _Distance __n) { - __i = __i + __n; - __i = __n + __i; - return __i; - } - template - static _Iterator - __iterator_subtraction_assignment_requirement_violation(_Iterator __i, - _Distance __n) { - __i -= __n; - return __i; - } - template - static _Iterator - __iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) { - __i = __i - __n; - return __i; - } - template - static _Distance - __difference_operator_requirement_violation(_Iterator __i, _Iterator __j, - _Distance __n) { - __n = __i - __j; - return __n; - } - template - static _Type - __element_access_operator_requirement_violation(_Exp __x, _Type*, - _Distance __n) { - return __x[__n]; - } - template - static void - __element_assignment_operator_requirement_violation(_Exp __x, - _Type* __t, - _Distance __n) { - __x[__n] = *__t; - } - -}; /* _STL_ERROR */ - -/* Associated Type Requirements */ - -__STL_BEGIN_NAMESPACE -template struct iterator_traits; -__STL_END_NAMESPACE - -template -struct __value_type_type_definition_requirement_violation { - typedef typename __STD::iterator_traits<_Iter>::value_type value_type; -}; - -template -struct __difference_type_type_definition_requirement_violation { - typedef typename __STD::iterator_traits<_Iter>::difference_type - difference_type; -}; - -template -struct __reference_type_definition_requirement_violation { - typedef typename __STD::iterator_traits<_Iter>::reference reference; -}; - -template -struct __pointer_type_definition_requirement_violation { - typedef typename __STD::iterator_traits<_Iter>::pointer pointer; -}; - -template -struct __iterator_category_type_definition_requirement_violation { - typedef typename __STD::iterator_traits<_Iter>::iterator_category - iterator_category; -}; - -/* Assignable Requirements */ - - -template -struct _Assignable_concept_specification { - static void _Assignable_requirement_violation(_Type __a) { - _STL_ERROR::__assignment_operator_requirement_violation(__a); - _STL_ERROR::__copy_constructor_requirement_violation(__a); - _STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a); - _STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a); - } -}; - -/* DefaultConstructible Requirements */ - - -template -struct _DefaultConstructible_concept_specification { - static void _DefaultConstructible_requirement_violation(_Type __a) { - _STL_ERROR::__default_constructor_requirement_violation(__a); - } -}; - -/* EqualityComparable Requirements */ - -template -struct _EqualityComparable_concept_specification { - static void _EqualityComparable_requirement_violation(_Type __a) { - _STL_ERROR::__equality_comparable_requirement_violation(__a, __a); - } -}; - -/* LessThanComparable Requirements */ -template -struct _LessThanComparable_concept_specification { - static void _LessThanComparable_requirement_violation(_Type __a) { - _STL_ERROR::__less_than_comparable_requirement_violation(__a, __a); - } -}; - -/* TrivialIterator Requirements */ - -template -struct _TrivialIterator_concept_specification { -static void -_TrivialIterator_requirement_violation(_TrivialIterator __i) { - typedef typename - __value_type_type_definition_requirement_violation<_TrivialIterator>:: - value_type __T; - // Refinement of Assignable - _Assignable_concept_specification<_TrivialIterator>:: - _Assignable_requirement_violation(__i); - // Refinement of DefaultConstructible - _DefaultConstructible_concept_specification<_TrivialIterator>:: - _DefaultConstructible_requirement_violation(__i); - // Refinement of EqualityComparable - _EqualityComparable_concept_specification<_TrivialIterator>:: - _EqualityComparable_requirement_violation(__i); - // Valid Expressions - _STL_ERROR::__dereference_operator_requirement_violation(__i); -} -}; - -template -struct _Mutable_TrivialIterator_concept_specification { -static void -_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) { - _TrivialIterator_concept_specification<_TrivialIterator>:: - _TrivialIterator_requirement_violation(__i); - // Valid Expressions - _STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i); -} -}; - -/* InputIterator Requirements */ - -template -struct _InputIterator_concept_specification { -static void -_InputIterator_requirement_violation(_InputIterator __i) { - // Refinement of TrivialIterator - _TrivialIterator_concept_specification<_InputIterator>:: - _TrivialIterator_requirement_violation(__i); - // Associated Types - __difference_type_type_definition_requirement_violation<_InputIterator>(); - __reference_type_definition_requirement_violation<_InputIterator>(); - __pointer_type_definition_requirement_violation<_InputIterator>(); - __iterator_category_type_definition_requirement_violation<_InputIterator>(); - // Valid Expressions - _STL_ERROR::__preincrement_operator_requirement_violation(__i); - _STL_ERROR::__postincrement_operator_requirement_violation(__i); -} -}; - -/* OutputIterator Requirements */ - -template -struct _OutputIterator_concept_specification { -static void -_OutputIterator_requirement_violation(_OutputIterator __i) { - // Refinement of Assignable - _Assignable_concept_specification<_OutputIterator>:: - _Assignable_requirement_violation(__i); - // Associated Types - __iterator_category_type_definition_requirement_violation<_OutputIterator>(); - // Valid Expressions - _STL_ERROR::__dereference_operator_requirement_violation(__i); - _STL_ERROR::__preincrement_operator_requirement_violation(__i); - _STL_ERROR::__postincrement_operator_requirement_violation(__i); - _STL_ERROR:: - __postincrement_operator_and_assignment_requirement_violation(__i, *__i); -} -}; - -/* ForwardIterator Requirements */ - -template -struct _ForwardIterator_concept_specification { -static void -_ForwardIterator_requirement_violation(_ForwardIterator __i) { - // Refinement of InputIterator - _InputIterator_concept_specification<_ForwardIterator>:: - _InputIterator_requirement_violation(__i); -} -}; - -template -struct _Mutable_ForwardIterator_concept_specification { -static void -_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) { - _ForwardIterator_concept_specification<_ForwardIterator>:: - _ForwardIterator_requirement_violation(__i); - // Refinement of OutputIterator - _OutputIterator_concept_specification<_ForwardIterator>:: - _OutputIterator_requirement_violation(__i); -} -}; - -/* BidirectionalIterator Requirements */ - -template -struct _BidirectionalIterator_concept_specification { -static void -_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) { - // Refinement of ForwardIterator - _ForwardIterator_concept_specification<_BidirectionalIterator>:: - _ForwardIterator_requirement_violation(__i); - // Valid Expressions - _STL_ERROR::__predecrement_operator_requirement_violation(__i); - _STL_ERROR::__postdecrement_operator_requirement_violation(__i); -} -}; - -template -struct _Mutable_BidirectionalIterator_concept_specification { -static void -_Mutable_BidirectionalIterator_requirement_violation( - _BidirectionalIterator __i) -{ - _BidirectionalIterator_concept_specification<_BidirectionalIterator>:: - _BidirectionalIterator_requirement_violation(__i); - // Refinement of mutable_ForwardIterator - _Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>:: - _Mutable_ForwardIterator_requirement_violation(__i); - typedef typename - __value_type_type_definition_requirement_violation< - _BidirectionalIterator>::value_type __T; - typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0; - // Valid Expressions - _STL_ERROR:: - __postincrement_operator_and_assignment_requirement_violation(__i, - *__tmp_ptr); -} -}; - -/* RandomAccessIterator Requirements */ - -template -struct _RandomAccessIterator_concept_specification { -static void -_RandomAccessIterator_requirement_violation(_RandAccIter __i) { - // Refinement of BidirectionalIterator - _BidirectionalIterator_concept_specification<_RandAccIter>:: - _BidirectionalIterator_requirement_violation(__i); - // Refinement of LessThanComparable - _LessThanComparable_concept_specification<_RandAccIter>:: - _LessThanComparable_requirement_violation(__i); - typedef typename - __value_type_type_definition_requirement_violation<_RandAccIter> - ::value_type - value_type; - typedef typename - __difference_type_type_definition_requirement_violation<_RandAccIter> - ::difference_type - _Dist; - typedef typename _Mutable_trait<_Dist>::_Type _MutDist; - - // Valid Expressions - _STL_ERROR::__iterator_addition_assignment_requirement_violation(__i, - _MutDist()); - _STL_ERROR::__iterator_addition_requirement_violation(__i, - _MutDist()); - _STL_ERROR:: - __iterator_subtraction_assignment_requirement_violation(__i, - _MutDist()); - _STL_ERROR::__iterator_subtraction_requirement_violation(__i, - _MutDist()); - _STL_ERROR::__difference_operator_requirement_violation(__i, __i, - _MutDist()); - typename _Mutable_trait::_Type* __dummy_ptr = 0; - _STL_ERROR::__element_access_operator_requirement_violation(__i, - __dummy_ptr, - _MutDist()); -} -}; - -template -struct _Mutable_RandomAccessIterator_concept_specification { -static void -_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i) -{ - _RandomAccessIterator_concept_specification<_RandAccIter>:: - _RandomAccessIterator_requirement_violation(__i); - // Refinement of mutable_BidirectionalIterator - _Mutable_BidirectionalIterator_concept_specification<_RandAccIter>:: - _Mutable_BidirectionalIterator_requirement_violation(__i); - typedef typename - __value_type_type_definition_requirement_violation<_RandAccIter> - ::value_type - value_type; - typedef typename - __difference_type_type_definition_requirement_violation<_RandAccIter> - ::difference_type - _Dist; - - typename _Mutable_trait::_Type* __tmp_ptr = 0; - // Valid Expressions - _STL_ERROR::__element_assignment_operator_requirement_violation(__i, - __tmp_ptr, _Dist()); -} -}; - -#define __STL_TYPEDEF_REQUIREMENT(__REQUIREMENT) \ -template \ -struct __##__REQUIREMENT##__typedef_requirement_violation { \ - typedef typename Type::__REQUIREMENT __REQUIREMENT; \ -} - -__STL_TYPEDEF_REQUIREMENT(value_type); -__STL_TYPEDEF_REQUIREMENT(difference_type); -__STL_TYPEDEF_REQUIREMENT(size_type); -__STL_TYPEDEF_REQUIREMENT(reference); -__STL_TYPEDEF_REQUIREMENT(const_reference); -__STL_TYPEDEF_REQUIREMENT(pointer); -__STL_TYPEDEF_REQUIREMENT(const_pointer); - - -template -struct _Allocator_concept_specification { -static void -_Allocator_requirement_violation(_Alloc __a) { - // Refinement of DefaultConstructible - _DefaultConstructible_concept_specification<_Alloc>:: - _DefaultConstructible_requirement_violation(__a); - // Refinement of EqualityComparable - _EqualityComparable_concept_specification<_Alloc>:: - _EqualityComparable_requirement_violation(__a); - // Associated Types - __value_type__typedef_requirement_violation<_Alloc>(); - __difference_type__typedef_requirement_violation<_Alloc>(); - __size_type__typedef_requirement_violation<_Alloc>(); - __reference__typedef_requirement_violation<_Alloc>(); - __const_reference__typedef_requirement_violation<_Alloc>(); - __pointer__typedef_requirement_violation<_Alloc>(); - __const_pointer__typedef_requirement_violation<_Alloc>(); - typedef typename _Alloc::value_type _Tp; - //__STL_REQUIRES_SAME_TYPE(typename _Alloc::__STL_TEMPLATE rebind<_Tp>::other, - // _Alloc); -} -}; - -#endif /* __STL_USE_CONCEPT_CHECKS */ - -#endif /* __CONCEPT_CHECKS_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/container_concepts.h b/libstdc++-v3/bits/container_concepts.h deleted file mode 100644 index 99aec1c4b62..00000000000 --- a/libstdc++-v3/bits/container_concepts.h +++ /dev/null @@ -1,244 +0,0 @@ -/* - * Copyright (c) 1999 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef __STL_CONTAINER_CONCEPTS_H -#define __STL_CONTAINER_CONCEPTS_H - - -#include - -#ifdef __STL_USE_CONCEPT_CHECKS - - -// This file covers the following concepts: -// _Container -// _ForwardContainer -// _ReversibleContainer -// _const_ReversibleContainer -// _RandomAccessContainer -// - -struct _ERROR_IN_STL_CONTAINER { - - /* Container expresssions */ - - template - static void - __begin_iterator_accessor_requirement_violation(_Container __c) { - __c.begin(); - } - template - static void - __const_begin_iterator_accessor_requirement_violation(const _Container& __c) { - __c.begin(); - } - template - static void - __end_iterator_accessor_requirement_violation(_Container __c) { - __c.end(); - } - template - static void - __const_end_iterator_accessor_requirement_violation(const _Container& __c) { - __c.end(); - } - - template - static void - __rbegin_iterator_accessor_requirement_violation(_Container __c) { - __c.rbegin(); - } - template - static void - __const_rbegin_iterator_accessor_requirement_violation(const _Container& __c) { - __c.rbegin(); - } - template - static void - __rend_iterator_accessor_requirement_violation(_Container __c) { - __c.rend(); - } - template - static void - __const_rend_iterator_accessor_requirement_violation(const _Container& __c) { - __c.rend(); - } - template - static void - __size_function_must_be_const(const _Container& __c) { - __c.size(); - } - template - static void - __size_function_requirement_violation(_Container& __c) { - __c.size(); - __size_function_must_be_const(__c); - } - template - static void - __max_size_function_must_be_const(const _Container& __c) { - __c.max_size(); - } - template - static void - __max_size_function_requirement_violation(_Container& __c) { - __c.max_size(); - __max_size_function_must_be_const(__c); - } - template - static void - __empty_function_must_be_const(const _Container& __c) { - __c.empty(); - } - template - static void - __empty_function_requirement_violation(_Container& __c) { - __c.empty(); - __empty_function_must_be_const(__c); - } - template - static void - __swap_function_requirement_violation(_Container& __c) { - __c.swap(__c); - } - -}; - - -__STL_TYPEDEF_REQUIREMENT(iterator); -__STL_TYPEDEF_REQUIREMENT(const_iterator); - -/* Containers */ - -template -struct _Container_concept_specification { -static void -_Container_requirement_violation(_Container __c) { - // Refinement of Assignable - _Assignable_concept_specification<_Container>::_Assignable_requirement_violation(__c); - // Associated Types - __value_type__typedef_requirement_violation<_Container>(); - __difference_type__typedef_requirement_violation<_Container>(); - __size_type__typedef_requirement_violation<_Container>(); - __reference__typedef_requirement_violation<_Container>(); - __const_reference__typedef_requirement_violation<_Container>(); - __pointer__typedef_requirement_violation<_Container>(); - __const_pointer__typedef_requirement_violation<_Container>(); - __iterator__typedef_requirement_violation<_Container>(); - __const_iterator__typedef_requirement_violation<_Container>(); - // Valid Expressions - _ERROR_IN_STL_CONTAINER::__const_begin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__const_end_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__begin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__end_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__size_function_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__max_size_function_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__empty_function_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__swap_function_requirement_violation(__c); - // Requirements on Iterators - typedef typename _Container::iterator iter; - typedef typename _Container::const_iterator const_iter; - _InputIterator_concept_specification::_InputIterator_requirement_violation(const_iter()); - _InputIterator_concept_specification::_InputIterator_requirement_violation(iter()); -} -}; - -template -struct _ForwardContainer_concept_specification { -static void -_ForwardContainer_requirement_violation(_ForwardContainer __c) { - // Refinement of Container - _Container_concept_specification<_ForwardContainer>::_Container_requirement_violation(__c); - // Requirements on Iterators - typedef typename _ForwardContainer::iterator iter; - typedef typename _ForwardContainer::const_iterator const_iter; - _ForwardIterator_concept_specification::_ForwardIterator_requirement_violation(const_iter()); - _Mutable_ForwardIterator_concept_specification::_Mutable_ForwardIterator_requirement_violation(iter()); -} -}; - - -__STL_TYPEDEF_REQUIREMENT(reverse_iterator); -__STL_TYPEDEF_REQUIREMENT(const_reverse_iterator); - -template -struct _ReversibleContainer_concept_specification { -static void -_ReversibleContainer_requirement_violation(_ReversibleContainer __c) { - // Refinement of ForwardContainer - _ForwardContainer_concept_specification<_ReversibleContainer>::_ForwardContainer_requirement_violation(__c); - // Associated types - __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>(); - __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>(); - // Valid Expressions - _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c); - // Requirements on Iterators - typedef typename _ReversibleContainer::iterator iter; - typedef typename _ReversibleContainer::const_iterator const_iter; - _BidirectionalIterator_concept_specification::_BidirectionalIterator_requirement_violation(const_iter()); - _Mutable_BidirectionalIterator_concept_specification::_Mutable_BidirectionalIterator_requirement_violation(iter()); -} -}; - -template -struct _const_ReversibleContainer_concept_specification { -static void -_const_ReversibleContainer_requirement_violation(_ReversibleContainer __c) { - // Refinement of Container (JGS, not ForwardContainer) - _Container_concept_specification<_ReversibleContainer>::_Container_requirement_violation(__c); - // Associated types - __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>(); - __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>(); - // Valid Expressions - _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c); - _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c); - // Requirements on Iterators - typedef typename _ReversibleContainer::iterator iter; - typedef typename _ReversibleContainer::const_iterator const_iter; - - _BidirectionalIterator_concept_specification::_BidirectionalIterator_requirement_violation(const_iter()); -} -}; - - -template -struct _RandomAccessContainer_concept_specification { -static void -_RandomAccessContainer_requirement_violation(_RandomAccessContainer __c) { - // Refinement of ReversibleContainer - _ReversibleContainer_concept_specification<_RandomAccessContainer>::_ReversibleContainer_requirement_violation(__c); - // Valid Expressions - typedef typename _RandomAccessContainer::value_type __T; - typedef typename _RandomAccessContainer::difference_type _Dist; - typedef typename _Mutable_trait<__T>::_Type Type; - typedef Type* _TypePtr; - typedef typename _Mutable_trait<_Dist>::_Type Dist; - _STL_ERROR::__element_access_operator_requirement_violation(__c, - _TypePtr(), - Dist()); - // Requirements on Iterators - typedef typename _RandomAccessContainer::iterator iter; - typedef typename _RandomAccessContainer::const_iterator const_iter; - _RandomAccessIterator_concept_specification::_RandomAccessIterator_requirement_violation(const_iter()); - _Mutable_RandomAccessIterator_concept_specification::_Mutable_RandomAccessIterator_requirement_violation(iter()); -} -}; - -#endif /* if __STL_USE_CONCEPT_CHECKS */ - -#endif /* __STL_CONTAINER_CONCEPTS_H */ diff --git a/libstdc++-v3/bits/cpp_type_traits.h b/libstdc++-v3/bits/cpp_type_traits.h deleted file mode 100644 index 2b62ee8926e..00000000000 --- a/libstdc++-v3/bits/cpp_type_traits.h +++ /dev/null @@ -1,301 +0,0 @@ -// The -*- C++ -*- type traits classes for internal use in libstdc++ - -// Copyright (C) 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_CPP_TYPE_TRAITS_H -#define _CPP_BITS_CPP_TYPE_TRAITS_H 1 - -// -// This file provides some compile-time information about various types. -// These informations were designed, on purpose, to be constant-expressions -// and not types as found in . In particular, they -// can be used in control structures and the optimizer hopefully will do -// the obvious thing. -// -// Why integral expressions, and not functions nor types? -// Firstly, these compile-time information entities are used as -// template-arguments so function return values won't work. We -// need compile-time entities. We're left with types and constant -// integral expressions. -// Secondly, from the point of view of ease of use type-based compile-time -// information is -not- *that* convenient. On has to write lots of -// overloaded functions and to hope that the compiler will select the right -// one. As a net effect, the overall structure isn't very clear at first -// glance. -// Thirdly, partial ordering and overload resolution (of template functions) -// is very costly in terms of compiler-resource. It is a Good Thing to -// keep these resource consumption as least as possible. -// -// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06. -// - -namespace std { - - template - struct __is_void - { - enum - { - _M_type = 0 - }; - }; - - template<> - struct __is_void - { - enum - { - _M_type = 1 - }; - }; - - // - // Integer types - // - template - struct __is_integer - { - enum - { - _M_type = 0 - }; - }; - - // Thirteen specializations (yes there are eleven standard integer - // types; 'long long' and 'unsigned long long' are supported as - // extensions) - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - -# ifdef _GLIBCPP_USE_WCHAR_T - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; -# endif - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - -# ifdef _GLIBCPP_USE_LONG_LONG - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_integer - { - enum - { - _M_type = 1 - }; - }; -# endif - - // - // Floating point types - // - template - struct __is_floating - { - enum - { - _M_type = 0 - }; - }; - - // three specializations (float, double and 'long double') - template<> - struct __is_floating - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_floating - { - enum - { - _M_type = 1 - }; - }; - - template<> - struct __is_floating - { - enum - { - _M_type = 1 - }; - }; - - // - // An arithmetic type is an integer type or a floating point type - // - template - struct __is_arithmetic - { - enum - { - _M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type - }; - }; - - // - // A fundamental type is `void' or and arithmetic type - // - template - struct __is_fundamental - { - enum - { - _M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type - }; - }; - - // - // For the immediate use, the following is a good approximation - // - template - struct __is_pod - { - enum - { - _M_type = __is_fundamental<_Tp>::_M_type - }; - }; - -} // namespace std - - -#endif //_CPP_BITS_CPP_TYPE_TRAITS_H - - - - - - - diff --git a/libstdc++-v3/bits/exception_support.h b/libstdc++-v3/bits/exception_support.h deleted file mode 100644 index e4d033c9ada..00000000000 --- a/libstdc++-v3/bits/exception_support.h +++ /dev/null @@ -1,79 +0,0 @@ -// Methods and support infrastructure for exceptions -*- C++ -*- - -// Copyright (C) 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 15 Exception handling -// - -// This file declares functions whose only purpose is to throw an -// exception. They help break a circularity between and -// . See src/stdexcept.cc, where these functions are -// defined. - -// XXX: These functions serve a similar purpose to those in -// stl/bits/stl_range_errors.h . Eventually the two approaches should -// be merged. - -#ifndef _CPP_EXCEPTION_SUPPORT_H -#define _CPP_EXCEPTION_SUPPORT_H 1 - -namespace std { - -#if _GLIBCPP_USE_EXCEPTIONS - // Internal functions for string implementation. - extern void __out_of_range(const char *__str); - extern void __length_error(const char *__str); - -# define __OUTOFRANGE(__cond) \ - do { if (__cond) __out_of_range(#__cond); } while (0) -# define __LENGTHERROR(__cond) \ - do { if (__cond) __length_error(#__cond); } while (0) -#else -# include -# define __OUTOFRANGE(__cond) assert(!(__cond)) -# define __LENGTHERROR(__cond) assert(!(__cond)) -#endif - -} // namespace std - -#endif /* _CPP_EXCEPTION_SUPPORT_H */ - - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/fpos.h b/libstdc++-v3/bits/fpos.h deleted file mode 100644 index 27792b04a84..00000000000 --- a/libstdc++-v3/bits/fpos.h +++ /dev/null @@ -1,121 +0,0 @@ -// File position object and stream types - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27 Input/output library -// - -#ifndef _CPP_BITS_FPOS_H -#define _CPP_BITS_FPOS_H 1 - -// Need this here as well as in std_ios because fpos is used in -// char_traits, and char_traits is used by string, which may or may -// not have included the std_ios file. -#include - -namespace std { - - // 27.4.1 Types - - // 27.4.3 Template class fpos - template - class fpos - { - public: - - // Types: - typedef _StateT __state_type; - - __state_type - state() const { return _M_st; } - - void - state(__state_type __st) { _M_st = __st; } - - // NB: The standard defines only the implicit copy ctor and the - // previous two members. The rest is a "conforming extension". - fpos(): _M_st(__state_type()), _M_pos(streamoff()) { } - - fpos(streamoff __pos, __state_type __st) - : _M_st(__st), _M_pos(__pos) { } - - fpos(streamoff __pos) - : _M_st(), _M_pos(__pos) { } - - operator streamoff() const { return _M_pos; } - - fpos& - operator+=(streamoff __off) { _M_pos += __off; return *this; } - - fpos& - operator-=(streamoff __off) { _M_pos -= __off; return *this; } - - bool - operator==(const fpos& __pos2) const { return _M_pos == __pos2._M_pos; } - - bool - operator!=(const fpos& __pos2) const { return _M_pos != __pos2._M_pos; } - - streamoff - _M_position() const { return _M_pos; } - - void - _M_position(streamoff __pos) { _M_pos = __pos; } - - private: - __state_type _M_st; - streamoff _M_pos; - }; - - template - inline fpos<_State> - operator+(const fpos<_State>& __pos, streamoff __off) - { - fpos<_State> t(__pos); - return t += __off; - } - - template - inline fpos<_State> - operator-(const fpos<_State>& __pos, streamoff __off) - { - fpos<_State> t(__pos); - return t -= __off; - } - - template - inline streamoff - operator-(const fpos<_State>& __pos1, const fpos<_State>& __pos2) - { return __pos1._M_position() - __pos2._M_position(); } - -} // namespace std - -#endif /* _CPP_BITS_FPOS_H */ - - diff --git a/libstdc++-v3/bits/fstream.tcc b/libstdc++-v3/bits/fstream.tcc deleted file mode 100644 index d3a57501097..00000000000 --- a/libstdc++-v3/bits/fstream.tcc +++ /dev/null @@ -1,586 +0,0 @@ -// File based streams -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.8 File-based streams -// - -#ifndef _CPP_BITS_FSTREAM_TCC -#define _CPP_BITS_FSTREAM_TCC 1 - -namespace std -{ - template - void - basic_filebuf<_CharT, _Traits>:: - _M_filebuf_init() - { - _M_buf_unified = true; // Tie input to output for basic_filebuf. - _M_buf_size = _M_buf_size_opt; - try { - _M_file = new __file_type(&_M_lock); - } - catch(...) { - delete _M_file; - throw; - } - } - - template - void - basic_filebuf<_CharT, _Traits>:: - _M_allocate_buffers() - { - // Allocate internal buffer. - try { - _M_buf = new char_type[_M_buf_size]; - } - catch(...) { - delete [] _M_buf; - throw; - } - - // Allocate pback buffer. - try { - _M_pback = new char_type[_M_pback_size]; - } - catch(...) { - delete [] _M_pback; - throw; - } - } - - template - basic_filebuf<_CharT, _Traits>:: - basic_filebuf() - : __streambuf_type(), _M_file(NULL), _M_state_cur(), _M_state_beg(), - _M_last_overflowed(false) - { _M_fcvt = &use_facet<__codecvt_type>(this->getloc()); } - - template - basic_filebuf<_CharT, _Traits>:: - basic_filebuf(int __fd, const char* /*__name*/, ios_base::openmode __mode) - : __streambuf_type(), _M_state_cur(), _M_state_beg(), - _M_last_overflowed(false) - { - _M_fcvt = &use_facet<__codecvt_type>(this->getloc()); - _M_filebuf_init(); - _M_file->sys_open(__fd, __mode); - if (this->is_open() && _M_buf_size) - { - _M_allocate_buffers(); - _M_mode = __mode; - - // XXX So that istream::getc() will only need to get 1 char, - // as opposed to BUF_SIZE. - if (__fd == 0) - _M_buf_size = 1; - - this->_M_set_indeterminate(); - } - } - - template - basic_filebuf<_CharT, _Traits>::__filebuf_type* - basic_filebuf<_CharT, _Traits>:: - open(const char* __s, ios_base::openmode __mode) - { - __filebuf_type *__ret = NULL; - if (!this->is_open()) - { - _M_filebuf_init(); - _M_file->open(__s, __mode); - if (this->is_open() && _M_buf_size) - { - _M_allocate_buffers(); - _M_mode = __mode; - - // For time being, set both (in/out) sets of pointers. - _M_set_indeterminate(); - if (__mode & ios_base::ate - && this->seekoff(0, ios_base::end, __mode) < 0) - this->close(); - __ret = this; - } - } - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::__filebuf_type* - basic_filebuf<_CharT, _Traits>:: - close() - { - __filebuf_type *__ret = NULL; - if (this->is_open()) - { - bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - if (__testput) - _M_really_overflow(traits_type::eof()); - - // NB: Do this here so that re-opened filebufs will be cool... - _M_pback_destroy(); - -#if 0 - // XXX not done - if (_M_last_overflowed) - { - _M_output_unshift(); - _M_really_overflow(traits_type::eof()); - } -#endif - - _M_mode = ios_base::openmode(0); - if (_M_buf_size) - delete [] _M_buf; - _M_buf = NULL; - delete [] _M_pback; - _M_pback = NULL; - this->setg(NULL, NULL, NULL); - this->setp(NULL, NULL); - __ret = this; - } - - // Can actually allocate this file as part of an open and never - // have it be opened..... - if (_M_file) - { - delete _M_file; - _M_file = NULL; - } - _M_last_overflowed = false; - return __ret; - } - - template - streamsize - basic_filebuf<_CharT, _Traits>:: - showmanyc() - { - streamsize __ret = -1; - bool __testin = _M_mode & ios_base::in; - - if (__testin) - { - bool __testeof = false; - if (_M_in_cur >= _M_in_end) - __testeof = this->underflow() == traits_type::eof(); - if (!__testeof) - __ret = _M_in_end - _M_in_cur; - } - _M_last_overflowed = false; - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::int_type - basic_filebuf<_CharT, _Traits>:: - underflow() - { - int_type __ret = traits_type::eof(); - bool __testin = _M_mode & ios_base::in; - - if (__testin) - { - // Check for pback madness, and if so swich back to the - // normal buffers and jet outta here before expensive - // fileops happen... - if (_M_pback_init) - { - _M_pback_destroy(); - if (_M_in_cur < _M_in_end) - return traits_type::to_int_type(*_M_in_cur); - } - - bool __testget = _M_in_cur && _M_in_beg < _M_in_cur; - bool __testinit = _M_is_indeterminate(); - bool __testout = _M_mode & ios_base::out; - - // Sync internal and external buffers. - // NB: __testget -> __testput as _M_buf_unified here. - if (__testget) - { - if (__testout) - _M_really_overflow(); - else - _M_file->seekoff(_M_in_cur - _M_in_beg, - ios_base::cur, ios_base::in); - } - - if (__testinit || __testget) - { -#if 1 - streamsize __size = _M_file->xsgetn(_M_in_beg, _M_buf_size); - if (0 < __size) - { - _M_set_determinate(__size); - streamoff __p = _M_file->seekoff(0 - __size, ios_base::cur, - ios_base::in); - if (__p == -1) - { - // XXX Something is wrong, do error checking. - } - else - { - if (__testout) - _M_out_cur = _M_in_cur; - __ret = traits_type::to_int_type(*_M_in_cur); - } - } -#else - // 2000-08-04 bkoz disable - // Part one: (Re)fill external buf (_M_file->_IO_*) from - // external byte sequence (whatever physical byte sink or - // FILE actually is.) - char_type __conv_buf[_M_buf_size]; - streamsize __size = _M_file->xsgetn(__conv_buf, _M_buf_size); - - // Part two: (Re)fill internal buf contents from external buf. - if (0 < __size) - { - _M_set_determinate(__size); - - char* __conv_cur = __conv_buf; - _M_state_beg = _M_state_cur; - __res_type __r = _M_fcvt->in(_M_state_cur, - __conv_buf, - __conv_buf + __size, - const_cast(__conv_cur), - _M_in_beg, _M_in_end, _M_in_cur); - - if (__r == codecvt_base::partial) - { - // XXX Retry with larger _M_buf size. - } - - // Set pointers to internal and external buffers - // correctly. . . - if (__r != codecvt_base::error) - { - if (__testout) - _M_out_cur = _M_in_cur; - __ret = traits_type::to_int_type(*_M_in_cur); - } - - // Part three: Sync the current internal buffer - // position with the (now overshot) external buffer - // position. - streamoff __p = _M_file->seekoff(0 - __size, ios_base::cur, - ios_base::in); - if (__p == -1) - { - // XXX Something is wrong, do error checking. - } - } -#endif - } - } - _M_last_overflowed = false; - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::int_type - basic_filebuf<_CharT, _Traits>:: - pbackfail(int_type __i) - { - int_type __ret = traits_type::eof(); - bool __testin = _M_mode & ios_base::in; - - if (__testin) - { - bool __testpb = _M_in_beg < _M_in_cur; - char_type __c = traits_type::to_char_type(__i); - bool __testeof = traits_type::eq_int_type(__i, __ret); - - if (__testpb) - { - bool __testout = _M_mode & ios_base::out; - bool __testeq = traits_type::eq(__c, this->gptr()[-1]); - - // Try to put back __c into input sequence in one of three ways. - // Order these tests done in is unspecified by the standard. - if (!__testeof && __testeq) - { - --_M_in_cur; - if (__testout) - --_M_out_cur; - __ret = __i; - } - else if (__testeof) - { - --_M_in_cur; - if (__testout) - --_M_out_cur; - __ret = traits_type::not_eof(__i); - } - else if (!__testeof) - { - --_M_in_cur; - if (__testout) - --_M_out_cur; - _M_pback_create(); - *_M_in_cur = __c; - __ret = __i; - } - } - else - { - // At the beginning of the buffer, need to make a - // putback position available. - this->seekoff(-1, ios_base::cur); - 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); - } - } - _M_last_overflowed = false; - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::int_type - basic_filebuf<_CharT, _Traits>:: - overflow(int_type __c) - { - int_type __ret = traits_type::eof(); - bool __testpos = _M_out_cur && _M_out_cur >= _M_buf + _M_buf_size; - bool __testout = _M_mode & ios_base::out; - - if (__testout) - { - if (!__testpos) - { - *_M_out_cur = traits_type::to_char_type(__c); - _M_out_cur_move(1); - __ret = traits_type::not_eof(__c); - } - else - __ret = this->_M_really_overflow(__c); - } - - _M_last_overflowed = false; // Set in _M_really_overflow, below. - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::int_type - basic_filebuf<_CharT, _Traits>:: - _M_really_overflow(int_type __c) - { - int_type __ret = traits_type::eof(); - bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - - if (__testput) - { - bool __testeof = traits_type::eq_int_type(__c, traits_type::eof()); -#if 1 - int __plen = _M_out_end - _M_out_beg; - streamsize __len = _M_file->xsputn(_M_out_beg, __plen); - if (!__testeof) - { - char_type __pending = traits_type::to_char_type(__c); - __len += _M_file->xsputn(&__pending, 1); - ++__plen; - } - traits_type::to_char_type(__c); - // NB: Need this so that external byte sequence reflects - // internal buffer. - _M_file->sync(); - if (__len == __plen) - { - _M_set_indeterminate(); - __ret = traits_type::not_eof(__c); - } -#else - // Part one: Allocate temporary conversion buffer on - // stack. Convert internal buffer plus __c (ie, - // "pending sequence") to temporary conversion buffer. - int __plen = _M_out_end - _M_out_beg; - char_type __pbuf[__plen + 1]; - traits_type::copy(__pbuf, this->pbase(), __plen); - if (!__testeof) - { - __pbuf[__plen] = traits_type::to_char_type(__c); - ++__plen; - } - - char_type* __pend; - char __conv_buf[__plen]; - char* __conv_end; - _M_state_beg = _M_state_cur; - - __res_type __r = _M_fcvt->out(_M_state_cur, - __pbuf, __pbuf + __plen, - const_cast(__pend), - __conv_buf, __conv_buf + __plen, - __conv_end); - - // Part two: (Re)spill converted "pending sequence" - // contents (now in temporary conversion buffer) to - // external buffer (_M_file->_IO_*) using - // _M_file->sys_write(), and do error (minimal) checking. - if (__r != codecvt_base::error) - { - streamsize __len = _M_file->xsputn(__conv_buf, __plen); - // NB: Need this so that external byte sequence reflects - // internal buffer. - _M_file->sync(); - if (__len == __plen) - { - _M_set_indeterminate(); - __ret = traits_type::not_eof(__c); - } - } -#endif - } - _M_last_overflowed = true; - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::pos_type - basic_filebuf<_CharT, _Traits>:: - seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode) - { - pos_type __ret = pos_type(off_type(-1)); - bool __testopen = this->is_open(); - bool __testin = __mode & ios_base::in && _M_mode & ios_base::in; - bool __testout = __mode & ios_base::out && _M_mode & ios_base::out; - int __width = _M_fcvt->encoding(); - if (__width < 0) - __width = 0; - bool __testfail = __off != 0 && __width <= 0; - - if (__testopen && !__testfail && (__testin || __testout)) - { - // Ditch any pback buffers to avoid confusion. - _M_pback_destroy(); - - if (__way != ios_base::cur || __off != 0) - { - off_type __computed_off = __width * __off; - - bool __testget = _M_in_cur && _M_in_beg < _M_in_end; - bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - // Sync the internal and external streams. - // out - if (__testput || _M_last_overflowed) - { - // Part one: update the output sequence. - this->sync(); - // Part two: output unshift sequence. - _M_output_unshift(); - } - //in - // NB: underflow() rewinds the external buffer. - else if (__testget && __way == ios_base::cur) - __computed_off += _M_in_cur - _M_in_beg; - - __ret = _M_file->seekoff(__computed_off, __way, __mode); - _M_set_indeterminate(); - } - // NB: Need to do this in case _M_file in indeterminate - // 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_buf; - } - } - _M_last_overflowed = false; - return __ret; - } - - template - basic_filebuf<_CharT, _Traits>::pos_type - basic_filebuf<_CharT, _Traits>:: - seekpos(pos_type __pos, ios_base::openmode __mode) - { - pos_type __ret; - off_type __off = __pos; - - __ret = this->seekoff(__off, ios_base::beg, __mode); - - _M_last_overflowed = false; - return __ret; - } - - template - void - basic_filebuf<_CharT, _Traits>:: - _M_output_unshift() - { } - - template - void - basic_filebuf<_CharT, _Traits>:: - imbue(const locale& __loc) - { - bool __testbeg = gptr() == eback() && pptr() == pbase(); - bool __teststate = _M_fcvt->encoding() == -1; - - _M_buf_locale_init = true; - if (__testbeg && !__teststate && _M_buf_locale != __loc) - { - // XXX Will need to save these older values. - _M_buf_locale = __loc; - _M_fcvt = &use_facet<__codecvt_type>(_M_buf_locale); - // XXX Necessary? - _M_buf_fctype = &use_facet<__ctype_type>(_M_buf_locale); - } - // NB this may require the reconversion of previously - // converted chars. This in turn may cause the reconstruction - // of the original file. YIKES!! - // XXX The part in the above comment is not done. - _M_last_overflowed = false; - } - -} // namespace std - -#endif // _CPP_BITS_FSTREAM_TCC - - - - - - - - - - diff --git a/libstdc++-v3/bits/generic_shadow.h b/libstdc++-v3/bits/generic_shadow.h deleted file mode 100644 index b2a554f89ee..00000000000 --- a/libstdc++-v3/bits/generic_shadow.h +++ /dev/null @@ -1,59 +0,0 @@ -// generic C header shadow file -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// This file is included by all the standard C headers -// after defining _SHADOW_NAME. - -#ifdef _IN_C_LEGACY_ /* sub-included by a C header */ - - // Get out of the "swamp." - } // Close extern "C" - } // Close namespace _C_legacy:: - -# undef _IN_C_LEGACY_ -# include _SHADOW_NAME - - // Dive back into the "swamp." - namespace _C_legacy { - extern "C" { -# define _IN_C_LEGACY_ - -#else /* not _IN_C_LEGACY_: directly included by user program */ - -# include _SHADOW_NAME - - // Expose global C names, including non-standard ones, but shadow - // some names and types with the std:: C++ version. - - using namespace ::_C_legacy::_C_shadow; - -#endif /* _IN_C_LEGACY_ */ - - - diff --git a/libstdc++-v3/bits/gslice.h b/libstdc++-v3/bits/gslice.h deleted file mode 100644 index 737254c9da7..00000000000 --- a/libstdc++-v3/bits/gslice.h +++ /dev/null @@ -1,117 +0,0 @@ -// The template and inlines for the -*- C++ -*- gslice class. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_GSLICE_H -#define _CPP_BITS_GSLICE_H - -namespace std { - - class gslice - { - public: - gslice (); - gslice (size_t, const valarray&, const valarray&); - // XXX: the IS says the copy-ctor and copy-assignment operators are - // synthetized by the compiler but they are just unsuitable - // for a ref-counted semantic - gslice(const gslice&); - ~gslice(); - - // XXX: See the note above. - gslice& operator= (const gslice&); - - size_t start () const; - valarray size () const; - valarray stride () const; - - private: - struct _Indexer { - size_t _M_count; - size_t _M_start; - valarray _M_size; - valarray _M_stride; - valarray _M_index; - _Indexer(size_t, const valarray&, - const valarray&); - void _M_increment_use() { ++_M_count; } - size_t _M_decrement_use() { return --_M_count; } - }; - - _Indexer* _M_index; - - template friend class valarray; - }; - - inline size_t - gslice::start () const - { return _M_index ? _M_index->_M_start : 0; } - - inline valarray - gslice::size () const - { return _M_index ? _M_index->_M_size : valarray(); } - - inline valarray - gslice::stride () const - { return _M_index ? _M_index->_M_stride : valarray(); } - - inline gslice::gslice () : _M_index(0) {} - - inline - gslice::gslice(size_t __o, const valarray& __l, - const valarray& __s) - : _M_index(new gslice::_Indexer(__o, __l, __s)) {} - - inline - gslice::gslice(const gslice& __g) : _M_index(__g._M_index) - { if (_M_index) _M_index->_M_increment_use(); } - - inline - gslice::~gslice() - { if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; } - - inline gslice& - gslice::operator= (const gslice& __g) - { - if (__g._M_index) __g._M_index->_M_increment_use(); - if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; - _M_index = __g._M_index; - return *this; - } - - -} // std:: - - -#endif /* _CPP_BITS_GSLICE_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/gslice_array.h b/libstdc++-v3/bits/gslice_array.h deleted file mode 100644 index 23a1f6d438b..00000000000 --- a/libstdc++-v3/bits/gslice_array.h +++ /dev/null @@ -1,169 +0,0 @@ -// The template and inlines for the -*- C++ -*- gslice_array class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_GSLICE_ARRAY -#define _CPP_BITS_GSLICE_ARRAY 1 - -namespace std { - - template 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 - void operator= (const _Expr<_Dom,_Tp>&) const; - template - void operator*= (const _Expr<_Dom,_Tp>&) const; - template - void operator/= (const _Expr<_Dom,_Tp>&) const; - template - void operator%= (const _Expr<_Dom,_Tp>&) const; - template - void operator+= (const _Expr<_Dom,_Tp>&) const; - template - void operator-= (const _Expr<_Dom,_Tp>&) const; - template - void operator^= (const _Expr<_Dom,_Tp>&) const; - template - void operator&= (const _Expr<_Dom,_Tp>&) const; - template - void operator|= (const _Expr<_Dom,_Tp>&) const; - template - void operator<<= (const _Expr<_Dom,_Tp>&) const; - template - void operator>>= (const _Expr<_Dom,_Tp>&) const; - - private: - _Array<_Tp> _M_array; - const valarray& _M_index; - - friend class valarray<_Tp>; - - gslice_array (_Array<_Tp>, const valarray&); - - // this constructor needs to be implemented. - gslice_array (const gslice_array&); - - // not implemented - gslice_array(); - gslice_array& operator= (const gslice_array&); - }; - - template - inline - gslice_array<_Tp>::gslice_array (_Array<_Tp> __a, - const valarray& __i) - : _M_array (__a), _M_index (__i) {} - - - template - inline - gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a) - : _M_array (__a._M_array), _M_index (__a._M_index) {} - - - template - inline void - gslice_array<_Tp>::operator= (const _Tp& __t) - { - __valarray_fill (_M_array, _Array(_M_index), - _M_index.size(), __t); - } - - template - inline void - gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const - { - __valarray_copy (_Array<_Tp> (__v), __v.size (), - _M_array, _Array(_M_index)); - } - - template - template - inline void - gslice_array<_Tp>::operator= (const _Expr& __e) const - { - __valarray_copy (__e, _M_index.size(), _M_array, - _Array(_M_index)); - } - -#undef _DEFINE_VALARRAY_OPERATOR -#define _DEFINE_VALARRAY_OPERATOR(op, name) \ -template \ -inline void \ -gslice_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \ -{ \ - _Array_augmented_##name (_M_array, _Array(_M_index), \ - _Array<_Tp> (__v), __v.size ()); \ -} \ - \ -template template \ -inline void \ -gslice_array<_Tp>::operator op##= (const _Expr& __e) const \ -{ \ - _Array_augmented_##name (_M_array, _Array(_M_index), __e, \ - _M_index.size()); \ -} - -_DEFINE_VALARRAY_OPERATOR(*, multiplies) -_DEFINE_VALARRAY_OPERATOR(/, divides) -_DEFINE_VALARRAY_OPERATOR(%, modulus) -_DEFINE_VALARRAY_OPERATOR(+, plus) -_DEFINE_VALARRAY_OPERATOR(-, minus) -_DEFINE_VALARRAY_OPERATOR(^, xor) -_DEFINE_VALARRAY_OPERATOR(&, and) -_DEFINE_VALARRAY_OPERATOR(|, or) -_DEFINE_VALARRAY_OPERATOR(<<, shift_left) -_DEFINE_VALARRAY_OPERATOR(>>, shift_right) - -#undef _DEFINE_VALARRAY_OPERATOR - -} // std:: - -#endif /* _CPP_BITS_GSLICE_ARRAY */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/indirect_array.h b/libstdc++-v3/bits/indirect_array.h deleted file mode 100644 index 1ad3b911f6b..00000000000 --- a/libstdc++-v3/bits/indirect_array.h +++ /dev/null @@ -1,160 +0,0 @@ -// The template and inlines for the -*- C++ -*- indirect_array class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_INDIRECT_ARRAY_H -#define _CPP_BITS_INDIRECT_ARRAY_H - -namespace std { - - template class indirect_array - { - public: - typedef _Tp value_type; - - void operator= (const valarray<_Tp>&) const; - void operator*= (const valarray<_Tp>&) const; - void operator/= (const valarray<_Tp>&) const; - void operator%= (const valarray<_Tp>&) const; - void operator+= (const valarray<_Tp>&) const; - void operator-= (const valarray<_Tp>&) const; - void operator^= (const valarray<_Tp>&) const; - void operator&= (const valarray<_Tp>&) const; - void operator|= (const valarray<_Tp>&) const; - void operator<<= (const valarray<_Tp>&) const; - void operator>>= (const valarray<_Tp>&) const; - void operator= (const _Tp&); - // ~indirect_array(); - - template - void operator= (const _Expr<_Dom, _Tp>&) const; - template - void operator*= (const _Expr<_Dom, _Tp>&) const; - template - void operator/= (const _Expr<_Dom, _Tp>&) const; - template - void operator%= (const _Expr<_Dom, _Tp>&) const; - template - void operator+= (const _Expr<_Dom, _Tp>&) const; - template - void operator-= (const _Expr<_Dom, _Tp>&) const; - template - void operator^= (const _Expr<_Dom, _Tp>&) const; - template - void operator&= (const _Expr<_Dom, _Tp>&) const; - template - void operator|= (const _Expr<_Dom, _Tp>&) const; - template - void operator<<= (const _Expr<_Dom, _Tp>&) const; - template - void operator>>= (const _Expr<_Dom, _Tp>&) const; - - private: - indirect_array (const indirect_array&); - indirect_array (_Array<_Tp>, size_t, _Array); - - friend class valarray<_Tp>; - friend class gslice_array<_Tp>; - - const size_t _M_sz; - const _Array _M_index; - const _Array<_Tp> _M_array; - - // not implemented - indirect_array (); - indirect_array& operator= (const indirect_array&); - }; - - template - 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 - inline - indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s, - _Array __i) - : _M_sz (__s), _M_index (__i), _M_array (__a) {} - - // template - // inline indirect_array<_Tp>::~indirect_array() {} - - template - inline void - indirect_array<_Tp>::operator= (const _Tp& __t) - { __valarray_fill(_M_array, _M_index, _M_sz, __t); } - - template - inline void - indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const - { __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); } - - template - template - 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 \ -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 template \ -inline void \ -indirect_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \ -{ \ - _Array_augmented_##name (_M_array, _M_index, __e, _M_sz); \ -} - -_DEFINE_VALARRAY_OPERATOR(*, multiplies) -_DEFINE_VALARRAY_OPERATOR(/, divides) -_DEFINE_VALARRAY_OPERATOR(%, modulus) -_DEFINE_VALARRAY_OPERATOR(+, plus) -_DEFINE_VALARRAY_OPERATOR(-, minus) -_DEFINE_VALARRAY_OPERATOR(^, xor) -_DEFINE_VALARRAY_OPERATOR(&, and) -_DEFINE_VALARRAY_OPERATOR(|, or) -_DEFINE_VALARRAY_OPERATOR(<<, shift_left) -_DEFINE_VALARRAY_OPERATOR(>>, shift_right) - -#undef _DEFINE_VALARRAY_OPERATOR - -} // std:: - -#endif /* _CPP_BITS_INDIRECT_ARRAY_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/ios_base.h b/libstdc++-v3/bits/ios_base.h deleted file mode 100644 index 59462145522..00000000000 --- a/libstdc++-v3/bits/ios_base.h +++ /dev/null @@ -1,576 +0,0 @@ -// Iostreams base classes -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.8 File-based streams -// - -#ifndef _CPP_BITS_IOSBASE_H -#define _CPP_BITS_IOSBASE_H 1 - -namespace std { - - // The following definitions of bitmask types are enums, not ints, - // as permitted (but not required) in the standard, in order to provide - // better type safety in iostream calls. A side effect is that - // expressions involving them are no longer compile-time constants. - enum _Ios_Fmtflags { _S_ios_fmtflags_end = 1<<16 }; - - inline _Ios_Fmtflags - operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } - - inline _Ios_Fmtflags - operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } - - inline _Ios_Fmtflags - operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } - - inline _Ios_Fmtflags - operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a | __b; } - - inline _Ios_Fmtflags - operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a & __b; } - - inline _Ios_Fmtflags - operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a ^ __b; } - - inline _Ios_Fmtflags - operator~(_Ios_Fmtflags __a) - { return _Ios_Fmtflags(~static_cast(__a)); } - - - enum _Ios_Openmode { _S_ios_openmode_end = 1<<16 }; - - inline _Ios_Openmode - operator&(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } - - inline _Ios_Openmode - operator|(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } - - inline _Ios_Openmode - operator^(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } - - inline _Ios_Openmode - operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a | __b; } - - inline _Ios_Openmode - operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a & __b; } - - inline _Ios_Openmode - operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a ^ __b; } - - inline _Ios_Openmode - operator~(_Ios_Openmode __a) - { return _Ios_Openmode(~static_cast(__a)); } - - - enum _Ios_Iostate { _S_ios_iostate_end = 1<<16 }; - - inline _Ios_Iostate - operator&(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } - - inline _Ios_Iostate - operator|(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } - - inline _Ios_Iostate - operator^(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } - - inline _Ios_Iostate - operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a | __b; } - - inline _Ios_Iostate - operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a & __b; } - - inline _Ios_Iostate - operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a ^ __b; } - - inline _Ios_Iostate - operator~(_Ios_Iostate __a) - { return _Ios_Iostate(~static_cast(__a)); } - - enum _Ios_Seekdir { _S_ios_Seekdir_end = 1<<16 }; - - // 27.4.2 Class ios_base - class ios_base - { - public: - - // 27.4.2.1.1 Class ios_base::failure - class failure : public exception - { - public: -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Can't do exception(_msg) as defined in 27.4.2.1.1 - explicit - failure(const string& __str); - - virtual - ~failure() { }; - - virtual const - char* what() const throw() { return _M_name; } - - private: - enum { _M_bufsize = 256 }; - char _M_name[_M_bufsize]; -#endif - }; - - // 27.4.2.1.2 Type ios_base::fmtflags - typedef _Ios_Fmtflags fmtflags; - // 27.4.2.1.2 Type fmtflags - static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha); - static const fmtflags dec = fmtflags(__ios_flags::_S_dec); - static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed); - static const fmtflags hex = fmtflags(__ios_flags::_S_hex); - static const fmtflags internal = fmtflags(__ios_flags::_S_internal); - static const fmtflags left = fmtflags(__ios_flags::_S_left); - static const fmtflags oct = fmtflags(__ios_flags::_S_oct); - static const fmtflags right = fmtflags(__ios_flags::_S_right); - static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific); - static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase); - static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint); - static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos); - static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws); - static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf); - static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase); - static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield); - static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield); - static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield); - - // 27.4.2.1.3 Type ios_base::iostate - typedef _Ios_Iostate iostate; - static const iostate badbit = iostate(__ios_flags::_S_badbit); - static const iostate eofbit = iostate(__ios_flags::_S_eofbit); - static const iostate failbit = iostate(__ios_flags::_S_failbit); - static const iostate goodbit = iostate(0); - - // 27.4.2.1.4 Type openmode - typedef _Ios_Openmode openmode; - static const openmode app = openmode(__ios_flags::_S_app); - static const openmode ate = openmode(__ios_flags::_S_ate); - static const openmode binary = openmode(__ios_flags::_S_bin); - static const openmode in = openmode(__ios_flags::_S_in); - static const openmode out = openmode(__ios_flags::_S_out); - static const openmode trunc = openmode(__ios_flags::_S_trunc); - - // 27.4.2.1.5 Type seekdir - typedef _Ios_Seekdir seekdir; - static const seekdir beg = seekdir(0); - static const seekdir cur = seekdir(SEEK_CUR); - static const seekdir end = seekdir(SEEK_END); - -#ifdef _GLIBCPP_DEPRICATED - typedef int io_state; - typedef int open_mode; - typedef int seek_dir; -#endif - - // Callbacks; - enum event - { - erase_event, - imbue_event, - copyfmt_event - }; - - typedef void (*event_callback) (event, ios_base&, int); - - void - register_callback(event_callback __fn, int __index); - - protected: - // Data Members - streamsize _M_precision; - streamsize _M_width; - fmtflags _M_flags; - - // 27.4.2.6 Members for callbacks - // 27.4.2.6 ios_base callbacks - - struct _Callback_list - { - // Data Members - _Callback_list* _M_next; - ios_base::event_callback _M_fn; - int _M_index; - int _M_refcount; // 0 means one reference. - - _Callback_list(ios_base::event_callback __fn, int __index, - _Callback_list* __cb) - : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } - - void - _M_add_reference() { ++_M_refcount; } // XXX MT - - int - _M_remove_reference() { return _M_refcount--; } // 0 => OK to delete - }; - - _Callback_list* _M_callbacks; - - void - _M_call_callbacks(event __ev) throw(); - - void - _M_dispose_callbacks(void); - - // 27.4.2.5 Members for iword/pword storage - struct _Words - { - void* _M_pword; - long _M_iword; - }; - - static const int _S_local_words = 8; - _Words _M_word_array[_S_local_words]; // Guaranteed storage - _Words _M_dummy; // Only for failed iword/pword calls. - _Words* _M_words; - int _M_word_limit; - - _Words& - _M_grow_words(int __index); - - // Members for locale and locale caching. - locale _M_ios_locale; - - void - _M_init(); - - public: - // 27.4.2.1.6 Class ios_base::Init - // Used to initialize standard streams. In theory, g++ could use - // -finit-priority to order this stuff correctly without going - // through these machinations. - - class Init - { - friend class ios_base; - public: - Init(); - ~Init(); - private: - static int _S_ios_base_init; - filebuf* _M_cout; - filebuf* _M_cin; - filebuf* _M_cerr; -#ifdef _GLIBCPP_USE_WCHAR_T - wfilebuf* _M_wcout; - wfilebuf* _M_wcin; - wfilebuf* _M_wcerr; -#endif - }; - - // Fmtflags state: - inline fmtflags - flags() const { return _M_flags; } - - inline fmtflags - flags(fmtflags __fmtfl) - { - fmtflags __old = _M_flags; - _M_flags = __fmtfl; - return __old; - } - - inline fmtflags - setf(fmtflags __fmtfl) - { - fmtflags __old = _M_flags; - _M_flags |= __fmtfl; - return __old; - } - - inline fmtflags - setf(fmtflags __fmtfl, fmtflags __mask) - { - fmtflags __old = _M_flags; - _M_flags &= ~__mask; - _M_flags |= (__fmtfl & __mask); - return __old; - } - - inline void - unsetf(fmtflags __mask) { _M_flags &= ~__mask; } - - inline streamsize - precision() const { return _M_precision; } - - inline streamsize - precision(streamsize __prec) - { - streamsize __old = _M_precision; - _M_precision = __prec; - return __old; - } - - inline streamsize - width() const { return _M_width; } - - inline streamsize - width(streamsize __wide) - { - streamsize __old = _M_width; - _M_width = __wide; - return __old; - } - - static bool - sync_with_stdio(bool __sync = true); - - // Locales: - locale - imbue(const locale& __loc); - - inline locale - getloc() const { return _M_ios_locale; } - - // Storage: - static int - xalloc() throw(); - - inline long& - iword(int __ix) - { - _Words& __word = (__ix < _M_word_limit) - ? _M_words[__ix] : _M_grow_words(__ix); - return __word._M_iword; - } - - inline void*& - pword(int __ix) - { - _Words& __word = (__ix < _M_word_limit) - ? _M_words[__ix] : _M_grow_words(__ix); - return __word._M_pword; - } - - // Destructor - ~ios_base(); - - protected: - ios_base(); - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - private: - ios_base(const ios_base&); - - ios_base& - operator=(const ios_base&); -#endif - }; - - // 27.4.5.1 fmtflags manipulators: - inline ios_base& - boolalpha(ios_base& __base) - { - __base.setf(ios_base::boolalpha); - return __base; - } - - inline ios_base& - noboolalpha(ios_base& __base) - { - __base.unsetf(ios_base::boolalpha); - return __base; - } - - inline ios_base& - showbase(ios_base& __base) - { - __base.setf(ios_base::showbase); - return __base; - } - - inline ios_base& - noshowbase(ios_base& __base) - { - __base.unsetf(ios_base::showbase); - return __base; - } - - inline ios_base& - showpoint(ios_base& __base) - { - __base.setf(ios_base::showpoint); - return __base; - } - - inline ios_base& - noshowpoint(ios_base& __base) - { - __base.unsetf(ios_base::showpoint); - return __base; - } - - inline ios_base& - showpos(ios_base& __base) - { - __base.setf(ios_base::showpos); - return __base; - } - - inline ios_base& - noshowpos(ios_base& __base) - { - __base.unsetf(ios_base::showpos); - return __base; - } - - inline ios_base& - skipws(ios_base& __base) - { - __base.setf(ios_base::skipws); - return __base; - } - - inline ios_base& - noskipws(ios_base& __base) - { - __base.unsetf(ios_base::skipws); - return __base; - } - - inline ios_base& - uppercase(ios_base& __base) - { - __base.setf(ios_base::uppercase); - return __base; - } - - inline ios_base& - nouppercase(ios_base& __base) - { - __base.unsetf(ios_base::uppercase); - return __base; - } - - inline ios_base& - unitbuf(ios_base& __base) - { - __base.setf(ios_base::unitbuf); - return __base; - } - - inline ios_base& - nounitbuf(ios_base& __base) - { - __base.unsetf(ios_base::unitbuf); - return __base; - } - - // 27.4.5.2 adjustfield anipulators: - inline ios_base& - internal(ios_base& __base) - { - __base.setf(ios_base::internal, ios_base::adjustfield); - return __base; - } - - inline ios_base& - left(ios_base& __base) - { - __base.setf(ios_base::left, ios_base::adjustfield); - return __base; - } - - inline ios_base& - right(ios_base& __base) - { - __base.setf(ios_base::right, ios_base::adjustfield); - return __base; - } - - // 27.4.5.3 basefield anipulators: - inline ios_base& - dec(ios_base& __base) - { - __base.setf(ios_base::dec, ios_base::basefield); - return __base; - } - - inline ios_base& - hex(ios_base& __base) - { - __base.setf(ios_base::hex, ios_base::basefield); - return __base; - } - - inline ios_base& - oct(ios_base& __base) - { - __base.setf(ios_base::oct, ios_base::basefield); - return __base; - } - - // 27.4.5.4 floatfield anipulators: - inline ios_base& - fixed(ios_base& __base) - { - __base.setf(ios_base::fixed, ios_base::floatfield); - return __base; - } - - inline ios_base& - scientific(ios_base& __base) - { - __base.setf(ios_base::scientific, ios_base::floatfield); - return __base; - } - -} // namespace std - -#endif /* _CPP_BITS_IOSBASE_H */ - - - - - - - - - diff --git a/libstdc++-v3/bits/istream.tcc b/libstdc++-v3/bits/istream.tcc deleted file mode 100644 index 8ad2de04862..00000000000 --- a/libstdc++-v3/bits/istream.tcc +++ /dev/null @@ -1,1216 +0,0 @@ -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.6.2 Output streams -// - -#include - -namespace std { - - template - basic_istream<_CharT, _Traits>::sentry:: - sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws) - { - if (__in.good()) - { - if (__in.tie()) - __in.tie()->flush(); - if (!__noskipws && (__in.flags() & ios_base::skipws)) - { - const __int_type __eof = traits_type::eof(); - __int_type __c = __int_type(0); - __streambuf_type* __sb = __in.rdbuf(); - const __ctype_type* __ctype = __in._M_get_fctype_ios(); - bool __testsp = true; - bool __testeof = false; - - while (!__testeof && __testsp) - { - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testsp = __ctype->is(ctype_base::space, __c); - } - - if (!__testeof && !__testsp) - __sb->sputbackc(__c); -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -//195. Should basic_istream::sentry's constructor ever set eofbit? - else - __in.setstate(ios_base::eofbit); -#endif - } - } - _M_ok = __in.good(); - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(__istream_type& (*__pf)(__istream_type&)) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(__ios_type& (*__pf)(__ios_type&)) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(ios_base& (*__pf)(ios_base&)) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(bool& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(short& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(unsigned short& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(int& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(unsigned int& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(long& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(unsigned long& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - -#ifdef _GLIBCPP_USE_LONG_LONG - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(long long& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(unsigned long long& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } -#endif - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(float& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(double& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(long double& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(void*& __n) - { - sentry __cerb(*this, false); - if (__cerb) - { - try { - iostate __err = iostate(ios_base::goodbit); - _M_fnumget->get(*this, 0, *this, __err, __n); - this->setstate(__err); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(__streambuf_type* __sbout) - { - streamsize __xtrct = 0; - __streambuf_type* __sbin = this->rdbuf(); - sentry __cerb(*this, false); - if (__sbout && __cerb) - __xtrct = _S_copy_streambufs(*this, __sbin, __sbout); - if (!__sbout || !__xtrct) - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_istream<_CharT, _Traits>::int_type - basic_istream<_CharT, _Traits>:: - get(void) - { - const int_type __eof = traits_type::eof(); - int_type __c = __eof; - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - __c = this->rdbuf()->sbumpc(); - // 27.6.1.1 paragraph 3 - if (__c != __eof) - _M_gcount = 1; - else - this->setstate(ios_base::eofbit | ios_base::failbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __c; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(char_type& __c) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - const int_type __eof = traits_type::eof(); - int_type __bufval = this->rdbuf()->sbumpc(); - // 27.6.1.1 paragraph 3 - if (__bufval != __eof) - { - _M_gcount = 1; - __c = traits_type::to_char_type(__bufval); - } - else - this->setstate(ios_base::eofbit | ios_base::failbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(char_type* __s, streamsize __n, char_type __delim) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 1) - { - try { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sbumpc(); - bool __testdelim = __c == __idelim; - bool __testeof = __c == __eof; - - while (_M_gcount < __n - 1 && !__testeof && !__testdelim) - { - *__s++ = traits_type::to_char_type(__c); - ++_M_gcount; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testdelim = __c == __idelim; - } - if (__testdelim || _M_gcount == __n - 1) - __sb->sputbackc(__c); - if (__testeof) - this->setstate(ios_base::eofbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - *__s = char_type(NULL); - if (!_M_gcount) - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(__streambuf_type& __sb, char_type __delim) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - int_type __c; - __streambuf_type* __this_sb = this->rdbuf(); - try { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __c = __this_sb->sbumpc(); - bool __testdelim = __c == __idelim; - bool __testeof = __c == __eof; - bool __testput = true; - streamsize __n = __this_sb->in_avail(); - - while (_M_gcount <= __n && !__testeof && !__testdelim - && (__testput = __sb.sputc(traits_type::to_char_type(__c)) - != __eof)) - { - ++_M_gcount; - __c = __this_sb->sbumpc(); - __testeof = __c == __eof; - __testdelim = __c == __idelim; - } - if (__testdelim || !__testput) - __this_sb->sputbackc(traits_type::to_char_type(__c)); - if (__testeof) - this->setstate(ios_base::eofbit); - } - catch(exception& __fail){ - // Exception may result from sputc->overflow. - __this_sb->sputbackc(traits_type::to_char_type(__c)); - } - } - if (!_M_gcount) - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - getline(char_type* __s, streamsize __n, char_type __delim) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sbumpc(); - ++_M_gcount; - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - bool __testdelim = __c == __idelim; - bool __testeof = __c == __eof; - - while (_M_gcount < __n && !__testeof && !__testdelim) - { - *__s++ = traits_type::to_char_type(__c); - __c = __sb->sbumpc(); - ++_M_gcount; - __testeof = __c == __eof; - __testdelim = __c == __idelim; - } - - if (__testeof) - { - --_M_gcount; - this->setstate(ios_base::eofbit); - } - else if (!__testdelim) - { - --_M_gcount; - __sb->sputbackc(traits_type::to_char_type(__c)); - this->setstate(ios_base::failbit); - } - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - *__s = char_type(NULL); - if (!_M_gcount) - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - ignore(streamsize __n, int_type __delim) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 0) - { - try { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sbumpc(); - bool __testdelim = __c == __idelim; - bool __testeof = __c == __eof; - - __n = min(__n, numeric_limits::max()); - while (_M_gcount < __n - 1 && !__testeof && !__testdelim) - { - ++_M_gcount; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testdelim = __c == __idelim; - } - if ((_M_gcount == __n - 1 && !__testeof) || __testdelim) - ++_M_gcount; - if (__testeof) - this->setstate(ios_base::eofbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>::int_type - basic_istream<_CharT, _Traits>:: - peek(void) - { - int_type __c = traits_type::eof(); - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - __c = this->rdbuf()->sgetc(); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __c; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - read(char_type* __s, streamsize __n) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - if (__n > 0) - { - try { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sbumpc(); - bool __testeof = __c == __eof; - - while (_M_gcount < __n - 1 && !__testeof) - { - *__s++ = traits_type::to_char_type(__c); - ++_M_gcount; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - } - if (__testeof) - this->setstate(ios_base::eofbit | ios_base::failbit); - else - { - // _M_gcount == __n - 1 - *__s++ = traits_type::to_char_type(__c); - ++_M_gcount; - } - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - } - else - this->setstate(ios_base::failbit); - return *this; - } - - template - streamsize - basic_istream<_CharT, _Traits>:: - readsome(char_type* __s, streamsize __n) - { - const int_type __eof = traits_type::eof(); - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - if (__n > 0) - { - try { - streamsize __num = this->rdbuf()->in_avail(); - if (__num != static_cast(__eof)) - { - __num = min(__num, __n); - _M_gcount = this->rdbuf()->sgetn(__s, __num); - } - else - this->setstate(ios_base::eofbit); - } - - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - } - else - this->setstate(ios_base::failbit); - return _M_gcount; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - putback(char_type __c) - { - sentry __cerb(*this, true); - if (__cerb) - { - try { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - if (!__sb || __sb->sputbackc(__c) == __eof) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - else - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - unget(void) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - if (!__sb || __eof == __sb->sungetc()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - else - this->setstate(ios_base::failbit); - return *this; - } - - template - int - basic_istream<_CharT, _Traits>:: - sync(void) - { - int __ret = traits_type::eof(); - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - __streambuf_type* __sb = this->rdbuf(); - if (!__sb || __ret == __sb->pubsync()) - this->setstate(ios_base::badbit); - else - __ret = 0; - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __ret; - } - - template - typename basic_istream<_CharT, _Traits>::pos_type - basic_istream<_CharT, _Traits>:: - tellg(void) - { - pos_type __ret = pos_type(-1); - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { - __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __ret; - } - - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - seekg(pos_type __pos) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 136. seekp, seekg setting wrong streams? - this->rdbuf()->pubseekpos(__pos, ios_base::in); -#endif - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - seekg(off_type __off, ios_base::seekdir __dir) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - try { -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 136. seekp, seekg setting wrong streams? - this->rdbuf()->pubseekoff(__off, __dir, ios_base::in); -#endif - } - catch(exception& __fail){ - // 27.6.1.3 paragraph 1 - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - // 27.6.1.2.3 Character extraction templates - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - try { - __in.get(__c); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __in.setstate(ios_base::badbit); - if ((__in.exceptions() & ios_base::badbit) != 0) - throw; - } - } - else - __in.setstate(ios_base::failbit); - return __in; - } - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::__streambuf_type __streambuf_type; - typedef typename _Traits::int_type int_type; - typedef _CharT char_type; - typedef ctype<_CharT> __ctype_type; - int_type __extracted = 0; - - __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - try { - // Figure out how many characters to extract. - int_type __num = static_cast(__in.width()); - if (__num <= 0) - __num = basic_string<_CharT, _Traits>::npos; - - __streambuf_type* __sb = __in.rdbuf(); - const __ctype_type* __ctype = __in._M_get_fctype_ios(); - int_type __c = __sb->sbumpc(); - const int_type __eof = _Traits::eof(); - bool __testsp = __ctype->is(ctype_base::space, __c); - bool __testeof = __c == __eof; - - while (__extracted < __num - 1 && !__testeof && !__testsp) - { - *__s++ = __c; - ++__extracted; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testsp = __ctype->is(ctype_base::space, __c); - } - - if (!__testeof) - __sb->sputbackc(__c); - else - __in.setstate(ios_base::eofbit); - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -//68. Extractors for char* should store null at end - *__s = char_type(); -#endif - __in.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __in.setstate(ios_base::badbit); - if ((__in.exceptions() & ios_base::badbit) != 0) - throw; - } - } - if (!__extracted) - __in.setstate(ios_base::failbit); - return __in; - } - - // 27.6.1.4 Standard basic_istream manipulators - template - basic_istream<_CharT,_Traits>& - ws(basic_istream<_CharT,_Traits>& __in) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::__streambuf_type __streambuf_type; - typedef typename __istream_type::__ctype_type __ctype_type; - typedef typename __istream_type::int_type __int_type; - typedef typename __istream_type::char_type __char_type; - - __streambuf_type* __sb = __in.rdbuf(); - const __ctype_type* __ctype = __in._M_get_fctype_ios(); - const __int_type __eof = _Traits::eof(); - __int_type __c; - bool __testeof; - bool __testsp; - - do - { - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testsp = __ctype->is(ctype_base::space, __c); - } - while (!__testeof && __testsp); - - if (!__testeof && !__testsp) - __sb->sputbackc(__c); - else - __in.setstate(ios_base::eofbit); - - return __in; - } - - // 21.3.7.8 basic_string::getline and operators - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, - basic_string<_CharT, _Traits, _Alloc>& __str) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::int_type __int_type; - typedef typename __istream_type::__streambuf_type __streambuf_type; - typedef typename __istream_type::__ctype_type __ctype_type; - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef typename __string_type::size_type __size_type; - __int_type __extracted = 0; - - __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - __str.erase(); - streamsize __w = __in.width(); - __size_type __n; - __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size(); - - __streambuf_type* __sb = __in.rdbuf(); - const __ctype_type* __ctype = __in._M_get_fctype_ios(); - __int_type __c = __sb->sbumpc(); - const __int_type __eof = _Traits::eof(); - bool __testsp = __ctype->is(ctype_base::space, __c); - bool __testeof = __c == __eof; - - while (__extracted <= __n && !__testeof && !__testsp) - { - __str += _Traits::to_char_type(__c); - ++__extracted; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testsp = __ctype->is(ctype_base::space, __c); - } - if (!__testeof) - __sb->sputbackc(__c); - else - __in.setstate(ios_base::eofbit); - __in.width(0); - } -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 2000-02-01 Number to be determined - if (!__extracted) - __in.setstate (ios_base::failbit); -#endif - return __in; - } - - template - basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>& __in, - basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::int_type __int_type; - typedef typename __istream_type::__streambuf_type __streambuf_type; - typedef typename __istream_type::__ctype_type __ctype_type; - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef typename __string_type::size_type __size_type; - - __size_type __extracted = 0; - bool __testdelim = false; - __istream_type::sentry __cerb(__in, true); - if (__cerb) - { - __str.erase(); - __size_type __n = __str.max_size(); - - __int_type __idelim = _Traits::to_int_type(__delim); - __streambuf_type* __sb = __in.rdbuf(); - __int_type __c = __sb->sbumpc(); - const __int_type __eof = _Traits::eof(); - __testdelim = __c == __idelim; - bool __testeof = __c == __eof; - - while (__extracted <= __n && !__testeof && !__testdelim) - { - __str += _Traits::to_char_type(__c); - ++__extracted; - __c = __sb->sbumpc(); - __testeof = __c == __eof; - __testdelim = __c == __idelim; - } - if (__testeof) - __in.setstate(ios_base::eofbit); - } - if (!__extracted && !__testdelim) - __in.setstate(ios_base::failbit); - return __in; - } - - template - inline basic_istream<_CharT,_Traits>& - getline(basic_istream<_CharT, _Traits>& __in, - basic_string<_CharT,_Traits,_Alloc>& __str) - { return getline(__in, __str, __in.widen('\n')); } - -} // namespace std - -// Local Variables: -// mode:C++ -// End: - - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/limits_generic.h b/libstdc++-v3/bits/limits_generic.h deleted file mode 100644 index 45fcccb12dc..00000000000 --- a/libstdc++-v3/bits/limits_generic.h +++ /dev/null @@ -1,786 +0,0 @@ -// The template and inlines for the -*- C++ -*- numeric_limits classes. - -// Copyright (C) 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Note: this is not a conforming implementation. -// Written by Gabriel Dos Reis - -// -// ISO 14882:1998 -// 18.2.1 -// - -#ifndef _CPP_NUMERIC_LIMITS -#define _CPP_NUMERIC_LIMITS 1 - -#include -#include -#include -#if defined( _GLIBCPP_USE_WCHAR_T) -#include -#endif - -namespace std { - - enum float_round_style { - round_indeterminate = -1, - round_toward_zero = 0, - round_to_nearest = 1, - round_toward_infinity = 2, - round_toward_neg_infinity = 3 - }; - - enum float_denorm_style { - denorm_indeterminate = -1, - denorm_absent = 0, - denorm_present = 1 - }; - - template struct numeric_limits { - static const bool is_specialized = false; - - static _T min() throw() { return static_cast<_T>(0); } - static _T max() throw() { return static_cast<_T>(0); } - - static const int digits = 0; - static const int digits10 = 0; - static const bool is_signed = false; - static const bool is_integer = false; - static const bool is_exact = false; - static const int radix = 0; - - static _T epsilon() throw() { return static_cast<_T>(0); } - static _T round_error() throw() { return static_cast<_T>(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 _T infinity() throw() { return static_cast<_T>(0); } - static _T quiet_NaN() throw() { return static_cast<_T>(0); } - static _T signaling_NaN() throw() { return static_cast<_T>(0); } - static _T denorm_min() throw() { return static_cast<_T>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = false; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template _T __limits_infinity(); - template _T __limits_quiet_NaN(); - template _T __limits_signaling_NaN(); - template _T __limits_denorm_min(); - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static bool min() throw() - { return false; } - static bool max() throw() - { return true; } - - static const int digits = 8; - static const int digits10 = 2; - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static bool epsilon() throw() - { return 0; } - static bool 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 bool infinity() throw() - { return static_cast(0); } - static bool quiet_NaN() throw() - { return static_cast(0); } - static bool signaling_NaN() throw() - { return static_cast(0); } - static bool denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = true; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static char min() throw() - { return CHAR_MIN; } - static char max() throw() - { return CHAR_MAX; } - - static const int digits = 7; - static const int digits10 = 2; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static char epsilon() throw() - { return 0; } - static char 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 char infinity() throw() - { return static_cast(0); } - static char quiet_NaN() throw() - { return static_cast(0); } - static char signaling_NaN() throw() - { return static_cast(0); } - static char denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static signed char min() throw() - { return SCHAR_MIN; } - static signed char max() throw() - { return SCHAR_MAX; } - - static const int digits = 7; - static const int digits10 = 2; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static signed char epsilon() throw() - { return 0; } - static signed char 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 signed char infinity() throw() - { return static_cast(0); } - static signed char quiet_NaN() throw() - { return static_cast(0); } - static signed char signaling_NaN() throw() - { return static_cast(0); } - static signed char denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static unsigned char min() throw() - { return 0; } - static unsigned char max() throw() - { return UCHAR_MAX; } - - static const int digits = 8; - static const int digits10 = 2; - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned char epsilon() throw() - { return 0; } - static unsigned char 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 unsigned char infinity() throw() - { return static_cast(0); } - static unsigned char quiet_NaN() throw() - { return static_cast(0); } - static unsigned char signaling_NaN() throw() - { return static_cast(0); } - static unsigned char denorm_min() throw() - { return static_cast(0); } - - 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 tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - -#if defined( _GLIBCPP_USE_WCHAR_T) - template<> struct numeric_limits { - static const bool is_specialized = true; - - static wchar_t min() throw() - { return WCHAR_MIN; } - static wchar_t max() throw() - { return WCHAR_MAX; } - - static const int digits = 31; - static const int digits10 = 9; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static wchar_t epsilon() throw() - { return 0; } - static wchar_t 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 wchar_t infinity() throw() - { return static_cast(0); } - static wchar_t quiet_NaN() throw() - { return static_cast(0); } - static wchar_t signaling_NaN() throw() - { return static_cast(0); } - static wchar_t denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; -#endif - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static short min() throw() - { return SHRT_MIN; } - static short max() throw() - { return SHRT_MAX; } - - static const int digits = 15; - static const int digits10 = 4; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static short epsilon() throw() - { return 0; } - static short 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 short infinity() throw() - { return static_cast(0); } - static short quiet_NaN() throw() - { return static_cast(0); } - static short signaling_NaN() throw() - { return static_cast(0); } - static short denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static unsigned short min() throw() - { return 0; } - static unsigned short max() throw() - { return USHRT_MAX; } - - static const int digits = 16; - static const int digits10 = 4; - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned short epsilon() throw() - { return 0; } - static unsigned short 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 unsigned short infinity() throw() - { return static_cast(0); } - static unsigned short quiet_NaN() throw() - { return static_cast(0); } - static unsigned short signaling_NaN() throw() - { return static_cast(0); } - static unsigned short denorm_min() throw() - { return static_cast(0); } - - 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 tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static int min() throw() - { return INT_MIN; } - static int max() throw() - { return INT_MAX; } - - static const int digits = 31; - static const int digits10 = 9; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static int epsilon() throw() - { return 0; } - static int 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 int infinity() throw() - { return static_cast(0); } - static int quiet_NaN() throw() - { return static_cast(0); } - static int signaling_NaN() throw() - { return static_cast(0); } - static int denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = true; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static unsigned int min() throw() - { return 0; } - static unsigned int max() throw() - { return UINT_MAX; } - - static const int digits = 32; - static const int digits10 = 9; - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned int epsilon() throw() - { return 0; } - static unsigned int 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 unsigned int infinity() throw() - { return static_cast(0); } - static unsigned int quiet_NaN() throw() - { return static_cast(0); } - static unsigned int signaling_NaN() throw() - { return static_cast(0); } - static unsigned int denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = true; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = true; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static long min() throw() - { return LONG_MIN; } - static long max() throw() - { return LONG_MAX; } - - static const int digits = 31; - static const int digits10 = 9; - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static long epsilon() throw() - { return 0; } - static 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 infinity() throw() - { return static_cast(0); } - static long quiet_NaN() throw() - { return static_cast(0); } - static long signaling_NaN() throw() - { return static_cast(0); } - static long denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = true; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static unsigned long min() throw() - { return 0; } - static unsigned long max() throw() - { return ULONG_MAX; } - - static const int digits = 32; - static const int digits10 = 9; - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned long epsilon() throw() - { return 0; } - static unsigned 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 unsigned long infinity() throw() - { return static_cast(0); } - static unsigned long quiet_NaN() throw() - { return static_cast(0); } - static unsigned long signaling_NaN() throw() - { return static_cast(0); } - static unsigned long denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = true; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = true; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static float min() throw() - { return FLT_MIN; } - static float max() throw() - { return FLT_MAX; } - - 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 = FLT_RADIX; - static float epsilon() throw() - { return FLT_EPSILON; } - static float round_error() throw() - { return FLT_ROUNDS; } - - 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 = 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 float infinity() throw() - { return static_cast(0); } - static float quiet_NaN() throw() - { return static_cast(0); } - static float signaling_NaN() throw() - { return static_cast(0); } - static float denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static double min() throw() - { return DBL_MIN; } - static double max() throw() - { return DBL_MAX; } - - 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 = 2; - static double epsilon() throw() - { return DBL_EPSILON; } - static double round_error() throw() - { return 1.0; } - - 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 = 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 double infinity() throw() - { return static_cast(0); } - static double quiet_NaN() throw() - { return static_cast(0); } - static double signaling_NaN() throw() - { return static_cast(0); } - static double denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - - template<> struct numeric_limits { - static const bool is_specialized = true; - - static double min() throw() - { return LDBL_MIN; } - static double max() throw() - { return LDBL_MAX; } - - 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 = 2; - static double epsilon() throw() - { return LDBL_EPSILON; } - static double round_error() throw() - { return 1.0L; } - - 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 = 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 double infinity() throw() - { return static_cast(0); } - static double quiet_NaN() throw() - { return static_cast(0); } - static double signaling_NaN() throw() - { return static_cast(0); } - static double denorm_min() throw() - { return static_cast(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; - - static const bool traps = false; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; - }; - -} // namespace std - -#endif // _CPP_NUMERIC_LIMITS diff --git a/libstdc++-v3/bits/locale_facets.h b/libstdc++-v3/bits/locale_facets.h deleted file mode 100644 index 732eafce4ca..00000000000 --- a/libstdc++-v3/bits/locale_facets.h +++ /dev/null @@ -1,1733 +0,0 @@ -// Locale support -*- C++ -*- - -// Copyright (C) 1997-2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 22.1 Locales -// - -// Warning: this file is not meant for user inclusion. Use . - -#ifndef _CPP_BITS_LOCFACETS_H -#define _CPP_BITS_LOCFACETS_H 1 - -#include // For struct tm -#include // For bad_cast, which shouldn't be here. -#include // For ios_base -#include // For wctype_t - -namespace std -{ - // XXX This function is to be specialized for the "required" facets to - // be constructed lazily. The specializations must be declared after - // the definitions of the facets themselves; but they shouldn't be - // inline. Corresponding new's in locale::classic() should then be - // eliminated. Note that ctype<> should not get this treatment; - // see the use_facet<> specializations below. - // - struct _Bad_use_facet : public bad_cast - { - _Bad_use_facet() throw() {} - - _Bad_use_facet(_Bad_use_facet const& __b) throw() - : bad_cast(__b) { } - - _Bad_use_facet& - operator=(_Bad_use_facet const& __b) throw() - { - static_cast(this)->operator=(__b); - return *this; - } - - virtual char const* - what() const throw(); - - virtual - ~_Bad_use_facet() throw(); - }; - - template - const _Facet& - _Use_facet_failure_handler(const locale&) - { throw _Bad_use_facet(); } - - // 22.2.1 The ctype category - // Include host-specific ctype enums for ctype_base. - #include - - // 22.2.1.1 Template class ctype - // _Ctype_nois is the common base for ctype. It lacks "do_is" - // and related virtuals. These are filled in by _Ctype, below. - template - class _Ctype_nois : public locale::facet, public ctype_base - { - public: - // Types: - typedef _CharT char_type; - - char_type - toupper(char_type __c) const - { return this->do_toupper(__c); } - - const char_type* - toupper(char_type *__low, const char_type* __high) const - { return this->do_toupper(__low, __high); } - - char_type - tolower(char_type __c) const - { return this->do_tolower(__c); } - - const char_type* - tolower(char_type* __low, const char_type* __high) const - { return this->do_tolower(__low, __high); } - - char_type - widen(char __c) const - { return this->do_widen(__c); } - - const char* - widen(const char* __low, const char* __high, char_type* __to) const - { return this->do_widen(__low, __high, __to); } - - char - narrow(char_type __c, char __dfault) const - { return this->do_narrow(__c, __dfault); } - - const char_type* - narrow(const char_type* __low, const char_type* __high, - char __dfault, char *__to) const - { return this->do_narrow(__low, __high, __dfault, __to); } - - protected: - explicit - _Ctype_nois(size_t __refs = 0): locale::facet(__refs) { } - - virtual - ~_Ctype_nois() { } - - virtual char_type - do_toupper(char_type) const = 0; - - virtual const char_type* - do_toupper(char_type* __low, const char_type* __high) const = 0; - - virtual char_type - do_tolower(char_type) const = 0; - - virtual const char_type* - do_tolower(char_type* __low, const char_type* __high) const = 0; - - virtual char_type - do_widen(char) const = 0; - - virtual const char* - do_widen(const char* __low, const char* __high, - char_type* __dest) const = 0; - - virtual char - do_narrow(char_type, char __dfault) const = 0; - - virtual const char_type* - do_narrow(const char_type* __low, const char_type* __high, - char __dfault, char* __dest) const = 0; - }; - - - template - class _Ctype : public _Ctype_nois<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef typename _Ctype_nois<_CharT>::mask mask; - - bool - is(mask __m, char_type __c) const - { return this->do_is(__m, __c); } - - const char_type* - is(const char_type *__lo, const char_type *__hi, mask *__vec) const - { return this->do_is(__lo, __hi, __vec); } - - const char_type* - scan_is(mask __m, const char_type* __lo, const char_type* __hi) const - { return this->do_scan_is(__m, __lo, __hi); } - - const char_type* - scan_not(mask __m, const char_type* __lo, const char_type* __hi) const - { return this->do_scan_not(__m, __lo, __hi); } - - protected: - explicit - _Ctype(size_t __refs = 0) : _Ctype_nois<_CharT>(__refs) { } - - virtual - ~_Ctype() { } - - virtual bool - do_is(mask __m, char_type __c) const = 0; - - virtual const char_type* - do_is(const char_type* __lo, const char_type* __hi, - mask* __vec) const = 0; - - virtual const char_type* - do_scan_is(mask __m, const char_type* __lo, - const char_type* __hi) const = 0; - - virtual const char_type* - do_scan_not(mask __m, const char_type* __lo, - const char_type* __hi) const = 0; - }; - - template - class ctype : public _Ctype<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef typename ctype::mask mask; - - explicit - ctype(size_t __refs = 0) : _Ctype<_CharT>(__refs) { } - - static locale::id id; - - protected: - virtual - ~ctype() { } - - virtual bool - do_is(mask, char_type) const - { - // XXX Need definitions for these abstract mf's. - return true; - } - - virtual const char_type* - do_is(const char_type* __lo, const char_type*, mask*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual const char_type* - do_scan_is(mask, const char_type* __lo, const char_type*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual const char_type* - do_scan_not(mask, const char_type* __lo, const char_type*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual char_type - do_toupper(char_type __c) const - { - // XXX Need definitions for these abstract mf's. - return __c; - } - - virtual const char_type* - do_toupper(char_type* __lo, const char_type*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual char_type - do_tolower(char_type __c) const - { - // XXX Need definitions for these abstract mf's. - return __c; - } - - virtual const char_type* - do_tolower(char_type* __lo, const char_type*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual char_type - do_widen(char __c) const - { - // XXX Need definitions for these abstract mf's. - return __c; - } - - virtual const char* - do_widen(const char* __lo, const char*, char_type*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - - virtual char - do_narrow(char_type, char __c) const - { - // XXX Need definitions for these abstract mf's. - return __c; - } - - virtual const char_type* - do_narrow(const char_type* __lo, const char_type*, char, char*) const - { - // XXX Need definitions for these abstract mf's. - return __lo; - } - }; - - - // 22.2.1.3 ctype specializations - // NB: Can use _Ctype_nois to actually implement the "is" - // functionality in the non-virtual (thus inline-able) member - // fuctions. - template<> - class ctype : public _Ctype_nois - { - public: - // Types: - typedef char char_type; - typedef ctype::mask mask; - - private: - // Data Members: - bool _M_del; - __to_type const& _M_toupper; - __to_type const& _M_tolower; - const mask* const& _M_ctable; - const mask* _M_table; - - public: - static locale::id id; - static const size_t table_size = 1 + static_cast(-1); - - explicit - ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); - - inline bool - is(mask __m, char __c) const throw(); - - inline const char* - is(const char* __low, const char* __high, mask* __vec) const throw(); - - inline const char* - scan_is(mask __m, const char* __low, const char* __high) const throw(); - - inline const char* - scan_not(mask __m, const char* __low, const char* __high) const throw(); - - protected: - virtual - ~ctype(); - - // XXX - const mask* - table() const throw() - { return _M_table; } - - // XXX - const mask* - classic_table() throw() - { return _M_ctable; } - - virtual char_type - do_toupper(char_type) const; - - virtual const char_type* - do_toupper(char_type* __low, const char_type* __high) const; - - virtual char_type - do_tolower(char_type) const; - - virtual const char_type* - do_tolower(char_type* __low, const char_type* __high) const; - - virtual char_type - do_widen(char) const; - - virtual const char* - do_widen(const char* __low, const char* __high, - char_type* __dest) const; - - virtual char - do_narrow(char_type, char __dfault) const; - - virtual const char_type* - do_narrow(const char_type* __low, const char_type* __high, - char __dfault, char* __dest) const; - }; - - template<> - const ctype& - use_facet >(const locale& __loc); - -#ifdef _GLIBCPP_USE_WCHAR_T - // ctype specialization - template<> - class ctype : public _Ctype - { - public: - // Types: - typedef wchar_t char_type; - typedef ctype::mask mask; - typedef wctype_t __wmask_type; - - // Data Members: - static locale::id id; - - explicit - ctype(size_t __refs = 0); - - protected: - __wmask_type - _M_convert_to_wmask(const mask __m) const - { - __wmask_type __ret; - switch (__m) - { - case space: - __ret = wctype("space"); - break; - case print: - __ret = wctype("print"); - break; - case cntrl: - __ret = wctype("cntrl"); - break; - case upper: - __ret = wctype("upper"); - break; - case lower: - __ret = wctype("lower"); - break; - case alpha: - __ret = wctype("alpha"); - break; - case digit: - __ret = wctype("digit"); - break; - case punct: - __ret = wctype("punct"); - break; - case xdigit: - __ret = wctype("xdigit"); - break; - case alnum: - __ret = wctype("alnum"); - break; - case graph: - __ret = wctype("graph"); - break; - default: - __ret = 0; - } - return __ret; - }; - - virtual - ~ctype(); - - virtual bool - do_is(mask __m, char_type __c) const; - - virtual const char_type* - do_is(const char_type* __lo, const char_type* __hi, - mask* __vec) const; - - virtual const char_type* - do_scan_is(mask __m, const char_type* __lo, - const char_type* __hi) const; - - virtual const char_type* - do_scan_not(mask __m, const char_type* __lo, - const char_type* __hi) const; - - virtual char_type - do_toupper(char_type) const; - - virtual const char_type* - do_toupper(char_type* __low, const char_type* __high) const; - - virtual char_type - do_tolower(char_type) const; - - virtual const char_type* - do_tolower(char_type* __low, const char_type* __high) const; - - virtual char_type - do_widen(char) const; - - virtual const char* - do_widen(const char* __low, const char* __high, - char_type* __dest) const; - - virtual char - do_narrow(char_type, char __dfault) const; - - virtual const char_type* - do_narrow(const char_type* __low, const char_type* __high, - char __dfault, char* __dest) const; - - }; - - template<> - const ctype& - use_facet< const ctype >(const locale& __loc); -#endif //_GLIBCPP_USE_WCHAR_T - - // Include host-specific ctype specializations. - #include - - // 22.2.1.2 Template class ctype_byname - template - class ctype_byname : public ctype<_CharT> - { - public: - typedef _CharT char_type; - - explicit - ctype_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~ctype_byname() { } - }; - - // 22.2.1.4 Class ctype_byname specializations - template<> - ctype_byname::ctype_byname(const char*, size_t refs); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - ctype_byname::ctype_byname(const char*, size_t refs); -#endif - - - template - class _Numeric_get; // forward - - // _Format_cache holds the information extracted from the numpunct<> - // and moneypunct<> facets in a form optimized for parsing and - // formatting. It is stored via a void* pointer in the pword() - // array of an iosbase object passed to the _get and _put facets. - // NB: contains no user-serviceable parts. - template - class _Format_cache - { - public: - // Types: - typedef _CharT char_type; - typedef char_traits<_CharT> traits_type; - typedef basic_string<_CharT> string_type; - typedef typename string_type::size_type size_type; - - // Forward decls and Friends: - friend class locale; - template - friend class _Numeric_get; - friend class num_get<_CharT>; - friend class num_put<_CharT>; - friend class time_get<_CharT>; - friend class money_get<_CharT>; - friend class time_put<_CharT>; - friend class money_put<_CharT>; - - // Data Members: - - // ios_base::pword() reserved cell - static int _S_pword_ix; - - // True iff data members are consistent with the current locale, - // ie imbue sets this to false. - bool _M_valid; - - // A list of valid numeric literals: for the standard "C" locale, - // this would usually be: "-+xX0123456789abcdef0123456789ABCDEF" - static const char _S_literals[]; - - // NB: Code depends on the order of definitions of the names - // these are indices into _S_literals, above. - // This string is formatted for putting, not getting. (output, not input) - 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_ee = _S_digits + 14, // For scientific notation, 'E' - _S_Ee = _S_udigits + 14 // For scientific notation, 'e' - }; - - // The sign used to separate decimal values: for standard US - // locales, this would usually be: "." - // Abstracted from numpunct::decimal_point(). - char_type _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(). - char_type _M_thousands_sep; - - // However the US's "false" and "true" are translated. - // From numpunct::truename() and numpunct::falsename(), respectively. - string_type _M_truename; - string_type _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()). - string _M_grouping; - - _Format_cache(); - - ~_Format_cache() throw() { } - - // Given a member of the ios heirarchy as an argument, extract - // out all the current formatting information into a - // _Format_cache object and return a pointer to it. - static _Format_cache<_CharT>* - _S_get(ios_base& __ios); - - void - _M_populate(ios_base&); - - static void - _S_callback(ios_base::event __event, ios_base& __ios, int __ix) throw(); - }; - - template<> _Format_cache::_Format_cache(); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> _Format_cache::_Format_cache(); -#endif - - // _Numeric_get is used by num_get, money_get, and time_get to help - // in parsing out numbers. - template - class _Numeric_get - { - public: - // Types: - typedef _CharT char_type; - typedef _InIter iter_type; - - // Forward decls and Friends: - template - friend class num_get; - template - friend class time_get; - template - friend class money_get; - template - friend class num_put; - template - friend class time_put; - template - friend class money_put; - - private: - explicit - _Numeric_get() { } - - virtual - ~_Numeric_get() { } - - iter_type - _M_get_digits(iter_type __in, iter_type __end) const; - }; - - template - class num_get : public locale::facet - { - public: - // Types: - typedef _CharT char_type; - typedef _InIter iter_type; - typedef char_traits<_CharT> __traits_type; - - static locale::id id; - - explicit - num_get(size_t __refs = 0) : locale::facet(__refs) { } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, bool& __v) const - { return do_get(__in, __end, __io, __err, __v); } - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, short& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, int& __v) const - { return do_get(__in, __end, __io, __err, __v); } -#endif - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long& __v) const - { return do_get(__in, __end, __io, __err, __v); } - -#ifdef _GLIBCPP_USE_LONG_LONG - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long long& __v) const - { return do_get(__in, __end, __io, __err, __v); } -#endif - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned short& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned int& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long& __v) const - { return do_get(__in, __end, __io, __err, __v); } - -#ifdef _GLIBCPP_USE_LONG_LONG - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long long& __v) const - { return do_get(__in, __end, __io, __err, __v); } -#endif - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, float& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, double& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long double& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, void*& __v) const - { return do_get(__in, __end, __io, __err, __v); } - - protected: - virtual ~num_get() { } - - // This consolidates the extraction, storage and - // error-processing parts of the do_get(...) overloaded member - // functions. - // NB: This is specialized for char. - void - _M_extract(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, char* __xtrc, - int& __base, bool __fp = true) const; - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, short&) const; - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, int&) const; -#endif - virtual iter_type - do_get (iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const; -#ifdef _GLIBCPP_USE_LONG_LONG - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, - long long&) const; -#endif - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, - unsigned short&) const; - virtual iter_type - do_get(iter_type, iter_type, ios_base&, - ios_base::iostate& __err, unsigned int&) const; - virtual iter_type - do_get(iter_type, iter_type, ios_base&, - ios_base::iostate& __err, unsigned long&) const; -#ifdef _GLIBCPP_USE_LONG_LONG - virtual iter_type - do_get(iter_type, iter_type, ios_base&, - ios_base::iostate& __err, unsigned long long&) const; -#endif - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, - float&) const; - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, - double&) const; - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, - ios_base::iostate& __err, long double&) const; - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, - void*&) const; - }; - - // Declare specialized extraction member function. - template<> - void - num_get >:: - _M_extract(istreambuf_iterator __beg, - istreambuf_iterator __end, ios_base& __io, - ios_base::iostate& __err, char* __xtrc, - int& __base, bool __fp) const; - - // _Numeric_put is used by num_put, money_put, and time_put - // to help in formatting out numbers. - template - class _Numeric_put - { - public: - typedef _CharT char_type; - typedef _OutIter iter_type; - protected: - explicit - _Numeric_put() { } - - virtual - ~_Numeric_put() { } - }; - - template - class num_put : public locale::facet - { - public: - // Types: - typedef _CharT char_type; - typedef _OutIter iter_type; - - static locale::id id; - - explicit - num_put(size_t __refs = 0) : locale::facet(__refs) { } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const - { return do_put(__s, __f, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, long __v) const - { return do_put(__s, __f, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, - unsigned long __v) const - { return do_put(__s, __f, __fill, __v); } - -#ifdef _GLIBCPP_USE_LONG_LONG - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const - { return do_put(__s, __f, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, - unsigned long long __v) const - { return do_put(__s, __f, __fill, __v); } -#endif - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, double __v) const - { return do_put(__s, __f, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, - long double __v) const - { return do_put(__s, __f, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, - const void* __v) const - { return do_put(__s, __f, __fill, __v); } - - protected: - virtual - ~num_put() { }; - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, bool __v) const; - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, long __v) const; - -#ifdef _GLIBCPP_USE_LONG_LONG - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, long long __v) const; -#endif - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, unsigned long) const; - -#ifdef _GLIBCPP_USE_LONG_LONG - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const; -#endif - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, double __v) const; - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, long double __v) const; - - virtual iter_type - do_put(iter_type, ios_base&, char_type __fill, const void* __v) const; - }; - - template - class _Punct : public locale::facet - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - char_type - decimal_point() const - { return do_decimal_point(); } - - char_type - thousands_sep() const - { return do_thousands_sep(); } - - string - grouping() const - { return do_grouping(); } - protected: - - explicit - _Punct(size_t __refs = 0) : locale::facet(__refs) { } - - virtual - ~_Punct() { } - - virtual char_type - do_decimal_point() const - { return _M_decimal_point; } - - virtual char_type - do_thousands_sep() const - { return _M_thousands_sep; } - - virtual string - do_grouping() const - { return _M_grouping; } - - private: - char_type _M_decimal_point; - char_type _M_thousands_sep; - string _M_grouping; - - protected: - // for use at construction time only: - void - _M_init(char_type __d, char_type __t, const string& __g) - { - _M_decimal_point = __d; - _M_thousands_sep = __t; - _M_grouping = __g; - } - - }; - - template - class _Numpunct : public _Punct<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - string_type - truename() const - { return do_truename(); } - - string_type - falsename() const - { return do_falsename(); } - - protected: - explicit - _Numpunct(size_t __refs = 0) : _Punct<_CharT> (__refs) { } - - virtual - ~_Numpunct() { } - - virtual string_type - do_truename() const - { return _M_truename; } - - virtual string_type - do_falsename() const - { return _M_falsename; } - - private: - string_type _M_truename; - string_type _M_falsename; - - protected: - // For use only during construction - void - _M_boolnames_init(const string_type& __t, const string_type& __f) - { - _M_truename = __t; - _M_falsename = __f; - } - - }; - - template - class numpunct : public _Numpunct<_CharT> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - static locale::id id; - - explicit - numpunct(size_t __refs = 0) : _Numpunct<_CharT>(__refs) { } - protected: - - virtual - ~numpunct() { } - }; - - template<> - numpunct::numpunct(size_t __refs): _Numpunct(__refs) - { - _M_init('.', ',', ""); - _M_boolnames_init("true", "false"); - } - -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - numpunct::numpunct(size_t __refs): _Numpunct(__refs) - { - _M_init(L'.', L',', ""); - _M_boolnames_init(L"true", L"false"); - } -#endif - - template - class numpunct_byname : public numpunct<_CharT> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - explicit - numpunct_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~numpunct_byname() { } - }; - - template<> - numpunct_byname::numpunct_byname(const char*, size_t __refs); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - numpunct_byname::numpunct_byname(const char*, size_t __refs); -#endif - - template - class _Collate : public locale::facet - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - int - compare(const _CharT* __lo1, const _CharT* __hi1, - const _CharT* __lo2, const _CharT* __hi2) const - { return do_compare(__lo1, __hi1, __lo2, __hi2); } - - string_type - transform(const _CharT* __lo, const _CharT* __hi) const - { return do_transform(__lo, __hi); } - - long - hash(const _CharT* __lo, const _CharT* __hi) const - { return do_hash(__lo, __hi); } - - protected: - explicit - _Collate(size_t __refs = 0) : locale::facet(__refs) { } - - ~_Collate() { } // virtual - - virtual int - do_compare(const _CharT* __lo1, const _CharT* __hi1, - const _CharT* __lo2, const _CharT* __hi2) const = 0; - - virtual string_type - do_transform(const _CharT* __lo, const _CharT* __hi) const = 0; - - virtual long - do_hash(const _CharT* __lo, const _CharT* __hi) const = 0; - }; - - template - class collate : public _Collate<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - explicit - collate(size_t __refs = 0) : _Collate<_CharT> (__refs) { } - - static locale::id id; - - protected: - virtual - ~collate() { } - }; - - template<> - class collate : public _Collate - { - public: - // Types: - typedef char char_type; - typedef basic_string string_type; - - explicit - collate(size_t __refs = 0); - - static locale::id id; - - protected: - virtual - ~collate(); - - virtual int - do_compare(const char* __lo1, const char* __hi1, - const char* __lo2, const char* __hi2) const; - - virtual string_type - do_transform(const char* __lo, const char* __hi) const; - - virtual long - do_hash(const char* __lo, const char* __hi) const; - }; - -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - class collate : public _Collate - { - public: - // Types: - typedef wchar_t char_type; - typedef basic_string string_type; - - explicit - collate(size_t __refs = 0); - - static locale::id id; - - protected: - virtual - ~collate(); - - virtual int - do_compare(const wchar_t* __lo1, const wchar_t* __hi1, - const wchar_t* __lo2, const wchar_t* __hi2) const; - - virtual string_type - do_transform(const wchar_t* __lo, const wchar_t* __hi) const; - - virtual long - do_hash(const wchar_t* __lo, const wchar_t* __hi) const; - }; -#endif - - template - class collate_byname : public collate<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - explicit - collate_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~collate_byname() { } - }; - - template<> - collate_byname::collate_byname(const char*, size_t __refs); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - collate_byname::collate_byname(const char*, size_t __refs); -#endif - - class time_base - { - public: - enum dateorder { no_order, dmy, mdy, ymd, ydm }; - }; - - template - class time_get : public locale::facet, public time_base - { - public: - // Types: - typedef _CharT char_type; - typedef _InIter iter_type; - - static locale::id id; - - explicit - time_get(size_t __refs = 0) - : locale::facet (__refs), _M_daynames(0), _M_monthnames(0) { } - - dateorder - date_order() const - { return do_date_order(); } - - iter_type - get_time(iter_type __s, iter_type __end, ios_base& __f, - ios_base::iostate& __err, tm* __t) const - { return do_get_time(__s, __end, __f, __err, __t); } - - iter_type - get_date(iter_type __s, iter_type __end, ios_base& __f, - ios_base::iostate& __err, tm* __t) const - { return do_get_date(__s, __end, __f, __err, __t); } - - iter_type - get_weekday(iter_type __s, iter_type __end, ios_base& __f, - ios_base::iostate& __err, tm* __t) const - { return do_get_weekday(__s,__end,__f,__err,__t); } - - iter_type - get_monthname(iter_type __s, iter_type __end, ios_base& __f, - ios_base::iostate& __err, tm* __t) const - { return do_get_monthname(__s,__end,__f,__err,__t); } - - iter_type - get_year(iter_type __s, iter_type __end, ios_base& __f, - ios_base::iostate& __err, tm* __t) const - { return do_get_year(__s,__end,__f,__err,__t); } - - protected: - virtual - ~time_get() - { - delete [] _M_monthnames; - delete [] _M_daynames; - } - - virtual dateorder - do_date_order() const - { return time_base::ymd; } - - virtual iter_type - do_get_time(iter_type __s, iter_type /*__end*/, ios_base&, - ios_base::iostate& /*__err*/, tm* /*__t*/) const - { return __s; } - - virtual iter_type - do_get_date(iter_type __s, iter_type /*__end*/, ios_base&, - ios_base::iostate& /*__err*/, tm* /*__t*/) const - { return __s; } - - virtual iter_type - do_get_weekday(iter_type __s, iter_type __end, ios_base&, - ios_base::iostate& __err, tm* __t) const; - - virtual iter_type - do_get_monthname(iter_type __s, iter_type __end, ios_base&, - ios_base::iostate& __err, tm* __t) const; - - virtual iter_type - do_get_year(iter_type __s, iter_type /*__end*/, ios_base&, - ios_base::iostate& /*__err*/, tm* /*__t*/) const - { return __s; } - - mutable basic_string<_CharT>* _M_daynames; - mutable basic_string<_CharT>* _M_monthnames; - }; - - template - class time_get_byname : public time_get<_CharT, _InIter> - { - public: - typedef _CharT char_type; - typedef _InIter iter_type; - - explicit - time_get_byname(const char*, size_t __refs = 0) - : time_get<_CharT, _InIter>(__refs) { } - protected: - virtual - ~time_get_byname() { } - }; - - template - class time_put : public locale::facet, public time_base - { - public: - typedef _CharT char_type; - typedef _OutIter iter_type; - - static locale::id id; - - explicit - time_put(size_t __refs = 0) : locale::facet (__refs) { } - - // NB: this is a nonvirtual, calls do_put in a loop. - iter_type - put(iter_type __s, ios_base& /*__f*/, char_type /*__fill*/, - const tm* /*__tmb*/, const _CharT* /*__pattern*/, - const _CharT* /*__pat_end*/) const - { return __s; } - - iter_type - put(iter_type __s, ios_base& __f, char_type __fill, - const tm* __tmb, char __format, char __modifier = 0) const - { return do_put(__s, __f, __fill, __tmb, __format, __modifier); } - - protected: - virtual - ~time_put() { } - - virtual iter_type - do_put(iter_type __s, ios_base&, char_type, const tm* /*__t*/, - char /*__format*/, char /*__mod*/) const - { return __s; } - }; - - template - class time_put_byname : public time_put<_CharT, _OutIter> - { - public: - typedef _CharT char_type; - typedef _OutIter iter_type; - - explicit - time_put_byname(const char*, size_t __refs = 0) - : time_put<_CharT, _OutIter> (__refs) { } - - protected: - virtual - ~time_put_byname() { } - }; - - - template - class money_get : public locale::facet - { - public: - typedef _CharT char_type; - typedef _InIter iter_type; - typedef basic_string<_CharT> string_type; - - static locale::id id; - - explicit - money_get(size_t __refs = 0) : locale::facet(__refs) { } - - iter_type - get(iter_type __s, iter_type __end, bool __intl, - ios_base& __f, ios_base::iostate& __err, long double& __units) const - { return do_get(__s, __end, __intl, __f, __err, __units); } - - iter_type - get(iter_type __s, iter_type __end, bool __intl, ios_base& __f, - ios_base::iostate& __err, string_type& __digits) const - { return do_get(__s, __end, __intl, __f, __err, __digits); } - - protected: - virtual - ~money_get() { } - - virtual iter_type - do_get(iter_type __s, iter_type /*__end*/, bool /*__intl*/, - ios_base& /*__io*/, ios_base::iostate& /*__err*/, - long double& /*__units*/) const - { return __s; } - - virtual iter_type - do_get(iter_type __s, iter_type /*__end*/, bool /*__intl*/, - ios_base& /*__io*/, ios_base::iostate& /*__err*/, - string_type& /*__digits*/) const - { return __s; } - }; - - template - class money_put : public locale::facet - { - public: - typedef _CharT char_type; - typedef _OutIter iter_type; - typedef basic_string<_CharT> string_type; - - static locale::id id; - - explicit - money_put(size_t __refs = 0) : locale::facet(__refs) { } - - iter_type - put(iter_type __s, bool __intl, ios_base& __f, - char_type __fill, long double __units) const - { return do_put(__s, __intl, __f, __fill, __units); } - - iter_type - put(iter_type __s, bool __intl, ios_base& __f, - char_type __fill, const string_type& __digits) const - { return do_put(__s, __intl, __f, __fill, __digits); } - - protected: - virtual - ~money_put() { } - - virtual iter_type - do_put(iter_type __s, bool, ios_base& /*__io*/, char_type /*__fill*/, - long double /*__units*/) const - { return __s; } - - virtual iter_type - do_put(iter_type __s, bool, ios_base& /*__io*/, char_type /*__fill*/, - const string_type& /*__digits*/) const - { return __s; } - }; - - struct money_base - { - enum part { none, space, symbol, sign, value }; - struct pattern { char field[4]; }; - - static const pattern _S_default_pattern; - }; - - template - class _Moneypunct : public _Punct<_CharT>, public money_base - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - string_type - curr_symbol() const - { return do_curr_symbol(); } - - string_type - positive_sign() const - { return do_positive_sign(); } - - string_type - negative_sign() const - { return do_negative_sign(); } - - int - frac_digits() const - { return do_frac_digits(); } - - pattern - pos_format() const - { return do_pos_format(); } - - pattern - neg_format() const - { return do_neg_format(); } - - protected: - explicit - _Moneypunct(size_t __refs = 0) : _Punct<_CharT> (__refs) { } - - virtual - ~_Moneypunct() { } - - virtual string_type - do_curr_symbol() const - { return basic_string<_CharT>(); } - - virtual string_type - do_positive_sign() const - { return basic_string<_CharT>(); } - - virtual string_type - do_negative_sign() const - { return basic_string<_CharT>(); } - - virtual int - do_frac_digits() const - { return 0; } - - virtual pattern - do_pos_format() const - { return money_base::_S_default_pattern; } - - virtual pattern - do_neg_format() const - { return money_base::_S_default_pattern; } - }; - - template - class moneypunct : public _Moneypunct<_CharT> - { - public: - // Types: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - static const bool intl = _Intl; - static locale::id id; - - explicit - moneypunct(size_t __refs = 0) : _Moneypunct<_CharT> (__refs) { } - - protected: - virtual - ~moneypunct() { } - }; - - template - class moneypunct_byname : public moneypunct<_CharT,_Intl> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - static const bool intl = _Intl; - - explicit - moneypunct_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~moneypunct_byname() { } - }; - - template<> - moneypunct_byname:: - moneypunct_byname(const char*, size_t __refs); - template<> - moneypunct_byname:: - moneypunct_byname(const char*, size_t __refs); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - moneypunct_byname:: - moneypunct_byname(const char*, size_t __refs); - template<> - moneypunct_byname:: - moneypunct_byname (const char*, size_t __refs); -#endif - - struct messages_base - { - typedef int catalog; - }; - - template - class _Messages : public locale::facet, public messages_base - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - catalog - open(const basic_string& __s, const locale& __loc) const - { return do_open(__s, __loc); } - - string_type - get(catalog __c, int __set, int __msgid, const string_type& __s) const - { return do_get(__c,__set,__msgid,__s); } - - void - close(catalog __c) const - { return do_close(__c); } - - protected: - explicit - _Messages(size_t __refs = 0) : locale::facet(__refs) { } - - virtual - ~_Messages() { } - - // NB: Probably these should be pure, and implemented only in - // specializations of messages<>. But for now... - virtual catalog - do_open(const basic_string&, const locale&) const - { return 0; } - - virtual string_type - do_get(catalog, int, int /*__msgid*/, const string_type& __dfault) const - { return __dfault; } - - virtual void - do_close (catalog) const { } - }; - - template - class messages : public _Messages<_CharT> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - static locale::id id; - - explicit - messages(size_t __refs = 0) : _Messages<_CharT> (__refs) { } - protected: - virtual - ~messages() { } - }; - - template - class messages_byname : public messages<_CharT> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - explicit - messages_byname(const char*, size_t __refs = 0); - - protected: - virtual - ~messages_byname() { } - }; - - template<> - messages_byname::messages_byname(const char*, size_t __refs); -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - messages_byname::messages_byname(const char*, size_t __refs); -#endif - - // Subclause convenience interfaces, inlines - // NB: these are inline - // because, when used in a loop, some compilers can hoist the body - // out of the loop; then it's just as fast as the C is*() function. - template - inline bool - isspace(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::space, __c); } - - template - inline bool - isprint(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::print, __c); } - - template - inline bool - iscntrl(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::cntrl, __c); } - - template - inline bool - isupper(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::upper, __c); } - - template - inline bool islower(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::lower, __c); } - - template - inline bool - isalpha(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::alpha, __c); } - - template - inline bool - isdigit(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::digit, __c); } - - template - inline bool - ispunct(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::punct, __c); } - - template - inline bool - isxdigit(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::xdigit, __c); } - - template - inline bool - isalnum(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::alnum, __c); } - - template - inline bool - isgraph(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::graph, __c); } - - template - inline _CharT - toupper(_CharT __c, const locale& __loc) - { return use_facet >(__loc).toupper(__c); } - - template - inline _CharT - tolower(_CharT __c, const locale& __loc) - { return use_facet >(__loc).tolower(__c); } - -} // namespace std - -#endif /* _CPP_BITS_LOCFACETS_H */ - -// Local Variables: -// mode:c++ -// End: - diff --git a/libstdc++-v3/bits/locale_facets.tcc b/libstdc++-v3/bits/locale_facets.tcc deleted file mode 100644 index 594e6047a31..00000000000 --- a/libstdc++-v3/bits/locale_facets.tcc +++ /dev/null @@ -1,1277 +0,0 @@ -// Locale support -*- C++ -*- - -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Warning: this file is not meant for user inclusion. Use . - -#ifndef _CPP_BITS_LOCFACETS_TCC -#define _CPP_BITS_LOCFACETS_TCC 1 - -#include -#include // For strof, strtold -#include // For numeric_limits -#include // For auto_ptr -#include // For streambuf_iterators -#include // For isspace -#include - -namespace std -{ - template - locale - locale::combine(const locale& __other) - { - locale __copy(*this); - __copy._M_impl->_M_replace_facet(__other._M_impl, &_Facet::id); - __copy._M_impl->_M_has_name = false; - return __copy; - } - - template - bool - locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, - const basic_string<_CharT, _Traits, _Alloc>& __s2) const - { - // XXX should not need to qualify here. - // typedef collate<_CharT> __collate_type; - typedef std::collate<_CharT> __collate_type; - const __collate_type* __fcoll = &use_facet<__collate_type>(*this); - return (__fcoll->compare(__s1.data(), __s1.data() + __s1.length(), - __s2.data(), __s2.data() + __s2.length()) < 0); - } - - template - const _Facet& - use_facet(const locale& __loc) - { - typedef locale::_Impl::__vec_facet __vec_facet; - const locale::facet* __fp = (const _Facet*)0; // check derivation - locale::id& __id = _Facet::id; // check member id - size_t __i = __id._M_index; - __vec_facet* __facet = __loc._M_impl->_M_facets; - if (__i >= __facet->size() || (__fp = (*(__facet))[__i]) == 0) - return _Use_facet_failure_handler<_Facet>(__loc); - return static_cast(*__fp); - } - - template - bool - has_facet(const locale& __loc) throw() - { - typedef locale::_Impl::__vec_facet __vec_facet; - locale::id& __id = _Facet::id; // check member id - size_t __i = __id._M_index; - __vec_facet* __facet = __loc._M_impl->_M_facets; - return (__i < __facet->size() && (*__facet)[__i] != 0); - } - - // __match_parallel - // matches input __s against a set of __ntargs strings in __targets, - // placing in __matches a vector of indices into __targets which - // match, and in __remain the number of such matches. If it hits - // end of sequence before it minimizes the set, sets __eof. - // Empty strings are never matched. - template - _InIter - __match_parallel(_InIter __s, _InIter __end, int __ntargs, - const basic_string<_CharT>* __targets, - int* __matches, int& __remain, bool& __eof) - { - typedef basic_string<_CharT> __string_type; - __eof = false; - for (int __ti = 0; __ti < __ntargs; ++__ti) - __matches[__ti] = __ti; - __remain = __ntargs; - size_t __pos = 0; - do - { - { - int __ti = 0; - for (;__ti < __remain && - __pos == __targets[__matches[__ti]].size(); ++__ti) - { } - if (__ti == __remain) - { - if (__pos == 0) __remain = 0; - return __s; - } - } - if (__s == __end) - __eof = true; - bool __matched = false; - for (int __ti = 0; __ti < __remain; ) - { - const __string_type& __target = __targets[__matches[__ti]]; - if (__pos < __target.size()) - { - if (__eof || __target[__pos] != *__s) - { - __matches[__ti] = __matches[--__remain]; - continue; - } - __matched = true; - } - ++__ti; - } - if (__matched) - { - ++__s; - ++__pos; - } - for (int __ti = 0; __ti < __remain;) - { - if (__pos > __targets[__matches[__ti]].size()) - { - __matches[__ti] = __matches[--__remain]; - continue; - } - ++__ti; - } - } - while (__remain); - return __s; - } - - template - locale::id ctype<_CharT>::id; - - template - int _Format_cache<_CharT>::_S_pword_ix; - - template - const char _Format_cache<_CharT>:: - _S_literals[] = "-+xX0123456789abcdef0123456789ABCDEF"; - - template - _Format_cache<_CharT>::_Format_cache() - : _M_valid(true), _M_use_grouping(false) - { } - - template<> - _Format_cache::_Format_cache(); - - template<> - _Format_cache::_Format_cache(); - - template - void - _Format_cache<_CharT>::_M_populate(ios_base& __io) - { - locale __loc = __io.getloc (); - numpunct<_CharT> const& __np = use_facet >(__loc); - _M_truename = __np.truename(); - _M_falsename = __np.falsename(); - _M_thousands_sep = __np.thousands_sep(); - _M_decimal_point = __np.decimal_point(); - _M_grouping = __np.grouping(); - _M_use_grouping = _M_grouping.size() != 0 && _M_grouping.data()[0] != 0; - _M_valid = true; - } - - // This function is always called via a pointer installed in - // an ios_base by ios_base::register_callback. - template - void - _Format_cache<_CharT>:: - _S_callback(ios_base::event __ev, ios_base& __ios, int __ix) throw() - { - void*& __p = __ios.pword(__ix); - switch (__ev) - { - case ios_base::erase_event: - delete static_cast<_Format_cache<_CharT>*> (__p); __p = 0; - break; - case ios_base::copyfmt_event: - // If just stored zero, the callback would get registered again. - try { - __p = new _Format_cache<_CharT>; - } - catch(...) { - } - break; - case ios_base::imbue_event: - static_cast<_Format_cache<_CharT>*>(__p)->_M_valid = false; - break; - } - } - - template - _Format_cache<_CharT>* - _Format_cache<_CharT>::_S_get(ios_base& __ios) - { - if (!_S_pword_ix) - _S_pword_ix = ios_base::xalloc(); // XXX MT - void*& __p = __ios.pword(_S_pword_ix); - - // XXX What if pword fails? must check failbit, throw. - if (__p == 0) // XXX MT? maybe sentry takes care of it - { - auto_ptr<_Format_cache<_CharT> > __ap(new _Format_cache<_CharT>); - __ios.register_callback(&_Format_cache<_CharT>::_S_callback, - _S_pword_ix); - __p = __ap.release(); - } - _Format_cache<_CharT>* __ncp = static_cast<_Format_cache<_CharT>*>(__p); - if (!__ncp->_M_valid) - __ncp->_M_populate(__ios); - - return __ncp; - } - - template - locale::id num_get<_CharT, _InIter>::id; - - // This member function takes an (w)istreambuf_iterator object and - // parses it into a generic char array suitable for parsing with - // strto[l,ll,f,d]. The thought was to encapsulate the conversion - // into this one function, and thus the num_get::do_get member - // functions can just adjust for the type of the overloaded - // argument and process the char array returned from _M_extract. - // Other things were also considered, including a fused - // multiply-add loop that would obviate the need for any call to - // strto... at all: however, it would b e a bit of a pain, because - // you'd have to be able to return either floating or integral - // types, etc etc. The current approach seems to be smack dab in - // the middle between an unoptimized approach using sscanf, and - // some kind of hyper-optimized approach alluded to above. - - // XXX - // Need to do partial specialization to account for differences - // between character sets. For char, this is pretty - // straightforward, but for wchar_t, the conversion to a plain-jane - // char type is a bit more involved. - template - void - num_get<_CharT, _InIter>:: - _M_extract(_InIter /*__beg*/, _InIter /*__end*/, ios_base& /*__io*/, - ios_base::iostate& /*__err*/, char* /*__xtrc*/, - int& /*__base*/, bool /*__fp*/) const - { - // XXX Not currently done: need to expand upon char version below. - } - - template<> - void - num_get >:: - _M_extract(istreambuf_iterator __beg, - istreambuf_iterator __end, ios_base& __io, - ios_base::iostate& __err, char* __xtrc, int& __base, - bool __fp) const; - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // NB: This is an unresolved library defect #17 - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, bool& __v) const - { - // Parse bool values as long - if (!(__io.flags() & ios_base::boolalpha)) - { - // NB: We can't just call do_get(long) here, as it might - // refer to a derived class. - - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32] = {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long __l = strtol(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __l <= 1 - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __l; - else - __err |= ios_base::failbit; - } - - // Parse bool values as alphanumeric - else - { - typedef _Format_cache __fcache_type; - __fcache_type* __fmt = __fcache_type::_S_get(__io); - const char_type* __true = __fmt->_M_truename.c_str(); - const char_type* __false = __fmt->_M_falsename.c_str(); - const size_t __truelen = __traits_type::length(__true) - 1; - const size_t __falselen = __traits_type::length(__false) - 1; - - for (size_t __pos = 0; __beg != __end; ++__pos) - { - char_type __c = *__beg++; - bool __testf = __c == __false[__pos]; - bool __testt = __c == __true[__pos]; - if (!(__testf || __testt)) - { - __err |= ios_base::failbit; - break; - } - else if (__testf && __pos == __falselen) - { - __v = 0; - break; - } - else if (__testt && __pos == __truelen) - { - __v = 1; - break; - } - } - if (__beg == __end) - __err |= ios_base::eofbit; - } - - return __beg; - } -#endif - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, short& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long __l = strtol(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0 - && __l >= SHRT_MIN && __l <= SHRT_MAX) - __v = static_cast(__l); - else - __err |= ios_base::failbit; - - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, int& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32] = {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long __l = strtol(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0 - && __l >= INT_MIN && __l <= INT_MAX) - __v = static_cast(__l); - else - __err |= ios_base::failbit; - - return __beg; - } -#endif - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long __l = strtol(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __l; - else - __err |= ios_base::failbit; - - return __beg; - } - -#ifdef _GLIBCPP_USE_LONG_LONG - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long long& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long long __ll = strtoll(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __ll; - else - __err |= ios_base::failbit; - - return __beg; - } -#endif - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned short& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - unsigned long __ul = strtoul(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0 - && __ul <= USHRT_MAX) - __v = static_cast(__ul); - else - __err |= ios_base::failbit; - - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned int& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - unsigned long __ul = strtoul(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0 - && __ul <= UINT_MAX) - __v = static_cast(__ul); - else - __err |= ios_base::failbit; - - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32] = {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - unsigned long __ul = strtoul(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __ul; - else - __err |= ios_base::failbit; - - return __beg; - } - -#ifdef _GLIBCPP_USE_LONG_LONG - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long long& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - unsigned long long __ull = strtoull(__xtrc, &__sanity, __base); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __ull; - else - __err |= ios_base::failbit; - - return __beg; - } -#endif - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, float& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 256 for - // floating-point types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, true); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; -#ifdef _GLIBCPP_HAVE_STRTOF - float __f = strtof(__xtrc, &__sanity); -#else - float __f = static_cast(strtod(__xtrc, &__sanity)); -#endif - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __f; - else - __err |= ios_base::failbit; - - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, double& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 256 for - // floating-point types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, true); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - double __d = strtod(__xtrc, &__sanity); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __d; - else - __err |= ios_base::failbit; - - return __beg; - } - -#if defined(_GLIBCPP_HAVE_STRTOLD) && !defined(__hpux) - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long double& __v) const - { - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 256 for - // floating-point types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, true); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - long double __ld = strtold(__xtrc, &__sanity); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __ld; - else - __err |= ios_base::failbit; - - return __beg; - } -#else - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long double& __v) const - { - // Stage 1: extract - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, true); - - // Stage 2: determine a conversion specifier. - ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield; - const char* __conv; - if (__basefield == ios_base::oct) - __conv = "%Lo"; - else if (__basefield == ios_base::hex) - __conv = "%LX"; - else if (__basefield == 0) - __conv = "%Li"; - else - __conv = "%Lg"; - - // Stage 3: store results. - long double __ld; - int __p = sscanf(__xtrc, __conv, &__ld); - if (__p - && static_cast<__traits_type::int_type>(__p) != __traits_type::eof()) - __v = __ld; - else - __err |= ios_base::failbit; - - return __beg; - } -#endif - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, void*& __v) const - { - // Prepare for hex formatted input - typedef ios_base::fmtflags fmtflags; - fmtflags __fmt = __io.flags(); - fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield - | ios_base::uppercase | ios_base::internal); - __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase)); - - // Stage 1: extract and determine the conversion specifier. - // Assuming leading zeros eliminated, thus the size of 32 for - // integral types. - char __xtrc[32]= {'\0'}; - int __base; - _M_extract(__beg, __end, __io, __err, __xtrc, __base, false); - - // Stage 2: convert and store results. - char* __sanity; - errno = 0; - void* __vp = reinterpret_cast(strtoul(__xtrc, &__sanity, __base)); - if (!(__err & ios_base::failbit) - && __sanity != __xtrc && *__sanity == '\0' && errno == 0) - __v = __vp; - else - __err |= ios_base::failbit; - - // Reset from hex formatted input - __io.flags(__fmt); - return __beg; - } - - template - locale::id num_put<_CharT, _OutIter>::id; - - // _S_fill is specialized for ostreambuf_iterator, random access iterator. - template - inline _OutIter - _S_fill(_OutIter __s, _CharT __fill, int __padding); - - template - _RaIter - _S_fill(_RaIter __s, _CharT __fill, int __padding, - random_access_iterator_tag) - { - fill_n(__s, __fill); - return __s + __padding; - } - - template - _OutIter - _S_fill(_OutIter __s, _CharT __fill, int __padding, _Tag) - { - while (--__padding >= 0) { *__s = __fill; ++__s; } - return __s; - } - - template - inline _OutIter - _S_fill(_OutIter __s, _CharT __fill, int __padding) - { - return _S_fill(__s, __fill, __padding, - iterator_traits<_OutIter>::iterator_category()); - } - - template - _OutIter - _S_pad_numeric(_OutIter __s, ios_base::fmtflags /*__flags*/, - _CharT /*__fill*/, int /*__width*/, - _CharT const* /*__first*/, _CharT const* /*__middle*/, - _CharT const* /*__last*/) - { - // XXX Not currently done: non streambuf_iterator - return __s; - } - - // Partial specialization for ostreambuf_iterator. - template - ostreambuf_iterator<_CharT> - _S_pad_numeric(ostreambuf_iterator<_CharT> __s, ios_base::fmtflags __flags, - _CharT __fill, int __width, _CharT const* __first, - _CharT const* __middle, _CharT const* __last) - { - typedef ostreambuf_iterator<_CharT> __out_iter; - int __padding = __width - (__last - __first); - if (__padding < 0) - __padding = 0; - ios_base::fmtflags __aflags = __flags & ios_base::adjustfield; - bool __testfield = __padding == 0 || __aflags == ios_base::left - || __aflags == ios_base::internal; - - // This was needlessly complicated. - if (__first != __middle) - { - if (!__testfield) - { - _S_fill(__s, __fill, __padding); - __padding = 0; - } - copy(__first, __middle, __s); - } - __out_iter __s2 = __s; - - if (__padding && __aflags != ios_base::left) - { - _S_fill(__s2, __fill, __padding); - __padding = 0; - } - __out_iter __s3 = copy(__middle, __last, __s2); - if (__padding) - _S_fill(__s3, __fill, __padding); - return __s3; - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const - { - const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io); - ios_base::fmtflags __flags = __io.flags(); - - if ((__flags & ios_base::boolalpha) == 0) - { - unsigned long __uv = __v; - return _S_format(__s, __io, __fill, false, __uv); - } - else - { - const char_type* __first; - const char_type* __last; - if (__v) - { - __first = __fmt->_M_truename.data(); - __last = __first + __fmt->_M_truename.size(); - } - else - { - __first = __fmt->_M_falsename.data(); - __last = __first + __fmt->_M_falsename.size(); - } - copy(__first, __last, __s); - } - return __s; - } - - // _S_group_digits 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 __grouping != __grend. - template - _CharT* - _S_group_digits(_CharT* __s, _CharT __grsep, char const* __grouping, - char const* __grend, _CharT const* __first, - _CharT const* __last) - { - if (__last - __first > *__grouping) - { - __s = _S_group_digits(__s, __grsep, - (__grouping + 1 == __grend ? __grouping : __grouping + 1), - __grend, __first, __last - *__grouping); - __first = __last - *__grouping; - *__s++ = __grsep; - } - do - { - *__s++ = *__first++; - } - while (__first != __last); - return __s; - } - - template - _OutIter - _S_format(_OutIter __s, ios_base& __io, _CharT __fill, bool __neg, - _ValueT __v) - { - // Leave room for "+/-," "0x," and commas. - const long _M_room = numeric_limits<_ValueT>::digits10 * 2 + 4; - _CharT __digits[_M_room]; - _CharT* __front = __digits + _M_room; - ios_base::fmtflags __flags = __io.flags(); - const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io); - char const* __table = __fmt->_S_literals + __fmt->_S_digits; - - ios_base::fmtflags __basefield = (__flags & __io.basefield); - _CharT* __sign_end = __front; - if (__basefield == ios_base::hex) - { - if (__flags & ios_base::uppercase) - __table += 16; // use ABCDEF - do - *--__front = __table[__v & 15]; - while ((__v >>= 4) != 0); - __sign_end = __front; - if (__flags & ios_base::showbase) - { - *--__front = __fmt->_S_literals[__fmt->_S_x + - ((__flags & ios_base::uppercase) ? 1 : 0)]; - *--__front = __table[0]; - } - } - else if (__basefield == ios_base::oct) - { - do - *--__front = __table[__v & 7]; - while ((__v >>= 3) != 0); - if (__flags & ios_base::showbase - && static_cast(*__front) != __table[0]) - *--__front = __table[0]; - __sign_end = __front; - } - else - { - // NB: This is _lots_ faster than using ldiv. - do - *--__front = __table[__v % 10]; - while ((__v /= 10) != 0); - __sign_end = __front; - // NB: ios_base:hex || ios_base::oct assumed to be unsigned. - if (__neg || (__flags & ios_base::showpos)) - *--__front = __fmt->_S_literals[__fmt->_S_plus - __neg]; - } - - // XXX should specialize! - if (!__fmt->_M_use_grouping && !__io.width()) - return copy(__front, __digits + _M_room, __s); - - if (!__fmt->_M_use_grouping) - return _S_pad_numeric(__s, __flags, __fill, __io.width(0), - __front, __sign_end, __digits + _M_room); - - _CharT* __p = __digits; - while (__front < __sign_end) - *__p++ = *__front++; - const char* __gr = __fmt->_M_grouping.data(); - __front = _S_group_digits(__p, __fmt->_M_thousands_sep, __gr, - __gr + __fmt->_M_grouping.size(), __sign_end, __digits + _M_room); - return _S_pad_numeric(__s, __flags, __fill, __io.width(0), - __digits, __p, __front); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const - { - unsigned long __uv = __v; - bool __neg = false; - if (__v < 0) - { - __neg = true; - __uv = -__uv; - } - return _S_format(__s, __io, __fill, __neg, __uv); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long __v) const - { return _S_format(__s, __io, __fill, false, __v); } - -#ifdef _GLIBCPP_USE_LONG_LONG - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const - { - unsigned long long __uv = __v; - bool __neg = false; - if (__v < 0) - { - __neg = true; - __uv = -__uv; - } - return _S_format(__s, __b, __fill, __neg, __uv); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long long __v) const - { return _S_format(__s, __io, __fill, false, __v); } -#endif - - // Generic helper function - template - static _OutIter - _S_output_float(_OutIter __s, ios_base& __io, _CharT __fill, - const char* __sptr, size_t __slen) - { - // XXX Not currently done: non streambuf_iterator - return __s; - } - - // Partial specialization for ostreambuf_iterator. - template - static ostreambuf_iterator<_CharT> - _S_output_float(ostreambuf_iterator<_CharT> __s, ios_base& __io, - _CharT __fill, const char* __sptr, size_t __slen) - { - size_t __padding = __io.width() > streamsize(__slen) ? - __io.width() -__slen : 0; - locale __loc = __io.getloc(); - ctype<_CharT> const& __ct = use_facet >(__loc); - ios_base::fmtflags __adjfield = __io.flags() & ios_base::adjustfield; - const char* const __eptr = __sptr + __slen; - // [22.2.2.2.2.19] Table 61 - if (__adjfield == ios_base::internal) - { - // [22.2.2.2.2.14]; widen() - if (__sptr < __eptr && (*__sptr == '+' || *__sptr == '-')) - { - __s = __ct.widen(*__sptr); - ++__s; - ++__sptr; - } - __s = _S_fill(__s, __fill, __padding); - __padding = 0; - } - else if (__adjfield != ios_base::left) - { - __s = _S_fill(__s, __fill, __padding); - __padding = 0; - } - // the "C" locale decimal character - char __decimal_point = *(localeconv()->decimal_point); - const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io); - for (; __sptr != __eptr; ++__s, ++__sptr) - { - // [22.2.2.2.2.17]; decimal point conversion - if (*__sptr == __decimal_point) - __s = __fmt->_M_decimal_point; - // [22.2.2.2.2.14]; widen() - else - __s = __ct.widen(*__sptr); - } - // [22.2.2.2.2.19] Table 61 - if (__padding) - _S_fill(__s, __fill, __padding); - __io.width(0); - return __s; - } - - bool - _S_build_float_format(ios_base& __io, char* __fptr, char __modifier, - streamsize __prec); - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const - { - const streamsize __max_prec = numeric_limits::digits10 + 3; - streamsize __prec = __io.precision(); - // Protect against sprintf() buffer overflows. - if (__prec > __max_prec) - __prec = __max_prec; - // The *2 provides for signs, exp, 'E', and pad. - char __sbuf[__max_prec*2]; - size_t __slen; - // Long enough for the max format spec. - char __fbuf[16]; - if (_S_build_float_format(__io, __fbuf, 0, __prec)) - __slen = sprintf(__sbuf, __fbuf, __prec, __v); - else - __slen = sprintf(__sbuf, __fbuf, __v); - // [22.2.2.2.2] Stages 2-4. - return _S_output_float(__s, __io, __fill, __sbuf, __slen); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - long double __v) const - { - const streamsize __max_prec = numeric_limits::digits10 + 3; - streamsize __prec = __io.precision(); - // Protect against sprintf() buffer overflows. - if (__prec > __max_prec) - __prec = __max_prec; - // The *2 provides for signs, exp, 'E', and pad. - char __sbuf[__max_prec*2]; - size_t __slen; - // Long enough for the max format spec. - char __fbuf[16]; - // 'L' as per [22.2.2.2.2] Table 59 - if ( _S_build_float_format(__io, __fbuf, 'L', __prec)) - __slen = sprintf(__sbuf, __fbuf, __prec, __v); - else - __slen = sprintf(__sbuf, __fbuf, __v); - // [22.2.2.2.2] Stages 2-4 - return _S_output_float(__s, __io, __fill, __sbuf, __slen); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - const void* __v) const - { - typedef ios_base::fmtflags fmtflags; - fmtflags __fmt = __io.flags(); - fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield - | ios_base::uppercase | ios_base::internal); - __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase)); - try { - _OutIter __s2 = _S_format(__s, __io, __fill, false, - reinterpret_cast(__v)); - __io.flags(__fmt); - return __s2; - } - catch (...) { - __io.flags(__fmt); - throw; - } - } - - template - locale::id numpunct<_CharT>::id; - - template - locale::id collate<_CharT>::id; - - // Support for time_get: - // Note that these partial specializations could, and maybe should, - // be changed to full specializations (by eliminating the _Dummy - // argument) and moved to a .cc file. - template - struct _Weekdaynames; - - template - struct _Weekdaynames - { static const char* const _S_names[14]; }; - - template - const char* const - _Weekdaynames::_S_names[14] = - { - "Sun", "Sunday", - "Mon", "Monday", "Tue", "Tuesday", "Wed", "Wednesday", - "Thu", "Thursday", "Fri", "Friday", "Sat", "Saturday" - }; - -#ifdef _GLIBCPP_USE_WCHAR_T - template - struct _Weekdaynames - { static const wchar_t* const _S_names[14]; }; - - template - const wchar_t* const - _Weekdaynames::_S_names[14] = - { - L"Sun", L"Sunday", - L"Mon", L"Monday", L"Tue", L"Tuesday", L"Wed", L"Wednesday", - L"Thu", L"Thursday", L"Fri", L"Friday", L"Sat", L"Saturday" - }; -#endif - - template - struct _Monthnames; - - template - struct _Monthnames - { static const char* const _S_names[24]; }; - - template - const char* const - _Monthnames::_S_names[24] = - { - "Jan", "January", "Feb", "February", "Mar", "March", - "Apr", "April", "May", "May", "Jun", "June", - "Jul", "July", "Aug", "August", "Sep", "September", - "Oct", "October", "Nov", "November", "Dec", "December" - }; - -#ifdef _GLIBCPP_USE_WCHAR_T - template - struct _Monthnames - { static const wchar_t* const _S_names[24]; }; - - template - const wchar_t* const - _Monthnames::_S_names[24] = - { - L"Jan", L"January", L"Feb", L"February", L"Mar", L"March", - L"Apr", L"April", L"May", L"May", L"Jun", L"June", - L"Jul", L"July", L"Aug", L"August", L"Sep", L"September", - L"Oct", L"October", L"Nov", L"November", L"Dec", L"December" - }; -#endif - - template - locale::id time_get<_CharT, _InIter>::id; - - template - _InIter - time_get<_CharT, _InIter>:: - do_get_weekday(iter_type __s, iter_type __end, - ios_base& __io, ios_base::iostate& __err, tm* __t) const - { - if (!_M_daynames) - { - _M_daynames = new basic_string<_CharT>[14]; - for (int __i = 0; __i < 14; ++__i) - _M_daynames[__i] = _Weekdaynames<_CharT>::_S_names[__i]; - } - bool __at_eof = false; - int __remain = 0; - int __matches[14]; - iter_type __out = __match_parallel(__s, __end, 14, _M_daynames, - __matches, __remain, __at_eof); - __err = ios_base::iostate(0); - if (__at_eof) __err |= __io.eofbit; - if (__remain == 1 || - __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1)) - __t->tm_wday = (__matches[0]>>1); - else - __err |= __io.failbit; - return __out; - } - - template - _InIter - time_get<_CharT, _InIter>:: - do_get_monthname(iter_type __s, iter_type __end, - ios_base& __io, ios_base::iostate& __err, tm* __t) const - { - if (!_M_monthnames) - { - _M_monthnames = new basic_string<_CharT>[24]; - for (int __i = 0; __i < 24; ++__i) - _M_monthnames[__i] = _Monthnames<_CharT>::_S_names[__i]; - } - bool __at_eof = false; - int __remain = 0; - int __matches[24]; - iter_type __out = __match_parallel( __s, __end, 24, _M_monthnames, - __matches, __remain, __at_eof); - __err = ios_base::iostate(0); - if (__at_eof) __err |= __io.eofbit; - if (__remain == 1 || - __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1)) - __t->tm_mon = (__matches[0]>>1); - else - __err |= __io.failbit; - return __out; - } - - template - locale::id time_put<_CharT, _OutIter>::id; - - template - locale::id money_get<_CharT, _InIter>::id; - - template - locale::id money_put<_CharT, _OutIter>::id; - - template - locale::id moneypunct<_CharT, _Intl>::id; - - template - const bool moneypunct<_CharT, _Intl>::intl; - - template - const bool moneypunct_byname<_CharT, _Intl>::intl; - - template - locale::id messages<_CharT>::id; -} // std:: - -#endif /* _CPP_BITS_LOCFACETS_TCC */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/localefwd.h b/libstdc++-v3/bits/localefwd.h deleted file mode 100644 index 44e85604bdb..00000000000 --- a/libstdc++-v3/bits/localefwd.h +++ /dev/null @@ -1,508 +0,0 @@ -// Locale support -*- C++ -*- - -// Copyright (C) 1997-2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 22.1 Locales -// - -#ifndef _CPP_BITS_LOCCORE_H -#define _CPP_BITS_LOCCORE_H 1 - -#include -#include // For CHAR_BIT -#include // For string -#include // For isspace, etc. - -namespace std -{ - - // _Count_ones: compile-time computation of number of 1-bits in a value N - // This takes only 5 (or 6) instantiations, doing recursive descent - // in parallel -- ncm - template> _Shift) > - struct _Count_ones; - - template - struct _Count_ones<_Num, 0, _Mask> - { static const unsigned int _S_count = _Num; }; - - template - const unsigned int _Count_ones<_Num, 0, _Mask>::_S_count; - - template - struct _Count_ones - { - static const unsigned int _S_halfcount = - _Count_ones<_Num, _Shift/2, (_Mask^((~_Mask)>>(_Shift/2))) >::_S_count; - static const unsigned int _S_count - = (_S_halfcount&_Mask) + ((_S_halfcount>>_Shift)&_Mask); - }; - - template - const unsigned int _Count_ones<_Num, _Shift, _Mask>::_S_count; - - template - const unsigned int _Count_ones<_Num, _Shift, _Mask>::_S_halfcount; - - // 22.1.1 Locale - template class allocator; - template class vector; - class locale; - - // 22.1.3 Convenience interfaces - template - inline bool - isspace(_CharT, const locale&); - - template - inline bool - isprint(_CharT, const locale&); - - template - inline bool - iscntrl(_CharT, const locale&); - - template - inline bool - isupper(_CharT, const locale&); - - template - inline bool - islower(_CharT, const locale&); - - template - inline bool - isalpha(_CharT, const locale&); - - template - inline bool - isdigit(_CharT, const locale&); - - template - inline bool - ispunct(_CharT, const locale&); - - template - inline bool - isxdigit(_CharT, const locale&); - - template - inline bool - isalnum(_CharT, const locale&); - - template - inline bool - isgraph(_CharT, const locale&); - - template - inline _CharT - toupper(_CharT, const locale&); - - template - inline _CharT - tolower(_CharT, const locale&); - - - // 22.2.1 and 22.2.1.3 ctype - class ctype_base; - template - class ctype; - template<> class ctype; -#ifdef _GLIBCPP_USE_WCHAR_T - template<> class ctype; -#endif - - template - class ctype_byname; - // NB: Specialized for char and wchar_t in locfacets.h. - - class codecvt_base; - template - class codecvt; - template<> class codecvt; -#ifdef _GLIBCPP_USE_WCHAR_T - template<> class codecvt; -#endif - - template - class codecvt_byname; - template<> class codecvt_byname; -#ifdef _GLIBCPP_USE_WCHAR_T - template<> class codecvt_byname; -#endif - - // 22.2.2 and 22.2.3 numeric - template > - class num_get; - template > - class num_put; - template class numpunct; - template class numpunct_byname; - - // 22.2.4 collation - template - class collate; - template<> class collate; -#ifdef _GLIBCPP_USE_WCHAR_T - template<> class collate; -#endif - template class - collate_byname; - - // 22.2.5 date and time - class time_base; - template > - class time_get; - template > - class time_get_byname; - template > - class time_put; - template > - class time_put_byname; - - // 22.2.6 money - class money_base; - template > - class money_get; - template > - class money_put; - template - class moneypunct; - template - class moneypunct_byname; - - // 22.2.7 message retrieval - class messages_base; - template - class messages; - template - class messages_byname; - - - // 22.1.1 Class locale - class locale - { - public: - // Types: - typedef int category; - - // Forward decls and friends: - class facet; - class id; - class _Impl; - - friend class _Impl; - - template - friend const _Facet& - use_facet(const locale&); - - template - friend bool - has_facet(const locale&) throw(); - - // Category values: - // NB much depends on the order in which these appear: - static const category none = 0; - static const category collate = 0x0100; - static const category ctype = 0x0200; - static const category monetary = 0x0400; - static const category numeric = 0x0800; - static const category time = 0x1000; - static const category messages = 0x2000; - static const category all = (collate | ctype | monetary | - numeric | time | messages); - - // Construct/copy/destroy: - inline - locale() throw(); - - inline - locale(const locale& __other) throw(); - - explicit - locale(const char* __std_name); - - locale(const locale& __other, const char* __std_name, category __cat); - - locale(const locale& __other, const locale& __one, category __cat); - - template - locale(const locale& __other, _Facet* __f); - - inline - ~locale() throw(); - - const locale& - operator=(const locale& __other) throw(); - - template - locale - combine(const locale& __other); - - // Locale operations: - string - name() const; - - bool - operator==(const locale& __other) const throw (); - - inline bool - operator!=(const locale& __other) const throw () - { return !(operator==(__other)); } - - template - 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 reference locale - static _Impl* _S_global; - - static const int _S_categories_num = _Count_ones::_S_count; - static const int _S_facets_num = 26; - - explicit - locale(_Impl*) throw(); - - static inline void - _S_initialize() - { if (!_S_classic) classic(); } - - static int - _S_normalize_category(int); - }; - - - // locale implementation object - class locale::_Impl - { - public: - // Types. - typedef vector > __vec_facet; - typedef vector > __vec_string; - - // Friends. - friend class locale; - friend class locale::facet; - - template - friend const _Facet& - use_facet(const locale&); - - template - friend bool - has_facet(const locale&) throw(); - - private: - // Data Members. - size_t _M_references; - __vec_facet* _M_facets; - __vec_string* _M_category_names; - bool _M_has_name; - string _M_name; - static const locale::id* const _S_id_collate[]; - static const locale::id* const _S_id_ctype[]; - static const locale::id* const _S_id_monetary[]; - static const locale::id* const _S_id_numeric[]; - static const locale::id* const _S_id_time[]; - static const locale::id* const _S_id_messages[]; - static const locale::id* const* const _S_facet_categories[]; - - inline void - _M_add_reference() throw() - { ++_M_references; } // XXX MT - - inline void - _M_remove_reference() throw() - { - if (_M_references-- == 0) // XXX MT - { - try { - delete this; - } - catch(...) { - } - } - } - - _Impl(const _Impl&, size_t __refs); - _Impl(const _Impl&, const string&, category, size_t __refs); - _Impl(size_t __facets, size_t __refs, bool __has_name, string __name); - ~_Impl() throw(); - - 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 - inline void - _M_facet_init(_Facet* __facet) - { _M_install_facet(&_Facet::id, __facet); } - - void - _M_construct_collate(const char*); - - void - _M_construct_ctype(const char*); - - void - _M_construct_monetary(const char*); - - void - _M_construct_numeric(const char*); - - void - _M_construct_time(const char*); - - void - _M_construct_messages(const char*); - - category - _M_normalize_category_names(const string&, category __cat); - }; - - // class locale inlines, that need declaration of locale::_Imp - locale::locale() throw() - { - _S_initialize(); - (_M_impl = _S_global)->_M_add_reference(); - } // XXX MT - - locale::locale(const locale& __other) throw() - { (_M_impl = __other._M_impl)->_M_add_reference(); } - - template - locale::locale(const locale& __other, _Facet* __f) - { - _M_impl = new _Impl(*__other._M_impl, 1); - _M_impl->_M_install_facet(&_Facet::id, __f); - _M_impl->_M_has_name = false; - _M_impl->_M_name = "*"; - } - - locale::~locale() throw() - { _M_impl->_M_remove_reference(); } - - // 22.1.1.1.2 Class locale::facet - class locale::facet - { - friend class locale; - friend class locale::_Impl; - - protected: - explicit - facet(size_t __refs = 0) throw(); - - virtual - ~facet() { }; - - private: - size_t _M_references; - - 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 - { - friend class locale; - friend class locale::_Impl; - template - friend const _Facet& - use_facet(const locale&); - template - friend bool - has_facet(const locale&) throw (); - public: - id() {}; - private: - // 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 size_t _S_highwater; - - void - operator=(const id&); // not defined - - id(const id&); // not defined - }; - - template - const _Facet& - use_facet(const locale& __loc); - - template - bool - has_facet(const locale& __loc) throw(); - -} // namespace std - -#endif /* _CPP_BITS_LOCCORE_H */ - -// Local Variables: -// mode:c++ -// End: - diff --git a/libstdc++-v3/bits/mask_array.h b/libstdc++-v3/bits/mask_array.h deleted file mode 100644 index 5a15f7a5e97..00000000000 --- a/libstdc++-v3/bits/mask_array.h +++ /dev/null @@ -1,160 +0,0 @@ -// The template and inlines for the -*- C++ -*- mask_array class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_MASK_ARRAY_H -#define _CPP_BITS_MASK_ARRAY_H 1 - -namespace std { - - template class mask_array - { - public: - typedef _Tp value_type; - - void operator= (const valarray<_Tp>&) const; - void operator*= (const valarray<_Tp>&) const; - void operator/= (const valarray<_Tp>&) const; - void operator%= (const valarray<_Tp>&) const; - void operator+= (const valarray<_Tp>&) const; - void operator-= (const valarray<_Tp>&) const; - void operator^= (const valarray<_Tp>&) const; - void operator&= (const valarray<_Tp>&) const; - void operator|= (const valarray<_Tp>&) const; - void operator<<=(const valarray<_Tp>&) const; - void operator>>=(const valarray<_Tp>&) const; - void operator= (const _Tp&); - - // ~mask_array (); - - template - void operator= (const _Expr<_Dom,_Tp>&) const; - template - void operator*= (const _Expr<_Dom,_Tp>&) const; - template - void operator/= (const _Expr<_Dom,_Tp>&) const; - template - void operator%= (const _Expr<_Dom,_Tp>&) const; - template - void operator+= (const _Expr<_Dom,_Tp>&) const; - template - void operator-= (const _Expr<_Dom,_Tp>&) const; - template - void operator^= (const _Expr<_Dom,_Tp>&) const; - template - void operator&= (const _Expr<_Dom,_Tp>&) const; - template - void operator|= (const _Expr<_Dom,_Tp>&) const; - template - void operator<<=(const _Expr<_Dom,_Tp>&) const; - template - void operator>>=(const _Expr<_Dom,_Tp>&) const; - - private: - mask_array (_Array<_Tp>, size_t, _Array); - friend class valarray<_Tp>; - - const size_t _M_sz; - const _Array _M_mask; - const _Array<_Tp> _M_array; - - mask_array (const mask_array&); - - // not implemented - mask_array (); - mask_array& operator= (const mask_array&); - }; - - - template - 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 - inline - mask_array<_Tp>::mask_array (_Array<_Tp> __a, size_t __s, _Array __m) - : _M_sz (__s), _M_mask (__m), _M_array (__a) {} - - // template - // inline mask_array<_Tp>::~mask_array () {} - - template - inline void - mask_array<_Tp>::operator= (const _Tp& __t) - { __valarray_fill (_M_array, _M_sz, _M_mask, __t); } - - template - inline void - mask_array<_Tp>::operator= (const valarray<_Tp>& __v) const - { __valarray_copy (_Array<_Tp> (__v), __v.size (), _M_array, _M_mask); } - - template - template - inline void - mask_array<_Tp>::operator= (const _Expr& __e) const - { __valarray_copy (__e, __e.size (), _M_array, _M_mask); } - -#undef _DEFINE_VALARRAY_OPERATOR -#define _DEFINE_VALARRAY_OPERATOR(op, name) \ -template \ -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 template \ -inline void \ -mask_array<_Tp>::operator op##= (const _Expr& __e) const \ -{ \ - _Array_augmented_##name (_M_array, _M_mask, __e, __e.size ()); \ -} - -_DEFINE_VALARRAY_OPERATOR(*, multiplies) -_DEFINE_VALARRAY_OPERATOR(/, divides) -_DEFINE_VALARRAY_OPERATOR(%, modulus) -_DEFINE_VALARRAY_OPERATOR(+, plus) -_DEFINE_VALARRAY_OPERATOR(-, minus) -_DEFINE_VALARRAY_OPERATOR(^, xor) -_DEFINE_VALARRAY_OPERATOR(&, and) -_DEFINE_VALARRAY_OPERATOR(|, or) -_DEFINE_VALARRAY_OPERATOR(<<, shift_left) -_DEFINE_VALARRAY_OPERATOR(>>, shift_right) - -#undef _DEFINE_VALARRAY_OPERATOR - -} // std:: - -#endif /* _CPP_BITS_MASK_ARRAY_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/ostream.tcc b/libstdc++-v3/bits/ostream.tcc deleted file mode 100644 index 7f76b0d0e80..00000000000 --- a/libstdc++-v3/bits/ostream.tcc +++ /dev/null @@ -1,683 +0,0 @@ -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.6.2 Output streams -// - -#include - -namespace std { - - template - basic_ostream<_CharT, _Traits>::sentry:: - sentry(basic_ostream<_CharT,_Traits>& __os) - : _M_ok(__os.good()), _M_os(__os) - { - // XXX MT - if (_M_ok && __os.tie()) - __os.tie()->flush(); - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(__ostream_type& (*__pf)(__ostream_type&)) - { - sentry __cerb(*this); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.2.5.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(__ios_type& (*__pf)(__ios_type&)) - { - sentry __cerb(*this); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.2.5.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(ios_base& (*__pf)(ios_base&)) - { - sentry __cerb(*this); - if (__cerb) - { - try { - __pf(*this); - } - catch(exception& __fail){ - // 27.6.2.5.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(bool __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(long __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - bool __f; - ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt & ios_base::oct || __fmt & ios_base::hex) - __f = _M_fnumput->put(*this, *this, this->fill(), - static_cast(__n)).failed(); - else - __f = _M_fnumput->put(*this, *this, this->fill(), __n).failed(); - - if (__f) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - -#ifdef _GLIBCPP_USE_LONG_LONG - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(long long __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - bool __f; - ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt & ios_base::oct || __fmt & ios_base::hex) - __f = _M_fnumput->put(*this, *this, this->fill(), - static_cast(__n)).failed(); - else - __f = _M_fnumput->put(*this, *this, this->fill(), __n).failed(); - - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } -#endif - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(double __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(long double __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(const void* __n) - { - sentry __cerb(*this); - if (__cerb) - { - try { - if (_M_fnumput->put(*this, *this, this->fill(), __n).failed()) - this->setstate(ios_base::badbit); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - this->setstate(ios_base::badbit); - if ((this->exceptions() & ios_base::badbit) != 0) - throw; - } - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::operator<<(__streambuf_type* __sbin) - { - streamsize __xtrct = 0; - __streambuf_type* __sbout = this->rdbuf(); - sentry __cerb(*this); - if (__sbin && __cerb) - __xtrct = _S_copy_streambufs(*this, __sbin, __sbout); - if (!__sbin || !__xtrct) - this->setstate(ios_base::failbit); - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::put(char_type __c) - { - sentry __cerb(*this); - if (__cerb) - { - int_type __put = rdbuf()->sputc(__c); - if (__put != traits_type::to_int_type(__c)) - this->setstate(ios_base::badbit); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::write(const _CharT* __s, streamsize __n) - { - sentry __cerb(*this); - if (__cerb) - { - streamsize __put = this->rdbuf()->sputn(__s, __n); - if ( __put != __n) - this->setstate(ios_base::badbit); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::flush() - { - sentry __cerb(*this); - if (__cerb) - { - if (this->rdbuf() && this->rdbuf()->pubsync() == -1) - this->setstate(ios_base::badbit); - } - return *this; - } - - template - typename basic_ostream<_CharT, _Traits>::pos_type - basic_ostream<_CharT, _Traits>::tellp() - { - pos_type __ret = pos_type(-1); - bool __testok = this->fail() != true; - - if (__testok) - __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); - return __ret; - } - - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) - { - bool __testok = this->fail() != true; - - if (__testok) -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 136. seekp, seekg setting wrong streams? - this->rdbuf()->pubseekpos(__pos, ios_base::out); -#endif - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - seekp(off_type __off, ios_base::seekdir __d) - { - bool __testok = this->fail() != true; - - if (__testok) -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 136. seekp, seekg setting wrong streams? - rdbuf()->pubseekoff(__off, __d, ios_base::out); -#endif - return *this; - } - - // 27.6.2.5.4 Character inserters - - // Construct correctly padded string, as per 22.2.2.2.2 - // Similar in theory to _S_pad_numeric, from num_put, but it doesn't - // use _S_fill: perhaps it should. - // Assumes - // __newlen > __oldlen - // __news is allocated for __newlen size - template - void - _S_pad_char(basic_ios<_CharT, _Traits>& __ios, - _CharT* __news, const _CharT* __olds, - const streamsize __newlen, const streamsize __oldlen) - { - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - - int_type __plen = static_cast(__newlen - __oldlen); - char_type __pads[__plen]; - traits_type::assign(__pads, __plen, __ios.fill()); - - char_type* __beg; - char_type* __end; - size_t __mod = 0; - size_t __beglen; //either __plen or __oldlen - ios_base::fmtflags __fmt = __ios.flags() & ios_base::adjustfield; - - if (__fmt == ios_base::left) - { - // Padding last. - __beg = const_cast(__olds); - __beglen = __oldlen; - __end = __pads; - } - else if (__fmt == ios_base::internal) - { - // Pad after the sign, if there is one. - // Pad after 0[xX], if there is one. - // Who came up with these rules, anyway? Jeeze. - typedef _Format_cache<_CharT> __cache_type; - __cache_type const* __fmt = __cache_type::_S_get(__ios); - const char_type* __minus = traits_type::find(__olds, __oldlen, - __fmt->_S_minus); - const char_type* __plus = traits_type::find(__olds, __oldlen, - __fmt->_S_plus); - bool __testsign = __minus || __plus; - bool __testhex = __olds[0] == '0' - && (__olds[1] == 'x' || __olds[1] == 'X'); - - if (__testhex) - { - __news[0] = __olds[0]; - __news[1] = __olds[1]; - __mod += 2; - __beg = const_cast(__olds + __mod); - __beglen = __oldlen - __mod; - __end = __pads; - } - else if (__testsign) - { - __mod += __plen; - const char_type* __sign = __minus ? __minus + 1: __plus + 1; - __beg = const_cast(__olds); - __beglen = __sign - __olds; - __end = const_cast(__sign + __plen); - traits_type::copy(__news + __beglen, __pads, __plen); - } - else - { - // Padding first. - __beg = __pads; - __beglen = __plen; - __end = const_cast(__olds); - } - } - else - { - // Padding first. - __beg = __pads; - __beglen = __plen; - __end = const_cast(__olds); - } - - traits_type::copy(__news, __beg, __beglen); - traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod); - } - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; - __ostream_type::sentry __cerb(__out); - if (__cerb) - { - try { - streamsize __w = __out.width(); - _CharT __pads[__w]; - __pads[0] = __c; - streamsize __len = 1; - if (__w > __len) - { - _S_pad_char(__out, __pads, &__c, __w, __len); - __len = __w; - } - __out.write(__pads, __len); - __out.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); - if ((__out.exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __out; - } - - // Specialization - template - basic_ostream& - operator<<(basic_ostream& __out, char __c) - { - typedef basic_ostream __ostream_type; - __ostream_type::sentry __cerb(__out); - if (__cerb) - { - try { - streamsize __w = __out.width(); - char __pads[__w + 1]; - __pads[0] = __c; - streamsize __len = 1; - if (__w > __len) - { - _S_pad_char(__out, __pads, &__c, __w, __len); - __len = __w; - } - __out.write(__pads, __len); - __out.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); - if ((__out.exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __out; - } - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; - __ostream_type::sentry __cerb(__out); - if (__cerb) - { - try { - streamsize __w = __out.width(); - _CharT __pads[__w]; - streamsize __len = static_cast(_Traits::length(__s)); - if (__w > __len) - { - _S_pad_char(__out, __pads, __s, __w, __len); - __s = __pads; - __len = __w; - } - __out.write(__s, __len); - __out.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); - if ((__out.exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __out; - } - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS -// 167. Improper use of traits_type::length() - typedef char_traits __ctraits_type; -#endif - __ostream_type::sentry __cerb(__out); - if (__cerb) - { - size_t __clen = __ctraits_type::length(__s); - _CharT __ws[__clen + 1]; - for (size_t __i = 0; __i <= __clen; ++__i) - __ws[__i] = __out.widen(__s[__i]); - _CharT* __str = __ws; - - try { - streamsize __len = static_cast(__clen); - streamsize __w = __out.width(); - _CharT __pads[__w]; - - if (__w > __len) - { - _S_pad_char(__out, __pads, __ws, __w, __len); - __str = __pads; - __len = __w; - } - __out.write(__str, __len); - __out.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); - if ((__out.exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __out; - } - - // Partial specializationss - template - basic_ostream& - operator<<(basic_ostream& __out, const char* __s) - { - typedef basic_ostream __ostream_type; - __ostream_type::sentry __cerb(__out); - if (__cerb) - { - try { - streamsize __w = __out.width(); - char __pads[__w]; - streamsize __len = static_cast(_Traits::length(__s)); - if (__w > __len) - { - _S_pad_char(__out, __pads, __s, __w, __len); - __s = __pads; - __len = __w; - } - __out.write(__s, __len); - __out.width(0); - } - catch(exception& __fail){ - // 27.6.1.2.1 Common requirements. - // Turn this on without causing an ios::failure to be thrown. - __out.setstate(ios_base::badbit); - if ((__out.exceptions() & ios_base::badbit) != 0) - throw; - } - } - return __out; - } - - // 21.3.7.8 basic_string::operator<< - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, - const basic_string<_CharT, _Traits, _Alloc>& __s) - { return (__out << __s.c_str()); } - -} // namespace std - -// Local Variables: -// mode:C++ -// End: - - - - - - - - - - diff --git a/libstdc++-v3/bits/pthread_allocimpl.h b/libstdc++-v3/bits/pthread_allocimpl.h deleted file mode 100644 index 3b63127ced7..00000000000 --- a/libstdc++-v3/bits/pthread_allocimpl.h +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 1996 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_BITS_PTHREAD_ALLOCIMPL_H -#define _CPP_BITS_PTHREAD_ALLOCIMPL_H 1 - -// Pthread-specific node allocator. -// This is similar to the default allocator, except that free-list -// information is kept separately for each thread, avoiding locking. -// This should be reasonably fast even in the presence of threads. -// The down side is that storage may not be well-utilized. -// It is not an error to allocate memory in thread A and deallocate -// it in thread B. But this effectively transfers ownership of the memory, -// so that it can only be reallocated by thread B. Thus this can effectively -// result in a storage leak if it's done on a regular basis. -// It can also result in frequent sharing of -// cache lines among processors, with potentially serious performance -// consequences. - -#include -#include -#include -#ifndef __RESTRICT -# define __RESTRICT -#endif - -#ifndef __STL_NO_BAD_ALLOC -# include -#endif - -__STL_BEGIN_NAMESPACE - -#define __STL_DATA_ALIGNMENT 8 - -union _Pthread_alloc_obj { - union _Pthread_alloc_obj * __free_list_link; - char __client_data[__STL_DATA_ALIGNMENT]; /* The client sees this. */ -}; - -// Pthread allocators don't appear to the client to have meaningful -// instances. We do in fact need to associate some state with each -// thread. That state is represented by -// _Pthread_alloc_per_thread_state<_Max_size>. - -template -struct _Pthread_alloc_per_thread_state { - typedef _Pthread_alloc_obj __obj; - enum { _S_NFREELISTS = _Max_size/__STL_DATA_ALIGNMENT }; - _Pthread_alloc_obj* volatile __free_list[_S_NFREELISTS]; - _Pthread_alloc_per_thread_state<_Max_size> * __next; - // Free list link for list of available per thread structures. - // When one of these becomes available for reuse due to thread - // termination, any objects in its free list remain associated - // with it. The whole structure may then be used by a newly - // created thread. - _Pthread_alloc_per_thread_state() : __next(0) - { - memset((void *)__free_list, 0, (size_t) _S_NFREELISTS * sizeof(__obj *)); - } - // Returns an object of size __n, and possibly adds to size n free list. - void *_M_refill(size_t __n); -}; - -// Pthread-specific allocator. -// The argument specifies the largest object size allocated from per-thread -// free lists. Larger objects are allocated using malloc_alloc. -// Max_size must be a power of 2. -template -class _Pthread_alloc_template { - -public: // but only for internal use: - - typedef _Pthread_alloc_obj __obj; - - // Allocates a chunk for nobjs of size size. nobjs may be reduced - // if it is inconvenient to allocate the requested number. - static char *_S_chunk_alloc(size_t __size, int &__nobjs); - - enum {_S_ALIGN = __STL_DATA_ALIGNMENT}; - - static size_t _S_round_up(size_t __bytes) { - return (((__bytes) + (int) _S_ALIGN-1) & ~((int) _S_ALIGN - 1)); - } - static size_t _S_freelist_index(size_t __bytes) { - return (((__bytes) + (int) _S_ALIGN-1)/(int)_S_ALIGN - 1); - } - -private: - // Chunk allocation state. And other shared state. - // Protected by _S_chunk_allocator_lock. - static pthread_mutex_t _S_chunk_allocator_lock; - static char *_S_start_free; - static char *_S_end_free; - static size_t _S_heap_size; - static _Pthread_alloc_per_thread_state<_Max_size>* _S_free_per_thread_states; - static pthread_key_t _S_key; - static bool _S_key_initialized; - // Pthread key under which per thread state is stored. - // Allocator instances that are currently unclaimed by any thread. - static void _S_destructor(void *instance); - // Function to be called on thread exit to reclaim per thread - // state. - static _Pthread_alloc_per_thread_state<_Max_size> *_S_new_per_thread_state(); - // Return a recycled or new per thread state. - static _Pthread_alloc_per_thread_state<_Max_size> *_S_get_per_thread_state(); - // ensure that the current thread has an associated - // per thread state. - class _M_lock; - friend class _M_lock; - class _M_lock { - public: - _M_lock () { pthread_mutex_lock(&_S_chunk_allocator_lock); } - ~_M_lock () { pthread_mutex_unlock(&_S_chunk_allocator_lock); } - }; - -public: - - /* n must be > 0 */ - static void * allocate(size_t __n) - { - __obj * volatile * __my_free_list; - __obj * __RESTRICT __result; - _Pthread_alloc_per_thread_state<_Max_size>* __a; - - if (__n > _Max_size) { - return(malloc_alloc::allocate(__n)); - } - if (!_S_key_initialized || - !(__a = (_Pthread_alloc_per_thread_state<_Max_size>*) - pthread_getspecific(_S_key))) { - __a = _S_get_per_thread_state(); - } - __my_free_list = __a -> __free_list + _S_freelist_index(__n); - __result = *__my_free_list; - if (__result == 0) { - void *__r = __a -> _M_refill(_S_round_up(__n)); - return __r; - } - *__my_free_list = __result -> __free_list_link; - return (__result); - }; - - /* p may not be 0 */ - static void deallocate(void *__p, size_t __n) - { - __obj *__q = (__obj *)__p; - __obj * volatile * __my_free_list; - _Pthread_alloc_per_thread_state<_Max_size>* __a; - - if (__n > _Max_size) { - malloc_alloc::deallocate(__p, __n); - return; - } - if (!_S_key_initialized || - !(__a = (_Pthread_alloc_per_thread_state<_Max_size> *) - pthread_getspecific(_S_key))) { - __a = _S_get_per_thread_state(); - } - __my_free_list = __a->__free_list + _S_freelist_index(__n); - __q -> __free_list_link = *__my_free_list; - *__my_free_list = __q; - } - - static void * reallocate(void *__p, size_t __old_sz, size_t __new_sz); - -} ; - -typedef _Pthread_alloc_template<> pthread_alloc; - - -template -void _Pthread_alloc_template<_Max_size>::_S_destructor(void * __instance) -{ - _M_lock __lock_instance; // Need to acquire lock here. - _Pthread_alloc_per_thread_state<_Max_size>* __s = - (_Pthread_alloc_per_thread_state<_Max_size> *)__instance; - __s -> __next = _S_free_per_thread_states; - _S_free_per_thread_states = __s; -} - -template -_Pthread_alloc_per_thread_state<_Max_size> * -_Pthread_alloc_template<_Max_size>::_S_new_per_thread_state() -{ - /* lock already held here. */ - if (0 != _S_free_per_thread_states) { - _Pthread_alloc_per_thread_state<_Max_size> *__result = - _S_free_per_thread_states; - _S_free_per_thread_states = _S_free_per_thread_states -> __next; - return __result; - } else { - return new _Pthread_alloc_per_thread_state<_Max_size>; - } -} - -template -_Pthread_alloc_per_thread_state<_Max_size> * -_Pthread_alloc_template<_Max_size>::_S_get_per_thread_state() -{ - /*REFERENCED*/ - _M_lock __lock_instance; // Need to acquire lock here. - int __ret_code; - _Pthread_alloc_per_thread_state<_Max_size> * __result; - if (!_S_key_initialized) { - if (pthread_key_create(&_S_key, _S_destructor)) { - __THROW_BAD_ALLOC; // defined in stl_alloc.h - } - _S_key_initialized = true; - } - __result = _S_new_per_thread_state(); - __ret_code = pthread_setspecific(_S_key, __result); - if (__ret_code) { - if (__ret_code == ENOMEM) { - __THROW_BAD_ALLOC; - } else { - // EINVAL - abort(); - } - } - return __result; -} - -/* We allocate memory in large chunks in order to avoid fragmenting */ -/* the malloc heap too much. */ -/* We assume that size is properly aligned. */ -template -char *_Pthread_alloc_template<_Max_size> -::_S_chunk_alloc(size_t __size, int &__nobjs) -{ - { - char * __result; - size_t __total_bytes; - size_t __bytes_left; - /*REFERENCED*/ - _M_lock __lock_instance; // Acquire lock for this routine - - __total_bytes = __size * __nobjs; - __bytes_left = _S_end_free - _S_start_free; - if (__bytes_left >= __total_bytes) { - __result = _S_start_free; - _S_start_free += __total_bytes; - return(__result); - } else if (__bytes_left >= __size) { - __nobjs = __bytes_left/__size; - __total_bytes = __size * __nobjs; - __result = _S_start_free; - _S_start_free += __total_bytes; - return(__result); - } else { - size_t __bytes_to_get = - 2 * __total_bytes + _S_round_up(_S_heap_size >> 4); - // Try to make use of the left-over piece. - if (__bytes_left > 0) { - _Pthread_alloc_per_thread_state<_Max_size>* __a = - (_Pthread_alloc_per_thread_state<_Max_size>*) - pthread_getspecific(_S_key); - __obj * volatile * __my_free_list = - __a->__free_list + _S_freelist_index(__bytes_left); - - ((__obj *)_S_start_free) -> __free_list_link = *__my_free_list; - *__my_free_list = (__obj *)_S_start_free; - } -# ifdef _SGI_SOURCE - // Try to get memory that's aligned on something like a - // cache line boundary, so as to avoid parceling out - // parts of the same line to different threads and thus - // possibly different processors. - { - const int __cache_line_size = 128; // probable upper bound - __bytes_to_get &= ~(__cache_line_size-1); - _S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get); - if (0 == _S_start_free) { - _S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get); - } - } -# else /* !SGI_SOURCE */ - _S_start_free = (char *)malloc_alloc::allocate(__bytes_to_get); -# endif - _S_heap_size += __bytes_to_get; - _S_end_free = _S_start_free + __bytes_to_get; - } - } - // lock is released here - return(_S_chunk_alloc(__size, __nobjs)); -} - - -/* Returns an object of size n, and optionally adds to size n free list.*/ -/* We assume that n is properly aligned. */ -/* We hold the allocation lock. */ -template -void *_Pthread_alloc_per_thread_state<_Max_size> -::_M_refill(size_t __n) -{ - int __nobjs = 128; - char * __chunk = - _Pthread_alloc_template<_Max_size>::_S_chunk_alloc(__n, __nobjs); - __obj * volatile * __my_free_list; - __obj * __result; - __obj * __current_obj, * __next_obj; - int __i; - - if (1 == __nobjs) { - return(__chunk); - } - __my_free_list = __free_list - + _Pthread_alloc_template<_Max_size>::_S_freelist_index(__n); - - /* Build free list in chunk */ - __result = (__obj *)__chunk; - *__my_free_list = __next_obj = (__obj *)(__chunk + __n); - for (__i = 1; ; __i++) { - __current_obj = __next_obj; - __next_obj = (__obj *)((char *)__next_obj + __n); - if (__nobjs - 1 == __i) { - __current_obj -> __free_list_link = 0; - break; - } else { - __current_obj -> __free_list_link = __next_obj; - } - } - return(__result); -} - -template -void *_Pthread_alloc_template<_Max_size> -::reallocate(void *__p, size_t __old_sz, size_t __new_sz) -{ - void * __result; - size_t __copy_sz; - - if (__old_sz > _Max_size - && __new_sz > _Max_size) { - return(realloc(__p, __new_sz)); - } - if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p); - __result = allocate(__new_sz); - __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz; - memcpy(__result, __p, __copy_sz); - deallocate(__p, __old_sz); - return(__result); -} - -template -_Pthread_alloc_per_thread_state<_Max_size> * -_Pthread_alloc_template<_Max_size>::_S_free_per_thread_states = 0; - -template -pthread_key_t _Pthread_alloc_template<_Max_size>::_S_key; - -template -bool _Pthread_alloc_template<_Max_size>::_S_key_initialized = false; - -template -pthread_mutex_t _Pthread_alloc_template<_Max_size>::_S_chunk_allocator_lock -= PTHREAD_MUTEX_INITIALIZER; - -template -char *_Pthread_alloc_template<_Max_size> -::_S_start_free = 0; - -template -char *_Pthread_alloc_template<_Max_size> -::_S_end_free = 0; - -template -size_t _Pthread_alloc_template<_Max_size> -::_S_heap_size = 0; - -#ifdef __STL_USE_STD_ALLOCATORS - -template -class pthread_allocator { - typedef pthread_alloc _S_Alloc; // The underlying allocator. -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - typedef _Tp value_type; - - template struct rebind { - typedef pthread_allocator<_NewType> other; - }; - - pthread_allocator() __STL_NOTHROW {} - pthread_allocator(const pthread_allocator& a) __STL_NOTHROW {} - template - pthread_allocator(const pthread_allocator<_OtherType>&) - __STL_NOTHROW {} - ~pthread_allocator() __STL_NOTHROW {} - - pointer address(reference __x) const { return &__x; } - const_pointer address(const_reference __x) const { return &__x; } - - // __n is permitted to be 0. The C++ standard says nothing about what - // the return value is when __n == 0. - _Tp* allocate(size_type __n, const void* = 0) { - return __n != 0 ? static_cast<_Tp*>(_S_Alloc::allocate(__n * sizeof(_Tp))) - : 0; - } - - // p is not permitted to be a null pointer. - void deallocate(pointer __p, size_type __n) - { _S_Alloc::deallocate(__p, __n * sizeof(_Tp)); } - - size_type max_size() const __STL_NOTHROW - { return size_t(-1) / sizeof(_Tp); } - - void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); } - void destroy(pointer _p) { _p->~_Tp(); } -}; - -template<> -class pthread_allocator { -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef void* pointer; - typedef const void* const_pointer; - typedef void value_type; - - template struct rebind { - typedef pthread_allocator<_NewType> other; - }; -}; - -template -inline bool operator==(const _Pthread_alloc_template<_Max_size>&, - const _Pthread_alloc_template<_Max_size>&) -{ - return true; -} - -template -inline bool operator==(const pthread_allocator<_T1>&, - const pthread_allocator<_T2>& a2) -{ - return true; -} - -template -inline bool operator!=(const pthread_allocator<_T1>&, - const pthread_allocator<_T2>&) -{ - return false; -} - -template -struct _Alloc_traits<_Tp, _Pthread_alloc_template<_Max_size> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max_size> > _Alloc_type; - typedef __allocator<_Tp, _Pthread_alloc_template<_Max_size> > - allocator_type; -}; - -template -struct _Alloc_traits<_Tp, __allocator<_Atype, _Pthread_alloc_template<_Max> > > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, _Pthread_alloc_template<_Max> > _Alloc_type; - typedef __allocator<_Tp, _Pthread_alloc_template<_Max> > allocator_type; -}; - -template -struct _Alloc_traits<_Tp, pthread_allocator<_Atype> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, _Pthread_alloc_template<> > _Alloc_type; - typedef pthread_allocator<_Tp> allocator_type; -}; - - -#endif /* __STL_USE_STD_ALLOCATORS */ - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_PTHREAD_ALLOCIMPL_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/sbuf_iter.h b/libstdc++-v3/bits/sbuf_iter.h deleted file mode 100644 index 7a0e1d5db22..00000000000 --- a/libstdc++-v3/bits/sbuf_iter.h +++ /dev/null @@ -1,264 +0,0 @@ -// Streambuf iterators - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// XXX Should specialize copy, find algorithms for streambuf iterators. - -#ifndef _CPP_BITS_SBUF_ITER_H -#define _CPP_BITS_SBUF_ITER_H 1 - -namespace std -{ - - template - class ostreambuf_iterator -#if 0 // XXX this is standard: - : public iterator -#else - : public output_iterator -#endif - { - public: - - // Types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_ostream<_CharT, _Traits> ostream_type; - - inline - ostreambuf_iterator(ostream_type& __s) throw () - : _M_sbuf(__s.rdbuf()), _M_failed(false) { } - - ostreambuf_iterator(streambuf_type* __s) throw () - : _M_sbuf(__s), _M_failed(false) { } - - ostreambuf_iterator& - operator=(_CharT __c); - - ostreambuf_iterator& - operator*() throw() - { return *this; } - - ostreambuf_iterator& - operator++(int) throw() - { return *this; } - - ostreambuf_iterator& - operator++() throw() - { return *this; } - - bool - failed() const throw() - { return _M_failed; } - - private: - streambuf_type* _M_sbuf; - bool _M_failed; - -#if 0 - template<> - friend char const* - copy(char const* __first, char const* __last, - ostreambuf_iterator > __to); - template<> - friend wchar_t const* - copy(wchar_t const* __first, wchar_t const* __last, - ostreambuf_iterator > __to); -#endif - }; - - template - inline ostreambuf_iterator<_CharT, _Traits>& - ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c) - { - if (!_M_failed && - _Traits::eq_int_type(_M_sbuf->sputc(__c),_Traits::eof())) - _M_failed = true; - return *this; - } - - -#if 0 - // Optimized specializations of standard algorithms - // These are specialized only for standard types - // (with no unbound arguments) to avoid creating - // overload problems with user specializations. - - template<> - char const* - copy(char const* __first, char const* __last, - ostreambuf_iterator > __to) - { - if (!__to._M_failed) - __to._M_sbuf->sputn(__first, __last-__first); - return __last; - } - - template<> - wchar_t const* - copy(wchar_t const* __first, wchar_t const* __last, - ostreambuf_iterator > __to) - { - if (!__to._M_failed) - __to._M_sbuf->sputn(__first, __last-__first); - return __last; - } -#endif - - // 24.5.3 Template class istreambuf_iterator - template - class istreambuf_iterator - : public iterator - { - public: - - // Types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename _Traits::int_type int_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_istream<_CharT, _Traits> istream_type; - // Non-standard Types: - typedef istreambuf_iterator<_CharT, _Traits> __istreambufiter_type; - - istreambuf_iterator() throw() - : _M_istreambuf(NULL), _M_c(-2) { } - - istreambuf_iterator(istream_type& __s) throw() - : _M_istreambuf(__s.rdbuf()), _M_c(-2) { } - - istreambuf_iterator(streambuf_type* __s) throw() - : _M_istreambuf(__s), _M_c(-2) { } - - // NB: This should really have an int_type return - // value, so "end of stream" postion can be checked without - // hacking. - char_type - operator*() const - { - // The result of operator*() on an end of stream is undefined. - char_type __ret; - if (_M_istreambuf && _M_c != static_cast(-2)) - __ret = _M_c; - else if (_M_istreambuf) - __ret = traits_type::to_char_type(_M_istreambuf->sgetc()); - else - __ret = static_cast(traits_type::eof()); - return __ret; - } - - __istreambufiter_type& - operator++() - { - if (_M_istreambuf) - _M_istreambuf->sbumpc(); - _M_c = -2; - return *this; - } - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // 14882 says return a proxy object. It should be a const - // proxy object, but since this class is not mandated, it - // should allow this signature: - const __istreambufiter_type - operator++(int) - { - if (_M_istreambuf) - _M_c = _M_istreambuf->sbumpc(); - return *this; - } -#endif - - bool - equal(const __istreambufiter_type& __b) - { - int_type __eof = traits_type::eof(); - bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof; - bool __beof = !__b._M_istreambuf - || __b._M_istreambuf->sgetc() == __eof; - return (__thiseof && __beof || (!__thiseof && !__beof)); - } - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // 110 istreambuf_iterator::equal not const - // NB: there is also number 111 pending on this function. - bool - equal(const __istreambufiter_type& __b) const - { - int_type __eof = traits_type::eof(); - bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof; - bool __beof = !__b._M_istreambuf - || __b._M_istreambuf->sgetc() == __eof; - return (__thiseof && __beof || (!__thiseof && !__beof)); - } -#endif - - private: - // 24.5.3 istreambuf_iterator - // p 1 - // If the end of stream is reached (streambuf_type::sgetc() - // returns traits_type::eof()), the iterator becomes equal to - // the "end of stream" iterator value. - // NB: This implementation assumes the "end of stream" value - // is EOF, or -1. - streambuf_type* _M_istreambuf; - int_type _M_c; - }; - - template - inline bool - operator==(const istreambuf_iterator<_CharT, _Traits>& __a, - const istreambuf_iterator<_CharT, _Traits>& __b) - { return __a.equal(__b); } - - template - inline bool - operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, - const istreambuf_iterator<_CharT, _Traits>& __b) - { return !__a.equal(__b); } - -} // std:: - -#endif /* _CPP_BITS_SBUF_ITER_H */ - - - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/sequence_concepts.h b/libstdc++-v3/bits/sequence_concepts.h deleted file mode 100644 index af582fb3345..00000000000 --- a/libstdc++-v3/bits/sequence_concepts.h +++ /dev/null @@ -1,204 +0,0 @@ -/* - * Copyright (c) 1999 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef STL_SEQUENCE_CONCEPTS_H -#define STL_SEQUENCE_CONCEPTS_H - -#include - -#ifdef __STL_USE_CONCEPT_CHECKS - -// This file covers the following concepts: -// _Sequence -// _FrontInsertionSequence -// _BackInsertionSequence - -struct _ERROR_IN_STL_SEQ { - - template - static void - __fill_constructor_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - typename _XX::difference_type __n = typename _XX::difference_type(); - _XX __x(__n, __t); - __sink_unused_warning(__x); - } - template - static void - __fill_default_constructor_requirement_violation(_XX& __s) { - _STL_ERROR::__default_constructor_requirement_violation(*__s.begin()); - typename _XX::difference_type __n = typename _XX::difference_type(); - _XX __x(__n); - __sink_unused_warning(__x); - } - template - static void - __range_constructor_requirement_violation(_XX& __s) { - _XX __x(__s.begin(), __s.end()); - __sink_unused_warning(__x); - } - template - static void - __insert_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - typename _XX::iterator __p = typename _XX::iterator(); - __p = __s.insert(__p, __t); - } - template - static void - __fill_insert_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - typename _XX::iterator __p = typename _XX::iterator(); - typename _XX::difference_type __n = typename _XX::difference_type(); - __s.insert(__p, __n, __t); - } - template - static void - __range_insert_function_requirement_violation(_XX& __s) { - typename _XX::iterator __p = typename _XX::iterator(); - typename _XX::iterator __i = typename _XX::iterator(); - typename _XX::iterator __j = typename _XX::iterator(); - __s.insert(__p, __i, __j); - } - template - static void - __insert_element_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - std::pair __r; - __r = __s.insert(__t); - __sink_unused_warning(__r); - } - template - static void - __unconditional_insert_element_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - typename _XX::iterator __p; - __p = __s.insert(__t); - __sink_unused_warning(__p); - } - template - static void - __erase_function_requirement_violation(_XX& __s) { - typename _XX::iterator __p = typename _XX::iterator(); - __p = __s.erase(__p); - } - template - static void - __range_erase_function_requirement_violation(_XX& __s) { - typename _XX::iterator __p = typename _XX::iterator(); - typename _XX::iterator __q = typename _XX::iterator(); - __p = __s.erase(__p, __q); - } - template - static void - __const_front_function_requirement_violation(const _XX& __s) { - typename _XX::const_reference __t = __s.front(); - __sink_unused_warning(__t); - } - template - static void - __front_function_requirement_violation(_XX& __s) { - typename _XX::reference __t = __s.front(); - __const_front_function_requirement_violation(__s); - __sink_unused_warning(__t); - } - template - static void - __const_back_function_requirement_violation(const _XX& __s) { - typename _XX::const_reference __t = __s.back(); - __sink_unused_warning(__t); - } - template - static void - __back_function_requirement_violation(_XX& __s) { - typename _XX::reference __t = __s.back(); - __const_back_function_requirement_violation(__s); - __sink_unused_warning(__t); - } - template - static void - __push_front_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - __s.push_front(__t); - } - template - static void - __pop_front_function_requirement_violation(_XX& __s) { - __s.pop_front(); - } - template - static void - __push_back_function_requirement_violation(_XX& __s) { - typename _XX::value_type __t = typename _XX::value_type(); - __s.push_back(__t); - } - template - static void - __pop_back_function_requirement_violation(_XX& __s) { - __s.pop_back(); - } - -}; - -/* Sequence Containers */ - -template -struct _Sequence_concept_specification { -static void -_Sequence_requirement_violation(_Sequence __s) { - // Refinement of ForwardContainer - _ForwardContainer_concept_specification<_Sequence>::_ForwardContainer_requirement_violation(__s); - // Refinement of DefaultConstructible - _DefaultConstructible_concept_specification<_Sequence>::_DefaultConstructible_requirement_violation(__s); - // Valid Expressions - _ERROR_IN_STL_SEQ::__fill_constructor_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__fill_default_constructor_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__range_constructor_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__insert_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__fill_insert_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__range_insert_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__erase_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__range_erase_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__front_function_requirement_violation(__s); -} -}; - -template -struct _FrontInsertionSequence_concept_specification { -static void -_FrontInsertionSequence_requirement_violation(_FrontInsertionSequence __s) { - // Refinement of Sequence - _Sequence_concept_specification<_FrontInsertionSequence>::_Sequence_requirement_violation(__s); - // Valid Expressions - _ERROR_IN_STL_SEQ::__push_front_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__pop_front_function_requirement_violation(__s); -} -}; - -template -struct _BackInsertionSequence_concept_specification { -static void -_BackInsertionSequence_requirement_violation(_BackInsertionSequence __s) { - // Refinement of Sequence - _Sequence_concept_specification<_BackInsertionSequence>::_Sequence_requirement_violation(__s); - // Valid Expressions - _ERROR_IN_STL_SEQ::__back_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__push_back_function_requirement_violation(__s); - _ERROR_IN_STL_SEQ::__pop_back_function_requirement_violation(__s); -} -}; - -#endif /* if __STL_USE_CONCEPT_CHECKS */ - - -#endif /* STL_SEQUENCE_CONCEPTS_H */ diff --git a/libstdc++-v3/bits/slice.h b/libstdc++-v3/bits/slice.h deleted file mode 100644 index 3e4f7a743f6..00000000000 --- a/libstdc++-v3/bits/slice.h +++ /dev/null @@ -1,77 +0,0 @@ -// The template and inlines for the -*- C++ -*- slice class. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_SLICE_H -#define _CPP_BITS_SLICE_H - -namespace std { - -class slice -{ -public: - slice (); - slice (size_t, size_t, size_t); - - size_t start () const; - size_t size () const; - size_t stride () const; - -private: - size_t _M_off; // offset - size_t _M_sz; // size - size_t _M_st; // stride unit -}; - -inline slice::slice () {} - -inline slice::slice (size_t __o, size_t __d, size_t __s) - : _M_off (__o), _M_sz (__d), _M_st (__s) {} - -inline size_t -slice::start () const - { return _M_off; } - -inline size_t -slice::size () const - { return _M_sz; } - -inline size_t -slice::stride () const - { return _M_st; } - -} // std:: - - -#endif /* _CPP_BITS_SLICE_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/slice_array.h b/libstdc++-v3/bits/slice_array.h deleted file mode 100644 index 4681cb590dc..00000000000 --- a/libstdc++-v3/bits/slice_array.h +++ /dev/null @@ -1,161 +0,0 @@ -// The template and inlines for the -*- C++ -*- slice_array class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_SLICE_ARRAY_H -#define _CPP_BITS_SLICE_ARRAY_H 1 - -namespace std { - - template - class slice_array - { - public: - typedef _Tp value_type; - - void operator= (const valarray<_Tp>&) const; - void operator*= (const valarray<_Tp>&) const; - void operator/= (const valarray<_Tp>&) const; - void operator%= (const valarray<_Tp>&) const; - void operator+= (const valarray<_Tp>&) const; - void operator-= (const valarray<_Tp>&) const; - void operator^= (const valarray<_Tp>&) const; - void operator&= (const valarray<_Tp>&) const; - void operator|= (const valarray<_Tp>&) const; - void operator<<= (const valarray<_Tp>&) const; - void operator>>= (const valarray<_Tp>&) const; - void operator= (const _Tp &); - // ~slice_array (); - - template - void operator= (const _Expr<_Dom,_Tp>&) const; - template - void operator*= (const _Expr<_Dom,_Tp>&) const; - template - void operator/= (const _Expr<_Dom,_Tp>&) const; - template - void operator%= (const _Expr<_Dom,_Tp>&) const; - template - void operator+= (const _Expr<_Dom,_Tp>&) const; - template - void operator-= (const _Expr<_Dom,_Tp>&) const; - template - void operator^= (const _Expr<_Dom,_Tp>&) const; - template - void operator&= (const _Expr<_Dom,_Tp>&) const; - template - void operator|= (const _Expr<_Dom,_Tp>&) const; - template - void operator<<= (const _Expr<_Dom,_Tp>&) const; - template - void operator>>= (const _Expr<_Dom,_Tp>&) const; - - private: - friend class valarray<_Tp>; - slice_array(_Array<_Tp>, const slice&); - - const size_t _M_sz; - const size_t _M_stride; - const _Array<_Tp> _M_array; - - // this constructor is implemented since we need to return a value. - slice_array (const slice_array&); - - // not implemented - slice_array (); - slice_array& operator= (const slice_array&); - }; - - template - 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 - 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 - // inline slice_array<_Tp>::~slice_array () {} - - template - inline void - slice_array<_Tp>::operator= (const _Tp& __t) - { __valarray_fill (_M_array, _M_sz, _M_stride, __t); } - - template - inline void - slice_array<_Tp>::operator= (const valarray<_Tp>& __v) const - { __valarray_copy (_Array<_Tp> (__v), _M_array, _M_sz, _M_stride); } - - template - template - inline void - slice_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const - { __valarray_copy (__e, _M_sz, _M_array, _M_stride); } - -#undef _DEFINE_VALARRAY_OPERATOR -#define _DEFINE_VALARRAY_OPERATOR(op, name) \ -template \ -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 template \ -inline void \ -slice_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \ -{ \ - _Array_augmented_##name (_M_array, _M_stride, __e, _M_sz); \ -} - - -_DEFINE_VALARRAY_OPERATOR(*, multiplies) -_DEFINE_VALARRAY_OPERATOR(/, divides) -_DEFINE_VALARRAY_OPERATOR(%, modulus) -_DEFINE_VALARRAY_OPERATOR(+, plus) -_DEFINE_VALARRAY_OPERATOR(-, minus) -_DEFINE_VALARRAY_OPERATOR(^, xor) -_DEFINE_VALARRAY_OPERATOR(&, and) -_DEFINE_VALARRAY_OPERATOR(|, or) -_DEFINE_VALARRAY_OPERATOR(<<, shift_left) -_DEFINE_VALARRAY_OPERATOR(>>, shift_right) - -#undef _DEFINE_VALARRAY_OPERATOR - -} // std:: - -#endif /* _CPP_BITS_SLICE_ARRAY_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/sstream.tcc b/libstdc++-v3/bits/sstream.tcc deleted file mode 100644 index 5c737b4fa2e..00000000000 --- a/libstdc++-v3/bits/sstream.tcc +++ /dev/null @@ -1,220 +0,0 @@ -// String based streams -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.7 String-based streams -// - -#ifndef _CPP_BITS_SSTREAM_TCC -#define _CPP_BITS_SSTREAM_TCC 1 - -#include - -namespace std { - - template - basic_stringbuf<_CharT, _Traits, _Alloc>::int_type - basic_stringbuf<_CharT, _Traits, _Alloc>:: - pbackfail(int_type __c) - { - int_type __ret = traits_type::eof(); - bool __testeof = traits_type::eq_int_type(__c, traits_type::eof()); - bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur; - - // Try to put back __c into input sequence in one of three ways. - // Order these tests done in is unspecified by the standard. - if (__testpos) - { - if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]) - && !__testeof) - { - --_M_in_cur; - __ret = __c; - } - else if (!__testeof) - { - --_M_in_cur; - *_M_in_cur = traits_type::to_char_type(__c); - __ret = __c; - } - else if (__testeof) - { - --_M_in_cur; - __ret = traits_type::not_eof(__c); - } - } - return __ret; - } - - template - basic_stringbuf<_CharT, _Traits, _Alloc>::int_type - basic_stringbuf<_CharT, _Traits, _Alloc>:: - overflow(int_type __c) - { - int_type __ret = traits_type::eof(); - bool __testeof = traits_type::eq_int_type(__c, __ret); - bool __testwrite = _M_out_cur < _M_buf + _M_buf_size; - bool __testout = _M_mode & ios_base::out; - - // Try to append __c into output sequence in one of two ways. - // Order these tests done in is unspecified by the standard. - if (__testout) - { - if (!__testeof) - { - __size_type __len = max(_M_buf_size, _M_buf_size_opt); - __len *= 2; - - if (__testwrite) - __ret = this->sputc(__c); - else if (__len <= _M_string.max_size()) - { - // Force-allocate, re-sync. - _M_string = this->str(); - _M_string.reserve(__len); - _M_buf_size = static_cast(__len); - _M_really_sync(_M_in_cur - _M_in_beg, - _M_out_cur - _M_out_beg); - *_M_out_cur = traits_type::to_char_type(__c); - _M_out_cur_move(1); - __ret = __c; - } - } - else - __ret = traits_type::not_eof(__c); - } - return __ret; - } - - template - basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type - basic_stringbuf<_CharT, _Traits, _Alloc>:: - seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode) - { - pos_type __ret = pos_type(off_type(-1)); - bool __testin = __mode & ios_base::in && _M_mode & ios_base::in; - bool __testout = __mode & ios_base::out && _M_mode & ios_base::out; - bool __testboth = __testin && __testout && __way != ios_base::cur; - - if (_M_buf_size && ((__testin != __testout) || __testboth)) - { - char_type* __beg = _M_buf; - char_type* __curi = NULL; - char_type* __curo = NULL; - char_type* __endi = NULL; - char_type* __endo = NULL; - - if (__testin) - { - __curi = this->gptr(); - __endi = this->egptr(); - } - if (__testout) - { - __curo = this->pptr(); - __endo = this->epptr(); - } - - off_type __newoffi = 0; - off_type __newoffo = 0; - if (__way == ios_base::cur) - { - __newoffi = __curi - __beg; - __newoffo = __curo - __beg; - } - else if (__way == ios_base::end) - { - __newoffi = __endi - __beg; - __newoffo = __endo - __beg; - } - - if (__testin - && __newoffi + __off >= 0 && __endi - __beg >= __newoffi + __off) - { - _M_in_cur = __beg + __newoffi + __off; - __ret = pos_type(__newoffi); - } - if (__testout - && __newoffo + __off >= 0 && __endo - __beg >= __newoffo + __off) - { - _M_out_cur_move(__newoffo + __off - (_M_out_cur - __beg)); - __ret = pos_type(__newoffo); - } - } - return __ret; - } - - template - basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type - basic_stringbuf<_CharT, _Traits, _Alloc>:: - seekpos(pos_type __sp, ios_base::openmode __mode) - { - pos_type __ret = pos_type(off_type(-1)); - off_type __pos = __sp._M_position(); - char_type* __beg = NULL; - char_type* __end = NULL; - bool __testin = __mode & ios_base::in && _M_mode & ios_base::in; - bool __testout = __mode & ios_base::out && _M_mode & ios_base::out; - - if (__testin) - { - __beg = this->eback(); - __end = this->egptr(); - } - if (__testout) - { - __beg = this->pbase(); - __end = _M_buf + _M_buf_size; - } - - if (0 <= __pos && __pos <= __end - __beg) - { - // Need to set both of these if applicable - if (__testin) - _M_in_cur = _M_in_beg + __pos; - if (__testout) - _M_out_cur_move((__pos) - (_M_out_cur - __beg)); - __ret = pos_type(off_type(__pos)); - } - - return __ret; - } - -} // namespace std - -#endif /* _CPP_BITS_SSTREAM_TCC */ - - - - - - - - - diff --git a/libstdc++-v3/bits/std_algorithm.h b/libstdc++-v3/bits/std_algorithm.h deleted file mode 100644 index 3f084265506..00000000000 --- a/libstdc++-v3/bits/std_algorithm.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_ALGORITHM -#define _CPP_ALGORITHM 1 - -#include -#include -#include -#include -#include - -#endif /* _CPP_ALGORITHM */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_bitset.h b/libstdc++-v3/bits/std_bitset.h deleted file mode 100644 index 52f567854cb..00000000000 --- a/libstdc++-v3/bits/std_bitset.h +++ /dev/null @@ -1,1076 +0,0 @@ -/* - * Copyright (c) 1998 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef __SGI_STL_BITSET -#define __SGI_STL_BITSET - -// 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 of class bitset<> that those unused bits are -// always zero. - -// Most of the actual code isn't contained in bitset<> itself, but in the -// base class _Base_bitset. The base class works with whole words, not with -// individual bits. This allows us to specialize _Base_bitset for the -// important special case where the bitset is only a single word. - -// The C++ standard does not define the precise semantics of operator[]. -// In this implementation the const version of operator[] is equivalent -// to test(), except that it does no range checking. The non-const version -// returns a reference to a bit, again without doing any range checking. - - -#include // for size_t -#include // for memset -#include -#include // for invalid_argument, out_of_range, - // overflow_error - -#ifdef __STL_USE_NEW_IOSTREAMS -#include -#else -#include // for istream, ostream -#endif - -#define __BITS_PER_WORD (CHAR_BIT*sizeof(unsigned long)) -#define __BITSET_WORDS(__n) \ - ((__n) < 1 ? 1 : ((__n) + __BITS_PER_WORD - 1)/__BITS_PER_WORD) - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1209 -#endif - -// structure to aid in counting bits -template -struct _Bit_count { - static unsigned char _S_bit_count[256]; -}; - -// Mapping from 8 bit unsigned integers to the index of the first one -// bit: -template -struct _First_one { - static unsigned char _S_first_one[256]; -}; - -// -// Base class: general case. -// - -template -struct _Base_bitset { - typedef unsigned long _WordT; - - _WordT _M_w[_Nw]; // 0 is the least significant word. - - _Base_bitset( void ) { _M_do_reset(); } - _Base_bitset(unsigned long __val) { - _M_do_reset(); - _M_w[0] = __val; - } - - static size_t _S_whichword( size_t __pos ) - { return __pos / __BITS_PER_WORD; } - static size_t _S_whichbyte( size_t __pos ) - { return (__pos % __BITS_PER_WORD) / CHAR_BIT; } - static size_t _S_whichbit( size_t __pos ) - { return __pos % __BITS_PER_WORD; } - static _WordT _S_maskbit( size_t __pos ) - { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } - - _WordT& _M_getword(size_t __pos) { return _M_w[_S_whichword(__pos)]; } - _WordT _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; } - - _WordT& _M_hiword() { return _M_w[_Nw - 1]; } - _WordT _M_hiword() const { return _M_w[_Nw - 1]; } - - void _M_do_and(const _Base_bitset<_Nw>& __x) { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _M_w[__i] &= __x._M_w[__i]; - } - } - - void _M_do_or(const _Base_bitset<_Nw>& __x) { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _M_w[__i] |= __x._M_w[__i]; - } - } - - void _M_do_xor(const _Base_bitset<_Nw>& __x) { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _M_w[__i] ^= __x._M_w[__i]; - } - } - - void _M_do_left_shift(size_t __shift); - void _M_do_right_shift(size_t __shift); - - void _M_do_flip() { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _M_w[__i] = ~_M_w[__i]; - } - } - - void _M_do_set() { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _M_w[__i] = ~static_cast<_WordT>(0); - } - } - - void _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); } - - bool _M_is_equal(const _Base_bitset<_Nw>& __x) const { - for (size_t __i = 0; __i < _Nw; ++__i) { - if (_M_w[__i] != __x._M_w[__i]) - return false; - } - return true; - } - - bool _M_is_any() const { - for ( size_t __i = 0; __i < _Nw; __i++ ) { - if ( _M_w[__i] != static_cast<_WordT>(0) ) - return true; - } - return false; - } - - size_t _M_do_count() const { - size_t __result = 0; - const unsigned char* __byte_ptr = (const unsigned char*)_M_w; - const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw); - - while ( __byte_ptr < __end_ptr ) { - __result += _Bit_count::_S_bit_count[*__byte_ptr]; - __byte_ptr++; - } - return __result; - } - - unsigned long _M_do_to_ulong() const; - - // find first "on" bit - size_t _M_do_find_first(size_t __not_found) const; - - // find the next "on" bit that follows "prev" - size_t _M_do_find_next(size_t __prev, size_t __not_found) const; -}; - -// -// Definitions of non-inline functions from _Base_bitset. -// - -template -void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) -{ - if (__shift != 0) { - const size_t __wshift = __shift / __BITS_PER_WORD; - const size_t __offset = __shift % __BITS_PER_WORD; - - if (__offset == 0) - for (size_t __n = _Nw - 1; __n >= __wshift; --__n) - _M_w[__n] = _M_w[__n - __wshift]; - - else { - const size_t __sub_offset = __BITS_PER_WORD - __offset; - for (size_t __n = _Nw - 1; __n > __wshift; --__n) - _M_w[__n] = (_M_w[__n - __wshift] << __offset) | - (_M_w[__n - __wshift - 1] >> __sub_offset); - _M_w[__wshift] = _M_w[0] << __offset; - } - - fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); - } -} - -template -void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) -{ - if (__shift != 0) { - const size_t __wshift = __shift / __BITS_PER_WORD; - const size_t __offset = __shift % __BITS_PER_WORD; - const size_t __limit = _Nw - __wshift - 1; - - if (__offset == 0) - for (size_t __n = 0; __n <= __limit; ++__n) - _M_w[__n] = _M_w[__n + __wshift]; - - else { - const size_t __sub_offset = __BITS_PER_WORD - __offset; - for (size_t __n = 0; __n < __limit; ++__n) - _M_w[__n] = (_M_w[__n + __wshift] >> __offset) | - (_M_w[__n + __wshift + 1] << __sub_offset); - _M_w[__limit] = _M_w[_Nw-1] >> __offset; - } - - fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); - } -} - -template -unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const -{ - for (size_t __i = 1; __i < _Nw; ++__i) - if (_M_w[__i]) - __STL_THROW(overflow_error("bitset")); - - return _M_w[0]; -} - -template -size_t _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const -{ - for ( size_t __i = 0; __i < _Nw; __i++ ) { - _WordT __thisword = _M_w[__i]; - if ( __thisword != static_cast<_WordT>(0) ) { - // find byte within word - for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { - unsigned char __this_byte - = static_cast(__thisword & (~(unsigned char)0)); - if ( __this_byte ) - return __i*__BITS_PER_WORD + __j*CHAR_BIT + - _First_one::_S_first_one[__this_byte]; - - __thisword >>= CHAR_BIT; - } - } - } - // not found, so return an indication of failure. - return __not_found; -} - -template -size_t -_Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const -{ - // make bound inclusive - ++__prev; - - // check out of bounds - if ( __prev >= _Nw * __BITS_PER_WORD ) - return __not_found; - - // search first word - size_t __i = _S_whichword(__prev); - _WordT __thisword = _M_w[__i]; - - // mask off bits below bound - __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); - - if ( __thisword != static_cast<_WordT>(0) ) { - // find byte within word - // get first byte into place - __thisword >>= _S_whichbyte(__prev) * CHAR_BIT; - for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) { - unsigned char __this_byte - = static_cast(__thisword & (~(unsigned char)0)); - if ( __this_byte ) - return __i*__BITS_PER_WORD + __j*CHAR_BIT + - _First_one::_S_first_one[__this_byte]; - - __thisword >>= CHAR_BIT; - } - } - - // check subsequent words - __i++; - for ( ; __i < _Nw; __i++ ) { - _WordT __thisword = _M_w[__i]; - if ( __thisword != static_cast<_WordT>(0) ) { - // find byte within word - for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { - unsigned char __this_byte - = static_cast(__thisword & (~(unsigned char)0)); - if ( __this_byte ) - return __i*__BITS_PER_WORD + __j*CHAR_BIT + - _First_one::_S_first_one[__this_byte]; - - __thisword >>= CHAR_BIT; - } - } - } - - // not found, so return an indication of failure. - return __not_found; -} // end _M_do_find_next - - -// ------------------------------------------------------------ - -// -// Base class: specialization for a single word. -// - -__STL_TEMPLATE_NULL struct _Base_bitset<1> { - typedef unsigned long _WordT; - _WordT _M_w; - - _Base_bitset( void ) : _M_w(0) {} - _Base_bitset(unsigned long __val) : _M_w(__val) {} - - static size_t _S_whichword( size_t __pos ) - { return __pos / __BITS_PER_WORD; } - static size_t _S_whichbyte( size_t __pos ) - { return (__pos % __BITS_PER_WORD) / CHAR_BIT; } - static size_t _S_whichbit( size_t __pos ) - { return __pos % __BITS_PER_WORD; } - static _WordT _S_maskbit( size_t __pos ) - { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } - - _WordT& _M_getword(size_t) { return _M_w; } - _WordT _M_getword(size_t) const { return _M_w; } - - _WordT& _M_hiword() { return _M_w; } - _WordT _M_hiword() const { return _M_w; } - - void _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; } - void _M_do_or(const _Base_bitset<1>& __x) { _M_w |= __x._M_w; } - void _M_do_xor(const _Base_bitset<1>& __x) { _M_w ^= __x._M_w; } - void _M_do_left_shift(size_t __shift) { _M_w <<= __shift; } - void _M_do_right_shift(size_t __shift) { _M_w >>= __shift; } - void _M_do_flip() { _M_w = ~_M_w; } - void _M_do_set() { _M_w = ~static_cast<_WordT>(0); } - void _M_do_reset() { _M_w = 0; } - - bool _M_is_equal(const _Base_bitset<1>& __x) const - { return _M_w == __x._M_w; } - bool _M_is_any() const - { return _M_w != 0; } - - size_t _M_do_count() const { - size_t __result = 0; - const unsigned char* __byte_ptr = (const unsigned char*)&_M_w; - const unsigned char* __end_ptr - = ((const unsigned char*)&_M_w)+sizeof(_M_w); - while ( __byte_ptr < __end_ptr ) { - __result += _Bit_count::_S_bit_count[*__byte_ptr]; - __byte_ptr++; - } - return __result; - } - - unsigned long _M_do_to_ulong() const { return _M_w; } - - size_t _M_do_find_first(size_t __not_found) const; - - // find the next "on" bit that follows "prev" - size_t _M_do_find_next(size_t __prev, size_t __not_found) const; - -}; - -// -// Definitions of non-inline functions from the single-word version of -// _Base_bitset. -// - -size_t _Base_bitset<1>::_M_do_find_first(size_t __not_found) const -{ - _WordT __thisword = _M_w; - - if ( __thisword != static_cast<_WordT>(0) ) { - // find byte within word - for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { - unsigned char __this_byte - = static_cast(__thisword & (~(unsigned char)0)); - if ( __this_byte ) - return __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; - - __thisword >>= CHAR_BIT; - } - } - // not found, so return a value that indicates failure. - return __not_found; -} - -size_t _Base_bitset<1>::_M_do_find_next(size_t __prev, size_t __not_found ) const -{ - // make bound inclusive - ++__prev; - - // check out of bounds - if ( __prev >= __BITS_PER_WORD ) - return __not_found; - - // search first (and only) word - _WordT __thisword = _M_w; - - // mask off bits below bound - __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); - - if ( __thisword != static_cast<_WordT>(0) ) { - // find byte within word - // get first byte into place - __thisword >>= _S_whichbyte(__prev) * CHAR_BIT; - for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) { - unsigned char __this_byte - = static_cast(__thisword & (~(unsigned char)0)); - if ( __this_byte ) - return __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; - - __thisword >>= CHAR_BIT; - } - } - - // not found, so return a value that indicates failure. - return __not_found; -} // end _M_do_find_next - - -// ------------------------------------------------------------ -// Helper class to zero out the unused high-order bits in the highest word. - -template struct _Sanitize { - static void _M_do_sanitize(unsigned long& __val) - { __val &= ~((~static_cast(0)) << _Extrabits); } -}; - -__STL_TEMPLATE_NULL struct _Sanitize<0> { - static void _M_do_sanitize(unsigned long) {} -}; - - - -// ------------------------------------------------------------ -// Class bitset. -// _Nb may be any nonzero number of type size_t. - -template -class bitset : private _Base_bitset<__BITSET_WORDS(_Nb)> -{ -private: - typedef _Base_bitset<__BITSET_WORDS(_Nb)> _Base; - typedef unsigned long _WordT; - -private: - void _M_do_sanitize() { - _Sanitize<_Nb%__BITS_PER_WORD>::_M_do_sanitize(this->_M_hiword()); - } - -public: - - // bit reference: - class reference; - friend class reference; - - class reference { - friend class bitset; - - _WordT *_M_wp; - size_t _M_bpos; - - // left undefined - reference(); - - public: - reference( bitset& __b, size_t __pos ) { - _M_wp = &__b._M_getword(__pos); - _M_bpos = _Base::_S_whichbit(__pos); - } - - ~reference() {} - - // for b[i] = __x; - reference& operator=(bool __x) { - if ( __x ) - *_M_wp |= _Base::_S_maskbit(_M_bpos); - else - *_M_wp &= ~_Base::_S_maskbit(_M_bpos); - - return *this; - } - - // for b[i] = b[__j]; - reference& operator=(const reference& __j) { - if ( (*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)) ) - *_M_wp |= _Base::_S_maskbit(_M_bpos); - else - *_M_wp &= ~_Base::_S_maskbit(_M_bpos); - - return *this; - } - - // flips the bit - bool operator~() const - { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } - - // for __x = b[i]; - operator bool() const - { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } - - // for b[i].flip(); - reference& flip() { - *_M_wp ^= _Base::_S_maskbit(_M_bpos); - return *this; - } - }; - - // 23.3.5.1 constructors: - bitset() {} - bitset(unsigned long __val) : _Base_bitset<__BITSET_WORDS(_Nb)>(__val) - { _M_do_sanitize(); } - -#ifdef __STL_MEMBER_TEMPLATES - template - explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s, - size_t __pos = 0) - : _Base() - { - if (__pos > __s.size()) - __STL_THROW(out_of_range("bitset")); - _M_copy_from_string(__s, __pos, - basic_string<_CharT, _Traits, _Alloc>::npos); - } - template - bitset(const basic_string<_CharT, _Traits, _Alloc>& __s, - size_t __pos, - size_t __n) - : _Base() - { - if (__pos > __s.size()) - __STL_THROW(out_of_range("bitset")); - _M_copy_from_string(__s, __pos, __n); - } -#else /* __STL_MEMBER_TEMPLATES */ - explicit bitset(const basic_string& __s, - size_t __pos = 0, - size_t __n = basic_string::npos) - : _Base() - { - if (__pos > __s.size()) - __STL_THROW(out_of_range("bitset")); - _M_copy_from_string(__s, __pos, __n); - } -#endif /* __STL_MEMBER_TEMPLATES */ - - // 23.3.5.2 bitset operations: - bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) { - this->_M_do_and(__rhs); - return *this; - } - - bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) { - this->_M_do_or(__rhs); - return *this; - } - - bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) { - this->_M_do_xor(__rhs); - return *this; - } - - bitset<_Nb>& operator<<=(size_t __pos) { - this->_M_do_left_shift(__pos); - this->_M_do_sanitize(); - return *this; - } - - bitset<_Nb>& operator>>=(size_t __pos) { - this->_M_do_right_shift(__pos); - this->_M_do_sanitize(); - return *this; - } - - // - // Extension: - // Versions of single-bit set, reset, flip, test with no range checking. - // - - bitset<_Nb>& _Unchecked_set(size_t __pos) { - this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); - return *this; - } - - bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) { - if (__val) - this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); - else - this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); - - return *this; - } - - bitset<_Nb>& _Unchecked_reset(size_t __pos) { - this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); - return *this; - } - - bitset<_Nb>& _Unchecked_flip(size_t __pos) { - this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); - return *this; - } - - bool _Unchecked_test(size_t __pos) const { - return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) - != static_cast<_WordT>(0); - } - - // Set, reset, and flip. - - bitset<_Nb>& set() { - this->_M_do_set(); - this->_M_do_sanitize(); - return *this; - } - - bitset<_Nb>& set(size_t __pos) { - if (__pos >= _Nb) - __STL_THROW(out_of_range("bitset")); - - return _Unchecked_set(__pos); - } - - bitset<_Nb>& set(size_t __pos, int __val) { - if (__pos >= _Nb) - __STL_THROW(out_of_range("bitset")); - - return _Unchecked_set(__pos, __val); - } - - bitset<_Nb>& reset() { - this->_M_do_reset(); - return *this; - } - - bitset<_Nb>& reset(size_t __pos) { - if (__pos >= _Nb) - __STL_THROW(out_of_range("bitset")); - - return _Unchecked_reset(__pos); - } - - bitset<_Nb>& flip() { - this->_M_do_flip(); - this->_M_do_sanitize(); - return *this; - } - - bitset<_Nb>& flip(size_t __pos) { - if (__pos >= _Nb) - __STL_THROW(out_of_range("bitset")); - - return _Unchecked_flip(__pos); - } - - bitset<_Nb> operator~() const { - return bitset<_Nb>(*this).flip(); - } - - // element access: - //for b[i]; - reference operator[](size_t __pos) { return reference(*this,__pos); } - bool operator[](size_t __pos) const { return _Unchecked_test(__pos); } - - unsigned long to_ulong() const { return this->_M_do_to_ulong(); } - -#if defined(__STL_MEMBER_TEMPLATES) && \ - defined(__STL_EXPLICIT_FUNCTION_TMPL_ARGS) - template - basic_string<_CharT, _Traits, _Alloc> to_string() const { - basic_string<_CharT, _Traits, _Alloc> __result; - _M_copy_to_string(__result); - return __result; - } -#endif /* member templates and explicit function template args */ - - // Helper functions for string operations. -#ifdef __STL_MEMBER_TEMPLATES - template - void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, - size_t, - size_t); - - template - void _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const; -#else /* __STL_MEMBER_TEMPLATES */ - void _M_copy_from_string(const basic_string&, size_t, size_t); - void _M_copy_to_string(basic_string&) const; -#endif /* __STL_MEMBER_TEMPLATES */ - - size_t count() const { return this->_M_do_count(); } - - size_t size() const { return _Nb; } - - bool operator==(const bitset<_Nb>& __rhs) const { - return this->_M_is_equal(__rhs); - } - bool operator!=(const bitset<_Nb>& __rhs) const { - return !this->_M_is_equal(__rhs); - } - - bool test(size_t __pos) const { - if (__pos > _Nb) - __STL_THROW(out_of_range("bitset")); - - return _Unchecked_test(__pos); - } - - bool any() const { return this->_M_is_any(); } - bool none() const { return !this->_M_is_any(); } - - bitset<_Nb> operator<<(size_t __pos) const - { return bitset<_Nb>(*this) <<= __pos; } - bitset<_Nb> operator>>(size_t __pos) const - { return bitset<_Nb>(*this) >>= __pos; } - - // - // EXTENSIONS: bit-find operations. These operations are - // experimental, and are subject to change or removal in future - // versions. - // - - // find the index of the first "on" bit - size_t _Find_first() const - { return this->_M_do_find_first(_Nb); } - - // find the index of the next "on" bit after prev - size_t _Find_next( size_t __prev ) const - { return this->_M_do_find_next(__prev, _Nb); } - -}; - -// -// Definitions of non-inline member functions. -// - -#ifdef __STL_MEMBER_TEMPLATES - -template -template -void bitset<_Nb> - ::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, - size_t __pos, - size_t __n) -{ - reset(); - const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos)); - for (size_t __i = 0; __i < __nbits; ++__i) { - switch(__s[__pos + __nbits - __i - 1]) { - case '0': - break; - case '1': - set(__i); - break; - default: - __STL_THROW(invalid_argument("bitset")); - } - } -} - -template -template -void bitset<_Nb> - ::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const -{ - __s.assign(_Nb, '0'); - - for (size_t __i = 0; __i < _Nb; ++__i) - if (_Unchecked_test(__i)) - __s[_Nb - 1 - __i] = '1'; -} - -#else /* __STL_MEMBER_TEMPLATES */ - -template -void bitset<_Nb>::_M_copy_from_string(const basic_string& __s, - size_t __pos, size_t __n) -{ - reset(); - size_t __tmp = _Nb; - const size_t __nbits = min(__tmp, min(__n, __s.size() - __pos)); - for (size_t __i = 0; __i < __nbits; ++__i) { - switch(__s[__pos + __nbits - __i - 1]) { - case '0': - break; - case '1': - set(__i); - break; - default: - __STL_THROW(invalid_argument("bitset")); - } - } -} - -template -void bitset<_Nb>::_M_copy_to_string(basic_string& __s) const -{ - __s.assign(_Nb, '0'); - - for (size_t __i = 0; __i < _Nb; ++__i) - if (_Unchecked_test(__i)) - __s[_Nb - 1 - __i] = '1'; -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -// ------------------------------------------------------------ - -// -// 23.3.5.3 bitset operations: -// - -template -inline bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) { - bitset<_Nb> __result(__x); - __result &= __y; - return __result; -} - - -template -inline bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) { - bitset<_Nb> __result(__x); - __result |= __y; - return __result; -} - -template -inline bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) { - bitset<_Nb> __result(__x); - __result ^= __y; - return __result; -} - -#ifdef __STL_USE_NEW_IOSTREAMS - -template -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) -{ - typedef typename _Traits::char_type char_type; - basic_string<_CharT, _Traits> __tmp; - __tmp.reserve(_Nb); - - // Skip whitespace - typename basic_istream<_CharT, _Traits>::sentry __sentry(__is); - if (__sentry) { - basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf(); - for (size_t __i = 0; __i < _Nb; ++__i) { - static _Traits::int_type __eof = _Traits::eof(); - - typename _Traits::int_type __c1 = __buf->sbumpc(); - if (_Traits::eq_int_type(__c1, __eof)) { - __is.setstate(ios_base::eofbit); - break; - } - else { - char_type __c2 = _Traits::to_char_type(__c1); - char_type __c = __is.narrow(__c2, '*'); - - if (__c == '0' || __c == '1') - __tmp.push_back(__c); - else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) { - __is.setstate(ios_base::failbit); - break; - } - } - } - - if (__tmp.empty()) - __is.setstate(ios_base::failbit); - else - __x._M_copy_from_string(__tmp, static_cast(0), _Nb); - } - - return __is; -} - -template -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x) -{ - basic_string<_CharT, _Traits> __tmp; - __x._M_copy_to_string(__tmp); - return __os << __tmp; -} - -#else /* __STL_USE_NEW_IOSTREAMS */ - -template -istream& operator>>(istream& __is, bitset<_Nb>& __x) { - string __tmp; - __tmp.reserve(_Nb); - - if (__is.flags() & ios::skipws) { - char __c; - do - __is.get(__c); - while (__is && isspace(__c)); - if (__is) - __is.putback(__c); - } - - for (size_t __i = 0; __i < _Nb; ++__i) { - char __c; - __is.get(__c); - - if (!__is) - break; - else if (__c != '0' && __c != '1') { - __is.putback(__c); - break; - } - else - __tmp.push_back(__c); - } - - if (__tmp.empty()) - __is.clear(__is.rdstate() | ios::failbit); - else - __x._M_copy_from_string(__tmp, static_cast(0), _Nb); - - return __is; -} - -template -ostream& operator<<(ostream& __os, const bitset<_Nb>& __x) { - string __tmp; - __x._M_copy_to_string(__tmp); - return __os << __tmp; -} - -#endif /* __STL_USE_NEW_IOSTREAMS */ - -// ------------------------------------------------------------ -// Lookup tables for find and count operations. - -template -unsigned char _Bit_count<__dummy>::_S_bit_count[] = { - 0, /* 0 */ 1, /* 1 */ 1, /* 2 */ 2, /* 3 */ 1, /* 4 */ - 2, /* 5 */ 2, /* 6 */ 3, /* 7 */ 1, /* 8 */ 2, /* 9 */ - 2, /* 10 */ 3, /* 11 */ 2, /* 12 */ 3, /* 13 */ 3, /* 14 */ - 4, /* 15 */ 1, /* 16 */ 2, /* 17 */ 2, /* 18 */ 3, /* 19 */ - 2, /* 20 */ 3, /* 21 */ 3, /* 22 */ 4, /* 23 */ 2, /* 24 */ - 3, /* 25 */ 3, /* 26 */ 4, /* 27 */ 3, /* 28 */ 4, /* 29 */ - 4, /* 30 */ 5, /* 31 */ 1, /* 32 */ 2, /* 33 */ 2, /* 34 */ - 3, /* 35 */ 2, /* 36 */ 3, /* 37 */ 3, /* 38 */ 4, /* 39 */ - 2, /* 40 */ 3, /* 41 */ 3, /* 42 */ 4, /* 43 */ 3, /* 44 */ - 4, /* 45 */ 4, /* 46 */ 5, /* 47 */ 2, /* 48 */ 3, /* 49 */ - 3, /* 50 */ 4, /* 51 */ 3, /* 52 */ 4, /* 53 */ 4, /* 54 */ - 5, /* 55 */ 3, /* 56 */ 4, /* 57 */ 4, /* 58 */ 5, /* 59 */ - 4, /* 60 */ 5, /* 61 */ 5, /* 62 */ 6, /* 63 */ 1, /* 64 */ - 2, /* 65 */ 2, /* 66 */ 3, /* 67 */ 2, /* 68 */ 3, /* 69 */ - 3, /* 70 */ 4, /* 71 */ 2, /* 72 */ 3, /* 73 */ 3, /* 74 */ - 4, /* 75 */ 3, /* 76 */ 4, /* 77 */ 4, /* 78 */ 5, /* 79 */ - 2, /* 80 */ 3, /* 81 */ 3, /* 82 */ 4, /* 83 */ 3, /* 84 */ - 4, /* 85 */ 4, /* 86 */ 5, /* 87 */ 3, /* 88 */ 4, /* 89 */ - 4, /* 90 */ 5, /* 91 */ 4, /* 92 */ 5, /* 93 */ 5, /* 94 */ - 6, /* 95 */ 2, /* 96 */ 3, /* 97 */ 3, /* 98 */ 4, /* 99 */ - 3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */ - 4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */ - 5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */ - 5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */ - 4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */ - 6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */ - 2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */ - 4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */ - 3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */ - 3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */ - 4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */ - 5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */ - 2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */ - 4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */ - 4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */ - 6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */ - 4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */ - 5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */ - 6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */ - 4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */ - 3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */ - 5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */ - 4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */ - 6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */ - 5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */ - 4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */ - 5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */ - 6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */ - 4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */ - 6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */ - 6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */ - 8 /* 255 */ -}; // end _Bit_count - -template -unsigned char _First_one<__dummy>::_S_first_one[] = { - 0, /* 0 */ 0, /* 1 */ 1, /* 2 */ 0, /* 3 */ 2, /* 4 */ - 0, /* 5 */ 1, /* 6 */ 0, /* 7 */ 3, /* 8 */ 0, /* 9 */ - 1, /* 10 */ 0, /* 11 */ 2, /* 12 */ 0, /* 13 */ 1, /* 14 */ - 0, /* 15 */ 4, /* 16 */ 0, /* 17 */ 1, /* 18 */ 0, /* 19 */ - 2, /* 20 */ 0, /* 21 */ 1, /* 22 */ 0, /* 23 */ 3, /* 24 */ - 0, /* 25 */ 1, /* 26 */ 0, /* 27 */ 2, /* 28 */ 0, /* 29 */ - 1, /* 30 */ 0, /* 31 */ 5, /* 32 */ 0, /* 33 */ 1, /* 34 */ - 0, /* 35 */ 2, /* 36 */ 0, /* 37 */ 1, /* 38 */ 0, /* 39 */ - 3, /* 40 */ 0, /* 41 */ 1, /* 42 */ 0, /* 43 */ 2, /* 44 */ - 0, /* 45 */ 1, /* 46 */ 0, /* 47 */ 4, /* 48 */ 0, /* 49 */ - 1, /* 50 */ 0, /* 51 */ 2, /* 52 */ 0, /* 53 */ 1, /* 54 */ - 0, /* 55 */ 3, /* 56 */ 0, /* 57 */ 1, /* 58 */ 0, /* 59 */ - 2, /* 60 */ 0, /* 61 */ 1, /* 62 */ 0, /* 63 */ 6, /* 64 */ - 0, /* 65 */ 1, /* 66 */ 0, /* 67 */ 2, /* 68 */ 0, /* 69 */ - 1, /* 70 */ 0, /* 71 */ 3, /* 72 */ 0, /* 73 */ 1, /* 74 */ - 0, /* 75 */ 2, /* 76 */ 0, /* 77 */ 1, /* 78 */ 0, /* 79 */ - 4, /* 80 */ 0, /* 81 */ 1, /* 82 */ 0, /* 83 */ 2, /* 84 */ - 0, /* 85 */ 1, /* 86 */ 0, /* 87 */ 3, /* 88 */ 0, /* 89 */ - 1, /* 90 */ 0, /* 91 */ 2, /* 92 */ 0, /* 93 */ 1, /* 94 */ - 0, /* 95 */ 5, /* 96 */ 0, /* 97 */ 1, /* 98 */ 0, /* 99 */ - 2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */ - 0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */ - 1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */ - 0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */ - 3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */ - 0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */ - 1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */ - 0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */ - 2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */ - 0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */ - 1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */ - 0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */ - 5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */ - 0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */ - 1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */ - 0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */ - 2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */ - 0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */ - 1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */ - 0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */ - 3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */ - 0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */ - 1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */ - 0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */ - 2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */ - 0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */ - 1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */ - 0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */ - 4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */ - 0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */ - 1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */ - 0, /* 255 */ -}; // end _First_one - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1209 -#endif - -__STL_END_NAMESPACE - - -#undef __BITS_PER_WORD -#undef __BITSET_WORDS - -#endif /* __SGI_STL_BITSET */ - - -// Local Variables: -// mode:C++ -// End: - diff --git a/libstdc++-v3/bits/std_cassert.h b/libstdc++-v3/bits/std_cassert.h deleted file mode 100644 index 5d9d18445f9..00000000000 --- a/libstdc++-v3/bits/std_cassert.h +++ /dev/null @@ -1,39 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 19.2 Assertions -// - -// Note: This is not a conforming implementation. - -// No include guards on this header... - -# pragma GCC system_header -# include_next diff --git a/libstdc++-v3/bits/std_cctype.h b/libstdc++-v3/bits/std_cctype.h deleted file mode 100644 index 1c1e69c6c5d..00000000000 --- a/libstdc++-v3/bits/std_cctype.h +++ /dev/null @@ -1,211 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: -// - -#ifndef _CPP_CCTYPE -#define _CPP_CCTYPE 1 - -// This keeps isanum, et al from being propagated as macros. -#if __linux__ -#define __NO_CTYPE 1 -#endif - -# pragma GCC system_header -# include_next - -// Sequester the C non-inline implementations in the _C_Swamp:: -// namespace, and provide C++ inlines for them in the std:: namespace -// where they belong. - -namespace std -{ - // NB: If not using namespaces, can't have any of these definitions, - // as they will duplicate what's in the global namespace. - -#ifdef toupper - inline int - _S_toupper_helper(int __c) { return toupper(__c); } -# undef toupper - inline int - toupper(int __c) { return _S_toupper_helper(__c); } -#else - inline int - toupper(int __c) { return ::toupper(__c); } -#endif - -#ifdef tolower - inline int - _S_tolower_helper(int __c) { return tolower(__c); } -# undef tolower - inline int - tolower(int __c) { return _S_tolower_helper(__c); } -#else - inline int - tolower(int __c) { return ::tolower(__c); } -#endif - -#ifdef isspace - inline int - _S_isspace_helper(int __c) { return isspace(__c); } -# undef isspace - inline int - isspace(int __c) { return _S_isspace_helper(__c); } -#else - inline int - isspace(int __c) { return ::isspace(__c); } -#endif - -#ifdef isprint - inline int - _S_isprint_helper(int __c) { return isprint(__c); } -# undef isprint - inline int - isprint(int __c) { return _S_isprint_helper(__c); } -#else - inline int - isprint(int __c) { return ::isprint(__c); } -#endif - -#ifdef iscntrl - inline int - _S_iscntrl_helper(int __c) { return iscntrl(__c); } -# undef iscntrl - inline int - iscntrl(int __c) { return _S_iscntrl_helper(__c); } -#else - inline int - iscntrl(int __c) { return ::iscntrl(__c); } -#endif - -#ifdef isupper - inline int - _S_isupper_helper(int __c) { return isupper(__c); } -# undef isupper - inline int - isupper(int __c) { return _S_isupper_helper(__c); } -#else - inline int - isupper(int __c) { return ::isupper(__c); } -#endif - -#ifdef islower - inline int - _S_islower_helper(int __c) { return islower(__c); } -# undef islower - inline int - islower(int __c) { return _S_islower_helper(__c); } -#else - inline int - islower(int __c) { return ::islower(__c); } -#endif - -#ifdef isalpha - inline int - _S_isalpha_helper(int __c) { return isalpha(__c); } -# undef isalpha - inline int - isalpha(int __c) { return _S_isalpha_helper(__c); } -#else - inline int - isalpha(int __c) { return ::isalpha(__c); } -#endif - -#ifdef isdigit - inline int - _S_isdigit_helper(int __c) { return isdigit(__c); } -# undef isdigit - inline int - isdigit(int __c) { return _S_isdigit_helper(__c); } -#else - inline int - isdigit(int __c) { return ::isdigit(__c); } -#endif - -#ifdef ispunct - inline int - _S_ispunct_helper(int __c) { return ispunct(__c); } -# undef ispunct - inline int - ispunct(int __c) { return _S_ispunct_helper(__c); } -#else - inline int - ispunct(int __c) { return ::ispunct(__c); } -#endif - -#ifdef isxdigit - inline int - _S_isxdigit_helper(int __c) { return isxdigit(__c); } -# undef isxdigit - inline int - isxdigit(int __c) { return _S_isxdigit_helper(__c); } -#else - inline int - isxdigit(int __c) { return ::isxdigit(__c); } -#endif - -#ifdef isalnum - inline int - _S_isalnum_helper(int __c) { return isalnum(__c); } -# undef isalnum - inline int - isalnum(int __c) { return _S_isalnum_helper(__c); } -#else - inline int - isalnum(int __c) { return ::isalnum(__c); } -#endif - -#ifdef isgraph - inline int - _S_isgraph_helper(int __c) { return isgraph(__c); } -# undef isgraph - inline int - isgraph(int __c) { return _S_isgraph_helper(__c); } -#else - inline int - isgraph(int __c) { return ::isgraph(__c); } -#endif - -} // namespace std - -#endif // _CPP_CCTYPE - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/std_cerrno.h b/libstdc++-v3/bits/std_cerrno.h deleted file mode 100644 index abd28d560d8..00000000000 --- a/libstdc++-v3/bits/std_cerrno.h +++ /dev/null @@ -1,40 +0,0 @@ -// The -*- C++ -*- error number header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 19.3 Error numbers -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CERRNO -#define _CPP_CERRNO 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_cfloat.h b/libstdc++-v3/bits/std_cfloat.h deleted file mode 100644 index 8a317fcb490..00000000000 --- a/libstdc++-v3/bits/std_cfloat.h +++ /dev/null @@ -1,47 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 18.2.2 Implementation properties: C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CFLOAT -#define _CPP_CFLOAT 1 -# pragma GCC system_header -# include_next - -#if 0 -# ifdef __GLIBC__ -// For GNU libc we must also include this one: -# include -# endif -#endif -#endif diff --git a/libstdc++-v3/bits/std_climits.h b/libstdc++-v3/bits/std_climits.h deleted file mode 100644 index ddd6bd8b40f..00000000000 --- a/libstdc++-v3/bits/std_climits.h +++ /dev/null @@ -1,42 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 18.2.2 Implementation properties: C library -// - -// Note: This is not a conforming implementation. - -#ifndef _CPP_CLIMITS -#define _CPP_CLIMITS 1 -# pragma GCC system_header -# include_next -#endif - - diff --git a/libstdc++-v3/bits/std_clocale.h b/libstdc++-v3/bits/std_clocale.h deleted file mode 100644 index a8a44b8571a..00000000000 --- a/libstdc++-v3/bits/std_clocale.h +++ /dev/null @@ -1,41 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 18.2.2 Implementation properties: C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CLOCALE -#define _CPP_CLOCALE 1 -# pragma GCC system_header -# include_next -#endif - diff --git a/libstdc++-v3/bits/std_cmath.h b/libstdc++-v3/bits/std_cmath.h deleted file mode 100644 index d7df14b2198..00000000000 --- a/libstdc++-v3/bits/std_cmath.h +++ /dev/null @@ -1,506 +0,0 @@ -// -*- C++ -*- C math library. - -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 26.5 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CMATH -#define _CPP_CMATH 1 -# pragma GCC system_header -# include_next -# include_next - -# include - -namespace std { - - // - // int - // - - inline int abs(int i) - { return i > 0 ? i : -i; } - - inline long abs(long i) - { return i > 0 ? i : -i; } - - // - // float - // - -#if _GLIBCPP_HAVE___BUILTIN_FABSF - inline float abs(float __x) - { return __builtin_fabsf(__x); } -#elif _GLIBCPP_HAVE_FABSF - inline float abs(float __x) - { return ::fabsf(__x); } -#else - inline float abs(float __x) - { return ::fabs(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_ACOSF - inline float acos(float __x) - { return ::acosf(__x); } -#else - inline float acos(float __x) - { return ::acos(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_ASINF - inline float asin(float __x) - { return ::asinf(__x); } -#else - inline float asin(float __x) - { return ::asin(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_ATANF - inline float atan(float __x) - { return ::atanf(__x); } -#else - inline float atan(float __x) - { return ::atan(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_ATAN2F - inline float atan2(float __y, float __x) - { return ::atan2f(__y, __x); } -#else - inline float atan2(float __y, float __x) - { return ::atan2(static_cast(__y), static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_CEILF - inline float ceil(float __x) - { return ::ceilf(__x); } -#else - inline float ceil(float __x) - { return ::ceil(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_COSF - inline float cos(float __x) - { return __builtin_cosf(__x); } -#elif _GLIBCPP_HAVE_COSF - inline float cos(float __x) - { return ::cosf(__x); } -#else - inline float cos(float __x) - { return ::cos(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_COSHF - inline float cosh(float __x) - { return ::coshf(__x); } -#else - inline float cosh(float __x) - { return ::cosh(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_EXPF - inline float exp(float __x) - { return ::expf(__x); } -#else - inline float exp(float __x) - { return ::exp(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_FABSF - inline float fabs(float __x) - { return __builtin_fabsf(__x); } -#elif _GLIBCPP_HAVE_FABSF - inline float fabs(float __x) - { return ::fabsf(__x); } -#else - inline float fabs(float __x) - { return ::fabs(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_FLOORF - inline float floor(float __x) - { return ::floorf(__x); } -#else - inline float floor(float __x) - { return ::floor(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_FMODF - inline float fmod(float __x, float __y) - { return ::fmodf(__x, __y); } -#else - inline float fmod(float __x, float __y) - { return ::fmod(static_cast(__x), static_cast(__y)); } -#endif - -#if _GLIBCPP_HAVE_FREXPF - inline float frexp(float __x, int* __exp) - { return ::frexpf(__x, __exp); } -#else - inline float frexp(float __x, int* __exp) - { return ::frexp(__x, __exp); } -#endif - -#if _GLIBCPP_HAVE_LDEXPF - inline float ldexp(float __x, int __exp) - { return ::ldexpf(__x, __exp); } -#else - inline float ldexp(float __x, int __exp) - { return ::ldexp(static_cast(__x), __exp); } -#endif - -#if _GLIBCPP_HAVE_LOGF - inline float log(float __x) - { return ::logf(__x); } -#else - inline float log(float __x) - { return ::log(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_LOG10F - inline float log10(float __x) - { return ::log10f(__x); } -#else - inline float log10(float __x) - { return ::log10(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_MODFF - inline float modf(float __x, float* __iptr) - { return ::modff(__x, __iptr); } -#else - inline float modf(float __x, float* __iptr) - { - double __tmp; - double __res = ::modf(static_cast(__x), &__tmp); - *__iptr = static_cast (__tmp); - return __res; - } -#endif - -#if _GLIBCPP_HAVE_POWF - inline float pow(float __x, float __y) - { return ::powf(__x, __y); } -#else - inline float pow(float __x, float __y) - { return ::pow(static_cast(__x), static_cast(__y)); } -#endif - - float pow(float, int); - -#if _GLIBCPP_HAVE___BUILTIN_SINF - inline float sin(float __x) - { return __builtin_sinf(__x); } -#elif _GLIBCPP_HAVE_SINF - inline float sin(float __x) - { return ::sinf(__x); } -#else - inline float sin(float __x) - { return ::sin(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_SINHF - inline float sinh(float __x) - { return ::sinhf(__x); } -#else - inline float sinh(float __x) - { return ::sinh(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_SQRTF - inline float sqrt(float __x) - { return __builtin_sqrtf(__x); } -#elif _GLIBCPP_HAVE_SQRTF - inline float sqrt(float __x) - { return ::sqrtf(__x); } -#else - inline float sqrt(float __x) - { return ::sqrt(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_TANF - inline float tan(float __x) - { return ::tanf(__x); } -#else - inline float tan(float __x) - { return ::tan(static_cast(__x)); } -#endif - -#if _GLIBCPP_HAVE_TANHF - inline float tanh(float __x) - { return ::tanhf(__x); } -#else - inline float tanh(float __x) - { return ::tanh(static_cast(__x)); } -#endif - - // - // double - // - -#if _GLIBCPP_HAVE___BUILTIN_FABS - inline double abs(double __x) - { return __builtin_fabs(__x); } -#else - inline double abs(double __x) - { return ::fabs(__x); } -#endif - - inline double acos(double __x) - { return ::acos(__x); } - - inline double asin(double __x) - { return ::asin(__x); } - - inline double atan(double __x) - { return ::atan(__x); } - - inline double atan2(double __y, double __x) - { return ::atan2(__y, __x); } - - inline double ceil(double __x) - { return ::ceil(__x); } - -#if _GLIBCPP_HAVE___BUILTIN_COS - inline double cos(double __x) - { return __builtin_cos(__x); } -#else - inline double cos(double __x) - { return ::cos(__x); } -#endif - - inline double cosh(double __x) - { return ::cosh(__x); } - - inline double exp(double __x) - { return ::exp(__x); } - - -#if _GLIBCPP_HAVE___BUILTIN_FABS - inline double fabs(double __x) - { return __builtin_fabs(__x); } -#else - inline double fabs(double __x) - { return ::fabs(__x); } -#endif - - inline double floor(double __x) - { return ::floor(__x); } - - inline double fmod(double __x, double __y) - { return ::fmod(__x, __y); } - - inline double frexp(double __x, int* __exp) - { return ::frexp(__x, __exp); } - - inline double ldexp(double __x, int __exp) - { return ::ldexp(__x, __exp); } - - inline double log(double __x) - { return ::log(__x); } - - inline double log10(double __x) - { return ::log10(__x); } - - inline double modf(double __x, double* __iptr) - { return ::modf(__x, __iptr); } - - inline double pow(double __x, double __y) - { return ::pow(__x, __y); } - - double pow (double, int); - -#if _GLIBCPP_HAVE___BUILTIN_SIN - inline double sin(double __x) - { return __builtin_sin(__x); } -#else - inline double sin(double __x) - { return ::sin(__x); } -#endif - - inline double sinh(double __x) - { return ::sinh(__x); } - -#if _GLIBCPP_HAVE___BUILTIN_SQRT - inline double sqrt(double __x) - { return __builtin_fsqrt(__x); } -#else - inline double sqrt(double __x) - { return ::sqrt(__x); } -#endif - - inline double tan(double __x) - { return ::tan(__x); } - - inline double tanh(double __x) - { return ::tanh(__x); } - - // - // long double - // -#if _GLIBCPP_HAVE___BUILTIN_FABSL - inline long double abs(long double __x) - { return __builtin_fabsl(__x); } -#elif _GLIBCPP_HAVE_FABSL - inline long double abs(long double __x) - { return ::fabsl(__x); } -#endif - -#if _GLIBCPP_HAVE_ACOSL - inline long double acos(long double __x) - { return ::acosl(__x); } -#endif - -#if _GLIBCPP_HAVE_ASINL - inline long double asin(long double __x) - { return ::asinl(__x); } -#endif - -#if _GLIBCPP_HAVE_ATANL - inline long double atan(long double __x) - { return ::atanl(__x); } -#endif - -#if _GLIBCPP_HAVE_ATAN2L - inline long double atan2(long double __y, long double __x) - { return ::atan2l(__y, __x); } -#endif - -#if _GLIBCPP_HAVE_CEILL - inline long double ceil(long double __x) - { return ::ceill(__x); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_COSL - inline long double cos(long double __x) - { return __builtin_cosl(__x); } -#elif _GLIBCPP_HAVE_COSL - inline long double cos(long double __x) - { return ::cosl(__x); } -#endif - -#if _GLIBCPP_HAVE_COSHL - inline long double cosh(long double __x) - { return ::coshl(__x); } -#endif - -#if _GLIBCPP_HAVE_EXPL - inline long double exp(long double __x) - { return ::expl(__x); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_FABSL - inline long double fabs(long double __x) - { return __builtin_fabsl(__x); } -#elif _GLIBCPP_HAVE_FABSL - inline long double fabs(long double __x) - { return ::fabsl(__x); } -#endif - -#if _GLIBCPP_HAVE_FLOORL - inline long double floor(long double __x) - { return ::floorl(__x); } -#endif - -#if _GLIBCPP_HAVE_FMODL - inline long double fmod(long double __x, long double __y) - { return ::fmodl(__x, __y); } -#endif - -#if _GLIBCPP_HAVE_FREXPL - inline long double frexp(long double __x, int* __exp) - { return ::frexpl(__x, __exp); } -#endif - -#if _GLIBCPP_HAVE_LDEXPL - inline long double ldexp(long double __x, int __exp) - { return ::ldexpl(__x, __exp); } -#endif - -#if _GLIBCPP_HAVE_LOGL - inline long double log(long double __x) - { return ::logl(__x); } -#endif - -#if _GLIBCPP_HAVE_LOG10L - inline long double log10(long double __x) - { return ::log10l(__x); } -#endif - -#if _GLIBCPP_HAVE_MODFL - inline long double modf(long double __x, long double* __iptr) - { return ::modfl(__x, __iptr); } -#endif - -#if _GLIBCPP_HAVE_POWL - inline long double pow(long double __x, long double __y) - { return ::powl(__x, __y); } -#endif - - long double pow(long double, int); - -#if _GLIBCPP_HAVE___BUILTIN_SINL - inline long double sin(long double __x) - { return __builtin_sinl(__x); } -#elif _GLIBCPP_HAVE_SINL - inline long double sin(long double __x) - { return ::sinl(__x); } -#endif - -#if _GLIBCPP_HAVE_SINHL - inline long double sinh(long double __x) - { return ::sinhl(__x); } -#endif - -#if _GLIBCPP_HAVE___BUILTIN_SQRTL - inline long double sqrt(long double __x) - { return __builtin_sqrtl(__x); } -#elif _GLIBCPP_HAVE_SQRTL - inline long double sqrt(long double __x) - { return ::sqrtl(__x); } -#endif - -#if _GLIBCPP_HAVE_TANL - inline long double tan(long double __x) - { return ::tanl(__x); } -#endif - -#if _GLIBCPP_HAVE_TANHL - inline long double tanh(long double __x) - { return ::tanhl(__x); } -#endif - -} // std - -#endif // _CPP_CMATH - - diff --git a/libstdc++-v3/bits/std_complex.h b/libstdc++-v3/bits/std_complex.h deleted file mode 100644 index 63f735181da..00000000000 --- a/libstdc++-v3/bits/std_complex.h +++ /dev/null @@ -1,961 +0,0 @@ -// The template and inlines for the -*- C++ -*- complex number classes. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO 14882/26.2.1 -// Note: this is not a conforming implementation. -// Initially implemented by Ulrich Drepper -// Improved by Gabriel Dos Reis -// - -#ifndef _CPP_COMPLEX -#define _CPP_COMPLEX 1 - -#include -#include - -namespace std -{ - - // Forward declarations - template class complex; - template<> class complex; - template<> class complex; - template<> class complex; - - template _Tp abs(const complex<_Tp>&); - template _Tp arg(const complex<_Tp>&); - - template complex<_Tp> conj(const complex<_Tp>&); - template complex<_Tp> polar(const _Tp&, const _Tp&); - - // Transcendentals: - template complex<_Tp> cos(const complex<_Tp>&); - template complex<_Tp> cosh(const complex<_Tp>&); - template complex<_Tp> exp(const complex<_Tp>&); - template complex<_Tp> log(const complex<_Tp>&); - template complex<_Tp> log10(const complex<_Tp>&); - template complex<_Tp> pow(const complex<_Tp>&, int); - template complex<_Tp> pow(const complex<_Tp>&, const _Tp&); - template complex<_Tp> pow (const complex<_Tp>&, - const complex<_Tp>&); - template complex<_Tp> pow(const _Tp&, const complex<_Tp>&); - template complex<_Tp> sin(const complex<_Tp>&); - template complex<_Tp> sinh(const complex<_Tp>&); - template complex<_Tp> sqrt(const complex<_Tp>&); - template complex<_Tp> tan(const complex<_Tp>&); - template complex<_Tp> tanh(const complex<_Tp>&); - - - // - // 26.2.2 Primary template class complex - // - template - class complex - { - public: - typedef _Tp value_type; - - complex(const _Tp& = _Tp(), const _Tp & = _Tp()); - - // Let's the compiler synthetize the copy constructor - // complex (const complex<_Tp>&); - template - complex(const complex<_Up>&); - - _Tp real() const; - _Tp imag() const; - - complex<_Tp>& operator=(const _Tp&); - complex<_Tp>& operator+=(const _Tp&); - complex<_Tp>& operator-=(const _Tp&); - complex<_Tp>& operator*=(const _Tp&); - complex<_Tp>& operator/=(const _Tp&); - - // Let's the compiler synthetize the - // copy and assignment operator - // complex<_Tp>& operator= (const complex<_Tp>&); - template - complex<_Tp>& operator=(const complex<_Up>&); - template - complex<_Tp>& operator+=(const complex<_Up>&); - template - complex<_Tp>& operator-=(const complex<_Up>&); - template - complex<_Tp>& operator*=(const complex<_Up>&); - template - complex<_Tp>& operator/=(const complex<_Up>&); - - private: - _Tp _M_real, _M_imag; - }; - - template - inline _Tp - complex<_Tp>::real() const { return _M_real; } - - template - inline _Tp - complex<_Tp>::imag() const { return _M_imag; } - - - // - // 26.2.3 complex specializations - // - - // - // complex specialization - // - template<> class complex - { - public: - typedef float value_type; - - complex(float = 0.0f, float = 0.0f); -#ifdef _GLIBCPP_BUGGY_COMPLEX - complex(const complex& __z) : _M_value(__z._M_value) { } -#endif - explicit complex(const complex&); - explicit complex(const complex&); - - float real() const; - float imag() const; - - complex& operator=(float); - complex& operator+=(float); - complex& operator-=(float); - complex& operator*=(float); - complex& operator/=(float); - - // Let's the compiler synthetize the copy and assignment - // operator. It always does a pretty good job. - // complex& operator= (const complex&); - template - complex&operator=(const complex<_Tp>&); - template - complex& operator+=(const complex<_Tp>&); - template - complex& operator-=(const complex<_Tp>&); - template - complex& operator*=(const complex<_Tp>&); - template - complex&operator/=(const complex<_Tp>&); - - private: - typedef __complex__ float _ComplexT; - _ComplexT _M_value; - - complex(_ComplexT __z) : _M_value(__z) { } - - friend class complex; - friend class complex; - - friend float abs<>(const complex&); - friend float arg<>(const complex&); - - friend complex conj<>(const complex&); - - friend complex cos<>(const complex&); - friend complex cosh<>(const complex&); - friend complex exp<>(const complex&); - friend complex log<>(const complex&); - friend complex log10<>(const complex&); - friend complex pow<>(const complex&, int); - friend complex pow<>(const complex&, const float&); - friend complex pow<>(const complex&, - const complex&); - friend complex pow<>(const float&, const complex&); - friend complex sin<>(const complex&); - friend complex sinh<>(const complex&); - friend complex sqrt<>(const complex&); - friend complex tan<>(const complex&); - friend complex tanh<>(const complex&); - }; - - inline float - complex::real() const - { return __real__ _M_value; } - - inline float - complex::imag() const - { return __imag__ _M_value; } - - - // - // complex specialization - // - template<> class complex - { - public: - typedef double value_type; - - complex(double =0.0, double =0.0); -#ifdef _GLIBCPP_BUGGY_COMPLEX - complex(const complex& __z) : _M_value(__z._M_value) { } -#endif - complex(const complex&); - explicit complex(const complex&); - - double real() const; - double imag() const; - - complex& operator=(double); - complex& operator+=(double); - complex& operator-=(double); - complex& operator*=(double); - complex& operator/=(double); - - // The compiler will synthetize this, efficiently. - // complex& operator= (const complex&); - template - complex& operator=(const complex<_Tp>&); - template - complex& operator+=(const complex<_Tp>&); - template - complex& operator-=(const complex<_Tp>&); - template - complex& operator*=(const complex<_Tp>&); - template - complex& operator/=(const complex<_Tp>&); - - private: - typedef __complex__ double _ComplexT; - _ComplexT _M_value; - - complex(_ComplexT __z) : _M_value(__z) { } - - friend class complex; - friend class complex; - - friend double abs<>(const complex&); - friend double arg<>(const complex&); - - friend complex conj<>(const complex&); - friend complex cos<>(const complex&); - friend complex cosh<>(const complex&); - friend complex exp<>(const complex&); - friend complex log<>(const complex&); - friend complex log10<>(const complex&); - friend complex pow<>(const complex&, int); - friend complex pow<>(const complex&, const double&); - friend complex pow<>(const complex&, - const complex&); - friend complex pow<>(const double&, const complex&); - friend complex sin<>(const complex&); - friend complex sinh<>(const complex&); - friend complex sqrt<>(const complex&); - friend complex tan<>(const complex&); - friend complex tanh<>(const complex&); - }; - - inline double - complex::real() const - { return __real__ _M_value; } - - inline double - complex::imag() const - { return __imag__ _M_value; } - - - // - // complex specialization - // - template<> class complex - { - public: - typedef long double value_type; - - complex(long double = 0.0L, long double = 0.0L); -#ifdef _GLIBCPP_BUGGY_COMPLEX - complex(const complex& __z) : _M_value(__z._M_value) { } -#endif - complex(const complex&); - complex(const complex&); - - long double real() const; - long double imag() const; - - complex& operator= (long double); - complex& operator+= (long double); - complex& operator-= (long double); - complex& operator*= (long double); - complex& operator/= (long double); - - // The compiler knows how to do this efficiently - // complex& operator= (const complex&); - - template - complex& operator=(const complex<_Tp>&); - template - complex& operator+=(const complex<_Tp>&); - template - complex& operator-=(const complex<_Tp>&); - template - complex& operator*=(const complex<_Tp>&); - template - complex& operator/=(const complex<_Tp>&); - - private: - typedef __complex__ long double _ComplexT; - _ComplexT _M_value; - - complex(_ComplexT __z) : _M_value(__z) { } - - friend class complex; - friend class complex; - - friend long double abs<>(const complex&); - friend long double arg<>(const complex&); - - friend complex conj<>(const complex&); - friend complex cos<>(const complex&); - friend complex cosh<>(const complex&); - friend complex exp<>(const complex&); - friend complex log<>(const complex&); - friend complex log10<>(const complex&); - friend complex pow<>(const complex&, int); - friend complex pow<>(const complex&, - const long double&); - friend complex pow<>(const complex&, - const complex&); - friend complex pow<>(const long double&, - const complex&); - friend complex sin<>(const complex&); - friend complex sinh<>(const complex&); - friend complex sqrt<>(const complex&); - friend complex tan<>(const complex&); - friend complex tanh<>(const complex&); - }; - - inline - complex::complex(long double __r, long double __i) - { - __real__ _M_value = __r; - __imag__ _M_value = __i; - } - - inline - complex::complex(const complex& __z) - : _M_value(_ComplexT(__z._M_value)) { } - - inline - complex::complex(const complex& __z) - : _M_value(_ComplexT(__z._M_value)) { } - - inline long double - complex::real() const - { return __real__ _M_value; } - - inline long double - complex::imag() const - { return __imag__ _M_value; } - - inline complex& - complex::operator=(long double __r) - { - __real__ _M_value = __r; - __imag__ _M_value = 0.0L; - return *this; - } - - inline complex& - complex::operator+=(long double __r) - { - __real__ _M_value += __r; - return *this; - } - - inline complex& - complex::operator-=(long double __r) - { - __real__ _M_value -= __r; - return *this; - } - - inline complex& - complex::operator*=(long double __r) - { - __real__ _M_value *= __r; - return *this; - } - - inline complex& - complex::operator/=(long double __r) - { - __real__ _M_value /= __r; - return *this; - } - - template - inline complex& - complex::operator=(const complex<_Tp>& __z) - { - __real__ _M_value = __z.real(); - __imag__ _M_value = __z.imag(); - return *this; - } - - template - inline complex& - complex::operator+=(const complex<_Tp>& __z) - { - __real__ _M_value += __z.real(); - __imag__ _M_value += __z.imag(); - return *this; - } - - template - inline complex& - complex::operator-=(const complex<_Tp>& __z) - { - __real__ _M_value -= __z.real(); - __imag__ _M_value -= __z.imag(); - return *this; - } - - template - inline complex& - complex::operator*=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value *= __t; - return *this; - } - - template - inline complex& - complex::operator/=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value /= __t; - return *this; - } - - // - // complex continued. - // - inline - complex::complex(float r, float i) - { - __real__ _M_value = r; - __imag__ _M_value = i; - } - - inline - complex::complex(const complex& __z) - : _M_value(_ComplexT(__z._M_value)) { } - - inline - complex::complex(const complex& __z) - : _M_value(_ComplexT(__z._M_value)) { } - - inline complex& - complex::operator=(float __f) - { - __real__ _M_value = __f; - __imag__ _M_value = 0.0f; - return *this; - } - - inline complex& - complex::operator+=(float __f) - { - __real__ _M_value += __f; - return *this; - } - - inline complex& - complex::operator-=(float __f) - { - __real__ _M_value -= __f; - return *this; - } - - inline complex& - complex::operator*=(float __f) - { - _M_value *= __f; - return *this; - } - - inline complex& - complex::operator/=(float __f) - { - _M_value /= __f; - return *this; - } - - template - inline complex& - complex::operator=(const complex<_Tp>& __z) - { - __real__ _M_value = __z.real(); - __imag__ _M_value = __z.imag(); - return *this; - } - - template - inline complex& - complex::operator+=(const complex<_Tp>& __z) - { - __real__ _M_value += __z.real(); - __imag__ _M_value += __z.imag(); - return *this; - } - - template - inline complex& - complex::operator-=(const complex<_Tp>& __z) - { - __real__ _M_value -= __z.real(); - __imag__ _M_value -= __z.real(); - return *this; - } - - template - inline complex& - complex::operator*=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value *= __t; - return *this; - } - - template - inline complex& - complex::operator/=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value /= __t; - return *this; - } - - - // - // complex continued. - // - inline - complex::complex(double __r, double __i) - { - __real__ _M_value = __r; - __imag__ _M_value = __i; - } - - inline - complex::complex(const complex& __z) - : _M_value(_ComplexT(__z._M_value)) { } - - inline - complex::complex(const complex& __z) - { - __real__ _M_value = __z.real(); - __imag__ _M_value = __z.imag(); - } - - inline complex& - complex::operator=(double __d) - { - __real__ _M_value = __d; - __imag__ _M_value = 0.0; - return *this; - } - - inline complex& - complex::operator+=(double __d) - { - __real__ _M_value += __d; - return *this; - } - - inline complex& - complex::operator-=(double __d) - { - __real__ _M_value -= __d; - return *this; - } - - inline complex& - complex::operator*=(double __d) - { - _M_value *= __d; - return *this; - } - - inline complex& - complex::operator/=(double __d) - { - _M_value /= __d; - return *this; - } - - template - inline complex& - complex::operator=(const complex<_Tp>& __z) - { - __real__ _M_value = __z.real(); - __imag__ _M_value = __z.imag(); - return *this; - } - - template - inline complex& - complex::operator+=(const complex<_Tp>& __z) - { - __real__ _M_value += __z.real(); - __imag__ _M_value += __z.imag(); - return *this; - } - - template - inline complex& - complex::operator-=(const complex<_Tp>& __z) - { - __real__ _M_value -= __z.real(); - __imag__ _M_value -= __z.imag(); - return *this; - } - - template - inline complex& - complex::operator*=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value *= __t; - return *this; - } - - template - inline complex& - complex::operator/=(const complex<_Tp>& __z) - { - _ComplexT __t; - __real__ __t = __z.real(); - __imag__ __t = __z.imag(); - _M_value /= __t; - return *this; - } - - // - // Primary template class complex continued. - // - // 26.2.4 - template - inline - complex<_Tp>::complex(const _Tp& __r, const _Tp& __i) - : _M_real(__r), _M_imag(__i) { } - - template - template - inline - complex<_Tp>::complex(const complex<_Up>& __z) - : _M_real(__z.real()), _M_imag(__z.imag()) { } - - // 26.2.7/6 - template - inline complex<_Tp> - conj(const complex<_Tp>& __z) - { return complex<_Tp>(__z.real(), -__z.imag()); } - - // 26.2.7/4 - template - inline _Tp - norm(const complex<_Tp>& __z) - { - // XXX: Grammar school computation - return __z.real() * __z.real() + __z.imag() * __z.imag(); - } - - template - complex<_Tp>& - complex<_Tp>::operator=(const _Tp& __t) - { - _M_real = __t; - _M_imag = _Tp(); - return *this; - } - - // 26.2.5/1 - template - inline complex<_Tp>& - complex<_Tp>::operator+=(const _Tp& __t) - { - _M_real += __t; - return *this; - } - - // 26.2.5/3 - template - inline complex<_Tp>& - complex<_Tp>::operator-=(const _Tp& __t) - { - _M_real -= __t; - return *this; - } - - // 26.2.5/5 - template - complex<_Tp>& - complex<_Tp>::operator*=(const _Tp& __t) - { - _M_real *= __t; - _M_imag *= __t; - return *this; - } - - // 26.2.5/7 - template - complex<_Tp>& - complex<_Tp>::operator/=(const _Tp& __t) - { - _M_real /= __t; - _M_imag /= __t; - return *this; - } - - template - template - complex<_Tp>& - complex<_Tp>::operator=(const complex<_Up>& __z) - { - _M_real = __z.real(); - _M_imag = __z.imag(); - return *this; - } - - // 26.2.5/9 - template - template - complex<_Tp>& - complex<_Tp>::operator+=(const complex<_Up>& __z) - { - _M_real += __z.real(); - _M_imag += __z.imag(); - return *this; - } - - // 26.2.5/11 - template - template - complex<_Tp>& - complex<_Tp>::operator-=(const complex<_Up>& __z) - { - _M_real -= __z.real(); - _M_imag -= __z.imag(); - return *this; - } - - // 26.2.5/13 - // XXX: this is a grammar school implementation. - template - template - complex<_Tp>& - complex<_Tp>::operator*=(const complex<_Up>& __z) - { - _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); - _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); - _M_real = __r; - return *this; - } - - // 26.2.5/15 - // XXX: this is a grammar school implementation. - template - template - complex<_Tp>& - complex<_Tp>::operator/=(const complex<_Up>& __z) - { - _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); - _Tp __n = norm(__z); - _M_imag = (_M_real * __z.imag() - _M_imag * __z.real()) / __n; - _M_real = __r / __n; - return *this; - } - - // Operators: - template - inline complex<_Tp> - operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) += __y; } - - template - inline complex<_Tp> - operator+(const complex<_Tp>& __x, const _Tp& __y) - { return complex<_Tp> (__x) += __y; } - - template - inline complex<_Tp> - operator+(const _Tp& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__y) += __x; } - - template - inline complex<_Tp> - operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) -= __y; } - - template - inline complex<_Tp> - operator-(const complex<_Tp>& __x, const _Tp& __y) - { return complex<_Tp> (__x) -= __y; } - - template - inline complex<_Tp> - operator-(const _Tp& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) -= __y; } - - template - inline complex<_Tp> - operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) *= __y; } - - template - inline complex<_Tp> - operator*(const complex<_Tp>& __x, const _Tp& __y) - { return complex<_Tp> (__x) *= __y; } - - template - inline complex<_Tp> - operator*(const _Tp& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__y) *= __x; } - - template - inline complex<_Tp> - operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) /= __y; } - - template - inline complex<_Tp> - operator/(const complex<_Tp>& __x, const _Tp& __y) - { return complex<_Tp> (__x) /= __y; } - - template - inline complex<_Tp> - operator/(const _Tp& __x, const complex<_Tp>& __y) - { return complex<_Tp> (__x) /= __y; } - - template - inline complex<_Tp> - operator+(const complex<_Tp>& __x) - { return __x; } - - template - inline complex<_Tp> - operator-(const complex<_Tp>& __x) - { return complex<_Tp>(-__x.real(), -__x.imag()); } - - template - inline bool - operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return __x.real() == __y.real() && __x.imag() == __y.imag(); } - - template - inline bool - operator==(const complex<_Tp>& __x, const _Tp& __y) - { return __x.real() == __y && __x.imag() == 0; } - - template - inline bool - operator==(const _Tp& __x, const complex<_Tp>& __y) - { return __x == __y.real() && 0 == __y.imag(); } - - template - inline bool - operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) - { return __x.real() != __y.real() || __x.imag() != __y.imag(); } - - template - inline bool - operator!=(const complex<_Tp>& __x, const _Tp& __y) - { return __x.real() != __y || __x.imag() != 0; } - - template - inline bool - operator!=(const _Tp& __x, const complex<_Tp>& __y) - { return __x != __y.real() || 0 != __y.imag(); } - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>&, complex<_Tp>&); - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>&, const complex<_Tp>&); - - - // Values: - template - inline _Tp - real(const complex<_Tp>& __z) - { return __z.real(); } - - template - inline _Tp - imag(const complex<_Tp>& __z) - { return __z.imag(); } - - - // We use here a few more specializations. - template<> - inline complex - conj(const complex &__x) -#ifdef _GLIBCPP_BUGGY_FLOAT_COMPLEX - { - complex __tmpf(~__x._M_value); - return __tmpf; - } -#else - { return complex(~__x._M_value); } -#endif - - template<> - inline complex - conj(const complex &__x) - { return complex (~__x._M_value); } - - template<> - inline complex - conj(const complex &__x) - { return complex (~__x._M_value); } - -} // namespace std - -#endif /* _CPP_COMPLEX */ - - - - diff --git a/libstdc++-v3/bits/std_csetjmp.h b/libstdc++-v3/bits/std_csetjmp.h deleted file mode 100644 index fc5b339036a..00000000000 --- a/libstdc++-v3/bits/std_csetjmp.h +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.4.6 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSETJMP -#define _CPP_CSETJMP 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_csignal.h b/libstdc++-v3/bits/std_csignal.h deleted file mode 100644 index 34c03eb3df1..00000000000 --- a/libstdc++-v3/bits/std_csignal.h +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.4.6 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSIGNAL -#define _CPP_CSIGNAL 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_cstdarg.h b/libstdc++-v3/bits/std_cstdarg.h deleted file mode 100644 index f7f4235a290..00000000000 --- a/libstdc++-v3/bits/std_cstdarg.h +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.4.6 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSTDARG -#define _CPP_CSTDARG 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_cstddef.h b/libstdc++-v3/bits/std_cstddef.h deleted file mode 100644 index 5557c759571..00000000000 --- a/libstdc++-v3/bits/std_cstddef.h +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 18.1 Types -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSTDDEF -#define _CPP_CSTDDEF 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_cstdio.h b/libstdc++-v3/bits/std_cstdio.h deleted file mode 100644 index 919a03ca4c7..00000000000 --- a/libstdc++-v3/bits/std_cstdio.h +++ /dev/null @@ -1,61 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.8.2 C Library files -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSTDIO -#define _CPP_CSTDIO 1 -# pragma GCC system_header -# include_next - -#ifndef SEEK_CUR -#define SEEK_CUR 1 -#endif - -#ifndef SEEK_END -#define SEEK_END 2 -#endif - -#ifndef SEEK_SET -#define SEEK_SET 4 -#endif - -#endif - - - - - - - - diff --git a/libstdc++-v3/bits/std_cstdlib.h b/libstdc++-v3/bits/std_cstdlib.h deleted file mode 100644 index ee5435739ad..00000000000 --- a/libstdc++-v3/bits/std_cstdlib.h +++ /dev/null @@ -1,54 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.4.6 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSTDLIB -#define _CPP_CSTDLIB 1 - -// This keeps isanum, et al from being propagated as macros. -#if __linux__ -#define __USE_ISOC9X 1 -#endif - -# pragma GCC system_header -# include_next - -#endif // _CPP_CSTDLIB - - - - - - - diff --git a/libstdc++-v3/bits/std_cstring.h b/libstdc++-v3/bits/std_cstring.h deleted file mode 100644 index 06bcdda6535..00000000000 --- a/libstdc++-v3/bits/std_cstring.h +++ /dev/null @@ -1,44 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.4.6 C library -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CSTRING -#define _CPP_CSTRING 1 -# if defined __GLIBC__ && __GLIBC__ >= 2 -// We must not see the optimized string functions GNU libc defines. -# define __NO_STRING_INLINES -# endif -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_ctime.h b/libstdc++-v3/bits/std_ctime.h deleted file mode 100644 index b30b318f595..00000000000 --- a/libstdc++-v3/bits/std_ctime.h +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 20.5 Date and time -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CTIME -#define _CPP_CTIME 1 -# pragma GCC system_header -# include_next -#endif diff --git a/libstdc++-v3/bits/std_cwchar.h b/libstdc++-v3/bits/std_cwchar.h deleted file mode 100644 index 77349f9d318..00000000000 --- a/libstdc++-v3/bits/std_cwchar.h +++ /dev/null @@ -1,78 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: ??? -// - -// Note: this is not a conforming implementation. - -#ifndef _CPP_CWCHAR -#define _CPP_CWCHAR 1 - -#include - -#if _GLIBCPP_USE_WCHAR_T - # pragma GCC system_header - # include_next -#else -# ifdef __cplusplus -extern "C" -{ -#endif - typedef struct - { - int __fill[6]; - } mbstate_t; -# ifdef __cplusplus -} -# endif -#endif //_GLIBCPP_USE_WCHAR_T - -#endif // _CPP_CWCHAR - - - - - - - - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/std_cwctype.h b/libstdc++-v3/bits/std_cwctype.h deleted file mode 100644 index c67f2ba9720..00000000000 --- a/libstdc++-v3/bits/std_cwctype.h +++ /dev/null @@ -1,160 +0,0 @@ -// -*- C++ -*- forwarding header. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: -// - -#ifndef _CPP_CWCTYPE -#define _CPP_CWCTYPE 1 - -# pragma GCC system_header -# include_next - -// Sequester the C non-inline implementations in the _C_Swamp:: -// namespace, and provide C++ inlines for them in the std:: namespace -// where they belong. - -namespace std -{ - -#ifdef towupper - inline wint_t - _S_towupper_helper(wint_t __wc) { return towupper(__wc); } -# undef towupper - inline wint_t - towupper(wint_t __wc) { return _S_towupper_helper(__wc); } -#endif - -#ifdef towlower - inline wint_t - _S_towlower_helper(wint_t __wc) { return towlower(__wc); } -# undef towlower - inline wint_t - towlower(wint_t __wc) { return _S_towlower_helper(__wc); } -#endif - -#ifdef iswspace - inline int - _S_iswspace_helper(wint_t __wc) { return iswspace(__wc); } -# undef iswspace - inline int - iswspace(wint_t __wc) { return _S_iswspace_helper(__wc); } -#endif - -#ifdef iswprint - inline int - _S_iswprint_helper(wint_t __wc) { return iswprint(__wc); } -# undef iswprint - inline int - iswprint(wint_t __wc) { return _S_iswprint_helper(__wc); } -#endif - -#ifdef iswcntrl - inline int - _S_iswcntrl_helper(wint_t __wc) { return iswcntrl(__wc); } -# undef iswcntrl - inline int - iswcntrl(wint_t __wc) { return _S_iswcntrl_helper(__wc); } -#endif - -#ifdef iswupper - inline int - _S_iswupper_helper(wint_t __wc) { return iswupper(__wc); } -# undef iswupper - inline int - iswupper(wint_t __wc) { return _S_iswupper_helper(__wc); } -#endif - -#ifdef iswlower - inline int - _S_iswlower_helper(wint_t __wc) { return iswlower(__wc); } -# undef iswlower - inline int - iswlower(wint_t __wc) { return _S_iswlower_helper(__wc); } -#endif - -#ifdef iswalpha - inline int - _S_iswalpha_helper(wint_t __wc) { return iswalpha(__wc); } -# undef iswalpha - inline int - iswalpha(wint_t __wc) { return _S_iswalpha_helper(__wc); } -#endif - -#ifdef iswdigit - inline int - _S_iswdigit_helper(wint_t __wc) { return iswdigit(__wc); } -# undef iswdigit - inline int - iswdigit(wint_t __wc) { return _S_iswdigit_helper(__wc); } -#endif - -#ifdef iswpunct - inline int - _S_iswpunct_helper(wint_t __wc) { return iswpunct(__wc); } -# undef iswpunct - inline int - iswpunct(wint_t __wc) { return _S_iswpunct_helper(__wc); } -#endif - -#ifdef iswxdigit - inline int - _S_iswxdigit_helper (wint_t __wc) { return iswxdigit(__wc); } -# undef iswxdigit - inline int - iswxdigit(wint_t __wc) { return _S_iswxdigit_helper(__wc); } -#endif - -#ifdef iswalnum - inline int - _S_iswalnum_helper(wint_t __wc) { return iswalnum(__wc); } -# undef iswalnum - inline int - iswalnum(wint_t __wc) { return _S_iswalnum_helper(__wc); } -#endif - -#ifdef iswgraph - inline int - _S_iswgraph_helper(wint_t __wc) { return iswgraph(__wc); } -# undef iswgraph - inline int - iswgraph(wint_t __wc) { return _S_iswgraph_helper(__wc); } -#endif - -} // namespace std - -#endif // _CPP_CWCTYPE - - - - - - - diff --git a/libstdc++-v3/bits/std_deque.h b/libstdc++-v3/bits/std_deque.h deleted file mode 100644 index 574ab313755..00000000000 --- a/libstdc++-v3/bits/std_deque.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_DEQUE -#define _CPP_DEQUE 1 - -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_DEQUE */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_exception.h b/libstdc++-v3/bits/std_exception.h deleted file mode 100644 index 0735601891f..00000000000 --- a/libstdc++-v3/bits/std_exception.h +++ /dev/null @@ -1,81 +0,0 @@ - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -#ifndef _CPP_EXCEPTION -#define _CPP_EXCEPTION 1 - -#ifdef __GNUG__ -#pragma GCC system_header -#include_next -#else - -#include - -__STL_BEGIN_NAMESPACE - - // 18.6 Exception handling - class exception; - class bad_exception; - - typedef void (*unexpected_handler)(); - unexpected_handler set_unexpected(unexpected_handler) throw(); - void unexpected(); - typedef void (*terminate_handler)(); - terminate_handler set_terminate(terminate_handler) throw(); - void terminate(); - bool uncaught_exception(); - - // 18.6.1 Class exception - class exception { - public: - exception() throw(); - exception(const exception&) throw(); - exception& operator=(const exception&) throw(); - virtual ~exception() throw(); - virtual const char* what() const throw(); - }; - - // 18.6.2.1 Class bad_exception - class bad_exception : public exception { - public: - bad_exception() throw(); - bad_exception(const bad_exception&) throw(); - bad_exception& operator=(const bad_exception&) throw(); - virtual ~bad_exception() throw(); - virtual const char* what() const throw(); - }; - -__STL_END_NAMESPACE - -#endif /* __GNUG__ */ - -#endif /* _CPP_EXCEPTION */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_fstream.h b/libstdc++-v3/bits/std_fstream.h deleted file mode 100644 index 4cafb2d9ee3..00000000000 --- a/libstdc++-v3/bits/std_fstream.h +++ /dev/null @@ -1,420 +0,0 @@ -// File based streams -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.8 File-based streams -// - -#ifndef _CPP_FSTREAM -#define _CPP_FSTREAM 1 - -#include -#include -#include -#include // For codecvt -#include // For __mutext_type - -namespace std { - - template - class basic_filebuf : public basic_streambuf<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_streambuf __streambuf_type; - typedef basic_filebuf __filebuf_type; - typedef __basic_file __file_type; - typedef typename traits_type::state_type __state_type; - typedef codecvt __codecvt_type; - typedef typename __codecvt_type::result __res_type; - - friend class ios_base; // For sync_with_stdio. - - private: - // Data Members: - // External buffer. - __file_type* _M_file; - - // Current and beginning state type for codecvt. - __state_type _M_state_cur; - __state_type _M_state_beg; - - // Cached value from use_facet. - const __codecvt_type* _M_fcvt; - - // MT lock inherited from libio or other low-level io library. - __c_lock _M_lock; - - // XXX Needed? - bool _M_last_overflowed; - - public: - // Constructors/destructor: - basic_filebuf(); - - // Non-standard ctor: - basic_filebuf(int __fd, const char* __name, ios_base::openmode __mode); - - virtual - ~basic_filebuf() - { - this->close(); - _M_fcvt = NULL; - _M_last_overflowed = false; - } - - // Members: - bool - is_open(void) const { return _M_file ? _M_file->is_open() : false; } - - __filebuf_type* - open(const char* __s, ios_base::openmode __mode); - - __filebuf_type* - close(void); - - protected: - // Allocate up pback and internal buffers. - void - _M_allocate_buffers(); - - // Create __file_type object and initialize it properly. - void - _M_filebuf_init(); - - // Overridden virtual functions: - virtual streamsize - showmanyc(void); - - // Stroustrup, 1998, p. 628 - // underflow() and uflow() functions are called to get the next - // charater from the real input source when the buffer is empty. - // Buffered input uses underflow() - virtual int_type - underflow(void); - - virtual int_type - pbackfail(int_type __c = _Traits::eof()); - - // NB: For what the standard expects of the overflow function, - // see _M_really_overflow(), below. Because basic_streambuf's - // sputc/sputn call overflow directly, and the complications of - // this implementation's setting of the initial pointers all - // equal to _M_buf when initializing, it seems essential to have - // 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. - virtual int_type - overflow(int_type __c = _Traits::eof()); - - // Stroustrup, 1998, p 648 - // The overflow() function is called to transfer characters to the - // real output destination when the buffer is full. A call to - // overflow(c) outputs the contents of the buffer plus the - // character c. - // 27.5.2.4.5 - // Consume some sequence of the characters in the pending sequence. - int_type - _M_really_overflow(int_type __c = _Traits::eof()); - - virtual __streambuf_type* - setbuf(char_type* __s, streamsize __n) - { - if (!this->is_open() && __s == 0 && __n == 0) - { - _M_buf_size = 0; - _M_buf_size_opt = 0; - } - _M_last_overflowed = false; - return this; - } - - virtual pos_type - seekoff(off_type __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - virtual pos_type - seekpos(pos_type __pos, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - virtual int - sync(void) - { - bool __testput = _M_out_cur && _M_out_beg < _M_out_end; - if (__testput) - { - // Make sure that libio resyncs its idea of the file position - // with the external file. - _M_file->sync(); - - // Need to restore current position. This interpreted as - // the position of the external byte sequence (_M_file) - // plus the offset in the current internal buffer - // (_M_out_beg - _M_out_cur) - streamoff __cur = _M_file->seekoff(0, ios_base::cur); - off_type __off = _M_out_cur - _M_out_beg; - _M_really_overflow(); - _M_file->seekpos(__cur + __off); - } - _M_last_overflowed = false; - return 0; - } - - virtual void - imbue(const locale& __loc); - - virtual streamsize - xsgetn(char_type* __s, streamsize __n) - { - streamsize __ret = 0; - // Clear out pback buffer before going on to the real deal... - if (_M_pback_init) - { - while (__ret < __n && _M_in_cur < _M_in_end) - { - *__s = *_M_in_cur; - ++__ret; - ++__s; - ++_M_in_cur; - } - _M_pback_destroy(); - } - if (__ret < __n) - __ret += __streambuf_type::xsgetn(__s, __n - __ret); - return __ret; - } - - virtual streamsize - xsputn(const char_type* __s, streamsize __n) - { - _M_pback_destroy(); - return __streambuf_type::xsputn(__s, __n); - } - - void - _M_output_unshift(); - }; - - - // 27.8.1.5 Template class basic_ifstream - template - class basic_ifstream : public basic_istream<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_filebuf __filebuf_type; - typedef basic_istream __istream_type; - - // Constructors/Destructors: - basic_ifstream() - : __istream_type(new __filebuf_type()) - { } - - explicit - basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) - : __istream_type(new __filebuf_type()) - { this->open(__s, __mode); } - - ~basic_ifstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __filebuf_type* - rdbuf() const - { return static_cast<__filebuf_type*>(_M_streambuf); } - - bool - is_open(void) { return rdbuf()->is_open(); } - - void - open(const char* __s, ios_base::openmode __mode = ios_base::in) - { - if (rdbuf()->open(__s, __mode | ios_base::in) == NULL) - this->setstate(ios_base::failbit); - } - - void - close(void) - { - if (!rdbuf()->close()) - this->setstate(ios_base::failbit); - } - }; - - - // 27.8.1.8 Template class basic_ofstream - template - class basic_ofstream : public basic_ostream<_CharT,_Traits> - { - public: - // Types: - 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: - typedef basic_filebuf __filebuf_type; - typedef basic_ostream __ostream_type; - - // Constructors: - basic_ofstream() - : __ostream_type(new __filebuf_type()) - { } - - explicit - basic_ofstream(const char* __s, - ios_base::openmode __mode = ios_base::out|ios_base::trunc) - : __ostream_type(new __filebuf_type()) - { this->open(__s, __mode); } - - ~basic_ofstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __filebuf_type* - rdbuf(void) const - { return static_cast<__filebuf_type*>(_M_streambuf); } - - bool - is_open(void) { return rdbuf()->is_open(); } - - void - open(const char* __s, - ios_base::openmode __mode = ios_base::out | ios_base::trunc) - { - if (!rdbuf()->open(__s, __mode | ios_base::out)) - this->setstate(ios_base::failbit); - } - - void - close(void) - { - if (!rdbuf()->close()) - setstate(ios_base::failbit); - } - }; - - - // 27.8.1.11 Template class basic_fstream - template - class basic_fstream : public basic_iostream<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_filebuf __filebuf_type; - typedef basic_ios __ios_type; - typedef basic_iostream __iostream_type; - - // Constructors/destructor: - basic_fstream() - : __iostream_type(new __filebuf_type()) - { } - - explicit - basic_fstream(const char* __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - : __iostream_type(new __filebuf_type()) - { this->open(__s, __mode); } - - ~basic_fstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __filebuf_type* - rdbuf(void) const - { return static_cast<__filebuf_type*>(_M_streambuf); } - - bool - is_open(void) { return rdbuf()->is_open(); } - - void - open(const char* __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { - if (!rdbuf()->open(__s, __mode)) - setstate (ios_base::failbit); - } - - void - close(void) - { - if (!rdbuf()->close()) - setstate (ios_base::failbit); - } - }; - -} // namespace std - - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -#ifdef _GLIBCPP_FULLY_COMPLIANT_HEADERS -# include -#endif -#endif - -#endif /* _CPP_FSTREAM */ - - - - - - diff --git a/libstdc++-v3/bits/std_functional.h b/libstdc++-v3/bits/std_functional.h deleted file mode 100644 index 0336c2aedab..00000000000 --- a/libstdc++-v3/bits/std_functional.h +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - */ - -#ifndef _CPP_FUNCTIONAL -#define _CPP_FUNCTIONAL - -#include -#include -#include - -#endif /* _CPP_FUNCTIONAL */ - -// Local Variables: -// mode:C++ -// End: - diff --git a/libstdc++-v3/bits/std_iomanip.h b/libstdc++-v3/bits/std_iomanip.h deleted file mode 100644 index 6fa49386b67..00000000000 --- a/libstdc++-v3/bits/std_iomanip.h +++ /dev/null @@ -1,219 +0,0 @@ -// Standard stream manipulators -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.6.3 Standard manipulators -// - -#ifndef _CPP_IOMANIP -#define _CPP_IOMANIP 1 - -#include -#include -#include - -namespace std { - - struct _Resetiosflags { ios_base::fmtflags _M_mask; }; - - inline _Resetiosflags - resetiosflags(ios_base::fmtflags __mask) - { - _Resetiosflags __x; - __x._M_mask = __mask; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Resetiosflags __f) - { - __is.setf(ios_base::fmtflags(0), __f._M_mask); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Resetiosflags __f) - { - __os.setf(ios_base::fmtflags(0), __f._M_mask); - return __os; - } - - - struct _Setiosflags { ios_base::fmtflags _M_mask; }; - - inline _Setiosflags - setiosflags (ios_base::fmtflags __mask) - { - _Setiosflags __x; - __x._M_mask = __mask; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Setiosflags __f) - { - __is.setf(__f._M_mask); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Setiosflags __f) - { - __os.setf(__f._M_mask); - return __os; - } - - - struct _Setbase { int _M_base; }; - - inline _Setbase - setbase (int __base) - { - _Setbase __x; - __x._M_base = __base; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Setbase __f) - { - __is.setf(__f._M_base == 8 ? ios_base::oct : - __f._M_base == 10 ? ios_base::dec : - __f._M_base == 16 ? ios_base::hex : - ios_base::fmtflags(0), ios_base::basefield); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Setbase __f) - { - __os.setf(__f._M_base == 8 ? ios_base::oct : - __f._M_base == 10 ? ios_base::dec : - __f._M_base == 16 ? ios_base::hex : - ios_base::fmtflags(0), ios_base::basefield); - return __os; - } - - - template - struct _Setfill { _CharT _M_c; }; - - template - _Setfill<_CharT> - setfill(_CharT __c) - { - _Setfill<_CharT> __x; - __x._M_c = __c; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Setfill<_CharT> __f) - { - __is.fill(__f._M_c); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Setfill<_CharT> __f) - { - __os.fill(__f._M_c); - return __os; - } - - - struct _Setprecision { int _M_n; }; - - inline _Setprecision - setprecision(int __n) - { - _Setprecision __x; - __x._M_n = __n; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Setprecision __f) - { - __is.precision(__f._M_n); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Setprecision __f) - { - __os.precision(__f._M_n); - return __os; - } - - - struct _Setw { int _M_n; }; - - inline _Setw - setw(int __n) - { - _Setw __x; - __x._M_n = __n; - return __x; - } - - template - basic_istream<_CharT,_Traits>& - operator>>(basic_istream<_CharT,_Traits>& __is, _Setw __f) - { - __is.width(__f._M_n); - return __is; - } - - template - basic_ostream<_CharT,_Traits>& - operator<<(basic_ostream<_CharT,_Traits>& __os, _Setw __f) - { - __os.width(__f._M_n); - return __os; - } - -} // namespace std - -#endif /* __IOMANIP */ - - - - - diff --git a/libstdc++-v3/bits/std_ios.h b/libstdc++-v3/bits/std_ios.h deleted file mode 100644 index 5c61547bff9..00000000000 --- a/libstdc++-v3/bits/std_ios.h +++ /dev/null @@ -1,52 +0,0 @@ -// Iostreams base classes -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.4 Iostreams base classes -// - -#ifndef _CPP_IOS -#define _CPP_IOS 1 - -#include -#include // For ios_base::failure -#include // For char_traits, streamoff, streamsize, fpos -#include // For string. -#include // For SEEK_SET, SEEK_CUR, SEEK_END -#include // For class locale -#include // For ios_base declarations. -#include -#include - -#endif /* _CPP_IOS */ - - - - - diff --git a/libstdc++-v3/bits/std_iosfwd.h b/libstdc++-v3/bits/std_iosfwd.h deleted file mode 100644 index 8f198800a01..00000000000 --- a/libstdc++-v3/bits/std_iosfwd.h +++ /dev/null @@ -1,157 +0,0 @@ -// Forwarding declarations -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.2 Forward declarations -// - -#ifndef _CPP_IOSFWD -#define _CPP_IOSFWD 1 - -#include -#include // For mbstate_t - -namespace std { - - // Generic declarations. - template struct char_traits; - template class allocator; - - // Forward declarations - template<> class char_traits; -#ifdef _GLIBCPP_USE_WCHAR_T - template<> class char_traits; -#endif - - template > - class basic_ios; - - template > - class basic_streambuf; - - template > - class basic_istream; - - template > - class basic_ostream; - - template > - class basic_iostream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringbuf; - - template, - typename _Alloc = allocator<_CharT> > - class basic_istringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_ostringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringstream; - - template > - class basic_filebuf; - - template > - class basic_ifstream; - - template > - class basic_ofstream; - - template > - class basic_fstream; - - template > - class istreambuf_iterator; - - template > - class ostreambuf_iterator; - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Not included. - class ios_base; -#endif - - template struct fpos; -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Can't have self-recursive types for streampos. - // 21.1.3.1 char_traits sets size_type to streampos - // 27.4.1 - // And here, where streampos is typedefed to fpos - typedef fpos streampos; -# ifdef _GLIBCPP_USE_WCHAR_T - typedef fpos wstreampos; -# endif -#endif - - typedef basic_ios ios; - typedef basic_streambuf streambuf; - typedef basic_istream istream; - typedef basic_ostream ostream; - typedef basic_iostream iostream; - typedef basic_stringbuf stringbuf; - typedef basic_istringstream istringstream; - typedef basic_ostringstream ostringstream; - typedef basic_stringstream stringstream; - typedef basic_filebuf filebuf; - typedef basic_ifstream ifstream; - typedef basic_ofstream ofstream; - typedef basic_fstream fstream; - -#ifdef _GLIBCPP_USE_WCHAR_T - typedef basic_ios wios; - typedef basic_streambuf wstreambuf; - typedef basic_istream wistream; - typedef basic_ostream wostream; - typedef basic_iostream wiostream; - typedef basic_stringbuf wstringbuf; - typedef basic_istringstream wistringstream; - typedef basic_ostringstream wostringstream; - typedef basic_stringstream wstringstream; - typedef basic_filebuf wfilebuf; - typedef basic_ifstream wifstream; - typedef basic_ofstream wofstream; - typedef basic_fstream wfstream; -#endif - -} // namespace std - -#endif // _CPP_IOSFWD - - - - - - - diff --git a/libstdc++-v3/bits/std_iostream.h b/libstdc++-v3/bits/std_iostream.h deleted file mode 100644 index b08d038046d..00000000000 --- a/libstdc++-v3/bits/std_iostream.h +++ /dev/null @@ -1,58 +0,0 @@ -// Standard iostream objects -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.3 Standard iostream objects -// - -#ifndef _CPP_IOSTREAM -#define _CPP_IOSTREAM 1 - -#include -#include -#include - -namespace std { - - extern istream cin; - extern ostream cout; - extern ostream cerr; - extern ostream clog; -#ifdef _GLIBCPP_USE_WCHAR_T - extern wistream wcin; - extern wostream wcout; - extern wostream wcerr; - extern wostream wclog; -#endif - - // For construction of filebuffers for cout, cin, cerr, clog et. al. - static ios_base::Init __ioinit; -} // namespace std - -#endif /* _CPP_IOSTREAM */ diff --git a/libstdc++-v3/bits/std_istream.h b/libstdc++-v3/bits/std_istream.h deleted file mode 100644 index baddea47f8a..00000000000 --- a/libstdc++-v3/bits/std_istream.h +++ /dev/null @@ -1,307 +0,0 @@ -// Input streams -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.6.1 Input streams -// - -#ifndef _CPP_ISTREAM -#define _CPP_ISTREAM 1 - -#include -#include // For numeric_limits - -namespace std { - - // 27.6.1.1 Template class basic_istream - template - class basic_istream : virtual public basic_ios<_CharT, _Traits> - { - public: - - // Types (inherited from basic_ios (27.4.4)): - 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 basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_ios<_CharT, _Traits> __ios_type; - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef istreambuf_iterator<_CharT> __istreambuf_iter; - typedef num_get<_CharT, __istreambuf_iter> __numget_type; - typedef ctype<_CharT> __ctype_type; - - protected: - // Data Members: - streamsize _M_gcount; - - public: - // 27.6.1.1.1 Constructor/destructor: - explicit - basic_istream(__streambuf_type* __sb) - { - this->init(__sb); - _M_gcount = streamsize(0); - } - - virtual - ~basic_istream() - { - _M_gcount = streamsize(0); - _M_fnumget = NULL; - } - - // 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>> - __istream_type& - operator>>(__istream_type& (*__pf)(__istream_type&)); - - __istream_type& - operator>>(__ios_type& (*__pf)(__ios_type&)); - - __istream_type& - operator>>(ios_base& (*__pf)(ios_base&)); - - // 27.6.1.2.2 Arithmetic Extractors - __istream_type& - operator>>(bool& __n); - - __istream_type& - operator>>(short& __n); - - __istream_type& - operator>>(unsigned short& __n); - - __istream_type& - operator>>(int& __n); - - __istream_type& - operator>>(unsigned int& __n); - - __istream_type& - operator>>(long& __n); - - __istream_type& - operator>>(unsigned long& __n); - -#ifdef _GLIBCPP_USE_LONG_LONG - __istream_type& - operator>>(long long& __n); - - __istream_type& - operator>>(unsigned long long& __n); -#endif - - __istream_type& - operator>>(float& __f); - - __istream_type& - operator>>(double& __f); - - __istream_type& - operator>>(long double& __f); - - __istream_type& - operator>>(void*& __p); - - __istream_type& - operator>>(__streambuf_type* __sb); - - // 27.6.1.3 Unformatted input: - inline streamsize - gcount(void) const - { return _M_gcount; } - - int_type - get(void); - - __istream_type& - get(char_type& __c); - - __istream_type& - get(char_type* __s, streamsize __n, char_type __delim); - - inline __istream_type& - get(char_type* __s, streamsize __n) - { return get(__s, __n, this->widen('\n')); } - - __istream_type& - get(__streambuf_type& __sb, char_type __delim); - - inline __istream_type& - get(__streambuf_type& __sb) - { return get(__sb, this->widen('\n')); } - - __istream_type& - getline(char_type* __s, streamsize __n, char_type __delim); - - inline __istream_type& - getline(char_type* __s, streamsize __n) - { return getline(__s, __n, this->widen('\n')); } - - __istream_type& - ignore(streamsize __n = 1, int_type __delim = traits_type::eof()); - - int_type - peek(void); - - __istream_type& - read(char_type* __s, streamsize __n); - - streamsize - readsome(char_type* __s, streamsize __n); - - __istream_type& - putback(char_type __c); - - __istream_type& - unget(void); - - int - sync(void); - - pos_type - tellg(void); - - __istream_type& - seekg(pos_type); - - __istream_type& - seekg(off_type, ios_base::seekdir); - - private: -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Not defined. - __istream_type& - operator=(const __istream_type&); - - basic_istream(const __istream_type&); -#endif - }; - - template - class basic_istream<_CharT, _Traits>::sentry - { - public: - - typedef _Traits traits_type; - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef __istream_type::__ctype_type __ctype_type; - typedef typename _Traits::int_type __int_type; - - explicit - sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); - - operator bool() { return _M_ok; } - - private: - bool _M_ok; - }; - - // 27.6.1.2.3 Character extraction templates - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); - - template - basic_istream& - operator>>(basic_istream& __in, unsigned char& __c) - { return (__in >> static_cast(__c)); } - - template - basic_istream& - operator>>(basic_istream& __in, signed char& __c) - { return (__in >> static_cast(__c)); } - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); - - template - basic_istream& - operator>>(basic_istream& __in, unsigned char* __s) - { return (__in >> reinterpret_cast(__s)); } - - template - basic_istream& - operator>>(basic_istream& __in, signed char* __s) - { return (__in >> reinterpret_cast(__s)); } - - // 27.6.1.5 Template class basic_iostream - template - class basic_iostream - : public basic_istream<_CharT, _Traits>, - public basic_ostream<_CharT, _Traits> - { - public: - - // Non-standard Types: - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_ostream<_CharT, _Traits> __ostream_type; - - explicit - basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) - : __istream_type(__sb), __ostream_type(__sb) - { } - - virtual - ~basic_iostream() { } - }; - - // 27.6.1.4 Standard basic_istream manipulators - template - basic_istream<_CharT, _Traits>& - ws(basic_istream<_CharT, _Traits>& __is); - -} // namespace std - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -#ifdef _GLIBCPP_FULLY_COMPLIANT_HEADERS -# include -#endif -#endif - -#endif /* _CPP_ISTREAM */ - - - - - - - - diff --git a/libstdc++-v3/bits/std_iterator.h b/libstdc++-v3/bits/std_iterator.h deleted file mode 100644 index 643cff99cb8..00000000000 --- a/libstdc++-v3/bits/std_iterator.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_ITERATOR -#define _CPP_ITERATOR 1 - -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_ITERATOR */ - -// Local Variables: -// mode:C++ -// End: - - - - - diff --git a/libstdc++-v3/bits/std_list.h b/libstdc++-v3/bits/std_list.h deleted file mode 100644 index eaf1258cca6..00000000000 --- a/libstdc++-v3/bits/std_list.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_LIST -#define _CPP_LIST 1 - -#include -#include -#include -#include -#include - -#endif /* _CPP_LIST */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_locale.h b/libstdc++-v3/bits/std_locale.h deleted file mode 100644 index 7eaba90e7ea..00000000000 --- a/libstdc++-v3/bits/std_locale.h +++ /dev/null @@ -1,46 +0,0 @@ -// Locale support -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 22.1 Locales -// - -#ifndef _CPP_LOCALE -#define _CPP_LOCALE 1 - -#include -#include -#include -#include - -#endif - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/std_map.h b/libstdc++-v3/bits/std_map.h deleted file mode 100644 index d7fe92d3ee0..00000000000 --- a/libstdc++-v3/bits/std_map.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_MAP -#define _CPP_MAP 1 - -#ifndef _CPP_BITS_STL_TREE_H -#include -#endif -#include -#include - -#endif /* _CPP_MAP */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_memory.h b/libstdc++-v3/bits/std_memory.h deleted file mode 100644 index 5ee126bd8e9..00000000000 --- a/libstdc++-v3/bits/std_memory.h +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright (c) 1997-1999 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - */ - -#ifndef _CPP_MEMORY -#define _CPP_MEMORY 1 - -#include -#include -#include -#include //for iterator_traits -#include -#include -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \ - defined(__STL_MEMBER_TEMPLATES) - - template struct auto_ptr_ref { - _Tp1* _M_ptr; - auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {} -}; - -#endif - -template class auto_ptr { -private: - _Tp* _M_ptr; - -public: - typedef _Tp element_type; - - explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {} - auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {} - -#ifdef __STL_MEMBER_TEMPLATES - template auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW - : _M_ptr(__a.release()) {} -#endif /* __STL_MEMBER_TEMPLATES */ - - auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW { - reset(__a.release()); - return *this; - } - -#ifdef __STL_MEMBER_TEMPLATES - template - auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW { - reset(__a.release()); - return *this; - } -#endif /* __STL_MEMBER_TEMPLATES */ - - // Note: 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 (17.4.3.6/2) - // this is prohibited. - ~auto_ptr() { delete _M_ptr; } - - _Tp& operator*() const __STL_NOTHROW { - return *_M_ptr; - } - _Tp* operator->() const __STL_NOTHROW { - return _M_ptr; - } - _Tp* get() const __STL_NOTHROW { - return _M_ptr; - } - _Tp* release() __STL_NOTHROW { - _Tp* __tmp = _M_ptr; - _M_ptr = 0; - return __tmp; - } - void reset(_Tp* __p = 0) __STL_NOTHROW { - if (__p != _M_ptr) { - delete _M_ptr; - _M_ptr = __p; - } - } - - // According to the C++ standard, these conversions are required. Most - // present-day compilers, however, do not enforce that requirement---and, - // in fact, most present-day compilers do not support the language - // features that these conversions rely on. - -#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \ - defined(__STL_MEMBER_TEMPLATES) - -public: - auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW - : _M_ptr(__ref._M_ptr) {} - - auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW { - if (__ref._M_ptr != this->get()) { - delete _M_ptr; - _M_ptr = __ref._M_ptr; - } - return *this; - } - - template operator auto_ptr_ref<_Tp1>() __STL_NOTHROW - { return auto_ptr_ref<_Tp>(this->release()); } - template operator auto_ptr<_Tp1>() __STL_NOTHROW - { return auto_ptr<_Tp1>(this->release()); } - -#endif /* auto ptr conversions && member templates */ -}; - -__STL_END_NAMESPACE - -#endif /* _CPP_MEMORY */ - - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_new.h b/libstdc++-v3/bits/std_new.h deleted file mode 100644 index 2e019a9562d..00000000000 --- a/libstdc++-v3/bits/std_new.h +++ /dev/null @@ -1,82 +0,0 @@ - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -#ifndef _CPP_NEW -#define _CPP_NEW 1 - -#include - -#ifdef __GNUG__ -# pragma GCC system_header -# include_next -#else - -#include - - -// 18.4 Dynamic memory management - -__STL_BEGIN_NAMESPACE - - class bad_alloc; - struct nothrow_t {}; - extern const nothrow_t nothrow; - typedef void (*new_handler)(); - new_handler set_new_handler(new_handler) throw(); - - class bad_alloc : public exception { - public: - bad_alloc() throw(); - bad_alloc(const bad_alloc&) throw(); - bad_alloc& operator=(const bad_alloc&) throw(); - virtual ~bad_alloc() throw(); - virtual const char* what() const throw(); - }; - -__STL_END_NAMESPACE - - void* operator new(__STD::size_t) throw(__STD::bad_alloc); - void* operator new(__STD::size_t, const __STD::nothrow_t&) throw(); - void operator delete(void*) throw(); - void operator delete(void*, const __STD::nothrow_t&) throw(); - void* operator new[](__STD::size_t) throw(__STD::bad_alloc); - void* operator new[](__STD::size_t, const __STD::nothrow_t&) throw(); - void operator delete[](void*) throw(); - void operator delete[](void*, const __STD::nothrow_t&) throw(); - void* operator new (__STD::size_t, void*) throw(); - void* operator new[](__STD::size_t, void*) throw(); - void operator delete (void*, void*) throw(); - void operator delete[](void*, void*) throw(); - -#endif - -#endif /* _CPP_NEW */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_numeric.h b/libstdc++-v3/bits/std_numeric.h deleted file mode 100644 index 8b7c6fd9666..00000000000 --- a/libstdc++-v3/bits/std_numeric.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_NUMERIC -#define _CPP_NUMERIC 1 - -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_NUMERIC */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_ostream.h b/libstdc++-v3/bits/std_ostream.h deleted file mode 100644 index eb63e93623a..00000000000 --- a/libstdc++-v3/bits/std_ostream.h +++ /dev/null @@ -1,288 +0,0 @@ -// Output streams -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.6.2 Output streams -// - -#ifndef _CPP_OSTREAM -#define _CPP_OSTREAM 1 - -#include - -namespace std { - - // 27.6.2.1 Template class basic_ostream - template - class basic_ostream : virtual public basic_ios<_CharT, _Traits> - { - public: - - // Types (inherited from basic_ios (27.4.4)): - 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 basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_ios<_CharT, _Traits> __ios_type; - typedef basic_ostream<_CharT, _Traits> __ostream_type; - typedef ostreambuf_iterator<_CharT> __ostreambuf_iter; - typedef num_put<_CharT, __ostreambuf_iter> __numput_type; - typedef ctype<_CharT> __ctype_type; - - // 27.6.2.2 Constructor/destructor: - explicit - basic_ostream(__streambuf_type* __sb) - { this->init(__sb); } - - virtual - ~basic_ostream() - { _M_fnumput = NULL; } - - // 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<< - __ostream_type& - operator<<(__ostream_type& (*__pf)(__ostream_type&)); - - __ostream_type& - operator<<(__ios_type& (*__pf)(__ios_type&)); - - __ostream_type& - operator<<(ios_base& (*__pf) (ios_base&)); - - // 27.6.2.5.2 Arithmetic Inserters - __ostream_type& - operator<<(long __n); - - __ostream_type& - operator<<(unsigned long __n); - - __ostream_type& - operator<<(bool __n); - - __ostream_type& - operator<<(short __n) - { - ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt & ios_base::oct || __fmt & ios_base::hex) - return this->operator<<(static_cast - (static_cast(__n))); - else - return this->operator<<(static_cast(__n)); - } - - __ostream_type& - operator<<(unsigned short __n) - { return this->operator<<(static_cast(__n)); } - - __ostream_type& - operator<<(int __n) - { - ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt & ios_base::oct || __fmt & ios_base::hex) - return this->operator<<(static_cast - (static_cast(__n))); - else - return this->operator<<(static_cast(__n)); - } - - __ostream_type& - operator<<(unsigned int __n) - { return this->operator<<(static_cast(__n)); } - -#ifdef _GLIBCPP_USE_LONG_LONG - __ostream_type& - operator<<(long long __n); - - __ostream_type& - operator<<(unsigned long long __n); -#endif - - __ostream_type& - operator<<(double __f); - - __ostream_type& - operator<<(float __f) - { return this->operator<<(static_cast(__f)); } - - __ostream_type& - operator<<(long double __f); - - __ostream_type& - operator<<(const void* __p); - - __ostream_type& - operator<<(__streambuf_type* __sb); - - // Unformatted output: - __ostream_type& - put(char_type __c); - - __ostream_type& - write(const char_type* __s, streamsize __n); - - __ostream_type& - flush(); - - // Seeks: - pos_type - tellp(); - - __ostream_type& - seekp(pos_type); - - __ostream_type& - seekp(off_type, ios_base::seekdir); - - private: -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // Not defined. - __ostream_type& - operator=(const __ostream_type&); - - basic_ostream(const __ostream_type&); -#endif - }; - - // 27.6.2.3 Class basic_ostream::sentry - template - class basic_ostream<_CharT, _Traits>::sentry - { - // Data Members: - bool _M_ok; - basic_ostream<_CharT,_Traits>& _M_os; - - public: - explicit - sentry(basic_ostream<_CharT,_Traits>& __os); - - ~sentry() - { - // XXX MT - if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception()) - { - // Can't call flush directly or else will get into recursive lock. - if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) - _M_os.setstate(ios_base::badbit); - } - } - - operator bool() - { return _M_ok; } - }; - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c); - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) - { return (__out << __out.widen(__c)); } - - // Specialization - template - basic_ostream& - operator<<(basic_ostream& __out, char __c); - - // Signed and unsigned - template - basic_ostream& - operator<<(basic_ostream& __out, signed char __c) - { return (__out << static_cast(__c)); } - - template - basic_ostream& - operator<<(basic_ostream& __out, unsigned char __c) - { return (__out << static_cast(__c)); } - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s); - - template - basic_ostream<_CharT, _Traits> & - operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); - - // Partial specializationss - template - basic_ostream& - operator<<(basic_ostream& __out, const char* __s); - - // Signed and unsigned - template - basic_ostream& - operator<<(basic_ostream& __out, const signed char* __s) - { return (__out << reinterpret_cast(__s)); } - - template - basic_ostream & - operator<<(basic_ostream& __out, const unsigned char* __s) - { return (__out << reinterpret_cast(__s)); } - - // 27.6.2.7 Standard basic_ostream manipulators - template - basic_ostream<_CharT, _Traits>& - endl(basic_ostream<_CharT, _Traits>& __os) - { return flush(__os.put(__os.widen('\n'))); } - - template - basic_ostream<_CharT, _Traits>& - ends(basic_ostream<_CharT, _Traits>& __os) - { return __os.put(_Traits::_S_eos()); } - - template - basic_ostream<_CharT, _Traits>& - flush(basic_ostream<_CharT, _Traits>& __os) - { return __os.flush(); } - -} // namespace std - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -#ifdef _GLIBCPP_FULLY_COMPLIANT_HEADERS -# include -#endif -#endif - -#endif /* _CPP_OSTREAM */ - - - - - - - diff --git a/libstdc++-v3/bits/std_queue.h b/libstdc++-v3/bits/std_queue.h deleted file mode 100644 index 198b2c03508..00000000000 --- a/libstdc++-v3/bits/std_queue.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_QUEUE -#define _CPP_QUEUE 1 - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_QUEUE */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_set.h b/libstdc++-v3/bits/std_set.h deleted file mode 100644 index 7a5f5c5b4ec..00000000000 --- a/libstdc++-v3/bits/std_set.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_SET -#define _CPP_SET 1 - -#ifndef _CPP_BITS_STL_TREE_H /* XXX is this guard needed? */ -#include -#endif -#include -#include - -#endif /* _CPP_SET */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_sstream.h b/libstdc++-v3/bits/std_sstream.h deleted file mode 100644 index f3207110d2d..00000000000 --- a/libstdc++-v3/bits/std_sstream.h +++ /dev/null @@ -1,366 +0,0 @@ -// String based streams -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.7 String-based streams -// - -#ifndef _CPP_SSTREAM -#define _CPP_SSTREAM 1 - -#include -#include - -namespace std { - - template - class basic_stringbuf : public basic_streambuf<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_streambuf __streambuf_type; - typedef basic_string __string_type; - typedef typename __string_type::size_type __size_type; - - private: - // Data Members: - __string_type _M_string; - - public: - // Constructors: - explicit - basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) - : __streambuf_type(), _M_string() - { _M_stringbuf_init(__mode); } - - explicit - basic_stringbuf(const __string_type& __str, - ios_base::openmode __mode = ios_base::in | ios_base::out) - : __streambuf_type(), _M_string(__str) - { _M_stringbuf_init(__mode); } - - // Get and set: - __string_type - str() const - { - if (_M_mode & ios_base::in && !(_M_mode & ios_base::out)) - return _M_string; - else - { - // This is the deal: _M_string.size() is value that - // represents the size of the intial string that makes - // _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) - __len = max(__size_type(_M_out_end - _M_out_beg), __len); - return __string_type(_M_out_beg, _M_out_beg + __len); - } - } - - void - str(const __string_type& __s) - { - _M_string = __s; - _M_stringbuf_init(_M_mode); - } - - protected: - // Common initialization code for both ctors goes here. - void - _M_stringbuf_init(ios_base::openmode __mode) - { - // _M_buf_size is a convenient alias for "what the streambuf - // thinks the allocated size of the string really is." This is - // necessary as ostringstreams are implemented with the - // streambufs having control of the allocation and - // re-allocation of the internal string object, _M_string. - _M_buf_size = _M_string.size(); - - // NB: Start ostringstream buffers at 1024 bytes. This is an - // experimental value (pronounced "arbitrary" in some of the - // hipper english-speaking countries), and can be changed to - // suite particular needs. - _M_buf_size_opt = 512; - _M_mode = __mode; - if (_M_mode & ios_base::ate) - _M_really_sync(0, _M_buf_size); - else - _M_really_sync(0, 0); - } - - // Overridden virtual functions: - virtual int_type - underflow() - { - if (_M_in_cur && _M_in_cur < _M_in_end) - return traits_type::to_int_type(*gptr()); - else - return traits_type::eof(); - } - - virtual int_type - pbackfail(int_type __c = traits_type::eof()); - - virtual int_type - overflow(int_type __c = traits_type::eof()); - - virtual __streambuf_type* - setbuf(char_type* __s, streamsize __n) - { - if (__n) - { - _M_string = __string_type(__s, __n); - _M_really_sync(0, 0); - } - return this; - } - - virtual pos_type - seekoff(off_type __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - virtual pos_type - seekpos(pos_type __sp, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - // Internal function for correctly updating the internal buffer - // for a particular _M_string, due to initialization or - // re-sizing of an existing _M_string. - // Assumes: contents of _M_string and internal buffer match exactly. - // __i == _M_in_cur - _M_in_beg - // __o == _M_out_cur - _M_out_beg - virtual int - _M_really_sync(__size_type __i, __size_type __o) - { - char_type* __base = const_cast(_M_string.data()); - bool __testin = _M_mode & ios_base::in; - bool __testout = _M_mode & ios_base::out; - __size_type __len = _M_string.size(); - - _M_buf = __base; - if (__testin) - this->setg(__base, __base + __i, __base + __len); - if (__testout) - { - this->setp(__base, __base + __len); - _M_out_cur += __o; - } - return 0; - } - }; - - - // 27.7.2 Template class basic_istringstream - template - class basic_istringstream : public basic_istream<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; - typedef basic_istream __istream_type; - - // Constructors: - explicit - basic_istringstream(ios_base::openmode __mode = ios_base::in) - : __istream_type(new __stringbuf_type(__mode | ios_base::in)) - { } - - explicit - basic_istringstream(const __string_type& __str, - ios_base::openmode __mode = ios_base::in) - : __istream_type(new __stringbuf_type(__str, __mode | ios_base::in)) - { } - - ~basic_istringstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __stringbuf_type* - rdbuf() const - { return static_cast<__stringbuf_type*>(_M_streambuf); } - - __string_type - str() const - { return this->rdbuf()->str(); } - - void - str(const __string_type& __s) - { rdbuf()->str(__s); } - - }; - - - // 27.7.3 Template class basic_ostringstream - template - class basic_ostringstream : public basic_ostream<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; - typedef basic_ostream __ostream_type; - - // Constructors/destructor: - explicit - basic_ostringstream(ios_base::openmode __mode = ios_base::out) - : __ostream_type(new __stringbuf_type(__mode | ios_base::out)) - { } - - explicit - basic_ostringstream(const __string_type __str, - ios_base::openmode __mode = ios_base::out) - : __ostream_type(new __stringbuf_type(__str, __mode | ios_base::out)) - { } - - ~basic_ostringstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __stringbuf_type* - rdbuf() const - { return static_cast<__stringbuf_type*>(_M_streambuf); } - - __string_type - str() const - { return this->rdbuf()->str(); } - - void - str(const __string_type& __s) - { rdbuf()->str(__s); } - - }; - - - // 27.7.4 Template class basic_stringstream - template - class basic_stringstream : public basic_iostream<_CharT, _Traits> - { - public: - // Types: - 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: - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; - typedef basic_iostream __iostream_type; - - // Constructors/destructors - explicit - basic_stringstream(ios_base::openmode __mode = - ios_base::out | ios_base::in) - : __iostream_type(new __stringbuf_type(__mode)) - { } - - explicit - basic_stringstream(const __string_type& __str, - ios_base::openmode __mode = - ios_base::out | ios_base::in) - : __iostream_type(new __stringbuf_type(__str, __mode)) - { } - - ~basic_stringstream() - { - delete _M_streambuf; - _M_streambuf = NULL; - } - - // Members: - __stringbuf_type* - rdbuf() const - { return static_cast<__stringbuf_type*>(_M_streambuf); } - - __string_type - str() const - { return rdbuf()->str(); } - - void - str(const __string_type& __s) - { rdbuf()->str(__s); } - }; - -} // namespace std - - - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -#ifdef _GLIBCPP_FULLY_COMPLIANT_HEADERS -# include -#endif -#endif - - -#endif /* _CPP_SSTREAM */ - - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/std_stack.h b/libstdc++-v3/bits/std_stack.h deleted file mode 100644 index 53e7e21f0ec..00000000000 --- a/libstdc++-v3/bits/std_stack.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_STACK -#define _CPP_STACK 1 - -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_STACK */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_stdexcept.h b/libstdc++-v3/bits/std_stdexcept.h deleted file mode 100644 index 691b9b5825e..00000000000 --- a/libstdc++-v3/bits/std_stdexcept.h +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_STDEXCEPT -#define _CPP_STDEXCEPT 1 - -#include - -#if defined(__STL_USE_EXCEPTIONS) || \ - !(defined(_MIPS_SIM) && defined(_ABIO32) && _MIPS_SIM == _ABIO32) - -#include - -__STL_BEGIN_NAMESPACE - -class __Named_exception : public exception { -public: - __Named_exception(const string& __str); - virtual const char* what() const __STL_NOTHROW { return _M_name; } - -private: - enum { _S_bufsize = 256 }; - char _M_name[_S_bufsize]; -}; - -class logic_error : public __Named_exception { -public: - logic_error(const string& __s) : __Named_exception(__s) {} -}; - -class runtime_error : public __Named_exception { -public: - runtime_error(const string& __s) : __Named_exception(__s) {} -}; - -class domain_error : public logic_error { -public: - domain_error(const string& __arg) : logic_error(__arg) {} -}; - -class invalid_argument : public logic_error { -public: - invalid_argument(const string& __arg) : logic_error(__arg) {} -}; - -class length_error : public logic_error { -public: - length_error(const string& __arg) : logic_error(__arg) {} -}; - -class out_of_range : public logic_error { -public: - out_of_range(const string& __arg) : logic_error(__arg) {} -}; - -class range_error : public runtime_error { -public: - range_error(const string& __arg) : runtime_error(__arg) {} -}; - -class overflow_error : public runtime_error { -public: - overflow_error(const string& __arg) : runtime_error(__arg) {} -}; - -class underflow_error : public runtime_error { -public: - underflow_error(const string& __arg) : runtime_error(__arg) {} -}; - -__STL_END_NAMESPACE - -#endif /* Not o32, and no exceptions */ - -#endif /* _CPP_STDEXCEPT */ - -// Local Variables: -// mode:C++ -// End: - diff --git a/libstdc++-v3/bits/std_streambuf.h b/libstdc++-v3/bits/std_streambuf.h deleted file mode 100644 index 774046b6666..00000000000 --- a/libstdc++-v3/bits/std_streambuf.h +++ /dev/null @@ -1,528 +0,0 @@ -// Stream buffer classes -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.5 Stream buffers -// - -#ifndef _CPP_STREAMBUF -#define _CPP_STREAMBUF 1 - -#include -#include -#include // For SEEK_SET, SEEK_CUR, SEEK_END -#include -#include - -namespace std { - - template - static streamsize - _S_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> - template - class basic_streambuf - { - public: - // Types: - 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: - typedef ctype __ctype_type; - typedef basic_streambuf __streambuf_type; - - friend class basic_ios; - friend class basic_istream; - friend class basic_ostream; - friend class istreambuf_iterator; - friend class ostreambuf_iterator; - - friend streamsize - _S_copy_streambufs<>(basic_ios& __ios, - __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. - char_type* _M_buf; - - // Actual size of internal buffer, in bytes. - int_type _M_buf_size; - - // Optimal or preferred size of internal buffer, in bytes. - int_type _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. - 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 - 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. - ios_base::openmode _M_mode; - - // Current locale setting. - locale _M_buf_locale; - - // True iff locale is initialized. - bool _M_buf_locale_init; - - // Cached use_facet, which is based on the current locale info. - const __ctype_type* _M_buf_fctype; - - // 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. - int_type _M_pback_size; - char_type* _M_pback; - char_type* _M_pback_cur_save; - char_type* _M_pback_end_save; - bool _M_pback_init; - - // Initializes pback buffers, and moves normal buffers to safety. - // Assumptions: - // _M_in_cur has already been moved back - void - _M_pback_create() - { - if (!_M_pback_init) - { - int_type __dist = _M_in_end - _M_in_cur; - int_type __len = min(_M_pback_size, __dist); - traits_type::copy(_M_pback, _M_in_cur, __len); - _M_pback_cur_save = _M_in_cur; - _M_pback_end_save = _M_in_end; - this->setg(_M_pback, _M_pback, _M_pback + __len); - _M_pback_init = true; - } - } - - // Deactivates pback buffer contents, and restores normal buffer. - // Assumptions: - // The pback buffer has only moved forward. - void - _M_pback_destroy() - { - if (_M_pback_init) - { - // Length _M_in_cur moved in the pback buffer. - int_type __off_cur = _M_in_cur - _M_pback; - - // For in | out buffers, the end can be pushed back... - int_type __off_end = 0; - int_type __pback_len = _M_in_end - _M_pback; - int_type __save_len = _M_pback_end_save - _M_buf; - if (__pback_len > __save_len) - __off_end = __pback_len - __save_len; - - this->setg(_M_buf, _M_pback_cur_save + __off_cur, - _M_pback_end_save + __off_end); - _M_pback_cur_save = NULL; - _M_pback_end_save = NULL; - _M_pback_init = false; - } - } - - // Correctly sets the _M_out_cur pointer, and bumps the - // appropriate _M_*_end pointers as well. Necessary for the - // un-tied stringbufs, in in|out mode. - // Invariant: - // __n + _M_out_[cur, end] <= _M_buf + _M_buf_size - // Assuming all _M_*_[beg, cur, end] pointers are operating on - // the same range: - // _M_buf <= _M_*_ <= _M_buf + _M_buf_size - void - _M_out_cur_move(off_type __n) // argument needs to be +- - { - bool __testin = _M_mode & ios_base::in; - - _M_out_cur += __n; - if (__testin && _M_buf_unified) - _M_in_cur += __n; - if (_M_out_cur > _M_out_end) - { - _M_out_end = _M_out_cur; - // NB: in | out buffers drag the _M_in_end pointer along... - if (__testin) - _M_in_end += __n; - } - } - - // These three functions are used to clarify internal buffer - // maintenance. After an overflow, or after a seekoff call that - // started at beg or end, or possibly when the stream becomes - // unbuffered, and a myrid other obscure corner cases, the - // internal buffer does not truly reflect the contents of the - // external buffer. At this point, for whatever reason, it is in - // an indeterminate state. - void - _M_set_indeterminate(void) - { - if (_M_mode & ios_base::in) - this->setg(_M_buf, _M_buf, _M_buf); - if (_M_mode & ios_base::out) - this->setp(_M_buf, _M_buf); - } - - void - _M_set_determinate(off_type __off) - { - bool __testin = _M_mode & ios_base::in; - bool __testout = _M_mode & ios_base::out; - if (__testin) - { - this->setg(_M_buf, _M_buf, _M_buf + __off); - if (!__testout) - _M_buf_size = static_cast(__off); - } - if (__testout) - this->setp(_M_buf, _M_buf + __off); - - } - - bool - _M_is_indeterminate(void) - { - bool __ret = false; - if (_M_mode & ios_base::in) - __ret = _M_in_beg == _M_in_cur && _M_in_cur == _M_in_end; - if (_M_mode & ios_base::out) - __ret = _M_out_beg == _M_out_cur && _M_out_cur == _M_out_end; - return __ret; - } - - public: - virtual - ~basic_streambuf() - { - _M_buf_unified = false; - _M_buf_size = 0; - _M_buf_size_opt = 0; - _M_mode = ios_base::openmode(0); - _M_buf_fctype = NULL; - _M_buf_locale_init = false; - - } - - // Locales: - locale - pubimbue(const locale &__loc) - { - locale __tmp(this->getloc()); - this->imbue(__loc); - return __tmp; - } - - locale - getloc() const - { - if (_M_buf_locale_init) - return _M_buf_locale; - else - return locale(); - } - - // Buffer and positioning: - __streambuf_type* - pubsetbuf(char_type* __s, streamsize __n) - { return this->setbuf(__s, __n); } - - pos_type - pubseekoff(off_type __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { return this->seekoff(__off, __way, __mode); } - - pos_type - pubseekpos(pos_type __sp, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { return this->seekpos(__sp, __mode); } - - int - pubsync() { return this->sync(); } - - // Get and put areas: - // Get area: - streamsize - in_avail() - { - streamsize __ret; - if (_M_in_cur && _M_in_cur < _M_in_end) - { - if (_M_pback_init) - { - int_type __save_len = _M_pback_end_save - _M_pback_cur_save; - int_type __pback_len = _M_in_cur - _M_pback; - __ret = __save_len - __pback_len; - } - else - __ret = this->egptr() - this->gptr(); - } - else - __ret = this->showmanyc(); - return __ret; - } - - int_type - snextc() - { - int_type __eof = traits_type::eof(); - return (this->sbumpc() == __eof ? __eof : this->sgetc()); - } - - int_type - sbumpc(); - - int_type - sgetc() - { - int_type __ret; - if (_M_in_cur && _M_in_cur < _M_in_end) - __ret = traits_type::to_int_type(*gptr()); - else - __ret = this->underflow(); - return __ret; - } - - streamsize - sgetn(char_type* __s, streamsize __n) - { return this->xsgetn(__s, __n); } - - // Putback: - int_type - sputbackc(char_type __c); - - int_type - sungetc(); - - // Put area: - int_type - sputc(char_type __c); - - streamsize - sputn(const char_type* __s, streamsize __n) - { return this->xsputn(__s, __n); } - - protected: - basic_streambuf() - : _M_buf(NULL), _M_buf_size(0), - _M_buf_size_opt(static_cast(BUFSIZ)), _M_buf_unified(false), - _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0), _M_out_cur(0), - _M_out_end(0), _M_mode(ios_base::openmode(0)), _M_buf_locale(locale()), - _M_buf_locale_init(false), _M_pback_size(1), _M_pback(NULL), - _M_pback_cur_save(NULL), _M_pback_end_save(NULL), _M_pback_init(false) - { _M_buf_fctype = &use_facet<__ctype_type>(this->getloc()); } - - // Get area: - char_type* - eback() const { return _M_in_beg; } - - char_type* - gptr() const { return _M_in_cur; } - - char_type* - egptr() const { return _M_in_end; } - - void - gbump(int __n) { _M_in_cur += __n; } - - void - setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) - { - _M_in_beg = __gbeg; - _M_in_cur = __gnext; - _M_in_end = __gend; - if (!(_M_mode & ios_base::in) && __gbeg && __gnext && __gend) - _M_mode = _M_mode | ios_base::in; - } - - // Put area: - char_type* - pbase() const { return _M_out_beg; } - - char_type* - pptr() const { return _M_out_cur; } - - char_type* - epptr() const { return _M_out_end; } - - void - pbump(int __n) { _M_out_cur += __n; } - - void - setp(char_type* __pbeg, char_type* __pend) - { - _M_out_beg = _M_out_cur = __pbeg; - _M_out_end = __pend; - if (!(_M_mode & ios_base::out) && __pbeg && __pend) - _M_mode = _M_mode | ios_base::out; - // The output sequence is highly tied to _M_buf and - // _M_buf_size in addition to the actual pointers into the - // buffer. Because of this, (re)set _M_buf_size here, as - // sputc/xsputn need _M_buf_size to be accurate. (The - // corresponding input functions rely instead on _M_in_end.) - _M_buf_size = max(_M_buf_size, static_cast(__pend - __pbeg)); - } - - // Virtual functions: - // Locales: - virtual void - imbue(const locale& __loc) - { - _M_buf_locale_init = true; - if (_M_buf_locale != __loc) - { - _M_buf_locale = __loc; - _M_buf_fctype = &use_facet<__ctype_type>(_M_buf_locale); - } - } - - // Buffer management and positioning: - virtual basic_streambuf* - setbuf(char_type*, streamsize) - { return this; } - - 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)); } - - virtual pos_type - seekpos(pos_type, - ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) - { return pos_type(off_type(-1)); } - - virtual int - sync() { return 0; } - - // Get area: - virtual streamsize - showmanyc() { return 0; } - - virtual streamsize - xsgetn(char_type* __s, streamsize __n); - - virtual int_type - underflow() - { return traits_type::eof(); } - - virtual int_type - uflow() - { - int_type __ret = traits_type::eof(); - bool __testeof = this->underflow() == __ret; - bool __testpending = _M_in_cur && _M_in_cur < _M_in_end; - - if (!__testeof && __testpending) - { - __ret = traits_type::to_int_type(*_M_in_cur); - ++_M_in_cur; - if (_M_buf_unified && _M_mode & ios_base::out) - ++_M_out_cur; - } - return __ret; - } - - // Putback: - virtual int_type - pbackfail(int_type /* __c */ = traits_type::eof()) - { return traits_type::eof(); } - - // Put area: - virtual streamsize - xsputn(const char_type* __s, streamsize __n); - - virtual int_type - overflow(int_type /* __c */ = traits_type::eof()) - { return traits_type::eof(); } - -#ifdef _GLIBCPP_DEPRICATED - public: - void - stossc() - { - if (_M_in_cur < _M_in_end) - ++_M_in_cur; - else - this->uflow(); - } -#endif - -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - private: - basic_streambuf(const __streambuf_type&); - - __streambuf_type& - operator=(const __streambuf_type&); -#endif - }; - -} // namespace std - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -#ifdef _GLIBCPP_FULLY_COMPLIANT_HEADERS -#include -#endif -#endif - -#endif /* _CPP_STREAMBUF */ - - - - - - - - - - - diff --git a/libstdc++-v3/bits/std_string.h b/libstdc++-v3/bits/std_string.h deleted file mode 100644 index 6008eca2862..00000000000 --- a/libstdc++-v3/bits/std_string.h +++ /dev/null @@ -1,63 +0,0 @@ -// Components for manipulating sequences of characters -*- C++ -*- - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 21 Strings library -// - -#ifndef _CPP_STRING -#define _CPP_STRING 1 - -#include -#include -#include -#include -#include -#include // for operators >>, <<, and getline decls -#include - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# include // for find_if -# include -#endif - -#endif /* _CPP_STRING */ - - - - - - - - - - - - - diff --git a/libstdc++-v3/bits/std_strstream.h b/libstdc++-v3/bits/std_strstream.h deleted file mode 100644 index 2f784b36fce..00000000000 --- a/libstdc++-v3/bits/std_strstream.h +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Copyright (c) 1998 - * 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. - */ - -// WARNING: The classes defined in this header are DEPRECATED. This -// header is defined in section D.7.1 of the C++ standard, and it -// MAY BE REMOVED in a future standard revision. You should use the -// header instead. - -#ifndef __SGI_STL_STRSTREAM -#define __SGI_STL_STRSTREAM - -#if defined(__sgi) && !defined(__GNUC__) && !defined(_STANDARD_C_PLUS_PLUS) -#error This header file requires the -LANG:std option -#endif - -#include -#include -#include -#include -#include - -__STL_BEGIN_NAMESPACE - -//---------------------------------------------------------------------- -// Class strstreambuf, a streambuf class that manages an array of char. -// Note that this class is not a template. - -class strstreambuf : public basic_streambuf > -{ -public: // Types. - typedef char_traits _Traits; - typedef basic_streambuf _Base; - -public: // Constructor, destructor - explicit strstreambuf(streamsize __initial_capacity = 0); - strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*)); - - strstreambuf(char* __get, streamsize __n, char* __put = 0); - strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0); - strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0); - - strstreambuf(const char* __get, streamsize __n); - strstreambuf(const signed char* __get, streamsize __n); - strstreambuf(const unsigned char* __get, streamsize __n); - - virtual ~strstreambuf(); - -public: // strstreambuf operations. - void freeze(bool = true); - char* str(); - int pcount() const; - -protected: // Overridden virtual member functions. - virtual int_type overflow(int_type __c = _Traits::eof()); - virtual int_type pbackfail(int_type __c = _Traits::eof()); - virtual int_type underflow(); - virtual _Base* setbuf(char* __buf, streamsize __n); - virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir, - ios_base::openmode __mode - = ios_base::in | ios_base::out); - virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode - = ios_base::in | ios_base::out); - -private: // Helper functions. - // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun. - char* _M_alloc(size_t); - void _M_free(char*); - - // Helper function used in constructors. - void _M_setup(char* __get, char* __put, streamsize __n); - -private: // Data members. - void* (*_M_alloc_fun)(size_t); - void (*_M_free_fun)(void*); - - bool _M_dynamic : 1; - bool _M_frozen : 1; - bool _M_constant : 1; -}; - -//---------------------------------------------------------------------- -// Class istrstream, an istream that manages a strstreambuf. - -class istrstream : public basic_istream -{ -public: - explicit istrstream(char*); - explicit istrstream(const char*); - istrstream(char* , streamsize); - istrstream(const char*, streamsize); - virtual ~istrstream(); - - strstreambuf* rdbuf() const; - char* str(); - -private: - strstreambuf _M_buf; -}; - -//---------------------------------------------------------------------- -// Class ostrstream - -class ostrstream : public basic_ostream -{ -public: - ostrstream(); - ostrstream(char*, int, ios_base::openmode = ios_base::out); - virtual ~ostrstream(); - - strstreambuf* rdbuf() const; - void freeze(bool = true); - char* str(); - int pcount() const; - -private: - strstreambuf _M_buf; -}; - -//---------------------------------------------------------------------- -// Class strstream - -class strstream : public basic_iostream -{ -public: - typedef char char_type; - typedef char_traits::int_type int_type; - typedef char_traits::pos_type pos_type; - typedef char_traits::off_type off_type; - - strstream(); - strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out); - virtual ~strstream(); - - strstreambuf* rdbuf() const; - void freeze(bool = true); - int pcount() const; - char* str(); - -private: - strstreambuf _M_buf; -}; - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_STRSTREAM */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_typeinfo.h b/libstdc++-v3/bits/std_typeinfo.h deleted file mode 100644 index b0590121631..00000000000 --- a/libstdc++-v3/bits/std_typeinfo.h +++ /dev/null @@ -1,81 +0,0 @@ - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - - -#ifndef _CPP_TYPEINFO -#define _CPP_TYPEINFO 1 - -#include -#include - -#ifdef __GNUG__ -# pragma GCC system_header -# include_next -#else - -__STL_BEGIN_NAMESPACE - - class type_info { - public: - virtual ~type_info(); - bool operator==(const type_info& rhs) const; - bool operator!=(const type_info& rhs) const; - bool before(const type_info& rhs) const; - const char* name() const; - private: - type_info(const type_info& rhs); - type_info& operator=(const type_info& rhs); - }; - - class bad_cast : public exception { - public: - bad_cast() throw(); - bad_cast(const bad_cast&) throw(); - bad_cast& operator=(const bad_cast&) throw(); - virtual ~bad_cast() throw(); - virtual const char* what() const throw(); - }; - - class bad_typeid : public exception { - public: - bad_typeid() throw(); - bad_typeid(const bad_typeid&) throw(); - bad_typeid& operator=(const bad_typeid&) throw(); - virtual ~bad_typeid() throw(); - virtual const char* what() const throw(); - }; - -__STL_END_NAMESPACE - -#endif - -#endif /* _CPP_TYPEINFO */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_utility.h b/libstdc++-v3/bits/std_utility.h deleted file mode 100644 index e10dae35b6a..00000000000 --- a/libstdc++-v3/bits/std_utility.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_UTILITY -#define _CPP_UTILITY 1 - -#include -#include -#include - -#endif /* _CPP_UTILITY */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/std_valarray.h b/libstdc++-v3/bits/std_valarray.h deleted file mode 100644 index fa43c6dca0c..00000000000 --- a/libstdc++-v3/bits/std_valarray.h +++ /dev/null @@ -1,728 +0,0 @@ -// The template and inlines for the -*- C++ -*- valarray class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_VALARRAY -#define _CPP_VALARRAY 1 - -#include -#include -#include -#include -#include -#include -#include - -namespace std { - - template class _Expr; - - template class _ValArray; - - template class _Oper, - template class _Meta, class _Dom> struct _UnClos; - - template class _Oper, - template class _Meta1, - template class _Meta2, - class _Dom1, class _Dom2> class _BinClos; - - template class _Meta, class _Dom> class _SClos; - - template class _Meta, class _Dom> class _GClos; - - template class _Meta, class _Dom> class _IClos; - - template class _Meta, class _Dom> class _ValFunClos; - - template class _Meta, class _Dom> class _RefFunClos; - - template struct _Unary_plus; - template struct _Bitwise_and; - template struct _Bitwise_or; - template struct _Bitwise_xor; - template struct _Bitwise_not; - template struct _Shift_left; - template struct _Shift_right; - - template class valarray; // An array of type _Tp - class slice; // BLAS-like slice out of an array - template class slice_array; - class gslice; // generalized slice out of an array - template class gslice_array; - template class mask_array; // masked array - template class indirect_array; // indirected array - -} - -#include -#include - -namespace std { - - template class valarray - { - public: - typedef _Tp value_type; - - // _lib.valarray.cons_ construct/destroy: - valarray(); - explicit valarray(size_t); - valarray(const _Tp&, size_t); - valarray(const _Tp* __restrict__, size_t); - valarray(const valarray&); - valarray(const slice_array<_Tp>&); - valarray(const gslice_array<_Tp>&); - valarray(const mask_array<_Tp>&); - valarray(const indirect_array<_Tp>&); - template - valarray(const _Expr<_Dom,_Tp>& __e); - ~valarray(); - - // _lib.valarray.assign_ assignment: - valarray<_Tp>& operator=(const valarray<_Tp>&); - valarray<_Tp>& operator=(const _Tp&); - valarray<_Tp>& operator=(const slice_array<_Tp>&); - valarray<_Tp>& operator=(const gslice_array<_Tp>&); - valarray<_Tp>& operator=(const mask_array<_Tp>&); - valarray<_Tp>& operator=(const indirect_array<_Tp>&); - - template valarray<_Tp>& - operator= (const _Expr<_Dom,_Tp>&); - - // _lib.valarray.access_ element access: - _Tp operator[](size_t) const; - _Tp& operator[](size_t); - // _lib.valarray.sub_ subset operations: - _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const; - slice_array<_Tp> operator[](slice); - _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const; - gslice_array<_Tp> operator[](const gslice&); - valarray<_Tp> operator[](const valarray&) const; - mask_array<_Tp> operator[](const valarray&); - _Expr<_IClos<_ValArray, _Tp>, _Tp> - operator[](const valarray&) const; - indirect_array<_Tp> operator[](const valarray&); - - // _lib.valarray.unary_ unary operators: - _Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const; - _Expr<_UnClos,_Tp> operator- () const; - _Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const; - _Expr<_UnClos,bool> 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 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 - valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&); - template - valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); - template - 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; - - valarray<_Tp> shift (int) const; - valarray<_Tp> cshift(int) const; - _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const; - _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const; - void resize(size_t __size, _Tp __c = _Tp()); - - private: - size_t _M_size; - _Tp* __restrict__ _M_data; - - friend class _Array<_Tp>; - }; - - - template struct _Unary_plus : unary_function<_Tp,_Tp> { - _Tp operator() (const _Tp& __t) const { return __t; } - }; - - template struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x & __y; } - }; - - template struct _Bitwise_or : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x | __y; } - }; - - template struct _Bitwise_xor : binary_function<_Tp,_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x ^ __y; } - }; - - template struct _Bitwise_not : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __t) const { return ~__t; } - }; - - template struct _Shift_left : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x << __y; } - }; - - template struct _Shift_right : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __x, _Tp __y) const { return __x >> __y; } - }; - - - template - inline _Tp - valarray<_Tp>::operator[] (size_t __i) const - { return _M_data[__i]; } - - template - _Tp& - valarray<_Tp>::operator[] (size_t __i) - { return _M_data[__i]; } - -} // std:: - -#include -#include -#include -#include -#include -#include - -namespace std { - - template - inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {} - - template - 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 - 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 - 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 - 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 - 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_construct - (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); - } - - template - 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_construct - (__ga._M_array, _Array(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); - } - - template - 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_construct - (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); - } - - template - 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_construct - (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); - } - - template template - inline valarray<_Tp>::valarray (const _Expr<_Dom, _Tp>& __e) - : _M_size(__e.size ()), _M_data(__valarray_get_storage<_Tp>(_M_size)) - { __valarray_copy_construct (__e, _M_size, _Array<_Tp>(_M_data)); } - - template - inline valarray<_Tp>::~valarray () - { - __valarray_destroy_elements(_M_data, _M_data + _M_size); - __valarray_release_memory(_M_data); - } - - template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const valarray<_Tp>& __v) - { - __valarray_copy(__v._M_data, _M_size, _M_data); - return *this; - } - - template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Tp& __t) - { - __valarray_fill (_M_data, _M_size, __t); - return *this; - } - - template - 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 - inline valarray<_Tp>& - valarray<_Tp>::operator= (const gslice_array<_Tp>& __ga) - { - __valarray_copy (__ga._M_array, _Array(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); - return *this; - } - - template - 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 - 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 template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Expr<_Dom, _Tp>& __e) - { - __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); - return *this; - } - - template - 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)); - } - - template - inline slice_array<_Tp> - valarray<_Tp>::operator[] (slice __s) - { - return slice_array<_Tp> (_Array<_Tp>(_M_data), __s); - } - - template - 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)); - } - - template - inline gslice_array<_Tp> - valarray<_Tp>::operator[] (const gslice& __gs) - { - return gslice_array<_Tp> - (_Array<_Tp>(_M_data), __gs._M_index->_M_index); - } - - template - inline valarray<_Tp> - valarray<_Tp>::operator[] (const valarray& __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 (__m))); - } - - template - inline mask_array<_Tp> - valarray<_Tp>::operator[] (const valarray& __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 (__m)); - } - - template - inline _Expr<_IClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (const valarray& __i) const - { - typedef _IClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure, _Tp> (_Closure (*this, __i)); - } - - template - inline indirect_array<_Tp> - valarray<_Tp>::operator[] (const valarray& __i) - { - return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(), - _Array (__i)); - } - - template - inline size_t valarray<_Tp>::size () const { return _M_size; } - - template - inline _Tp - valarray<_Tp>::sum () const - { - return __valarray_sum(_M_data, _M_data + _M_size); - } - -// template -// inline _Tp -// valarray<_Tp>::product () const -// { -// return __valarray_product(_M_data, _M_data + _M_size); -// } - - template - inline valarray<_Tp> - valarray<_Tp>::shift (int __n) const - { - _Tp* const __a = static_cast<_Tp*> - (__builtin_alloca (sizeof(_Tp) * _M_size)); - if (! __n) // __n == 0: no shift - __valarray_copy_construct(_M_data, _M_data + _M_size, __a); - else if (__n > 0) { // __n > 0: shift left - if (__n > _M_size) - __valarray_default_construct(__a, __a + __n); - else { - __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); - __valarray_default_construct(__a+_M_size-__n, __a + _M_size); - } - } - else { // __n < 0: shift right - __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n); - __valarray_default_construct(__a, __a - __n); - } - return valarray<_Tp> (__a, _M_size); - } - - template - inline valarray<_Tp> - valarray<_Tp>::cshift (int __n) const - { - _Tp* const __a = static_cast<_Tp*> - (__builtin_alloca (sizeof(_Tp) * _M_size)); - if (! __n) // __n == 0: no cshift - __valarray_copy_construct(_M_data, _M_data + _M_size, __a); - else if (__n > 0) { // __n > 0: cshift left - __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n); - __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); - } - else { // __n < 0: cshift right - __valarray_copy_construct - (_M_data + _M_size+__n, _M_data + _M_size, __a); - __valarray_copy_construct - (_M_data, _M_data + _M_size+__n, __a - __n); - } - return valarray<_Tp> (__a, _M_size); - } - - template - inline void - valarray<_Tp>::resize (size_t __n, _Tp __c) - { - // This complication is so to make valarray > work - // even though it is not required by the standard. Nobody should - // be saying valarray > 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 - inline _Tp - valarray<_Tp>::min() const - { - return *min_element (_M_data, _M_data+_M_size); - } - - template - inline _Tp - valarray<_Tp>::max() const - { - return *max_element (_M_data, _M_data+_M_size); - } - - template - 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)); - } - - template - 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)); - } - -#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ - template \ - inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \ - valarray<_Tp>::operator _Op() const \ - { \ - typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (*this)); \ - } - - _DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus) - _DEFINE_VALARRAY_UNARY_OPERATOR(-, negate) - _DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not) - -#undef _DEFINE_VALARRAY_UNARY_OPERATOR - - template - inline _Expr<_UnClos, bool> - valarray<_Tp>::operator!() const - { - typedef _UnClos _Closure; - return _Expr<_Closure, bool> (_Closure (*this)); - } - -#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ - template \ - inline valarray<_Tp> & \ - valarray<_Tp>::operator _Op##= (const _Tp &__t) \ - { \ - _Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, __t); \ - return *this; \ - } \ - \ - template \ - 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) - -#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT - - -} // std:: - - -namespace std { - -#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ - template template \ - 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) - -#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT - - -#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ - template \ - inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \ - 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)); \ - } \ - \ - template \ - inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,_Tp> \ - operator _Op (const valarray<_Tp> &__v, const _Tp &__t) \ - { \ - typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (__v, __t)); \ - } \ - \ - template \ - 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 \ - 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 \ - inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,bool> \ - operator _Op (const valarray<_Tp> &__v, const _Tp &__t) \ - { \ - typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure, bool> (_Closure (__v, __t)); \ - } \ - \ - template \ - 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_VALARRAY_OPERATOR - -} // namespace std - -#endif // _CPP_VALARRAY - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/std_vector.h b/libstdc++-v3/bits/std_vector.h deleted file mode 100644 index 08ac4bd69de..00000000000 --- a/libstdc++-v3/bits/std_vector.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1996 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_VECTOR -#define _CPP_VECTOR 1 - -#include -#include -#include -#include -#include -#include -#include - -#endif /* _CPP_VECTOR */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_algo.h b/libstdc++-v3/bits/stl_algo.h deleted file mode 100644 index c432d3d3ebc..00000000000 --- a/libstdc++-v3/bits/stl_algo.h +++ /dev/null @@ -1,3297 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_ALGO_H -#define __SGI_STL_INTERNAL_ALGO_H - -#include - -// See concept_checks.h for the concept-checking macros -// __STL_REQUIRES, __STL_CONVERTIBLE, etc. - - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1209 -#endif - -// __median (an extension, not present in the C++ standard). - -template -inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) { - __STL_REQUIRES(_Tp, _LessThanComparable); - if (__a < __b) - if (__b < __c) - return __b; - else if (__a < __c) - return __c; - else - return __a; - else if (__a < __c) - return __a; - else if (__b < __c) - return __c; - else - return __b; -} - -template -inline const _Tp& -__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) { - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - if (__comp(__a, __b)) - if (__comp(__b, __c)) - return __b; - else if (__comp(__a, __c)) - return __c; - else - return __a; - else if (__comp(__a, __c)) - return __a; - else if (__comp(__b, __c)) - return __c; - else - return __b; -} - -// for_each. Apply a function to every element of a range. -template -_Function for_each(_InputIter __first, _InputIter __last, _Function __f) { - __STL_REQUIRES(_InputIter, _InputIterator); - for ( ; __first != __last; ++__first) - __f(*__first); - return __f; -} - -// find and find_if. - -template -inline _InputIter find(_InputIter __first, _InputIter __last, - const _Tp& __val, - input_iterator_tag) -{ - while (__first != __last && !(*__first == __val)) - ++__first; - return __first; -} - -template -inline _InputIter find_if(_InputIter __first, _InputIter __last, - _Predicate __pred, - input_iterator_tag) -{ - while (__first != __last && !__pred(*__first)) - ++__first; - return __first; -} - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -_RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last, - const _Tp& __val, - random_access_iterator_tag) -{ - typename iterator_traits<_RandomAccessIter>::difference_type __trip_count - = (__last - __first) >> 2; - - for ( ; __trip_count > 0 ; --__trip_count) { - if (*__first == __val) return __first; - ++__first; - - if (*__first == __val) return __first; - ++__first; - - if (*__first == __val) return __first; - ++__first; - - if (*__first == __val) return __first; - ++__first; - } - - switch(__last - __first) { - case 3: - if (*__first == __val) return __first; - ++__first; - case 2: - if (*__first == __val) return __first; - ++__first; - case 1: - if (*__first == __val) return __first; - ++__first; - case 0: - default: - return __last; - } -} - -template -_RandomAccessIter find_if(_RandomAccessIter __first, _RandomAccessIter __last, - _Predicate __pred, - random_access_iterator_tag) -{ - typename iterator_traits<_RandomAccessIter>::difference_type __trip_count - = (__last - __first) >> 2; - - for ( ; __trip_count > 0 ; --__trip_count) { - if (__pred(*__first)) return __first; - ++__first; - - if (__pred(*__first)) return __first; - ++__first; - - if (__pred(*__first)) return __first; - ++__first; - - if (__pred(*__first)) return __first; - ++__first; - } - - switch(__last - __first) { - case 3: - if (__pred(*__first)) return __first; - ++__first; - case 2: - if (__pred(*__first)) return __first; - ++__first; - case 1: - if (__pred(*__first)) return __first; - ++__first; - case 0: - default: - return __last; - } -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline _InputIter find(_InputIter __first, _InputIter __last, - const _Tp& __val) -{ - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_InputIter>::value_type, _Tp); - return find(__first, __last, __val, __ITERATOR_CATEGORY(__first)); -} - -template -inline _InputIter find_if(_InputIter __first, _InputIter __last, - _Predicate __pred) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_InputIter>::value_type); - return find_if(__first, __last, __pred, __ITERATOR_CATEGORY(__first)); -} - -// adjacent_find. - -template -_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _EqualityComparable); - if (__first == __last) - return __last; - _ForwardIter __next = __first; - while(++__next != __last) { - if (*__first == *__next) - return __first; - __first = __next; - } - return __last; -} - -template -_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last, - _BinaryPredicate __binary_pred) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - if (__first == __last) - return __last; - _ForwardIter __next = __first; - while(++__next != __last) { - if (__binary_pred(*__first, *__next)) - return __first; - __first = __next; - } - return __last; -} - -// count and count_if. There are two version of each, one whose return type -// type is void and one (present only if we have partial specialization) -// whose return type is iterator_traits<_InputIter>::difference_type. The -// C++ standard only has the latter version, but the former, which was present -// in the HP STL, is retained for backward compatibility. - -template -void count(_InputIter __first, _InputIter __last, const _Tp& __value, - _Size& __n) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter>::value_type, - _EqualityComparable); - __STL_REQUIRES(_Tp, _EqualityComparable); - for ( ; __first != __last; ++__first) - if (*__first == __value) - ++__n; -} - -template -void count_if(_InputIter __first, _InputIter __last, _Predicate __pred, - _Size& __n) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_InputIter>::value_type); - for ( ; __first != __last; ++__first) - if (__pred(*__first)) - ++__n; -} - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -typename iterator_traits<_InputIter>::difference_type -count(_InputIter __first, _InputIter __last, const _Tp& __value) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter>::value_type, - _EqualityComparable); - __STL_REQUIRES(_Tp, _EqualityComparable); - typename iterator_traits<_InputIter>::difference_type __n = 0; - for ( ; __first != __last; ++__first) - if (*__first == __value) - ++__n; - return __n; -} - -template -typename iterator_traits<_InputIter>::difference_type -count_if(_InputIter __first, _InputIter __last, _Predicate __pred) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_InputIter>::value_type); - typename iterator_traits<_InputIter>::difference_type __n = 0; - for ( ; __first != __last; ++__first) - if (__pred(*__first)) - ++__n; - return __n; -} - - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// search. - -template -_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2) -{ - __STL_REQUIRES(_ForwardIter1, _ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _ForwardIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - - // Test for empty ranges - if (__first1 == __last1 || __first2 == __last2) - return __first1; - - // Test for a pattern of length 1. - _ForwardIter2 __tmp(__first2); - ++__tmp; - if (__tmp == __last2) - return find(__first1, __last1, *__first2); - - // General case. - - _ForwardIter2 __p1, __p; - - __p1 = __first2; ++__p1; - - _ForwardIter1 __current = __first1; - - while (__first1 != __last1) { - __first1 = find(__first1, __last1, *__first2); - if (__first1 == __last1) - return __last1; - - __p = __p1; - __current = __first1; - if (++__current == __last1) - return __last1; - - while (*__current == *__p) { - if (++__p == __last2) - return __first1; - if (++__current == __last1) - return __last1; - } - - ++__first1; - } - return __first1; -} - -template -_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2, - _BinaryPred __predicate) -{ - __STL_REQUIRES(_ForwardIter1, _ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPred, bool, - typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - - // Test for empty ranges - if (__first1 == __last1 || __first2 == __last2) - return __first1; - - // Test for a pattern of length 1. - _ForwardIter2 __tmp(__first2); - ++__tmp; - if (__tmp == __last2) { - while (__first1 != __last1 && !__predicate(*__first1, *__first2)) - ++__first1; - return __first1; - } - - // General case. - - _ForwardIter2 __p1, __p; - - __p1 = __first2; ++__p1; - - _ForwardIter1 __current = __first1; - - while (__first1 != __last1) { - while (__first1 != __last1) { - if (__predicate(*__first1, *__first2)) - break; - ++__first1; - } - while (__first1 != __last1 && !__predicate(*__first1, *__first2)) - ++__first1; - if (__first1 == __last1) - return __last1; - - __p = __p1; - __current = __first1; - if (++__current == __last1) return __last1; - - while (__predicate(*__current, *__p)) { - if (++__p == __last2) - return __first1; - if (++__current == __last1) - return __last1; - } - - ++__first1; - } - return __first1; -} - -// search_n. Search for __count consecutive copies of __val. - -template -_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last, - _Integer __count, const _Tp& __val) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _EqualityComparable); - __STL_REQUIRES(_Tp, _EqualityComparable); - - if (__count <= 0) - return __first; - else { - __first = find(__first, __last, __val); - while (__first != __last) { - _Integer __n = __count - 1; - _ForwardIter __i = __first; - ++__i; - while (__i != __last && __n != 0 && *__i == __val) { - ++__i; - --__n; - } - if (__n == 0) - return __first; - else - __first = find(__i, __last, __val); - } - return __last; - } -} - -template -_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last, - _Integer __count, const _Tp& __val, - _BinaryPred __binary_pred) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPred, bool, - typename iterator_traits<_ForwardIter>::value_type, _Tp); - if (__count <= 0) - return __first; - else { - while (__first != __last) { - if (__binary_pred(*__first, __val)) - break; - ++__first; - } - while (__first != __last) { - _Integer __n = __count - 1; - _ForwardIter __i = __first; - ++__i; - while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) { - ++__i; - --__n; - } - if (__n == 0) - return __first; - else { - while (__i != __last) { - if (__binary_pred(*__i, __val)) - break; - ++__i; - } - __first = __i; - } - } - return __last; - } -} - -// swap_ranges - -template -_ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2) { - __STL_REQUIRES(_ForwardIter1, _Mutable_ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _Mutable_ForwardIterator); - __STL_CONVERTIBLE(typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - __STL_CONVERTIBLE(typename iterator_traits<_ForwardIter2>::value_type, - typename iterator_traits<_ForwardIter1>::value_type); - for ( ; __first1 != __last1; ++__first1, ++__first2) - iter_swap(__first1, __first2); - return __first2; -} - -// transform - -template -_OutputIter transform(_InputIter __first, _InputIter __last, - _OutputIter __result, _UnaryOperation __unary_op) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - - for ( ; __first != __last; ++__first, ++__result) - *__result = __unary_op(*__first); - return __result; -} - -template -_OutputIter transform(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _OutputIter __result, - _BinaryOperation __binary_op) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result) - *__result = __binary_op(*__first1, *__first2); - return __result; -} - -// replace, replace_if, replace_copy, replace_copy_if - -template -void replace(_ForwardIter __first, _ForwardIter __last, - const _Tp& __old_value, const _Tp& __new_value) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_ForwardIter>::value_type, _Tp); - __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type); - for ( ; __first != __last; ++__first) - if (*__first == __old_value) - *__first = __new_value; -} - -template -void replace_if(_ForwardIter __first, _ForwardIter __last, - _Predicate __pred, const _Tp& __new_value) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_ForwardIter>::value_type); - for ( ; __first != __last; ++__first) - if (__pred(*__first)) - *__first = __new_value; -} - -template -_OutputIter replace_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - const _Tp& __old_value, const _Tp& __new_value) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_InputIter>::value_type, _Tp); - for ( ; __first != __last; ++__first, ++__result) - *__result = *__first == __old_value ? __new_value : *__first; - return __result; -} - -template -_OutputIter replace_copy_if(_InputIter __first, _InputIter __last, - _OutputIter __result, - _Predicate __pred, const _Tp& __new_value) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_InputIter>::value_type); - for ( ; __first != __last; ++__first, ++__result) - *__result = __pred(*__first) ? __new_value : *__first; - return __result; -} - -// generate and generate_n - -template -void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_GENERATOR_CHECK(_Generator, - typename iterator_traits<_ForwardIter>::value_type); - for ( ; __first != __last; ++__first) - *__first = __gen(); -} - -template -_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) { - __STL_REQUIRES(_OutputIter, _OutputIterator); - for ( ; __n > 0; --__n, ++__first) - *__first = __gen(); - return __first; -} - -// remove, remove_if, remove_copy, remove_copy_if - -template -_OutputIter remove_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, const _Tp& __value) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_InputIter>::value_type, _Tp); - for ( ; __first != __last; ++__first) - if (!(*__first == __value)) { - *__result = *__first; - ++__result; - } - return __result; -} - -template -_OutputIter remove_copy_if(_InputIter __first, _InputIter __last, - _OutputIter __result, _Predicate __pred) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_InputIter>::value_type); - for ( ; __first != __last; ++__first) - if (!__pred(*__first)) { - *__result = *__first; - ++__result; - } - return __result; -} - -template -_ForwardIter remove(_ForwardIter __first, _ForwardIter __last, - const _Tp& __value) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_ForwardIter>::value_type, _Tp); - __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type); - __first = find(__first, __last, __value); - _ForwardIter __i = __first; - return __first == __last ? __first - : remove_copy(++__i, __last, __first, __value); -} - -template -_ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last, - _Predicate __pred) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_ForwardIter>::value_type); - __first = find_if(__first, __last, __pred); - _ForwardIter __i = __first; - return __first == __last ? __first - : remove_copy_if(++__i, __last, __first, __pred); -} - -// unique and unique_copy - -template -_OutputIter __unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, _Tp*) { - _Tp __value = *__first; - *__result = __value; - while (++__first != __last) - if (!(__value == *__first)) { - __value = *__first; - *++__result = __value; - } - return ++__result; -} - -template -inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - output_iterator_tag) { - return __unique_copy(__first, __last, __result, __VALUE_TYPE(__first)); -} - -template -_ForwardIter __unique_copy(_InputIter __first, _InputIter __last, - _ForwardIter __result, forward_iterator_tag) { - *__result = *__first; - while (++__first != __last) - if (!(*__result == *__first)) - *++__result = *__first; - return ++__result; -} - -template -inline _OutputIter unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter>::value_type, - _EqualityComparable); - if (__first == __last) return __result; - return __unique_copy(__first, __last, __result, - __ITERATOR_CATEGORY(__result)); -} - -template -_OutputIter __unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - _BinaryPredicate __binary_pred, _Tp*) { - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, _Tp, _Tp); - _Tp __value = *__first; - *__result = __value; - while (++__first != __last) - if (!__binary_pred(__value, *__first)) { - __value = *__first; - *++__result = __value; - } - return ++__result; -} - -template -inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - _BinaryPredicate __binary_pred, - output_iterator_tag) { - return __unique_copy(__first, __last, __result, __binary_pred, - __VALUE_TYPE(__first)); -} - -template -_ForwardIter __unique_copy(_InputIter __first, _InputIter __last, - _ForwardIter __result, - _BinaryPredicate __binary_pred, - forward_iterator_tag) { - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_InputIter>::value_type); - *__result = *__first; - while (++__first != __last) - if (!__binary_pred(*__result, *__first)) *++__result = *__first; - return ++__result; -} - -template -inline _OutputIter unique_copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - _BinaryPredicate __binary_pred) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - if (__first == __last) return __result; - return __unique_copy(__first, __last, __result, __binary_pred, - __ITERATOR_CATEGORY(__result)); -} - -template -_ForwardIter unique(_ForwardIter __first, _ForwardIter __last) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _EqualityComparable); - __first = adjacent_find(__first, __last); - return unique_copy(__first, __last, __first); -} - -template -_ForwardIter unique(_ForwardIter __first, _ForwardIter __last, - _BinaryPredicate __binary_pred) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - __first = adjacent_find(__first, __last, __binary_pred); - return unique_copy(__first, __last, __first, __binary_pred); -} - -// reverse and reverse_copy, and their auxiliary functions - -template -void __reverse(_BidirectionalIter __first, _BidirectionalIter __last, - bidirectional_iterator_tag) { - while (true) - if (__first == __last || __first == --__last) - return; - else - iter_swap(__first++, __last); -} - -template -void __reverse(_RandomAccessIter __first, _RandomAccessIter __last, - random_access_iterator_tag) { - while (__first < __last) - iter_swap(__first++, --__last); -} - -template -inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last) { - __STL_REQUIRES(_BidirectionalIter, _Mutable_BidirectionalIterator); - __reverse(__first, __last, __ITERATOR_CATEGORY(__first)); -} - -template -_OutputIter reverse_copy(_BidirectionalIter __first, - _BidirectionalIter __last, - _OutputIter __result) { - __STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - while (__first != __last) { - --__last; - *__result = *__last; - ++__result; - } - return __result; -} - -// rotate and rotate_copy, and their auxiliary functions - -template -_EuclideanRingElement __gcd(_EuclideanRingElement __m, - _EuclideanRingElement __n) -{ - while (__n != 0) { - _EuclideanRingElement __t = __m % __n; - __m = __n; - __n = __t; - } - return __m; -} - -template -_ForwardIter __rotate(_ForwardIter __first, - _ForwardIter __middle, - _ForwardIter __last, - _Distance*, - forward_iterator_tag) { - if (__first == __middle) - return __last; - if (__last == __middle) - return __first; - - _ForwardIter __first2 = __middle; - do { - swap(*__first++, *__first2++); - if (__first == __middle) - __middle = __first2; - } while (__first2 != __last); - - _ForwardIter __new_middle = __first; - - __first2 = __middle; - - while (__first2 != __last) { - swap (*__first++, *__first2++); - if (__first == __middle) - __middle = __first2; - else if (__first2 == __last) - __first2 = __middle; - } - - return __new_middle; -} - - -template -_BidirectionalIter __rotate(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, - _Distance*, - bidirectional_iterator_tag) { - __STL_REQUIRES(_BidirectionalIter, _Mutable_BidirectionalIterator); - if (__first == __middle) - return __last; - if (__last == __middle) - return __first; - - __reverse(__first, __middle, bidirectional_iterator_tag()); - __reverse(__middle, __last, bidirectional_iterator_tag()); - - while (__first != __middle && __middle != __last) - swap (*__first++, *--__last); - - if (__first == __middle) { - __reverse(__middle, __last, bidirectional_iterator_tag()); - return __last; - } - else { - __reverse(__first, __middle, bidirectional_iterator_tag()); - return __first; - } -} - -template -_RandomAccessIter __rotate(_RandomAccessIter __first, - _RandomAccessIter __middle, - _RandomAccessIter __last, - _Distance *, _Tp *) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - _Distance __n = __last - __first; - _Distance __k = __middle - __first; - _Distance __l = __n - __k; - _RandomAccessIter __result = __first + (__last - __middle); - - if (__k == 0) - return __last; - - else if (__k == __l) { - swap_ranges(__first, __middle, __middle); - return __result; - } - - _Distance __d = __gcd(__n, __k); - - for (_Distance __i = 0; __i < __d; __i++) { - _Tp __tmp = *__first; - _RandomAccessIter __p = __first; - - if (__k < __l) { - for (_Distance __j = 0; __j < __l/__d; __j++) { - if (__p > __first + __l) { - *__p = *(__p - __l); - __p -= __l; - } - - *__p = *(__p + __k); - __p += __k; - } - } - - else { - for (_Distance __j = 0; __j < __k/__d - 1; __j ++) { - if (__p < __last - __k) { - *__p = *(__p + __k); - __p += __k; - } - - *__p = * (__p - __l); - __p -= __l; - } - } - - *__p = __tmp; - ++__first; - } - - return __result; -} - -template -inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle, - _ForwardIter __last) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - return __rotate(__first, __middle, __last, - __DISTANCE_TYPE(__first), - __ITERATOR_CATEGORY(__first)); -} - -template -_OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle, - _ForwardIter __last, _OutputIter __result) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - return copy(__first, __middle, copy(__middle, __last, __result)); -} - -// Return a random number in the range [0, __n). This function encapsulates -// whether we're using rand (part of the standard C library) or lrand48 -// (not standard, but a much better choice whenever it's available). - -template -inline _Distance __random_number(_Distance __n) { -#ifdef __STL_NO_DRAND48 - return rand() % __n; -#else - return lrand48() % __n; -#endif -} - -// random_shuffle - -template -inline void random_shuffle(_RandomAccessIter __first, - _RandomAccessIter __last) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - if (__first == __last) return; - for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i) - iter_swap(__i, __first + __random_number((__i - __first) + 1)); -} - -template -void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last, - _RandomNumberGenerator& __rand) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - if (__first == __last) return; - for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i) - iter_swap(__i, __first + __rand((__i - __first) + 1)); -} - -// random_sample and random_sample_n (extensions, not part of the standard). - -template -_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last, - _OutputIter __out, const _Distance __n) -{ - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - _Distance __remaining = 0; - distance(__first, __last, __remaining); - _Distance __m = min(__n, __remaining); - - while (__m > 0) { - if (__random_number(__remaining) < __m) { - *__out = *__first; - ++__out; - --__m; - } - - --__remaining; - ++__first; - } - return __out; -} - -template -_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last, - _OutputIter __out, const _Distance __n, - _RandomNumberGenerator& __rand) -{ - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_UNARY_FUNCTION_CHECK(_RandomNumberGenerator, _Distance, _Distance); - _Distance __remaining = 0; - distance(__first, __last, __remaining); - _Distance __m = min(__n, __remaining); - - while (__m > 0) { - if (__rand(__remaining) < __m) { - *__out = *__first; - ++__out; - --__m; - } - - --__remaining; - ++__first; - } - return __out; -} - -template -_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last, - _RandomAccessIter __out, - const _Distance __n) -{ - _Distance __m = 0; - _Distance __t = __n; - for ( ; __first != __last && __m < __n; ++__m, ++__first) - __out[__m] = *__first; - - while (__first != __last) { - ++__t; - _Distance __M = __random_number(__t); - if (__M < __n) - __out[__M] = *__first; - ++__first; - } - - return __out + __m; -} - -template -_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last, - _RandomAccessIter __out, - _RandomNumberGenerator& __rand, - const _Distance __n) -{ - __STL_UNARY_FUNCTION_CHECK(_RandomNumberGenerator, _Distance, _Distance); - _Distance __m = 0; - _Distance __t = __n; - for ( ; __first != __last && __m < __n; ++__m, ++__first) - __out[__m] = *__first; - - while (__first != __last) { - ++__t; - _Distance __M = __rand(__t); - if (__M < __n) - __out[__M] = *__first; - ++__first; - } - - return __out + __m; -} - -template -inline _RandomAccessIter -random_sample(_InputIter __first, _InputIter __last, - _RandomAccessIter __out_first, _RandomAccessIter __out_last) -{ - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - return __random_sample(__first, __last, - __out_first, __out_last - __out_first); -} - - -template -inline _RandomAccessIter -random_sample(_InputIter __first, _InputIter __last, - _RandomAccessIter __out_first, _RandomAccessIter __out_last, - _RandomNumberGenerator& __rand) -{ - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - return __random_sample(__first, __last, - __out_first, __rand, - __out_last - __out_first); -} - -// partition, stable_partition, and their auxiliary functions - -template -_ForwardIter __partition(_ForwardIter __first, - _ForwardIter __last, - _Predicate __pred, - forward_iterator_tag) { - if (__first == __last) return __first; - - while (__pred(*__first)) - if (++__first == __last) return __first; - - _ForwardIter __next = __first; - - while (++__next != __last) - if (__pred(*__next)) { - swap(*__first, *__next); - ++__first; - } - - return __first; -} - -template -_BidirectionalIter __partition(_BidirectionalIter __first, - _BidirectionalIter __last, - _Predicate __pred, - bidirectional_iterator_tag) { - while (true) { - while (true) - if (__first == __last) - return __first; - else if (__pred(*__first)) - ++__first; - else - break; - --__last; - while (true) - if (__first == __last) - return __first; - else if (!__pred(*__last)) - --__last; - else - break; - iter_swap(__first, __last); - ++__first; - } -} - -template -inline _ForwardIter partition(_ForwardIter __first, - _ForwardIter __last, - _Predicate __pred) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_ForwardIter>::value_type); - return __partition(__first, __last, __pred, __ITERATOR_CATEGORY(__first)); -} - - -template -_ForwardIter __inplace_stable_partition(_ForwardIter __first, - _ForwardIter __last, - _Predicate __pred, _Distance __len) { - if (__len == 1) - return __pred(*__first) ? __last : __first; - _ForwardIter __middle = __first; - advance(__middle, __len / 2); - return rotate(__inplace_stable_partition(__first, __middle, __pred, - __len / 2), - __middle, - __inplace_stable_partition(__middle, __last, __pred, - __len - __len / 2)); -} - -template -_ForwardIter __stable_partition_adaptive(_ForwardIter __first, - _ForwardIter __last, - _Predicate __pred, _Distance __len, - _Pointer __buffer, - _Distance __buffer_size) -{ - if (__len <= __buffer_size) { - _ForwardIter __result1 = __first; - _Pointer __result2 = __buffer; - for ( ; __first != __last ; ++__first) - if (__pred(*__first)) { - *__result1 = *__first; - ++__result1; - } - else { - *__result2 = *__first; - ++__result2; - } - copy(__buffer, __result2, __result1); - return __result1; - } - else { - _ForwardIter __middle = __first; - advance(__middle, __len / 2); - return rotate(__stable_partition_adaptive( - __first, __middle, __pred, - __len / 2, __buffer, __buffer_size), - __middle, - __stable_partition_adaptive( - __middle, __last, __pred, - __len - __len / 2, __buffer, __buffer_size)); - } -} - -template -inline _ForwardIter -__stable_partition_aux(_ForwardIter __first, _ForwardIter __last, - _Predicate __pred, _Tp*, _Distance*) -{ - _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last); - if (__buf.size() > 0) - return __stable_partition_adaptive(__first, __last, __pred, - _Distance(__buf.requested_size()), - __buf.begin(), __buf.size()); - else - return __inplace_stable_partition(__first, __last, __pred, - _Distance(__buf.requested_size())); -} - -template -inline _ForwardIter stable_partition(_ForwardIter __first, - _ForwardIter __last, - _Predicate __pred) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_UNARY_FUNCTION_CHECK(_Predicate, bool, - typename iterator_traits<_ForwardIter>::value_type); - if (__first == __last) - return __first; - else - return __stable_partition_aux(__first, __last, __pred, - __VALUE_TYPE(__first), - __DISTANCE_TYPE(__first)); -} - -template -_RandomAccessIter __unguarded_partition(_RandomAccessIter __first, - _RandomAccessIter __last, - _Tp __pivot) -{ - while (true) { - while (*__first < __pivot) - ++__first; - --__last; - while (__pivot < *__last) - --__last; - if (!(__first < __last)) - return __first; - iter_swap(__first, __last); - ++__first; - } -} - -template -_RandomAccessIter __unguarded_partition(_RandomAccessIter __first, - _RandomAccessIter __last, - _Tp __pivot, _Compare __comp) -{ - while (true) { - while (__comp(*__first, __pivot)) - ++__first; - --__last; - while (__comp(__pivot, *__last)) - --__last; - if (!(__first < __last)) - return __first; - iter_swap(__first, __last); - ++__first; - } -} - -const int __stl_threshold = 16; - -// sort() and its auxiliary functions. - -template -void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) { - _RandomAccessIter __next = __last; - --__next; - while (__val < *__next) { - *__last = *__next; - __last = __next; - --__next; - } - *__last = __val; -} - -template -void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val, - _Compare __comp) { - _RandomAccessIter __next = __last; - --__next; - while (__comp(__val, *__next)) { - *__last = *__next; - __last = __next; - --__next; - } - *__last = __val; -} - -template -inline void __linear_insert(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*) { - _Tp __val = *__last; - if (__val < *__first) { - copy_backward(__first, __last, __last + 1); - *__first = __val; - } - else - __unguarded_linear_insert(__last, __val); -} - -template -inline void __linear_insert(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*, _Compare __comp) { - _Tp __val = *__last; - if (__comp(__val, *__first)) { - copy_backward(__first, __last, __last + 1); - *__first = __val; - } - else - __unguarded_linear_insert(__last, __val, __comp); -} - -template -void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last) { - if (__first == __last) return; - for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i) - __linear_insert(__first, __i, __VALUE_TYPE(__first)); -} - -template -void __insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last, _Compare __comp) { - if (__first == __last) return; - for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i) - __linear_insert(__first, __i, __VALUE_TYPE(__first), __comp); -} - -template -void __unguarded_insertion_sort_aux(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*) { - for (_RandomAccessIter __i = __first; __i != __last; ++__i) - __unguarded_linear_insert(__i, _Tp(*__i)); -} - -template -inline void __unguarded_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last) { - __unguarded_insertion_sort_aux(__first, __last, __VALUE_TYPE(__first)); -} - -template -void __unguarded_insertion_sort_aux(_RandomAccessIter __first, - _RandomAccessIter __last, - _Tp*, _Compare __comp) { - for (_RandomAccessIter __i = __first; __i != __last; ++__i) - __unguarded_linear_insert(__i, _Tp(*__i), __comp); -} - -template -inline void __unguarded_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last, - _Compare __comp) { - __unguarded_insertion_sort_aux(__first, __last, __VALUE_TYPE(__first), - __comp); -} - -template -void __final_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last) { - if (__last - __first > __stl_threshold) { - __insertion_sort(__first, __first + __stl_threshold); - __unguarded_insertion_sort(__first + __stl_threshold, __last); - } - else - __insertion_sort(__first, __last); -} - -template -void __final_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last, _Compare __comp) { - if (__last - __first > __stl_threshold) { - __insertion_sort(__first, __first + __stl_threshold, __comp); - __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp); - } - else - __insertion_sort(__first, __last, __comp); -} - -template -inline _Size __lg(_Size __n) { - _Size __k; - for (__k = 0; __n != 1; __n >>= 1) ++__k; - return __k; -} - -template -void __introsort_loop(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*, - _Size __depth_limit) -{ - while (__last - __first > __stl_threshold) { - if (__depth_limit == 0) { - partial_sort(__first, __last, __last); - return; - } - --__depth_limit; - _RandomAccessIter __cut = - __unguarded_partition(__first, __last, - _Tp(__median(*__first, - *(__first + (__last - __first)/2), - *(__last - 1)))); - __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit); - __last = __cut; - } -} - -template -void __introsort_loop(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*, - _Size __depth_limit, _Compare __comp) -{ - while (__last - __first > __stl_threshold) { - if (__depth_limit == 0) { - partial_sort(__first, __last, __last, __comp); - return; - } - --__depth_limit; - _RandomAccessIter __cut = - __unguarded_partition(__first, __last, - _Tp(__median(*__first, - *(__first + (__last - __first)/2), - *(__last - 1), __comp)), - __comp); - __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp); - __last = __cut; - } -} - -template -inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - if (__first != __last) { - __introsort_loop(__first, __last, - __VALUE_TYPE(__first), - __lg(__last - __first) * 2); - __final_insertion_sort(__first, __last); - } -} - -template -inline void sort(_RandomAccessIter __first, _RandomAccessIter __last, - _Compare __comp) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - if (__first != __last) { - __introsort_loop(__first, __last, - __VALUE_TYPE(__first), - __lg(__last - __first) * 2, - __comp); - __final_insertion_sort(__first, __last, __comp); - } -} - -// stable_sort() and its auxiliary functions. - -template -void __inplace_stable_sort(_RandomAccessIter __first, - _RandomAccessIter __last) { - if (__last - __first < 15) { - __insertion_sort(__first, __last); - return; - } - _RandomAccessIter __middle = __first + (__last - __first) / 2; - __inplace_stable_sort(__first, __middle); - __inplace_stable_sort(__middle, __last); - __merge_without_buffer(__first, __middle, __last, - __middle - __first, - __last - __middle); -} - -template -void __inplace_stable_sort(_RandomAccessIter __first, - _RandomAccessIter __last, _Compare __comp) { - if (__last - __first < 15) { - __insertion_sort(__first, __last, __comp); - return; - } - _RandomAccessIter __middle = __first + (__last - __first) / 2; - __inplace_stable_sort(__first, __middle, __comp); - __inplace_stable_sort(__middle, __last, __comp); - __merge_without_buffer(__first, __middle, __last, - __middle - __first, - __last - __middle, - __comp); -} - -template -void __merge_sort_loop(_RandomAccessIter1 __first, - _RandomAccessIter1 __last, - _RandomAccessIter2 __result, _Distance __step_size) { - _Distance __two_step = 2 * __step_size; - - while (__last - __first >= __two_step) { - __result = merge(__first, __first + __step_size, - __first + __step_size, __first + __two_step, - __result); - __first += __two_step; - } - - __step_size = min(_Distance(__last - __first), __step_size); - merge(__first, __first + __step_size, __first + __step_size, __last, - __result); -} - -template -void __merge_sort_loop(_RandomAccessIter1 __first, - _RandomAccessIter1 __last, - _RandomAccessIter2 __result, _Distance __step_size, - _Compare __comp) { - _Distance __two_step = 2 * __step_size; - - while (__last - __first >= __two_step) { - __result = merge(__first, __first + __step_size, - __first + __step_size, __first + __two_step, - __result, - __comp); - __first += __two_step; - } - __step_size = min(_Distance(__last - __first), __step_size); - - merge(__first, __first + __step_size, - __first + __step_size, __last, - __result, - __comp); -} - -const int __stl_chunk_size = 7; - -template -void __chunk_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last, _Distance __chunk_size) -{ - while (__last - __first >= __chunk_size) { - __insertion_sort(__first, __first + __chunk_size); - __first += __chunk_size; - } - __insertion_sort(__first, __last); -} - -template -void __chunk_insertion_sort(_RandomAccessIter __first, - _RandomAccessIter __last, - _Distance __chunk_size, _Compare __comp) -{ - while (__last - __first >= __chunk_size) { - __insertion_sort(__first, __first + __chunk_size, __comp); - __first += __chunk_size; - } - __insertion_sort(__first, __last, __comp); -} - -template -void __merge_sort_with_buffer(_RandomAccessIter __first, - _RandomAccessIter __last, - _Pointer __buffer, _Distance*) { - _Distance __len = __last - __first; - _Pointer __buffer_last = __buffer + __len; - - _Distance __step_size = __stl_chunk_size; - __chunk_insertion_sort(__first, __last, __step_size); - - while (__step_size < __len) { - __merge_sort_loop(__first, __last, __buffer, __step_size); - __step_size *= 2; - __merge_sort_loop(__buffer, __buffer_last, __first, __step_size); - __step_size *= 2; - } -} - -template -void __merge_sort_with_buffer(_RandomAccessIter __first, - _RandomAccessIter __last, _Pointer __buffer, - _Distance*, _Compare __comp) { - _Distance __len = __last - __first; - _Pointer __buffer_last = __buffer + __len; - - _Distance __step_size = __stl_chunk_size; - __chunk_insertion_sort(__first, __last, __step_size, __comp); - - while (__step_size < __len) { - __merge_sort_loop(__first, __last, __buffer, __step_size, __comp); - __step_size *= 2; - __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp); - __step_size *= 2; - } -} - -template -void __stable_sort_adaptive(_RandomAccessIter __first, - _RandomAccessIter __last, _Pointer __buffer, - _Distance __buffer_size) { - _Distance __len = (__last - __first + 1) / 2; - _RandomAccessIter __middle = __first + __len; - if (__len > __buffer_size) { - __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size); - __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size); - } - else { - __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0); - __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0); - } - __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), - _Distance(__last - __middle), __buffer, __buffer_size); -} - -template -void __stable_sort_adaptive(_RandomAccessIter __first, - _RandomAccessIter __last, _Pointer __buffer, - _Distance __buffer_size, _Compare __comp) { - _Distance __len = (__last - __first + 1) / 2; - _RandomAccessIter __middle = __first + __len; - if (__len > __buffer_size) { - __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, - __comp); - __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size, - __comp); - } - else { - __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0, - __comp); - __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0, - __comp); - } - __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), - _Distance(__last - __middle), __buffer, __buffer_size, - __comp); -} - -template -inline void __stable_sort_aux(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*, _Distance*) { - _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last); - if (buf.begin() == 0) - __inplace_stable_sort(__first, __last); - else - __stable_sort_adaptive(__first, __last, buf.begin(), - _Distance(buf.size())); -} - -template -inline void __stable_sort_aux(_RandomAccessIter __first, - _RandomAccessIter __last, _Tp*, _Distance*, - _Compare __comp) { - _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last); - if (buf.begin() == 0) - __inplace_stable_sort(__first, __last, __comp); - else - __stable_sort_adaptive(__first, __last, buf.begin(), - _Distance(buf.size()), - __comp); -} - -template -inline void stable_sort(_RandomAccessIter __first, - _RandomAccessIter __last) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - __stable_sort_aux(__first, __last, - __VALUE_TYPE(__first), - __DISTANCE_TYPE(__first)); -} - -template -inline void stable_sort(_RandomAccessIter __first, - _RandomAccessIter __last, _Compare __comp) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - __stable_sort_aux(__first, __last, - __VALUE_TYPE(__first), - __DISTANCE_TYPE(__first), - __comp); -} - -// partial_sort, partial_sort_copy, and auxiliary functions. - -template -void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle, - _RandomAccessIter __last, _Tp*) { - make_heap(__first, __middle); - for (_RandomAccessIter __i = __middle; __i < __last; ++__i) - if (*__i < *__first) - __pop_heap(__first, __middle, __i, _Tp(*__i), - __DISTANCE_TYPE(__first)); - sort_heap(__first, __middle); -} - -template -inline void partial_sort(_RandomAccessIter __first, - _RandomAccessIter __middle, - _RandomAccessIter __last) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first)); -} - -template -void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle, - _RandomAccessIter __last, _Tp*, _Compare __comp) { - make_heap(__first, __middle, __comp); - for (_RandomAccessIter __i = __middle; __i < __last; ++__i) - if (__comp(*__i, *__first)) - __pop_heap(__first, __middle, __i, _Tp(*__i), __comp, - __DISTANCE_TYPE(__first)); - sort_heap(__first, __middle, __comp); -} - -template -inline void partial_sort(_RandomAccessIter __first, - _RandomAccessIter __middle, - _RandomAccessIter __last, _Compare __comp) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - __partial_sort(__first, __middle, __last, __VALUE_TYPE(__first), __comp); -} - -template -_RandomAccessIter __partial_sort_copy(_InputIter __first, - _InputIter __last, - _RandomAccessIter __result_first, - _RandomAccessIter __result_last, - _Distance*, _Tp*) { - if (__result_first == __result_last) return __result_last; - _RandomAccessIter __result_real_last = __result_first; - while(__first != __last && __result_real_last != __result_last) { - *__result_real_last = *__first; - ++__result_real_last; - ++__first; - } - make_heap(__result_first, __result_real_last); - while (__first != __last) { - if (*__first < *__result_first) - __adjust_heap(__result_first, _Distance(0), - _Distance(__result_real_last - __result_first), - _Tp(*__first)); - ++__first; - } - sort_heap(__result_first, __result_real_last); - return __result_real_last; -} - -template -inline _RandomAccessIter -partial_sort_copy(_InputIter __first, _InputIter __last, - _RandomAccessIter __result_first, - _RandomAccessIter __result_last) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_CONVERTIBLE(typename iterator_traits<_InputIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - __STL_REQUIRES(typename iterator_traits<_InputIter>::value_type, - _LessThanComparable); - return __partial_sort_copy(__first, __last, __result_first, __result_last, - __DISTANCE_TYPE(__result_first), - __VALUE_TYPE(__first)); -} - -template -_RandomAccessIter __partial_sort_copy(_InputIter __first, - _InputIter __last, - _RandomAccessIter __result_first, - _RandomAccessIter __result_last, - _Compare __comp, _Distance*, _Tp*) { - if (__result_first == __result_last) return __result_last; - _RandomAccessIter __result_real_last = __result_first; - while(__first != __last && __result_real_last != __result_last) { - *__result_real_last = *__first; - ++__result_real_last; - ++__first; - } - make_heap(__result_first, __result_real_last, __comp); - while (__first != __last) { - if (__comp(*__first, *__result_first)) - __adjust_heap(__result_first, _Distance(0), - _Distance(__result_real_last - __result_first), - _Tp(*__first), - __comp); - ++__first; - } - sort_heap(__result_first, __result_real_last, __comp); - return __result_real_last; -} - -template -inline _RandomAccessIter -partial_sort_copy(_InputIter __first, _InputIter __last, - _RandomAccessIter __result_first, - _RandomAccessIter __result_last, _Compare __comp) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_CONVERTIBLE(typename iterator_traits<_InputIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - return __partial_sort_copy(__first, __last, __result_first, __result_last, - __comp, - __DISTANCE_TYPE(__result_first), - __VALUE_TYPE(__first)); -} - -// nth_element() and its auxiliary functions. - -template -void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, - _RandomAccessIter __last, _Tp*) { - while (__last - __first > 3) { - _RandomAccessIter __cut = - __unguarded_partition(__first, __last, - _Tp(__median(*__first, - *(__first + (__last - __first)/2), - *(__last - 1)))); - if (__cut <= __nth) - __first = __cut; - else - __last = __cut; - } - __insertion_sort(__first, __last); -} - -template -inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, - _RandomAccessIter __last) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - __nth_element(__first, __nth, __last, __VALUE_TYPE(__first)); -} - -template -void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, - _RandomAccessIter __last, _Tp*, _Compare __comp) { - while (__last - __first > 3) { - _RandomAccessIter __cut = - __unguarded_partition(__first, __last, - _Tp(__median(*__first, - *(__first + (__last - __first)/2), - *(__last - 1), - __comp)), - __comp); - if (__cut <= __nth) - __first = __cut; - else - __last = __cut; - } - __insertion_sort(__first, __last, __comp); -} - -template -inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, - _RandomAccessIter __last, _Compare __comp) { - __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - __nth_element(__first, __nth, __last, __VALUE_TYPE(__first), __comp); -} - - -// Binary search (lower_bound, upper_bound, equal_range, binary_search). - -template -_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (*__middle < __val) { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; -} - -template -inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_REQUIRES(_Tp, _LessThanComparable); - return __lower_bound(__first, __last, __val, - __DISTANCE_TYPE(__first)); -} - -template -_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Compare __comp, _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (__comp(*__middle, __val)) { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; -} - -template -inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - return __lower_bound(__first, __last, __val, __comp, - __DISTANCE_TYPE(__first)); -} - -template -_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (__val < *__middle) - __len = __half; - else { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - } - return __first; -} - -template -inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_REQUIRES(_Tp, _LessThanComparable); - return __upper_bound(__first, __last, __val, - __DISTANCE_TYPE(__first)); -} - -template -_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Compare __comp, _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (__comp(__val, *__middle)) - __len = __half; - else { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - } - return __first; -} - -template -inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - return __upper_bound(__first, __last, __val, __comp, - __DISTANCE_TYPE(__first)); -} - -template -pair<_ForwardIter, _ForwardIter> -__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, - _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle, __left, __right; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (*__middle < __val) { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else if (__val < *__middle) - __len = __half; - else { - __left = lower_bound(__first, __middle, __val); - advance(__first, __len); - __right = upper_bound(++__middle, __first, __val); - return pair<_ForwardIter, _ForwardIter>(__left, __right); - } - } - return pair<_ForwardIter, _ForwardIter>(__first, __first); -} - -template -inline pair<_ForwardIter, _ForwardIter> -equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_REQUIRES(_Tp, _LessThanComparable); - return __equal_range(__first, __last, __val, - __DISTANCE_TYPE(__first)); -} - -template -pair<_ForwardIter, _ForwardIter> -__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, - _Compare __comp, _Distance*) -{ - _Distance __len = 0; - distance(__first, __last, __len); - _Distance __half; - _ForwardIter __middle, __left, __right; - - while (__len > 0) { - __half = __len >> 1; - __middle = __first; - advance(__middle, __half); - if (__comp(*__middle, __val)) { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else if (__comp(__val, *__middle)) - __len = __half; - else { - __left = lower_bound(__first, __middle, __val, __comp); - advance(__first, __len); - __right = upper_bound(++__middle, __first, __val, __comp); - return pair<_ForwardIter, _ForwardIter>(__left, __right); - } - } - return pair<_ForwardIter, _ForwardIter>(__first, __first); -} - -template -inline pair<_ForwardIter, _ForwardIter> -equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, - _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - return __equal_range(__first, __last, __val, __comp, - __DISTANCE_TYPE(__first)); -} - -template -bool binary_search(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_REQUIRES(_Tp, _LessThanComparable); - _ForwardIter __i = lower_bound(__first, __last, __val); - return __i != __last && !(__val < *__i); -} - -template -bool binary_search(_ForwardIter __first, _ForwardIter __last, - const _Tp& __val, - _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_SAME_TYPE(_Tp, - typename iterator_traits<_ForwardIter>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - _ForwardIter __i = lower_bound(__first, __last, __val, __comp); - return __i != __last && !__comp(__val, *__i); -} - -// merge, with and without an explicitly supplied comparison function. - -template -_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) { - if (*__first2 < *__first1) { - *__result = *__first2; - ++__first2; - } - else { - *__result = *__first1; - ++__first1; - } - ++__result; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -template -_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result, _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter1>::value_type); - while (__first1 != __last1 && __first2 != __last2) { - if (__comp(*__first2, *__first1)) { - *__result = *__first2; - ++__first2; - } - else { - *__result = *__first1; - ++__first1; - } - ++__result; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -// inplace_merge and its auxiliary functions. - -template -void __merge_without_buffer(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, - _Distance __len1, _Distance __len2) { - if (__len1 == 0 || __len2 == 0) - return; - if (__len1 + __len2 == 2) { - if (*__middle < *__first) - iter_swap(__first, __middle); - return; - } - _BidirectionalIter __first_cut = __first; - _BidirectionalIter __second_cut = __middle; - _Distance __len11 = 0; - _Distance __len22 = 0; - if (__len1 > __len2) { - __len11 = __len1 / 2; - advance(__first_cut, __len11); - __second_cut = lower_bound(__middle, __last, *__first_cut); - distance(__middle, __second_cut, __len22); - } - else { - __len22 = __len2 / 2; - advance(__second_cut, __len22); - __first_cut = upper_bound(__first, __middle, *__second_cut); - distance(__first, __first_cut, __len11); - } - _BidirectionalIter __new_middle - = rotate(__first_cut, __middle, __second_cut); - __merge_without_buffer(__first, __first_cut, __new_middle, - __len11, __len22); - __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, - __len2 - __len22); -} - -template -void __merge_without_buffer(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, - _Distance __len1, _Distance __len2, - _Compare __comp) { - if (__len1 == 0 || __len2 == 0) - return; - if (__len1 + __len2 == 2) { - if (__comp(*__middle, *__first)) - iter_swap(__first, __middle); - return; - } - _BidirectionalIter __first_cut = __first; - _BidirectionalIter __second_cut = __middle; - _Distance __len11 = 0; - _Distance __len22 = 0; - if (__len1 > __len2) { - __len11 = __len1 / 2; - advance(__first_cut, __len11); - __second_cut = lower_bound(__middle, __last, *__first_cut, __comp); - distance(__middle, __second_cut, __len22); - } - else { - __len22 = __len2 / 2; - advance(__second_cut, __len22); - __first_cut = upper_bound(__first, __middle, *__second_cut, __comp); - distance(__first, __first_cut, __len11); - } - _BidirectionalIter __new_middle - = rotate(__first_cut, __middle, __second_cut); - __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22, - __comp); - __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, - __len2 - __len22, __comp); -} - -template -_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first, - _BidirectionalIter1 __middle, - _BidirectionalIter1 __last, - _Distance __len1, _Distance __len2, - _BidirectionalIter2 __buffer, - _Distance __buffer_size) { - _BidirectionalIter2 __buffer_end; - if (__len1 > __len2 && __len2 <= __buffer_size) { - __buffer_end = copy(__middle, __last, __buffer); - copy_backward(__first, __middle, __last); - return copy(__buffer, __buffer_end, __first); - } - else if (__len1 <= __buffer_size) { - __buffer_end = copy(__first, __middle, __buffer); - copy(__middle, __last, __first); - return copy_backward(__buffer, __buffer_end, __last); - } - else - return rotate(__first, __middle, __last); -} - -template -_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1, - _BidirectionalIter1 __last1, - _BidirectionalIter2 __first2, - _BidirectionalIter2 __last2, - _BidirectionalIter3 __result) { - if (__first1 == __last1) - return copy_backward(__first2, __last2, __result); - if (__first2 == __last2) - return copy_backward(__first1, __last1, __result); - --__last1; - --__last2; - while (true) { - if (*__last2 < *__last1) { - *--__result = *__last1; - if (__first1 == __last1) - return copy_backward(__first2, ++__last2, __result); - --__last1; - } - else { - *--__result = *__last2; - if (__first2 == __last2) - return copy_backward(__first1, ++__last1, __result); - --__last2; - } - } -} - -template -_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1, - _BidirectionalIter1 __last1, - _BidirectionalIter2 __first2, - _BidirectionalIter2 __last2, - _BidirectionalIter3 __result, - _Compare __comp) { - if (__first1 == __last1) - return copy_backward(__first2, __last2, __result); - if (__first2 == __last2) - return copy_backward(__first1, __last1, __result); - --__last1; - --__last2; - while (true) { - if (__comp(*__last2, *__last1)) { - *--__result = *__last1; - if (__first1 == __last1) - return copy_backward(__first2, ++__last2, __result); - --__last1; - } - else { - *--__result = *__last2; - if (__first2 == __last2) - return copy_backward(__first1, ++__last1, __result); - --__last2; - } - } -} - -template -void __merge_adaptive(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, - _Distance __len1, _Distance __len2, - _Pointer __buffer, _Distance __buffer_size) { - if (__len1 <= __len2 && __len1 <= __buffer_size) { - _Pointer __buffer_end = copy(__first, __middle, __buffer); - merge(__buffer, __buffer_end, __middle, __last, __first); - } - else if (__len2 <= __buffer_size) { - _Pointer __buffer_end = copy(__middle, __last, __buffer); - __merge_backward(__first, __middle, __buffer, __buffer_end, __last); - } - else { - _BidirectionalIter __first_cut = __first; - _BidirectionalIter __second_cut = __middle; - _Distance __len11 = 0; - _Distance __len22 = 0; - if (__len1 > __len2) { - __len11 = __len1 / 2; - advance(__first_cut, __len11); - __second_cut = lower_bound(__middle, __last, *__first_cut); - distance(__middle, __second_cut, __len22); - } - else { - __len22 = __len2 / 2; - advance(__second_cut, __len22); - __first_cut = upper_bound(__first, __middle, *__second_cut); - distance(__first, __first_cut, __len11); - } - _BidirectionalIter __new_middle = - __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, - __len22, __buffer, __buffer_size); - __merge_adaptive(__first, __first_cut, __new_middle, __len11, - __len22, __buffer, __buffer_size); - __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11, - __len2 - __len22, __buffer, __buffer_size); - } -} - -template -void __merge_adaptive(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, - _Distance __len1, _Distance __len2, - _Pointer __buffer, _Distance __buffer_size, - _Compare __comp) { - if (__len1 <= __len2 && __len1 <= __buffer_size) { - _Pointer __buffer_end = copy(__first, __middle, __buffer); - merge(__buffer, __buffer_end, __middle, __last, __first, __comp); - } - else if (__len2 <= __buffer_size) { - _Pointer __buffer_end = copy(__middle, __last, __buffer); - __merge_backward(__first, __middle, __buffer, __buffer_end, __last, - __comp); - } - else { - _BidirectionalIter __first_cut = __first; - _BidirectionalIter __second_cut = __middle; - _Distance __len11 = 0; - _Distance __len22 = 0; - if (__len1 > __len2) { - __len11 = __len1 / 2; - advance(__first_cut, __len11); - __second_cut = lower_bound(__middle, __last, *__first_cut, __comp); - distance(__middle, __second_cut, __len22); - } - else { - __len22 = __len2 / 2; - advance(__second_cut, __len22); - __first_cut = upper_bound(__first, __middle, *__second_cut, __comp); - distance(__first, __first_cut, __len11); - } - _BidirectionalIter __new_middle = - __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, - __len22, __buffer, __buffer_size); - __merge_adaptive(__first, __first_cut, __new_middle, __len11, - __len22, __buffer, __buffer_size, __comp); - __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11, - __len2 - __len22, __buffer, __buffer_size, __comp); - } -} - -template -inline void __inplace_merge_aux(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, _Tp*, _Distance*) { - _Distance __len1 = 0; - distance(__first, __middle, __len1); - _Distance __len2 = 0; - distance(__middle, __last, __len2); - - _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last); - if (__buf.begin() == 0) - __merge_without_buffer(__first, __middle, __last, __len1, __len2); - else - __merge_adaptive(__first, __middle, __last, __len1, __len2, - __buf.begin(), _Distance(__buf.size())); -} - -template -inline void __inplace_merge_aux(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, _Tp*, _Distance*, - _Compare __comp) { - _Distance __len1 = 0; - distance(__first, __middle, __len1); - _Distance __len2 = 0; - distance(__middle, __last, __len2); - - _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last); - if (__buf.begin() == 0) - __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp); - else - __merge_adaptive(__first, __middle, __last, __len1, __len2, - __buf.begin(), _Distance(__buf.size()), - __comp); -} - -template -inline void inplace_merge(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last) { - __STL_REQUIRES(_BidirectionalIter, _Mutable_BidirectionalIterator); - __STL_REQUIRES(typename iterator_traits<_BidirectionalIter>::value_type, - _LessThanComparable); - if (__first == __middle || __middle == __last) - return; - __inplace_merge_aux(__first, __middle, __last, - __VALUE_TYPE(__first), __DISTANCE_TYPE(__first)); -} - -template -inline void inplace_merge(_BidirectionalIter __first, - _BidirectionalIter __middle, - _BidirectionalIter __last, _Compare __comp) { - __STL_REQUIRES(_BidirectionalIter, _Mutable_BidirectionalIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_BidirectionalIter>::value_type, - typename iterator_traits<_BidirectionalIter>::value_type); - if (__first == __middle || __middle == __last) - return; - __inplace_merge_aux(__first, __middle, __last, - __VALUE_TYPE(__first), __DISTANCE_TYPE(__first), - __comp); -} - -// Set algorithms: includes, set_union, set_intersection, set_difference, -// set_symmetric_difference. All of these algorithms have the precondition -// that their input ranges are sorted and the postcondition that their output -// ranges are sorted. - -template -bool includes(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) - if (*__first2 < *__first1) - return false; - else if(*__first1 < *__first2) - ++__first1; - else - ++__first1, ++__first2; - - return __first2 == __last2; -} - -template -bool includes(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first2, *__first1)) - return false; - else if(__comp(*__first1, *__first2)) - ++__first1; - else - ++__first1, ++__first2; - - return __first2 == __last2; -} - -template -_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) { - if (*__first1 < *__first2) { - *__result = *__first1; - ++__first1; - } - else if (*__first2 < *__first1) { - *__result = *__first2; - ++__first2; - } - else { - *__result = *__first1; - ++__first1; - ++__first2; - } - ++__result; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -template -_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result, _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - while (__first1 != __last1 && __first2 != __last2) { - if (__comp(*__first1, *__first2)) { - *__result = *__first1; - ++__first1; - } - else if (__comp(*__first2, *__first1)) { - *__result = *__first2; - ++__first2; - } - else { - *__result = *__first1; - ++__first1; - ++__first2; - } - ++__result; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -template -_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) - if (*__first1 < *__first2) - ++__first1; - else if (*__first2 < *__first1) - ++__first2; - else { - *__result = *__first1; - ++__first1; - ++__first2; - ++__result; - } - return __result; -} - -template -_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result, _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first1, *__first2)) - ++__first1; - else if (__comp(*__first2, *__first1)) - ++__first2; - else { - *__result = *__first1; - ++__first1; - ++__first2; - ++__result; - } - return __result; -} - -template -_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) - if (*__first1 < *__first2) { - *__result = *__first1; - ++__first1; - ++__result; - } - else if (*__first2 < *__first1) - ++__first2; - else { - ++__first1; - ++__first2; - } - return copy(__first1, __last1, __result); -} - -template -_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result, _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first1, *__first2)) { - *__result = *__first1; - ++__first1; - ++__result; - } - else if (__comp(*__first2, *__first1)) - ++__first2; - else { - ++__first1; - ++__first2; - } - return copy(__first1, __last1, __result); -} - -template -_OutputIter -set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - while (__first1 != __last1 && __first2 != __last2) - if (*__first1 < *__first2) { - *__result = *__first1; - ++__first1; - ++__result; - } - else if (*__first2 < *__first1) { - *__result = *__first2; - ++__first2; - ++__result; - } - else { - ++__first1; - ++__first2; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -template -_OutputIter -set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _OutputIter __result, - _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - __STL_REQUIRES_SAME_TYPE( - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_InputIter1>::value_type, - typename iterator_traits<_InputIter2>::value_type); - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first1, *__first2)) { - *__result = *__first1; - ++__first1; - ++__result; - } - else if (__comp(*__first2, *__first1)) { - *__result = *__first2; - ++__first2; - ++__result; - } - else { - ++__first1; - ++__first2; - } - return copy(__first2, __last2, copy(__first1, __last1, __result)); -} - -// min_element and max_element, with and without an explicitly supplied -// comparison function. - -template -_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _LessThanComparable); - if (__first == __last) return __first; - _ForwardIter __result = __first; - while (++__first != __last) - if (*__result < *__first) - __result = __first; - return __result; -} - -template -_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last, - _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - if (__first == __last) return __first; - _ForwardIter __result = __first; - while (++__first != __last) - if (__comp(*__result, *__first)) __result = __first; - return __result; -} - -template -_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _LessThanComparable); - if (__first == __last) return __first; - _ForwardIter __result = __first; - while (++__first != __last) - if (*__first < *__result) - __result = __first; - return __result; -} - -template -_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last, - _Compare __comp) { - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - if (__first == __last) return __first; - _ForwardIter __result = __first; - while (++__first != __last) - if (__comp(*__first, *__result)) - __result = __first; - return __result; -} - -// next_permutation and prev_permutation, with and without an explicitly -// supplied comparison function. - -template -bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) { - __STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator); - __STL_REQUIRES(typename iterator_traits<_BidirectionalIter>::value_type, - _LessThanComparable); - if (__first == __last) - return false; - _BidirectionalIter __i = __first; - ++__i; - if (__i == __last) - return false; - __i = __last; - --__i; - - for(;;) { - _BidirectionalIter __ii = __i; - --__i; - if (*__i < *__ii) { - _BidirectionalIter __j = __last; - while (!(*__i < *--__j)) - {} - iter_swap(__i, __j); - reverse(__ii, __last); - return true; - } - if (__i == __first) { - reverse(__first, __last); - return false; - } - } -} - -template -bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last, - _Compare __comp) { - __STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_BidirectionalIter>::value_type, - typename iterator_traits<_BidirectionalIter>::value_type); - if (__first == __last) - return false; - _BidirectionalIter __i = __first; - ++__i; - if (__i == __last) - return false; - __i = __last; - --__i; - - for(;;) { - _BidirectionalIter __ii = __i; - --__i; - if (__comp(*__i, *__ii)) { - _BidirectionalIter __j = __last; - while (!__comp(*__i, *--__j)) - {} - iter_swap(__i, __j); - reverse(__ii, __last); - return true; - } - if (__i == __first) { - reverse(__first, __last); - return false; - } - } -} - -template -bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) { - __STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator); - __STL_REQUIRES(typename iterator_traits<_BidirectionalIter>::value_type, - _LessThanComparable); - if (__first == __last) - return false; - _BidirectionalIter __i = __first; - ++__i; - if (__i == __last) - return false; - __i = __last; - --__i; - - for(;;) { - _BidirectionalIter __ii = __i; - --__i; - if (*__ii < *__i) { - _BidirectionalIter __j = __last; - while (!(*--__j < *__i)) - {} - iter_swap(__i, __j); - reverse(__ii, __last); - return true; - } - if (__i == __first) { - reverse(__first, __last); - return false; - } - } -} - -template -bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last, - _Compare __comp) { - __STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator); - __STL_BINARY_FUNCTION_CHECK(_Compare, bool, - typename iterator_traits<_BidirectionalIter>::value_type, - typename iterator_traits<_BidirectionalIter>::value_type); - if (__first == __last) - return false; - _BidirectionalIter __i = __first; - ++__i; - if (__i == __last) - return false; - __i = __last; - --__i; - - for(;;) { - _BidirectionalIter __ii = __i; - --__i; - if (__comp(*__ii, *__i)) { - _BidirectionalIter __j = __last; - while (!__comp(*--__j, *__i)) - {} - iter_swap(__i, __j); - reverse(__ii, __last); - return true; - } - if (__i == __first) { - reverse(__first, __last); - return false; - } - } -} - -// find_first_of, with and without an explicitly supplied comparison function. - -template -_InputIter find_first_of(_InputIter __first1, _InputIter __last1, - _ForwardIter __first2, _ForwardIter __last2) -{ - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_InputIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - - for ( ; __first1 != __last1; ++__first1) - for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter) - if (*__first1 == *__iter) - return __first1; - return __last1; -} - -template -_InputIter find_first_of(_InputIter __first1, _InputIter __last1, - _ForwardIter __first2, _ForwardIter __last2, - _BinaryPredicate __comp) -{ - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, - typename iterator_traits<_InputIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - - for ( ; __first1 != __last1; ++__first1) - for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter) - if (__comp(*__first1, *__iter)) - return __first1; - return __last1; -} - - -// find_end, with and without an explicitly supplied comparison function. -// Search [first2, last2) as a subsequence in [first1, last1), and return -// the *last* possible match. Note that find_end for bidirectional iterators -// is much faster than for forward iterators. - -// find_end for forward iterators. -template -_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2, - forward_iterator_tag, forward_iterator_tag) -{ - if (__first2 == __last2) - return __last1; - else { - _ForwardIter1 __result = __last1; - while (1) { - _ForwardIter1 __new_result - = search(__first1, __last1, __first2, __last2); - if (__new_result == __last1) - return __result; - else { - __result = __new_result; - __first1 = __new_result; - ++__first1; - } - } - } -} - -template -_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2, - forward_iterator_tag, forward_iterator_tag, - _BinaryPredicate __comp) -{ - if (__first2 == __last2) - return __last1; - else { - _ForwardIter1 __result = __last1; - while (1) { - _ForwardIter1 __new_result - = search(__first1, __last1, __first2, __last2, __comp); - if (__new_result == __last1) - return __result; - else { - __result = __new_result; - __first1 = __new_result; - ++__first1; - } - } - } -} - -// find_end for bidirectional iterators. Requires partial specialization. -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -_BidirectionalIter1 -__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1, - _BidirectionalIter2 __first2, _BidirectionalIter2 __last2, - bidirectional_iterator_tag, bidirectional_iterator_tag) -{ - __STL_REQUIRES(_BidirectionalIter1, _BidirectionalIterator); - __STL_REQUIRES(_BidirectionalIter2, _BidirectionalIterator); - typedef reverse_iterator<_BidirectionalIter1> _RevIter1; - typedef reverse_iterator<_BidirectionalIter2> _RevIter2; - - _RevIter1 __rlast1(__first1); - _RevIter2 __rlast2(__first2); - _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1, - _RevIter2(__last2), __rlast2); - - if (__rresult == __rlast1) - return __last1; - else { - _BidirectionalIter1 __result = __rresult.base(); - advance(__result, -distance(__first2, __last2)); - return __result; - } -} - -template -_BidirectionalIter1 -__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1, - _BidirectionalIter2 __first2, _BidirectionalIter2 __last2, - bidirectional_iterator_tag, bidirectional_iterator_tag, - _BinaryPredicate __comp) -{ - __STL_REQUIRES(_BidirectionalIter1, _BidirectionalIterator); - __STL_REQUIRES(_BidirectionalIter2, _BidirectionalIterator); - typedef reverse_iterator<_BidirectionalIter1> _RevIter1; - typedef reverse_iterator<_BidirectionalIter2> _RevIter2; - - _RevIter1 __rlast1(__first1); - _RevIter2 __rlast2(__first2); - _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1, - _RevIter2(__last2), __rlast2, - __comp); - - if (__rresult == __rlast1) - return __last1; - else { - _BidirectionalIter1 __result = __rresult.base(); - advance(__result, -distance(__first2, __last2)); - return __result; - } -} -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// Dispatching functions for find_end. - -template -inline _ForwardIter1 -find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2) -{ - __STL_REQUIRES(_ForwardIter1, _ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _ForwardIterator); - __STL_REQUIRES_BINARY_OP(_OP_EQUAL, bool, - typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - return __find_end(__first1, __last1, __first2, __last2, - __ITERATOR_CATEGORY(__first1), - __ITERATOR_CATEGORY(__first2)); -} - -template -inline _ForwardIter1 -find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, - _ForwardIter2 __first2, _ForwardIter2 __last2, - _BinaryPredicate __comp) -{ - __STL_REQUIRES(_ForwardIter1, _ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_BinaryPredicate, bool, - typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - - return __find_end(__first1, __last1, __first2, __last2, - __ITERATOR_CATEGORY(__first1), - __ITERATOR_CATEGORY(__first2), - __comp); -} - -// is_heap, a predicate testing whether or not a range is -// a heap. This function is an extension, not part of the C++ -// standard. - -template -bool __is_heap(_RandomAccessIter __first, _Distance __n) -{ - _Distance __parent = 0; - for (_Distance __child = 1; __child < __n; ++__child) { - if (__first[__parent] < __first[__child]) - return false; - if ((__child & 1) == 0) - ++__parent; - } - return true; -} - -template -bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp, - _Distance __n) -{ - _Distance __parent = 0; - for (_Distance __child = 1; __child < __n; ++__child) { - if (__comp(__first[__parent], __first[__child])) - return false; - if ((__child & 1) == 0) - ++__parent; - } - return true; -} - -template -inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last) -{ - __STL_REQUIRES(_RandomAccessIter, _RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type, - _LessThanComparable); - return __is_heap(__first, __last - __first); -} - - -template -inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last, - _StrictWeakOrdering __comp) -{ - __STL_REQUIRES(_RandomAccessIter, _RandomAccessIterator); - __STL_BINARY_FUNCTION_CHECK(_StrictWeakOrdering, bool, - typename iterator_traits<_RandomAccessIter>::value_type, - typename iterator_traits<_RandomAccessIter>::value_type); - return __is_heap(__first, __comp, __last - __first); -} - -// is_sorted, a predicated testing whether a range is sorted in -// nondescending order. This is an extension, not part of the C++ -// standard. - -template -bool is_sorted(_ForwardIter __first, _ForwardIter __last) -{ - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_REQUIRES(typename iterator_traits<_ForwardIter>::value_type, - _LessThanComparable); - if (__first == __last) - return true; - - _ForwardIter __next = __first; - for (++__next; __next != __last; __first = __next, ++__next) { - if (*__next < *__first) - return false; - } - - return true; -} - -template -bool is_sorted(_ForwardIter __first, _ForwardIter __last, - _StrictWeakOrdering __comp) -{ - __STL_REQUIRES(_ForwardIter, _ForwardIterator); - __STL_BINARY_FUNCTION_CHECK(_StrictWeakOrdering, bool, - typename iterator_traits<_ForwardIter>::value_type, - typename iterator_traits<_ForwardIter>::value_type); - if (__first == __last) - return true; - - _ForwardIter __next = __first; - for (++__next; __next != __last; __first = __next, ++__next) { - if (__comp(*__next, *__first)) - return false; - } - - return true; -} - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1209 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_ALGO_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_algobase.h b/libstdc++-v3/bits/stl_algobase.h deleted file mode 100644 index 71889e0853f..00000000000 --- a/libstdc++-v3/bits/stl_algobase.h +++ /dev/null @@ -1,756 +0,0 @@ -/* - * - * 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-1998 - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - - -#ifndef __SGI_STL_INTERNAL_ALGOBASE_H -#define __SGI_STL_INTERNAL_ALGOBASE_H - -#include -#include -#ifndef __SGI_STL_INTERNAL_PAIR_H -#include -#endif -#ifndef _CPP_BITS_TYPE_TRAITS_H -#include -#endif -#include -#include -#include -#include -#include - -#ifdef __STL_USE_NEW_IOSTREAMS -#include -#else /* __STL_USE_NEW_IOSTREAMS */ -#include -#endif /* __STL_USE_NEW_IOSTREAMS */ - -#include -#include - -// We pick up concept_checks.h from stl_iterator_base.h. - -__STL_BEGIN_NAMESPACE - -// swap and iter_swap - -template -inline void __iter_swap(_ForwardIter1 __a, _ForwardIter2 __b, _Tp*) { - _Tp __tmp = *__a; - *__a = *__b; - *__b = __tmp; -} - -template -inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b) { - __STL_REQUIRES(_ForwardIter1, _Mutable_ForwardIterator); - __STL_REQUIRES(_ForwardIter2, _Mutable_ForwardIterator); - __STL_CONVERTIBLE(typename iterator_traits<_ForwardIter1>::value_type, - typename iterator_traits<_ForwardIter2>::value_type); - __STL_CONVERTIBLE(typename iterator_traits<_ForwardIter2>::value_type, - typename iterator_traits<_ForwardIter1>::value_type); - __iter_swap(__a, __b, __VALUE_TYPE(__a)); -} - -template -inline void swap(_Tp& __a, _Tp& __b) { - __STL_REQUIRES(_Tp, _Assignable); - _Tp __tmp = __a; - __a = __b; - __b = __tmp; -} - -//-------------------------------------------------- -// min and max - -#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x540 /* C++ Builder 4.0 */ - -#undef min -#undef max - -template -inline const _Tp& min(const _Tp& __a, const _Tp& __b) { - __STL_REQUIRES(_Tp, _LessThanComparable); - //return __b < __a ? __b : __a; - if (__b < __a) return __b; return __a; -} - -template -inline const _Tp& max(const _Tp& __a, const _Tp& __b) { - __STL_REQUIRES(_Tp, _LessThanComparable); - //return __a < __b ? __b : __a; - if (__a < __b) return __b; return __a; -} - -#endif /* __BORLANDC__ */ - -template -inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) { - //return __comp(__b, __a) ? __b : __a; - if (__comp(__b, __a)) return __b; return __a; -} - -template -inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) { - //return __comp(__a, __b) ? __b : __a; - if (__comp(__a, __b)) return __b; return __a; -} - -//-------------------------------------------------- -// copy - -// All of these auxiliary functions serve two purposes. (1) Replace -// calls to copy with memmove whenever possible. (Memmove, not memcpy, -// because the input and output ranges are permitted to overlap.) -// (2) If we're using random access iterators, then write the loop as -// a for loop with an explicit count. - -template -inline _OutputIter __copy(_InputIter __first, _InputIter __last, - _OutputIter __result, - input_iterator_tag, _Distance*) -{ - for ( ; __first != __last; ++__result, ++__first) - *__result = *__first; - return __result; -} - -template -inline _OutputIter -__copy(_RandomAccessIter __first, _RandomAccessIter __last, - _OutputIter __result, random_access_iterator_tag, _Distance*) -{ - for (_Distance __n = __last - __first; __n > 0; --__n) { - *__result = *__first; - ++__first; - ++__result; - } - return __result; -} - -template -inline _Tp* -__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result) { - memmove(__result, __first, sizeof(_Tp) * (__last - __first)); - return __result + (__last - __first); -} - -#if defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) - -template -inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last, - _OutputIter __result, __false_type) { - return __copy(__first, __last, __result, - __ITERATOR_CATEGORY(__first), - __DISTANCE_TYPE(__first)); -} - -template -inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last, - _OutputIter __result, __true_type) { - return __copy(__first, __last, __result, - __ITERATOR_CATEGORY(__first), - __DISTANCE_TYPE(__first)); -} - -#ifndef __USLC__ - -template -inline _Tp* __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result, - __true_type) { - return __copy_trivial(__first, __last, __result); -} - -#endif /* __USLC__ */ - -template -inline _Tp* __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result, - __true_type) { - return __copy_trivial(__first, __last, __result); -} - - -template -inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, - _OutputIter __result, _Tp*) { - typedef typename __type_traits<_Tp>::has_trivial_assignment_operator - _Trivial; - return __copy_aux2(__first, __last, __result, _Trivial()); -} - -template -inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last, - _OutputIter __result, __true_type) { - return _OutputIter(__copy_aux(__first, __last, __result.base(), - __VALUE_TYPE(__first))); -} - -template -inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last, - _OutputIter __result, __false_type) { - return __copy_aux(__first, __last, __result, __VALUE_TYPE(__first)); -} - -template -inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last, - _OutputIter __result, __true_type) { - typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal; - return __copy_ni2(__first.base(), __last.base(), __result, __Normal()); -} - -template -inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last, - _OutputIter __result, __false_type) { - typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal; - return __copy_ni2(__first, __last, __result, __Normal()); -} - -template -inline _OutputIter copy(_InputIter __first, _InputIter __last, - _OutputIter __result) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal; - return __copy_ni1(__first, __last, __result, __Normal()); -} - -// Hack for compilers that don't have partial ordering of function templates -// but do have partial specialization of class templates. -#elif defined(__STL_CLASS_PARTIAL_SPECIALIZATION) - -template -struct __copy_dispatch { - static _OutputIter copy(_InputIter __first, _InputIter __last, - _OutputIter __result) { - typedef typename iterator_traits<_InputIter>::iterator_category _Category; - typedef typename iterator_traits<_InputIter>::difference_type _Distance; - return __copy(__first, __last, __result, _Category(), (_Distance*) 0); - } -}; - -template -struct __copy_dispatch<_Tp*, _Tp*, __true_type> -{ - static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { - return __copy_trivial(__first, __last, __result); - } -}; - -template -struct __copy_dispatch -{ - static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { - return __copy_trivial(__first, __last, __result); - } -}; - -template -inline _OutputIter copy(_InputIter __first, _InputIter __last, - _OutputIter __result) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - typedef typename iterator_traits<_InputIter>::value_type _Tp; - typedef typename __type_traits<_Tp>::has_trivial_assignment_operator - _Trivial; - return __copy_dispatch<_InputIter, _OutputIter, _Trivial> - ::copy(__first, __last, __result); -} - -// Fallback for compilers with neither partial ordering nor partial -// specialization. Define the faster version for the basic builtin -// types. -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline _OutputIter copy(_InputIter __first, _InputIter __last, - _OutputIter __result) -{ - return __copy(__first, __last, __result, - __ITERATOR_CATEGORY(__first), - __DISTANCE_TYPE(__first)); -} - -#define __SGI_STL_DECLARE_COPY_TRIVIAL(_Tp) \ - inline _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { \ - memmove(__result, __first, sizeof(_Tp) * (__last - __first)); \ - return __result + (__last - __first); \ - } - -__SGI_STL_DECLARE_COPY_TRIVIAL(char) -__SGI_STL_DECLARE_COPY_TRIVIAL(signed char) -__SGI_STL_DECLARE_COPY_TRIVIAL(unsigned char) -__SGI_STL_DECLARE_COPY_TRIVIAL(short) -__SGI_STL_DECLARE_COPY_TRIVIAL(unsigned short) -__SGI_STL_DECLARE_COPY_TRIVIAL(int) -__SGI_STL_DECLARE_COPY_TRIVIAL(unsigned int) -__SGI_STL_DECLARE_COPY_TRIVIAL(long) -__SGI_STL_DECLARE_COPY_TRIVIAL(unsigned long) -#ifdef __STL_HAS_WCHAR_T -__SGI_STL_DECLARE_COPY_TRIVIAL(wchar_t) -#endif -#ifdef _STL_LONG_LONG -__SGI_STL_DECLARE_COPY_TRIVIAL(long long) -__SGI_STL_DECLARE_COPY_TRIVIAL(unsigned long long) -#endif -__SGI_STL_DECLARE_COPY_TRIVIAL(float) -__SGI_STL_DECLARE_COPY_TRIVIAL(double) -__SGI_STL_DECLARE_COPY_TRIVIAL(long double) - -#undef __SGI_STL_DECLARE_COPY_TRIVIAL -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -//-------------------------------------------------- -// copy_backward - -template -inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first, - _BidirectionalIter1 __last, - _BidirectionalIter2 __result, - bidirectional_iterator_tag, - _Distance*) -{ - while (__first != __last) - *--__result = *--__last; - return __result; -} - -template -inline _BidirectionalIter __copy_backward(_RandomAccessIter __first, - _RandomAccessIter __last, - _BidirectionalIter __result, - random_access_iterator_tag, - _Distance*) -{ - for (_Distance __n = __last - __first; __n > 0; --__n) - *--__result = *--__last; - return __result; -} - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -// This dispatch class is a workaround for compilers that do not -// have partial ordering of function templates. All we're doing is -// creating a specialization so that we can turn a call to copy_backward -// into a memmove whenever possible. - -template -struct __copy_backward_dispatch -{ - typedef typename iterator_traits<_BidirectionalIter1>::iterator_category - _Cat; - typedef typename iterator_traits<_BidirectionalIter1>::difference_type - _Distance; - - static _BidirectionalIter2 copy(_BidirectionalIter1 __first, - _BidirectionalIter1 __last, - _BidirectionalIter2 __result) { - return __copy_backward(__first, __last, __result, _Cat(), (_Distance*) 0); - } -}; - -template -struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type> -{ - static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { - const ptrdiff_t _Num = __last - __first; - memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - return __result - _Num; - } -}; - -template -struct __copy_backward_dispatch -{ - static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { - return __copy_backward_dispatch<_Tp*, _Tp*, __true_type> - ::copy(__first, __last, __result); - } -}; - -template -inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) { - typedef typename __type_traits::value_type> - ::has_trivial_assignment_operator - _Trivial; - return __copy_backward_dispatch<_BI1, _BI2, _Trivial> - ::copy(__first, __last, __result); -} - -template -inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last, - _BI2 __result, __true_type) { - return _BI2(__copy_backward_aux(__first, __last, __result.base())); -} - -template -inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last, - _BI2 __result, __false_type){ - return __copy_backward_aux(__first, __last, __result); -} - -template -inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last, - _BI2 __result, __true_type) { - typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal; - return __copy_backward_output_normal_iterator(__first.base(), __last.base(), - __result, __Normal()); -} - -template -inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last, - _BI2 __result, __false_type) { - typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal; - return __copy_backward_output_normal_iterator(__first, __last, __result, - __Normal()); -} - -template -inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { - __STL_REQUIRES(_BI1, _BidirectionalIterator); - __STL_REQUIRES(_BI2, _Mutable_BidirectionalIterator); - __STL_CONVERTIBLE(typename iterator_traits<_BI1>::value_type, - typename iterator_traits<_BI2>::value_type); - typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal; - return __copy_backward_input_normal_iterator(__first, __last, __result, - __Normal()); -} - -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { - return __copy_backward(__first, __last, __result, - __ITERATOR_CATEGORY(__first), - __DISTANCE_TYPE(__first)); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -//-------------------------------------------------- -// copy_n (not part of the C++ standard) - -template -pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count, - _OutputIter __result, - input_iterator_tag) { - for ( ; __count > 0; --__count) { - *__result = *__first; - ++__first; - ++__result; - } - return pair<_InputIter, _OutputIter>(__first, __result); -} - -template -inline pair<_RAIter, _OutputIter> -__copy_n(_RAIter __first, _Size __count, - _OutputIter __result, - random_access_iterator_tag) { - _RAIter __last = __first + __count; - return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result)); -} - -template -inline pair<_InputIter, _OutputIter> -__copy_n(_InputIter __first, _Size __count, _OutputIter __result) { - return __copy_n(__first, __count, __result, - __ITERATOR_CATEGORY(__first)); -} - -template -inline pair<_InputIter, _OutputIter> -copy_n(_InputIter __first, _Size __count, _OutputIter __result) { - __STL_REQUIRES(_InputIter, _InputIterator); - __STL_REQUIRES(_OutputIter, _OutputIterator); - return __copy_n(__first, __count, __result); -} - -//-------------------------------------------------- -// fill and fill_n - - -template -void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) { - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - for ( ; __first != __last; ++__first) - *__first = __value; -} - -template -_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value) { - __STL_REQUIRES(_OutputIter, _OutputIterator); - for ( ; __n > 0; --__n, ++__first) - *__first = __value; - return __first; -} - -// Specialization: for one-byte types we can use memset. - -inline void fill(unsigned char* __first, unsigned char* __last, - const unsigned char& __c) { - unsigned char __tmp = __c; - memset(__first, __tmp, __last - __first); -} - -inline void fill(signed char* __first, signed char* __last, - const signed char& __c) { - signed char __tmp = __c; - memset(__first, static_cast(__tmp), __last - __first); -} - -inline void fill(char* __first, char* __last, const char& __c) { - char __tmp = __c; - memset(__first, static_cast(__tmp), __last - __first); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline unsigned char* fill_n(unsigned char* __first, _Size __n, - const unsigned char& __c) { - fill(__first, __first + __n, __c); - return __first + __n; -} - -template -inline signed char* fill_n(char* __first, _Size __n, - const signed char& __c) { - fill(__first, __first + __n, __c); - return __first + __n; -} - -template -inline char* fill_n(char* __first, _Size __n, const char& __c) { - fill(__first, __first + __n, __c); - return __first + __n; -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -//-------------------------------------------------- -// equal and mismatch - -template -pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1, - _InputIter1 __last1, - _InputIter2 __first2) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _EqualityComparable); - __STL_REQUIRES(typename iterator_traits<_InputIter2>::value_type, - _EqualityComparable); - while (__first1 != __last1 && *__first1 == *__first2) { - ++__first1; - ++__first2; - } - return pair<_InputIter1, _InputIter2>(__first1, __first2); -} - -template -pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1, - _InputIter1 __last1, - _InputIter2 __first2, - _BinaryPredicate __binary_pred) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) { - ++__first1; - ++__first2; - } - return pair<_InputIter1, _InputIter2>(__first1, __first2); -} - -template -inline bool equal(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _EqualityComparable); - __STL_REQUIRES(typename iterator_traits<_InputIter2>::value_type, - _EqualityComparable); - for ( ; __first1 != __last1; ++__first1, ++__first2) - if (*__first1 != *__first2) - return false; - return true; -} - -template -inline bool equal(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _BinaryPredicate __binary_pred) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - for ( ; __first1 != __last1; ++__first1, ++__first2) - if (!__binary_pred(*__first1, *__first2)) - return false; - return true; -} - -//-------------------------------------------------- -// lexicographical_compare and lexicographical_compare_3way. -// (the latter is not part of the C++ standard.) - -template -bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - __STL_REQUIRES(typename iterator_traits<_InputIter2>::value_type, - _LessThanComparable); - for ( ; __first1 != __last1 && __first2 != __last2 - ; ++__first1, ++__first2) { - if (*__first1 < *__first2) - return true; - if (*__first2 < *__first1) - return false; - } - return __first1 == __last1 && __first2 != __last2; -} - -template -bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _Compare __comp) { - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - for ( ; __first1 != __last1 && __first2 != __last2 - ; ++__first1, ++__first2) { - if (__comp(*__first1, *__first2)) - return true; - if (__comp(*__first2, *__first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; -} - -inline bool -lexicographical_compare(const unsigned char* __first1, - const unsigned char* __last1, - const unsigned char* __first2, - const unsigned char* __last2) -{ - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - const int __result = memcmp(__first1, __first2, min(__len1, __len2)); - return __result != 0 ? __result < 0 : __len1 < __len2; -} - -inline bool lexicographical_compare(const char* __first1, const char* __last1, - const char* __first2, const char* __last2) -{ -#if CHAR_MAX == SCHAR_MAX - return lexicographical_compare((const signed char*) __first1, - (const signed char*) __last1, - (const signed char*) __first2, - (const signed char*) __last2); -#else /* CHAR_MAX == SCHAR_MAX */ - return lexicographical_compare((const unsigned char*) __first1, - (const unsigned char*) __last1, - (const unsigned char*) __first2, - (const unsigned char*) __last2); -#endif /* CHAR_MAX == SCHAR_MAX */ -} - -template -int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2) -{ - while (__first1 != __last1 && __first2 != __last2) { - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return 1; - ++__first1; - ++__first2; - } - if (__first2 == __last2) { - return !(__first1 == __last1); - } - else { - return -1; - } -} - -inline int -__lexicographical_compare_3way(const unsigned char* __first1, - const unsigned char* __last1, - const unsigned char* __first2, - const unsigned char* __last2) -{ - const ptrdiff_t __len1 = __last1 - __first1; - const ptrdiff_t __len2 = __last2 - __first2; - const int __result = memcmp(__first1, __first2, min(__len1, __len2)); - return __result != 0 ? __result - : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1)); -} - -inline int -__lexicographical_compare_3way(const char* __first1, const char* __last1, - const char* __first2, const char* __last2) -{ -#if CHAR_MAX == SCHAR_MAX - return __lexicographical_compare_3way( - (const signed char*) __first1, - (const signed char*) __last1, - (const signed char*) __first2, - (const signed char*) __last2); -#else - return __lexicographical_compare_3way((const unsigned char*) __first1, - (const unsigned char*) __last1, - (const unsigned char*) __first2, - (const unsigned char*) __last2); -#endif -} - -template -int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2) -{ - __STL_REQUIRES(_InputIter1, _InputIterator); - __STL_REQUIRES(_InputIter2, _InputIterator); - __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type, - _LessThanComparable); - __STL_REQUIRES(typename iterator_traits<_InputIter2>::value_type, - _LessThanComparable); - return __lexicographical_compare_3way(__first1, __last1, __first2, __last2); -} - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_ALGOBASE_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_alloc.h b/libstdc++-v3/bits/stl_alloc.h deleted file mode 100644 index ca22b90699f..00000000000 --- a/libstdc++-v3/bits/stl_alloc.h +++ /dev/null @@ -1,900 +0,0 @@ -/* - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_ALLOC_H -#define __SGI_STL_INTERNAL_ALLOC_H - -#ifdef __SUNPRO_CC -# define __PRIVATE public - // Extra access restrictions prevent us from really making some things - // private. -#else -# define __PRIVATE private -#endif - -#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG -# define __USE_MALLOC -#endif - - -// This implements some standard node allocators. These are -// NOT the same as the allocators in the C++ draft standard or in -// in the original STL. They do not encapsulate different pointer -// types; indeed we assume that there is only one pointer type. -// The allocation primitives are intended to allocate individual objects, -// not larger arenas as with the original STL allocators. - -#ifndef __THROW_BAD_ALLOC -# if defined(__STL_NO_BAD_ALLOC) || !defined(__STL_USE_EXCEPTIONS) -# include -# include -# define __THROW_BAD_ALLOC fprintf(stderr, "out of memory\n"); exit(1) -# else /* Standard conforming out-of-memory handling */ -# include -# define __THROW_BAD_ALLOC throw std::bad_alloc() -# endif -#endif - -#include -#include -#include -#include -#ifndef __RESTRICT -# define __RESTRICT -#endif - -#ifdef __STL_THREADS -# include -# define __NODE_ALLOCATOR_THREADS true -# ifdef __STL_SGI_THREADS - // We test whether threads are in use before locking. - // Perhaps this should be moved into stl_threads.h, but that - // probably makes it harder to avoid the procedure call when - // it isn't needed. - extern "C" { - extern int __us_rsthread_malloc; - } - // The above is copied from malloc.h. Including - // would be cleaner but fails with certain levels of standard - // conformance. -# define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \ - { _S_node_allocator_lock._M_acquire_lock(); } -# define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \ - { _S_node_allocator_lock._M_release_lock(); } -# else /* !__STL_SGI_THREADS */ -# define __NODE_ALLOCATOR_LOCK \ - { if (threads) _S_node_allocator_lock._M_acquire_lock(); } -# define __NODE_ALLOCATOR_UNLOCK \ - { if (threads) _S_node_allocator_lock._M_release_lock(); } -# endif -#else -// Thread-unsafe -# define __NODE_ALLOCATOR_LOCK -# define __NODE_ALLOCATOR_UNLOCK -# define __NODE_ALLOCATOR_THREADS false -#endif - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#endif - -// Malloc-based allocator. Typically slower than default alloc below. -// Typically thread-safe and more storage efficient. -#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG -# ifdef __DECLARE_GLOBALS_HERE - void (* __malloc_alloc_oom_handler)() = 0; - // g++ 2.7.2 does not handle static template data members. -# else - extern void (* __malloc_alloc_oom_handler)(); -# endif -#endif - -template -class __malloc_alloc_template { - -private: - - static void* _S_oom_malloc(size_t); - static void* _S_oom_realloc(void*, size_t); - -#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG - static void (* __malloc_alloc_oom_handler)(); -#endif - -public: - - static void* allocate(size_t __n) - { - void* __result = malloc(__n); - if (0 == __result) __result = _S_oom_malloc(__n); - return __result; - } - - static void deallocate(void* __p, size_t /* __n */) - { - free(__p); - } - - static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz) - { - void* __result = realloc(__p, __new_sz); - if (0 == __result) __result = _S_oom_realloc(__p, __new_sz); - return __result; - } - - static void (* __set_malloc_handler(void (*__f)()))() - { - void (* __old)() = __malloc_alloc_oom_handler; - __malloc_alloc_oom_handler = __f; - return(__old); - } - -}; - -// malloc_alloc out-of-memory handling - -#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG -template -void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0; -#endif - -template -void* -__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n) -{ - void (* __my_malloc_handler)(); - void* __result; - - for (;;) { - __my_malloc_handler = __malloc_alloc_oom_handler; - if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; } - (*__my_malloc_handler)(); - __result = malloc(__n); - if (__result) return(__result); - } -} - -template -void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n) -{ - void (* __my_malloc_handler)(); - void* __result; - - for (;;) { - __my_malloc_handler = __malloc_alloc_oom_handler; - if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; } - (*__my_malloc_handler)(); - __result = realloc(__p, __n); - if (__result) return(__result); - } -} - -typedef __malloc_alloc_template<0> malloc_alloc; - -template -class simple_alloc { - -public: - static _Tp* allocate(size_t __n) - { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); } - static _Tp* allocate(void) - { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); } - static void deallocate(_Tp* __p, size_t __n) - { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); } - static void deallocate(_Tp* __p) - { _Alloc::deallocate(__p, sizeof (_Tp)); } -}; - -// Allocator adaptor to check size arguments for debugging. -// Reports errors using assert. Checking can be disabled with -// NDEBUG, but it's far better to just use the underlying allocator -// instead when no checking is desired. -// There is some evidence that this can confuse Purify. -template -class debug_alloc { - -private: - - enum {_S_extra = 8}; // Size of space used to store size. Note - // that this must be large enough to preserve - // alignment. - -public: - - static void* allocate(size_t __n) - { - char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra); - *(size_t*)__result = __n; - return __result + (int) _S_extra; - } - - static void deallocate(void* __p, size_t __n) - { - char* __real_p = (char*)__p - (int) _S_extra; - assert(*(size_t*)__real_p == __n); - _Alloc::deallocate(__real_p, __n + (int) _S_extra); - } - - 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); - char* __result = (char*) - _Alloc::reallocate(__real_p, __old_sz + (int) _S_extra, - __new_sz + (int) _S_extra); - *(size_t*)__result = __new_sz; - return __result + (int) _S_extra; - } - -}; - - -# ifdef __USE_MALLOC - -typedef malloc_alloc alloc; -typedef malloc_alloc single_client_alloc; - -# else - - -// Default node allocator. -// With a reasonable compiler, this should be roughly as fast as the -// original STL class-specific allocators, but with less fragmentation. -// Default_alloc_template parameters are experimental and MAY -// DISAPPEAR in the future. Clients should just use alloc for now. -// -// Important implementation properties: -// 1. If the client request an object of size > _MAX_BYTES, the resulting -// object will be obtained directly from malloc. -// 2. In all other cases, we allocate an object of size exactly -// _S_round_up(requested_size). Thus the client has enough size -// information that we can return the object to the proper free list -// without permanently losing part of the object. -// - -// The first template parameter specifies whether more than one thread -// may use this allocator. It is safe to allocate an object from -// one instance of a default_alloc and deallocate it with another -// one. This effectively transfers its ownership to the second one. -// This may have undesirable effects on reference locality. -// The second parameter is unreferenced and serves only to allow the -// creation of multiple default_alloc instances. -// Node that containers built on different allocator instances have -// different types, limiting the utility of this approach. - -#if defined(__SUNPRO_CC) || defined(__GNUC__) -// breaks if we make these template class members: - enum {_ALIGN = 8}; - enum {_MAX_BYTES = 128}; - enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN -#endif - -template -class __default_alloc_template { - -private: - // Really we should use static const int x = N - // instead of enum { x = N }, but few compilers accept the former. -#if ! (defined(__SUNPRO_CC) || defined(__GNUC__)) - enum {_ALIGN = 8}; - enum {_MAX_BYTES = 128}; - enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN -# endif - static size_t - _S_round_up(size_t __bytes) - { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); } - -__PRIVATE: - union _Obj { - union _Obj* _M_free_list_link; - char _M_client_data[1]; /* The client sees this. */ - }; -private: -# if defined(__SUNPRO_CC) || defined(__GNUC__) || defined(__HP_aCC) - static _Obj* __STL_VOLATILE _S_free_list[]; - // Specifying a size results in duplicate def for 4.1 -# else - static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS]; -# endif - static size_t _S_freelist_index(size_t __bytes) { - return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1); - } - - // Returns an object of size __n, and optionally adds to size __n free list. - static void* _S_refill(size_t __n); - // Allocates a chunk for nobjs of size size. nobjs may be reduced - // if it is inconvenient to allocate the requested number. - static char* _S_chunk_alloc(size_t __size, int& __nobjs); - - // Chunk allocation state. - static char* _S_start_free; - static char* _S_end_free; - static size_t _S_heap_size; - -# ifdef __STL_THREADS - static _STL_mutex_lock _S_node_allocator_lock; -# endif - - // It would be nice to use _STL_auto_lock here. But we - // don't need the NULL check. And we do need a test whether - // threads have actually been started. - class _Lock; - friend class _Lock; - class _Lock { - public: - _Lock() { __NODE_ALLOCATOR_LOCK; } - ~_Lock() { __NODE_ALLOCATOR_UNLOCK; } - }; - -public: - - /* __n must be > 0 */ - static void* allocate(size_t __n) - { - void* __ret = 0; - - if (__n > (size_t) _MAX_BYTES) { - __ret = malloc_alloc::allocate(__n); - } - else { - _Obj* __STL_VOLATILE* __my_free_list - = _S_free_list + _S_freelist_index(__n); - // Acquire the lock here with a constructor call. - // This ensures that it is released in exit or during stack - // unwinding. -# ifndef _NOTHREADS - /*REFERENCED*/ - _Lock __lock_instance; -# endif - _Obj* __RESTRICT __result = *__my_free_list; - if (__result == 0) - __ret = _S_refill(_S_round_up(__n)); - else { - *__my_free_list = __result -> _M_free_list_link; - __ret = __result; - } - } - - return __ret; - }; - - /* __p may not be 0 */ - static void deallocate(void* __p, size_t __n) - { - if (__n > (size_t) _MAX_BYTES) - malloc_alloc::deallocate(__p, __n); - else { - _Obj* __STL_VOLATILE* __my_free_list - = _S_free_list + _S_freelist_index(__n); - _Obj* __q = (_Obj*)__p; - - // acquire lock -# ifndef _NOTHREADS - /*REFERENCED*/ - _Lock __lock_instance; -# endif /* _NOTHREADS */ - __q -> _M_free_list_link = *__my_free_list; - *__my_free_list = __q; - // lock is released here - } - } - - static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz); - -} ; - -typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc; -typedef __default_alloc_template single_client_alloc; - -template -inline bool operator==(const __default_alloc_template<__threads, __inst>&, - const __default_alloc_template<__threads, __inst>&) -{ - return true; -} - -# ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER -template -inline bool operator!=(const __default_alloc_template<__threads, __inst>&, - const __default_alloc_template<__threads, __inst>&) -{ - return false; -} -# endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - - - -/* We allocate memory in large chunks in order to avoid fragmenting */ -/* the malloc heap too much. */ -/* We assume that size is properly aligned. */ -/* We hold the allocation lock. */ -template -char* -__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size, - int& __nobjs) -{ - char* __result; - size_t __total_bytes = __size * __nobjs; - size_t __bytes_left = _S_end_free - _S_start_free; - - if (__bytes_left >= __total_bytes) { - __result = _S_start_free; - _S_start_free += __total_bytes; - return(__result); - } else if (__bytes_left >= __size) { - __nobjs = (int)(__bytes_left/__size); - __total_bytes = __size * __nobjs; - __result = _S_start_free; - _S_start_free += __total_bytes; - return(__result); - } else { - size_t __bytes_to_get = - 2 * __total_bytes + _S_round_up(_S_heap_size >> 4); - // Try to make use of the left-over piece. - if (__bytes_left > 0) { - _Obj* __STL_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; - } - _S_start_free = (char*)malloc(__bytes_to_get); - if (0 == _S_start_free) { - size_t __i; - _Obj* __STL_VOLATILE* __my_free_list; - _Obj* __p; - // Try to make do with what we have. That can't - // hurt. We do not try smaller requests, since that tends - // to result in disaster on multi-process machines. - for (__i = __size; - __i <= (size_t) _MAX_BYTES; - __i += (size_t) _ALIGN) { - __my_free_list = _S_free_list + _S_freelist_index(__i); - __p = *__my_free_list; - if (0 != __p) { - *__my_free_list = __p -> _M_free_list_link; - _S_start_free = (char*)__p; - _S_end_free = _S_start_free + __i; - return(_S_chunk_alloc(__size, __nobjs)); - // Any leftover piece will eventually make it to the - // right free list. - } - } - _S_end_free = 0; // In case of exception. - _S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get); - // This should either throw an - // exception or remedy the situation. Thus we assume it - // succeeded. - } - _S_heap_size += __bytes_to_get; - _S_end_free = _S_start_free + __bytes_to_get; - return(_S_chunk_alloc(__size, __nobjs)); - } -} - - -/* Returns an object of size __n, and optionally adds to size __n free list.*/ -/* We assume that __n is properly aligned. */ -/* We hold the allocation lock. */ -template -void* -__default_alloc_template<__threads, __inst>::_S_refill(size_t __n) -{ - int __nobjs = 20; - char* __chunk = _S_chunk_alloc(__n, __nobjs); - _Obj* __STL_VOLATILE* __my_free_list; - _Obj* __result; - _Obj* __current_obj; - _Obj* __next_obj; - int __i; - - if (1 == __nobjs) return(__chunk); - __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); - for (__i = 1; ; __i++) { - __current_obj = __next_obj; - __next_obj = (_Obj*)((char*)__next_obj + __n); - if (__nobjs - 1 == __i) { - __current_obj -> _M_free_list_link = 0; - break; - } else { - __current_obj -> _M_free_list_link = __next_obj; - } - } - return(__result); -} - -template -void* -__default_alloc_template::reallocate(void* __p, - size_t __old_sz, - size_t __new_sz) -{ - void* __result; - size_t __copy_sz; - - if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES) { - return(realloc(__p, __new_sz)); - } - if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p); - __result = allocate(__new_sz); - __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz; - memcpy(__result, __p, __copy_sz); - deallocate(__p, __old_sz); - return(__result); -} - -#ifdef __STL_THREADS - template - _STL_mutex_lock - __default_alloc_template<__threads, __inst>::_S_node_allocator_lock - __STL_MUTEX_INITIALIZER; -#endif - - -template -char* __default_alloc_template<__threads, __inst>::_S_start_free = 0; - -template -char* __default_alloc_template<__threads, __inst>::_S_end_free = 0; - -template -size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0; - -template -typename __default_alloc_template<__threads, __inst>::_Obj* __STL_VOLATILE -__default_alloc_template<__threads, __inst> ::_S_free_list[ -# if defined(__SUNPRO_CC) || defined(__GNUC__) || defined(__HP_aCC) - _NFREELISTS -# else - __default_alloc_template<__threads, __inst>::_NFREELISTS -# endif -] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -// The 16 zeros are necessary to make version 4.1 of the SunPro -// compiler happy. Otherwise it appears to allocate too little -// space for the array. - -#endif /* ! __USE_MALLOC */ - -// This implements allocators as specified in the C++ standard. -// -// Note that standard-conforming allocators use many language features -// that are not yet widely implemented. In particular, they rely on -// member templates, partial specialization, partial ordering of function -// templates, the typename keyword, and the use of the template keyword -// to refer to a template member of a dependent type. - -#ifdef __STL_USE_STD_ALLOCATORS - -template -class allocator { - typedef alloc _Alloc; // The underlying allocator. -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - typedef _Tp value_type; - - template struct rebind { - typedef allocator<_Tp1> other; - }; - - allocator() __STL_NOTHROW {} - allocator(const allocator&) __STL_NOTHROW {} - template allocator(const allocator<_Tp1>&) __STL_NOTHROW {} - ~allocator() __STL_NOTHROW {} - - pointer address(reference __x) const { return &__x; } - const_pointer address(const_reference __x) const { return &__x; } - - // __n is permitted to be 0. The C++ standard says nothing about what - // the return value is when __n == 0. - _Tp* allocate(size_type __n, const void* = 0) { - return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) - : 0; - } - - // __p is not permitted to be a null pointer. - void deallocate(pointer __p, size_type __n) - { _Alloc::deallocate(__p, __n * sizeof(_Tp)); } - - size_type max_size() const __STL_NOTHROW - { return size_t(-1) / sizeof(_Tp); } - - void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); } - void destroy(pointer __p) { __p->~_Tp(); } -}; - -template<> -class allocator { -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef void* pointer; - typedef const void* const_pointer; - typedef void value_type; - - template struct rebind { - typedef allocator<_Tp1> other; - }; -}; - - -template -inline bool operator==(const allocator<_T1>&, const allocator<_T2>&) -{ - return true; -} - -template -inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&) -{ - return false; -} - -// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc) -// into a standard-conforming allocator. Note that this adaptor does -// *not* assume that all objects of the underlying alloc class are -// identical, nor does it assume that all of the underlying alloc's -// member functions are static member functions. Note, also, that -// __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>. - -template -struct __allocator { - _Alloc __underlying_alloc; - - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - typedef _Tp value_type; - - template struct rebind { - typedef __allocator<_Tp1, _Alloc> other; - }; - - __allocator() __STL_NOTHROW {} - __allocator(const __allocator& __a) __STL_NOTHROW - : __underlying_alloc(__a.__underlying_alloc) {} - template - __allocator(const __allocator<_Tp1, _Alloc>& __a) __STL_NOTHROW - : __underlying_alloc(__a.__underlying_alloc) {} - ~__allocator() __STL_NOTHROW {} - - pointer address(reference __x) const { return &__x; } - const_pointer address(const_reference __x) const { return &__x; } - - // __n is permitted to be 0. - _Tp* allocate(size_type __n, const void* = 0) { - return __n != 0 - ? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp))) - : 0; - } - - // __p is not permitted to be a null pointer. - void deallocate(pointer __p, size_type __n) - { __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); } - - size_type max_size() const __STL_NOTHROW - { return size_t(-1) / sizeof(_Tp); } - - void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); } - void destroy(pointer __p) { __p->~_Tp(); } -}; - -template -class __allocator { - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef void* pointer; - typedef const void* const_pointer; - typedef void value_type; - - template struct rebind { - typedef __allocator<_Tp1, _Alloc> other; - }; -}; - -template -inline bool operator==(const __allocator<_Tp, _Alloc>& __a1, - const __allocator<_Tp, _Alloc>& __a2) -{ - return __a1.__underlying_alloc == __a2.__underlying_alloc; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER -template -inline bool operator!=(const __allocator<_Tp, _Alloc>& __a1, - const __allocator<_Tp, _Alloc>& __a2) -{ - return __a1.__underlying_alloc != __a2.__underlying_alloc; -} -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -// Comparison operators for all of the predifined SGI-style allocators. -// This ensures that __allocator (for example) will -// work correctly. - -template -inline bool operator==(const __malloc_alloc_template&, - const __malloc_alloc_template&) -{ - return true; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER -template -inline bool operator!=(const __malloc_alloc_template<__inst>&, - const __malloc_alloc_template<__inst>&) -{ - return false; -} -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -inline bool operator==(const debug_alloc<_Alloc>&, - const debug_alloc<_Alloc>&) { - return true; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER -template -inline bool operator!=(const debug_alloc<_Alloc>&, - const debug_alloc<_Alloc>&) { - return false; -} -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -// Another allocator adaptor: _Alloc_traits. This serves two -// purposes. First, make it possible to write containers that can use -// either SGI-style allocators or standard-conforming allocator. -// Second, provide a mechanism so that containers can query whether or -// not the allocator has distinct instances. If not, the container -// can avoid wasting a word of memory to store an empty object. - -// This adaptor uses partial specialization. The general case of -// _Alloc_traits<_Tp, _Alloc> assumes that _Alloc is a -// standard-conforming allocator, possibly with non-equal instances -// and non-static members. (It still behaves correctly even if _Alloc -// has static member and if all instances are equal. Refinements -// affect performance, not correctness.) - -// There are always two members: allocator_type, which is a standard- -// conforming allocator type for allocating objects of type _Tp, and -// _S_instanceless, a static const member of type bool. If -// _S_instanceless is true, this means that there is no difference -// between any two instances of type allocator_type. Furthermore, if -// _S_instanceless is true, then _Alloc_traits has one additional -// member: _Alloc_type. This type encapsulates allocation and -// deallocation of objects of type _Tp through a static interface; it -// has two member functions, whose signatures are -// static _Tp* allocate(size_t) -// static void deallocate(_Tp*, size_t) - -// The fully general version. - -template -struct _Alloc_traits -{ - static const bool _S_instanceless = false; - typedef typename _Allocator::__STL_TEMPLATE rebind<_Tp>::other - allocator_type; -}; - -template -const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless; - -// The version for the default allocator. - -template -struct _Alloc_traits<_Tp, allocator<_Tp1> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, alloc> _Alloc_type; - typedef allocator<_Tp> allocator_type; -}; - -// Versions for the predefined SGI-style allocators. - -template -struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type; - typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type; -}; - -#ifndef __USE_MALLOC -template -struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, __default_alloc_template<__threads, __inst> > - _Alloc_type; - typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> > - allocator_type; -}; -#endif - -template -struct _Alloc_traits<_Tp, debug_alloc<_Alloc> > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type; - typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type; -}; - -// Versions for the __allocator adaptor used with the predefined -// SGI-style allocators. - -template -struct _Alloc_traits<_Tp, - __allocator<_Tp1, __malloc_alloc_template<__inst> > > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type; - typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type; -}; - -#ifndef __USE_MALLOC -template -struct _Alloc_traits<_Tp, - __allocator<_Tp1, - __default_alloc_template<__thr, __inst> > > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, __default_alloc_template<__thr,__inst> > - _Alloc_type; - typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> > - allocator_type; -}; -#endif - -template -struct _Alloc_traits<_Tp, __allocator<_Tp1, debug_alloc<_Alloc> > > -{ - static const bool _S_instanceless = true; - typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type; - typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type; -}; - - -#endif /* __STL_USE_STD_ALLOCATORS */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#endif - -__STL_END_NAMESPACE - -#undef __PRIVATE - -#endif /* __SGI_STL_INTERNAL_ALLOC_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_config.h b/libstdc++-v3/bits/stl_config.h deleted file mode 100644 index 8a6e15c25de..00000000000 --- a/libstdc++-v3/bits/stl_config.h +++ /dev/null @@ -1,568 +0,0 @@ -/* - * - * 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 - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - */ - -#ifndef __STL_CONFIG_H -# define __STL_CONFIG_H - -// Flags: -// * __STL_NO_BOOL: defined if the compiler doesn't have bool as a builtin -// type. -// * __STL_HAS_WCHAR_T: defined if the compier has wchar_t as a builtin type. -// * __STL_NO_DRAND48: defined if the compiler doesn't have the drand48 -// function. -// * __STL_STATIC_TEMPLATE_MEMBER_BUG: defined if the compiler can't handle -// static members of template classes. -// * __STL_STATIC_CONST_INIT_BUG: defined if the compiler can't handle a -// constant-initializer in the declaration of a static const data member -// of integer type. (See section 9.4.2, paragraph 4, of the C++ standard.) -// * __STL_CLASS_PARTIAL_SPECIALIZATION: defined if the compiler supports -// partial specialization of template classes. -// * __STL_PARTIAL_SPECIALIZATION_SYNTAX: defined if the compiler -// supports partial specialization syntax for full specialization of -// class templates. (Even if it doesn't actually support partial -// specialization itself.) -// * __STL_FUNCTION_TMPL_PARTIAL_ORDER: defined if the compiler supports -// partial ordering of function templates. (a.k.a partial specialization -// of function templates.) -// * __STL_MEMBER_TEMPLATES: defined if the compiler supports template -// member functions of classes. -// * __STL_MEMBER_TEMPLATE_CLASSES: defined if the compiler supports -// nested classes that are member templates of other classes. -// * __STL_TEMPLATE_FRIENDS: defined if the compiler supports templatized -// friend declarations. -// * __STL_EXPLICIT_FUNCTION_TMPL_ARGS: defined if the compiler -// supports calling a function template by providing its template -// arguments explicitly. -// * __STL_LIMITED_DEFAULT_TEMPLATES: defined if the compiler is unable -// to handle default template parameters that depend on previous template -// parameters. -// * __STL_NON_TYPE_TMPL_PARAM_BUG: defined if the compiler has trouble with -// function template argument deduction for non-type template parameters. -// * __SGI_STL_NO_ARROW_OPERATOR: defined if the compiler is unable -// to support the -> operator for iterators. -// * __STL_DEFAULT_CONSTRUCTOR_BUG: defined if T() does not work properly -// when T is a builtin type. -// * __STL_USE_EXCEPTIONS: defined if the compiler (in the current compilation -// mode) supports exceptions. -// * __STL_USE_NAMESPACES: defined if the compiler has the necessary -// support for namespaces. -// * __STL_NO_EXCEPTION_HEADER: defined if the compiler does not have a -// standard-conforming header . -// * __STL_NO_BAD_ALLOC: defined if the compiler does not have a -// header, or if does not contain a bad_alloc class. If a bad_alloc -// class exists, it is assumed to be in namespace std. -// * __STL_SGI_THREADS: defined if this is being compiled for an SGI IRIX -// system in multithreaded mode, using native SGI threads instead of -// pthreads. -// * __STL_WIN32THREADS: defined if this is being compiled on a WIN32 -// compiler in multithreaded mode. -// * __STL_PTHREADS: defined if we should use portable pthreads -// synchronization. -// * __STL_UITHREADS: defined if we should use UI / solaris / UnixWare threads -// synchronization. UIthreads are similar to pthreads, but are based -// on an earlier version of the Posix threads standard. -// * __STL_LONG_LONG if the compiler has long long and unsigned long long -// types. (They're not in the C++ standard, but they are expected to be -// included in the forthcoming C9X standard.) -// * __STL_THREADS is defined if thread safety is needed. -// * __STL_VOLATILE is defined to be "volatile" if threads are being -// used, and the empty string otherwise. -// * __STL_USE_CONCEPT_CHECKS enables some extra compile-time error -// checking to make sure that user-defined template arguments satisfy -// all of the appropriate requirements. This may result in more -// comprehensible error messages. It incurs no runtime overhead. This -// feature requires member templates and partial specialization. -// * __STL_NO_USING_CLAUSE_IN_CLASS: The compiler does not handle "using" -// clauses inside of class definitions. -// * __STL_NO_FRIEND_TEMPLATE_CLASS: The compiler does not handle friend -// declaractions where the friend is a template class. -// * __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE: The compiler does not -// support the use of a function pointer type as the argument -// for a template. -// * __STL_MEMBER_TEMPLATE_KEYWORD: standard C++ requires the template -// keyword in a few new places (14.2.4). This flag is set for -// compilers that support (and require) this usage. - - -// User-settable macros that control compilation: -// * __STL_USE_SGI_ALLOCATORS: if defined, then the STL will use older -// SGI-style allocators, instead of standard-conforming allocators, -// even if the compiler supports all of the language features needed -// for standard-conforming allocators. -// * __STL_NO_NAMESPACES: if defined, don't put the library in namespace -// std, even if the compiler supports namespaces. -// * __STL_NO_RELOPS_NAMESPACE: if defined, don't put the relational -// operator templates (>, <=. >=, !=) in namespace std::rel_ops, even -// if the compiler supports namespaces and partial ordering of -// function templates. -// * __STL_ASSERTIONS: if defined, then enable runtime checking through the -// __stl_assert macro. -// * _PTHREADS: if defined, use Posix threads for multithreading support. -// * _UITHREADS:if defined, use SCO/Solaris/UI threads for multithreading -// support -// * _NOTHREADS: if defined, don't use any multithreading support. -// * _STL_NO_CONCEPT_CHECKS: if defined, disables the error checking that -// we get from __STL_USE_CONCEPT_CHECKS. -// * __STL_USE_NEW_IOSTREAMS: if defined, then the STL will use new, -// standard-conforming iostreams (e.g. the header). If not -// defined, the STL will use old cfront-style iostreams (e.g. the -// header). - -// Other macros defined by this file: - -// * bool, true, and false, if __STL_NO_BOOL is defined. -// * typename, as a null macro if it's not already a keyword. -// * explicit, as a null macro if it's not already a keyword. -// * namespace-related macros (__STD, __STL_BEGIN_NAMESPACE, etc.) -// * exception-related macros (__STL_TRY, __STL_UNWIND, etc.) -// * __stl_assert, either as a test or as a null macro, depending on -// whether or not __STL_ASSERTIONS is defined. - -# if defined(_PTHREADS) && !defined(_NOTHREADS) -# define __STL_PTHREADS -# endif - -# if defined(_UITHREADS) && !defined(_PTHREADS) && !defined(_NOTHREADS) -# define __STL_UITHREADS -# endif - -# if defined(__sgi) && !defined(__GNUC__) -# include -# if !defined(_BOOL) -# define __STL_NO_BOOL -# endif -# if defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32 -# define __STL_STATIC_CONST_INIT_BUG -# endif -# if defined(_WCHAR_T_IS_KEYWORD) -# define __STL_HAS_WCHAR_T -# endif -# if !defined(_TYPENAME_IS_KEYWORD) -# define __STL_NEED_TYPENAME -# endif -# ifdef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# endif -# if (_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32 -# define __STL_FUNCTION_TMPL_PARTIAL_ORDER -# endif -# ifdef _MEMBER_TEMPLATES -# define __STL_MEMBER_TEMPLATES -# define __STL_TEMPLATE_FRIENDS -# define __STL_MEMBER_TEMPLATE_CLASSES -# endif -# if defined(_MEMBER_TEMPLATE_KEYWORD) -# define __STL_MEMBER_TEMPLATE_KEYWORD -# endif -# if defined(_STANDARD_C_PLUS_PLUS) -# define __STL_EXPLICIT_FUNCTION_TMPL_ARGS -# endif -# if (_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32 -# define __STL_MEMBER_TEMPLATE_KEYWORD -# endif -# if COMPILER_VERSION < 720 || (defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32) -# define __STL_DEFAULT_CONSTRUCTOR_BUG -# endif -# if !defined(_EXPLICIT_IS_KEYWORD) -# define __STL_NEED_EXPLICIT -# endif -# ifdef __EXCEPTIONS -# define __STL_USE_EXCEPTIONS -# endif -# if (_COMPILER_VERSION >= 721) && defined(_NAMESPACES) -# define __STL_HAS_NAMESPACES -# endif -# if (_COMPILER_VERSION < 721) || \ - !defined(__STL_HAS_NAMESPACES) || defined(__STL_NO_NAMESPACES) -# define __STL_NO_EXCEPTION_HEADER -# endif -# if _COMPILER_VERSION < 730 || !defined(_STANDARD_C_PLUS_PLUS) || \ - !defined(_NAMESPACES) -# define __STL_NO_BAD_ALLOC -# endif -# if !defined(_NOTHREADS) && !defined(__STL_PTHREADS) -# define __STL_SGI_THREADS -# endif -# if defined(_LONGLONG) && defined(_SGIAPI) && _SGIAPI -# define __STL_LONG_LONG -# endif -# if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS) -# define __STL_USE_NEW_IOSTREAMS -# endif -# if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS) -# define __STL_CAN_THROW_RANGE_ERRORS -# endif -# if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS) -# define __SGI_STL_USE_AUTO_PTR_CONVERSIONS -# endif -# endif - - -/* - * Jochen Schlick '1999 - added new #defines (__STL)_UITHREADS (for - * providing SCO / Solaris / UI thread support) - * - added the necessary defines for the SCO UDK 7 - * compiler (and its template friend behavior) - * - all UDK7 specific STL changes are based on the - * macro __USLC__ being defined - */ -// SCO UDK 7 compiler (UnixWare 7x, OSR 5, UnixWare 2x) -# if defined(__USLC__) -# define __STL_HAS_WCHAR_T -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# define __STL_PARTIAL_SPECIALIZATION_SYNTAX -# define __STL_FUNCTION_TMPL_PARTIAL_ORDER -# define __STL_MEMBER_TEMPLATES -# define __STL_MEMBER_TEMPLATE_CLASSES -# define __STL_USE_EXCEPTIONS -# define __STL_HAS_NAMESPACES -# define __STL_USE_NAMESPACES -# define __STL_LONG_LONG -# if defined(_REENTRANT) -# define _UITHREADS /* if UnixWare < 7.0.1 */ -# define __STL_UITHREADS -// use the following defines instead of the UI threads defines when -// you want to use POSIX threads -//# define _PTHREADS /* only if UnixWare >=7.0.1 */ -//# define __STL_PTHREADS -# endif -# endif - - - -# ifdef __GNUC__ -# define __STL_HAS_WCHAR_T -# define __STL_MEMBER_TEMPLATES -# define __STL_MEMBER_TEMPLATE_CLASSES -# define __STL_TEMPLATE_FRIENDS -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# define __STL_PARTIAL_SPECIALIZATION_SYNTAX -# define __STL_FUNCTION_TMPL_PARTIAL_ORDER -# define __STL_EXPLICIT_FUNCTION_TMPL_ARGS -# define __SGI_STL_USE_AUTO_PTR_CONVERSIONS -# define __STL_HAS_NAMESPACES -# define __STL_USE_NAMESPACES -# define __STL_USE_EXCEPTIONS -# define __STL_THROW_RANGE_ERRORS -# define __STL_CAN_THROW_RANGE_ERRORS -# define __STL_USE_STD_ALLOCATORS -# define __USE_MALLOC // As the "underlying allocator" -//# define __STL_USE_NEW_IOSTREAMS //990209 bkoz--use standard .h includes. -# ifdef _REENTRANT -# define __STL_THREADS -# endif -# ifdef _PTHREADS -# define __STL_PTHREADS -# endif -# ifndef __STRICT_ANSI__ -# define __STL_LONG_LONG -# endif -# if (__GNUC__ < 2) || (__GNUC__ == 2 && __GNUC_MINOR__ < 95) -# define __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE -# endif -# endif - -# if defined(__SUNPRO_CC) -# define __STL_NO_BOOL -# define __STL_NEED_TYPENAME -# define __STL_NEED_EXPLICIT -# define __STL_USE_EXCEPTIONS -# ifdef _REENTRANT -# define __STL_PTHREADS -# endif -# define __SGI_STL_NO_ARROW_OPERATOR -# define __STL_PARTIAL_SPECIALIZATION_SYNTAX -# define __STL_NO_EXCEPTION_HEADER -# define __STL_NO_BAD_ALLOC -# endif - -# if defined(__COMO__) -# define __STL_MEMBER_TEMPLATES -# define __STL_MEMBER_TEMPLATE_CLASSES -# define __STL_TEMPLATE_FRIENDS -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# define __STL_USE_EXCEPTIONS -# define __STL_HAS_NAMESPACES -# endif - -// Intel compiler, which uses the EDG front end. -# if defined(__ICL) -# define __STL_LONG_LONG -# define __STL_MEMBER_TEMPLATES -# define __STL_MEMBER_TEMPLATE_CLASSES -# define __STL_TEMPLATE_FRIENDS -# define __STL_FUNCTION_TMPL_PARTIAL_ORDER -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# define __STL_NO_DRAND48 -# define __STL_HAS_NAMESPACES -# define __STL_USE_EXCEPTIONS -# define __STL_MEMBER_TEMPLATE_KEYWORD -# ifdef _CPPUNWIND -# define __STL_USE_EXCEPTIONS -# endif -# ifdef _MT -# define __STL_WIN32THREADS -# endif -# endif - -// Mingw32, egcs compiler using the Microsoft C runtime -# if defined(__MINGW32__) -# define __STL_NO_DRAND48 -# ifdef _MT -# define __STL_WIN32THREADS -# endif -# endif - -// Cygwin32, egcs compiler on MS Windows -# if defined(__CYGWIN__) -# define __STL_NO_DRAND48 -# endif - - - -// Microsoft compiler. -# if defined(_MSC_VER) && !defined(__ICL) && !defined(__MWERKS__) -# define __STL_NO_DRAND48 -# define __STL_STATIC_CONST_INIT_BUG -# define __STL_NEED_TYPENAME -# define __STL_NO_USING_CLAUSE_IN_CLASS -# define __STL_NO_FRIEND_TEMPLATE_CLASS -# if _MSC_VER < 1100 /* 1000 is version 4.0, 1100 is 5.0, 1200 is 6.0. */ -# define __STL_NEED_EXPLICIT -# define __STL_NO_BOOL -# define __STL_NO_BAD_ALLOC -# endif -# if _MSC_VER > 1000 -# include -# define __STL_DONT_USE_BOOL_TYPEDEF -# endif -# define __STL_NON_TYPE_TMPL_PARAM_BUG -# define __SGI_STL_NO_ARROW_OPERATOR -# define __STL_DEFAULT_CONSTRUCTOR_BUG -# ifdef _CPPUNWIND -# define __STL_USE_EXCEPTIONS -# endif -# ifdef _MT -# define __STL_WIN32THREADS -# endif -# if _MSC_VER >= 1200 -# define __STL_PARTIAL_SPECIALIZATION_SYNTAX -# define __STL_HAS_NAMESPACES -# define __STL_CAN_THROW_RANGE_ERRORS -# define NOMINMAX -# undef min -# undef max -// disable warning 'initializers put in unrecognized initialization area' -# pragma warning ( disable : 4075 ) -// disable warning 'empty controlled statement found' -# pragma warning ( disable : 4390 ) -// disable warning 'debug symbol greater than 255 chars' -# pragma warning ( disable : 4786 ) -# endif -# if _MSC_VER < 1100 -# define __STL_NO_EXCEPTION_HEADER -# define __STL_NO_BAD_ALLOC -# endif - // Because of a Microsoft front end bug, we must not provide a - // namespace qualifier when declaring a friend function. -# define __STD_QUALIFIER -# endif - -# if defined(__BORLANDC__) -# define __STL_NO_BAD_ALLOC -# define __STL_NO_DRAND48 -# define __STL_DEFAULT_CONSTRUCTOR_BUG -# if __BORLANDC__ >= 0x540 /* C++ Builder 4.0 */ -# define __STL_CLASS_PARTIAL_SPECIALIZATION -# define __STL_FUNCTION_TMPL_PARTIAL_ORDER -# define __STL_EXPLICIT_FUNCTION_TMPL_ARGS -# define __STL_MEMBER_TEMPLATES -# define __STL_TEMPLATE_FRIENDS -# else -# define __STL_NEED_TYPENAME -# define __STL_LIMITED_DEFAULT_TEMPLATES -# define __SGI_STL_NO_ARROW_OPERATOR -# define __STL_NON_TYPE_TMPL_PARAM_BUG -# endif -# ifdef _CPPUNWIND -# define __STL_USE_EXCEPTIONS -# endif -# ifdef __MT__ -# define __STL_WIN32THREADS -# endif -# endif - -# if defined(__STL_NO_BOOL) && !defined(__STL_DONT_USE_BOOL_TYPEDEF) - typedef int bool; -# define true 1 -# define false 0 -# endif - -# ifdef __STL_NEED_TYPENAME -# define typename -# endif - -# ifdef __STL_LIMITED_DEFAULT_TEMPLATES -# define __STL_DEPENDENT_DEFAULT_TMPL(_Tp) -# else -# define __STL_DEPENDENT_DEFAULT_TMPL(_Tp) = _Tp -# endif - -# ifdef __STL_MEMBER_TEMPLATE_KEYWORD -# define __STL_TEMPLATE template -# else -# define __STL_TEMPLATE -# endif - -# ifdef __STL_NEED_EXPLICIT -# define explicit -# endif - -# ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS -# define __STL_NULL_TMPL_ARGS <> -# else -# define __STL_NULL_TMPL_ARGS -# endif - -# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) \ - || defined (__STL_PARTIAL_SPECIALIZATION_SYNTAX) -# define __STL_TEMPLATE_NULL template<> -# else -# define __STL_TEMPLATE_NULL -# endif - -// Use standard-conforming allocators if we have the necessary language -// features. __STL_USE_SGI_ALLOCATORS is a hook so that users can -// disable new-style allocators, and continue to use the same kind of -// allocators as before, without having to edit library headers. -# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && \ - defined(__STL_MEMBER_TEMPLATES) && \ - defined(__STL_MEMBER_TEMPLATE_CLASSES) && \ - !defined(__STL_NO_BOOL) && \ - !defined(__STL_NON_TYPE_TMPL_PARAM_BUG) && \ - !defined(__STL_LIMITED_DEFAULT_TEMPLATES) && \ - !defined(__STL_USE_SGI_ALLOCATORS) -# define __STL_USE_STD_ALLOCATORS -# endif - -# ifndef __STL_DEFAULT_ALLOCATOR -# ifdef __STL_USE_STD_ALLOCATORS -# define __STL_DEFAULT_ALLOCATOR(T) allocator< T > -# else -# define __STL_DEFAULT_ALLOCATOR(T) alloc -# endif -# endif - -// __STL_NO_NAMESPACES is a hook so that users can disable namespaces -// without having to edit library headers. __STL_NO_RELOPS_NAMESPACE is -// a hook so that users can disable the std::rel_ops namespace, keeping -// the relational operator template in namespace std, without having to -// edit library headers. -# if defined(__STL_HAS_NAMESPACES) && !defined(__STL_NO_NAMESPACES) -# define __STL_USE_NAMESPACES -# define __STD std -# define __STL_BEGIN_NAMESPACE namespace std { -# define __STL_END_NAMESPACE } -# if defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) && \ - !defined(__STL_NO_RELOPS_NAMESPACE) -# define __STL_USE_NAMESPACE_FOR_RELOPS -# define __STL_BEGIN_RELOPS_NAMESPACE namespace std { namespace rel_ops { -# define __STL_END_RELOPS_NAMESPACE } } -# define __STD_RELOPS std::rel_ops -# else /* Use std::rel_ops namespace */ -# define __STL_USE_NAMESPACE_FOR_RELOPS -# define __STL_BEGIN_RELOPS_NAMESPACE namespace std { -# define __STL_END_RELOPS_NAMESPACE } -# define __STD_RELOPS std -# endif /* Use std::rel_ops namespace */ -# else -# define __STD -# define __STL_BEGIN_NAMESPACE -# define __STL_END_NAMESPACE -# undef __STL_USE_NAMESPACE_FOR_RELOPS -# define __STL_BEGIN_RELOPS_NAMESPACE -# define __STL_END_RELOPS_NAMESPACE -# define __STD_RELOPS -# undef __STL_USE_NAMESPACES -# endif - -// Some versions of the EDG front end sometimes require an explicit -// namespace spec where they shouldn't. This macro facilitates that. -// If the bug becomes irrelevant, then all uses of __STD_QUALIFIER -// should be removed. The 7.3 beta SGI compiler has this bug, but the -// MR version is not expected to have it. - -# if defined(__STL_USE_NAMESPACES) && !defined(__STD_QUALIFIER) -# define __STD_QUALIFIER std:: -# else -# define __STD_QUALIFIER -# endif - -# ifdef __STL_USE_EXCEPTIONS -# define __STL_TRY try -# define __STL_CATCH_ALL catch(...) -# define __STL_THROW(x) throw x -# define __STL_RETHROW throw -# define __STL_NOTHROW throw() -# define __STL_UNWIND(action) catch(...) { action; throw; } -# else -# define __STL_TRY -# define __STL_CATCH_ALL if (false) -# define __STL_THROW(x) -# define __STL_RETHROW -# define __STL_NOTHROW -# define __STL_UNWIND(action) -# endif - -#ifdef __STL_ASSERTIONS -# include -# define __stl_assert(expr) \ - if (!(expr)) { fprintf(stderr, "%s:%d STL assertion failure: %s\n", \ - __FILE__, __LINE__, # expr); abort(); } -#else -# define __stl_assert(expr) -#endif - -#if defined(__STL_WIN32THREADS) || defined(__STL_SGI_THREADS) \ - || defined(__STL_PTHREADS) || defined(__STL_UITHREADS) -# define __STL_THREADS -# define __STL_VOLATILE volatile -#else -# define __STL_VOLATILE -#endif - -#if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) \ - && defined(__STL_MEMBER_TEMPLATES) \ - && !defined(_STL_NO_CONCEPT_CHECKS) -# define __STL_USE_CONCEPT_CHECKS -#endif - - -#endif /* __STL_CONFIG_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_construct.h b/libstdc++-v3/bits/stl_construct.h deleted file mode 100644 index 7841f8dc75e..00000000000 --- a/libstdc++-v3/bits/stl_construct.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_CONSTRUCT_H -#define _CPP_BITS_STL_CONSTRUCT_H 1 - -#include - -__STL_BEGIN_NAMESPACE - -// construct and destroy. These functions are not part of the C++ standard, -// and are provided for backward compatibility with the HP STL. We also -// provide internal names _Construct and _Destroy that can be used within -// the library, so that standard-conforming pieces don't have to rely on -// non-standard extensions. - -// Internal names - -template -inline void _Construct(_T1* __p, const _T2& __value) { -new ((void*) __p) _T1(__value); -} - -template -inline void _Construct(_T1* __p) { - new ((void*) __p) _T1(); -} - -template -inline void _Destroy(_Tp* __pointer) { - __pointer->~_Tp(); -} - -template -void -__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type) -{ - for ( ; __first != __last; ++__first) - destroy(&*__first); -} - -template -inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {} - -template -inline void -__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*) -{ - typedef typename __type_traits<_Tp>::has_trivial_destructor - _Trivial_destructor; - __destroy_aux(__first, __last, _Trivial_destructor()); -} - -template -inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) { - __destroy(__first, __last, __VALUE_TYPE(__first)); -} - -inline void _Destroy(char*, char*) {} -inline void _Destroy(int*, int*) {} -inline void _Destroy(long*, long*) {} -inline void _Destroy(float*, float*) {} -inline void _Destroy(double*, double*) {} -#ifdef __STL_HAS_WCHAR_T -inline void _Destroy(wchar_t*, wchar_t*) {} -#endif /* __STL_HAS_WCHAR_T */ - -// -------------------------------------------------- -// Old names from the HP STL. - -template -inline void construct(_T1* __p, const _T2& __value) { - _Construct(__p, __value); -} - -template -inline void construct(_T1* __p) { - _Construct(__p); -} - -template -inline void destroy(_Tp* __pointer) { - _Destroy(__pointer); -} - -template -inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { - _Destroy(__first, __last); -} - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_CONSTRUCT_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_deque.h b/libstdc++-v3/bits/stl_deque.h deleted file mode 100644 index 0ad596eb3b9..00000000000 --- a/libstdc++-v3/bits/stl_deque.h +++ /dev/null @@ -1,1652 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#include - -#ifndef __SGI_STL_INTERNAL_DEQUE_H -#define __SGI_STL_INTERNAL_DEQUE_H - -/* Class invariants: - * For any nonsingular iterator i: - * i.node is the address of an element in the map array. The - * contents of i.node is a pointer to the beginning of a node. - * i.first == *(i.node) - * 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, and that a deque - * with N elements, where N is the buffer size, must have two nodes. - * 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]. - */ - - -/* - * In previous versions of deque, there was an extra template - * parameter so users could control the node size. This extension - * turns out to violate the C++ standard (it can be detected using - * template template parameters), and it has been removed. - */ - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -// Note: this function is simply a kludge to work around several compilers' -// bugs in handling constant expressions. -inline size_t __deque_buf_size(size_t __size) { - return __size < 512 ? size_t(512 / __size) : size_t(1); -} - -template -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; } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return _M_cur; } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - - difference_type operator-(const _Self& __x) const { - return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) + - (_M_cur - _M_first) + (__x._M_last - __x._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); } - - bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; } - bool operator!=(const _Self& __x) const { return !(*this == __x); } - bool operator<(const _Self& __x) const { - return (_M_node == __x._M_node) ? - (_M_cur < __x._M_cur) : (_M_node < __x._M_node); - } - bool operator>(const _Self& __x) const { return __x < *this; } - bool operator<=(const _Self& __x) const { return !(__x < *this); } - bool operator>=(const _Self& __x) const { return !(*this < __x); } - - 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 -inline _Deque_iterator<_Tp, _Ref, _Ptr> -operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x) -{ - return __x + __n; -} - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline random_access_iterator_tag -iterator_category(const _Deque_iterator<_Tp,_Ref,_Ptr>&) -{ - return random_access_iterator_tag(); -} - -template -inline _Tp* value_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) { return 0; } - -template -inline ptrdiff_t* distance_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) { - return 0; -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// 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. - -#ifdef __STL_USE_STD_ALLOCATORS - -// Base class for ordinary allocators. -template -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))); - } - void _M_deallocate_node(_Tp* __p) { - _M_node_allocator.deallocate(__p, __deque_buf_size(sizeof(_Tp))); - } - _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; -}; - -// Specialization for instanceless allocators. -template -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))); - } - void _M_deallocate_node(_Tp* __p) { - _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); - } - _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; -}; - -template -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; -}; - -#else /* __STL_USE_STD_ALLOCATORS */ - -template -class _Deque_base { -public: - typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator; - typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; - - typedef _Alloc allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Deque_base(const allocator_type&, size_t __num_elements) - : _M_map(0), _M_map_size(0), _M_start(), _M_finish() { - _M_initialize_map(__num_elements); - } - _Deque_base(const allocator_type&) - : _M_map(0), _M_map_size(0), _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: - _Tp** _M_map; - size_t _M_map_size; - iterator _M_start; - iterator _M_finish; - - typedef simple_alloc<_Tp, _Alloc> _Node_alloc_type; - typedef simple_alloc<_Tp*, _Alloc> _Map_alloc_type; - - _Tp* _M_allocate_node() - { return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); } - void _M_deallocate_node(_Tp* __p) - { _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); } - _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); } -}; - -#endif /* __STL_USE_STD_ALLOCATORS */ - -// Non-inline member functions from _Deque_base. - -template -_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); - } -} - -template -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; - - __STL_TRY { - _M_create_nodes(__nstart, __nfinish); - } - __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size), - _M_map = 0, _M_map_size = 0)); - _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 -void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish) -{ - _Tp** __cur; - __STL_TRY { - for (__cur = __nstart; __cur < __nfinish; ++__cur) - *__cur = _M_allocate_node(); - } - __STL_UNWIND(_M_destroy_nodes(__nstart, __cur)); -} - -template -void -_Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) -{ - for (_Tp** __n = __nstart; __n < __nfinish; ++__n) - _M_deallocate_node(*__n); -} - -template -class deque : protected _Deque_base<_Tp, _Alloc> { - - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - - typedef _Deque_base<_Tp, _Alloc> _Base; -public: // Basic types - 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(); } - -public: // Iterators - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - typedef reverse_iterator - const_reverse_iterator; - typedef reverse_iterator - reverse_iterator; -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -protected: // Internal typedefs - typedef pointer* _Map_pointer; - static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } - -protected: -#ifdef __STL_USE_NAMESPACES - 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; - - using _Base::_M_map; - using _Base::_M_map_size; - using _Base::_M_start; - using _Base::_M_finish; -#endif /* __STL_USE_NAMESPACES */ - -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)]; } - -#ifdef __STL_THROW_RANGE_ERRORS - void _M_range_check(size_type __n) const { - if (__n >= this->size()) - __stl_throw_range_error("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]; } -#endif /* __STL_THROW_RANGE_ERRORS */ - - 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()); } - -#ifdef __STL_MEMBER_TEMPLATES - - // Check whether it's an integral type. If so, it's not an iterator. - template - deque(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) : _Base(__a) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_initialize_dispatch(__first, __last, _Integral()); - } - - template - void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) { - _M_initialize_map(__n); - _M_fill_initialize(__x); - } - - template - void _M_initialize_dispatch(_InputIter __first, _InputIter __last, - __false_type) { - _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first)); - } - -#else /* __STL_MEMBER_TEMPLATES */ - - deque(const value_type* __first, const value_type* __last, - const allocator_type& __a = allocator_type()) - : _Base(__a, __last - __first) - { uninitialized_copy(__first, __last, _M_start); } - deque(const_iterator __first, const_iterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a, __last - __first) - { uninitialized_copy(__first, __last, _M_start); } - -#endif /* __STL_MEMBER_TEMPLATES */ - - ~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); - } - } - - void assign(size_type __n, const _Tp& __val) { - _M_fill_assign(__n, __val); - } - -#ifdef __STL_MEMBER_TEMPLATES - - template - void assign(_InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); - } - -private: // helper functions for assign() - - template - void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign((size_type) __n, (_Tp) __val); } - - template - void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type) { - _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); - } - - template - void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template - void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) { - size_type __len = 0; - distance(__first, __last, __len); - if (__len > size()) { - _ForwardIterator __mid = __first; - advance(__mid, size()); - copy(__first, __mid, begin()); - insert(end(), __mid, __last); - } - else - erase(copy(__first, __last, begin()), end()); - } - -#endif /* __STL_MEMBER_TEMPLATES */ - -public: // push_* and pop_* - - 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() { - 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) { - if (_M_start._M_cur != _M_start._M_first) { - construct(_M_start._M_cur - 1, __t); - --_M_start._M_cur; - } - else - _M_push_front_aux(__t); - } - - void push_front() { - if (_M_start._M_cur != _M_start._M_first) { - construct(_M_start._M_cur - 1); - --_M_start._M_cur; - } - else - _M_push_front_aux(); - } - - - 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(); - } - - void pop_front() { - if (_M_start._M_cur != _M_start._M_last - 1) { - destroy(_M_start._M_cur); - ++_M_start._M_cur; - } - else - _M_pop_front_aux(); - } - -public: // Insert - - iterator 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); - } - } - - 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); - -#ifdef __STL_MEMBER_TEMPLATES - - // Check whether it's an integral type. If so, it's not an iterator. - template - void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); - } - - template - void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, - __true_type) { - _M_fill_insert(__pos, (size_type) __n, (value_type) __x); - } - - template - void _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type) { - insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first)); - } - -#else /* __STL_MEMBER_TEMPLATES */ - - void insert(iterator __pos, - const value_type* __first, const value_type* __last); - void insert(iterator __pos, - const_iterator __first, const_iterator __last); - -#endif /* __STL_MEMBER_TEMPLATES */ - - 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); - -#ifdef __STL_MEMBER_TEMPLATES - - template - void _M_range_initialize(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template - void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - -#endif /* __STL_MEMBER_TEMPLATES */ - -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 - -#ifdef __STL_MEMBER_TEMPLATES - - template - void insert(iterator __pos, _InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template - void insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - -#endif /* __STL_MEMBER_TEMPLATES */ - - 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); - -#ifdef __STL_MEMBER_TEMPLATES - - template - void _M_insert_aux(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - size_type __n); - -#else /* __STL_MEMBER_TEMPLATES */ - - void _M_insert_aux(iterator __pos, - const value_type* __first, const value_type* __last, - size_type __n); - - void _M_insert_aux(iterator __pos, - const_iterator __first, const_iterator __last, - size_type __n); - -#endif /* __STL_MEMBER_TEMPLATES */ - - 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 - -#ifdef __STL_MEMBER_TEMPLATES - -template -template -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); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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); - __STL_TRY { - uninitialized_fill(__new_start, _M_start, __x); - _M_start = __new_start; - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - __STL_TRY { - uninitialized_fill(_M_finish, __new_finish, __x); - _M_finish = __new_finish; - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } - else - _M_insert_aux(__pos, __n, __x); -} - -#ifndef __STL_MEMBER_TEMPLATES - -template -void deque<_Tp, _Alloc>::insert(iterator __pos, - const value_type* __first, - const value_type* __last) { - size_type __n = __last - __first; - if (__pos._M_cur == _M_start._M_cur) { - iterator __new_start = _M_reserve_elements_at_front(__n); - __STL_TRY { - uninitialized_copy(__first, __last, __new_start); - _M_start = __new_start; - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - __STL_TRY { - uninitialized_copy(__first, __last, _M_finish); - _M_finish = __new_finish; - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } - else - _M_insert_aux(__pos, __first, __last, __n); -} - -template -void deque<_Tp,_Alloc>::insert(iterator __pos, - const_iterator __first, const_iterator __last) -{ - size_type __n = __last - __first; - if (__pos._M_cur == _M_start._M_cur) { - iterator __new_start = _M_reserve_elements_at_front(__n); - __STL_TRY { - uninitialized_copy(__first, __last, __new_start); - _M_start = __new_start; - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - __STL_TRY { - uninitialized_copy(__first, __last, _M_finish); - _M_finish = __new_finish; - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } - else - _M_insert_aux(__pos, __first, __last, __n); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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(__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(__new_start._M_node, _M_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 -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; -} - -// Precondition: _M_start and _M_finish have already been initialized, -// but none of the deque's elements have yet been constructed. -template -void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __value) { - _Map_pointer __cur; - __STL_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); - } - __STL_UNWIND(destroy(_M_start, iterator(*__cur, __cur))); -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -void deque<_Tp,_Alloc>::_M_range_initialize(_InputIterator __first, - _InputIterator __last, - input_iterator_tag) -{ - _M_initialize_map(0); - __STL_TRY { - for ( ; __first != __last; ++__first) - push_back(*__first); - } - __STL_UNWIND(clear()); -} - -template template -void deque<_Tp,_Alloc>::_M_range_initialize(_ForwardIterator __first, - _ForwardIterator __last, - forward_iterator_tag) -{ - size_type __n = 0; - distance(__first, __last, __n); - _M_initialize_map(__n); - - _Map_pointer __cur_node; - __STL_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); - } - __STL_UNWIND(destroy(_M_start, iterator(*__cur_node, __cur_node))); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -// Called only if _M_finish._M_cur == _M_finish._M_last - 1. -template -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(); - __STL_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; - } - __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1))); -} - -// Called only if _M_finish._M_cur == _M_finish._M_last - 1. -template -void deque<_Tp,_Alloc>::_M_push_back_aux() -{ - _M_reserve_map_at_back(); - *(_M_finish._M_node + 1) = _M_allocate_node(); - __STL_TRY { - construct(_M_finish._M_cur); - _M_finish._M_set_node(_M_finish._M_node + 1); - _M_finish._M_cur = _M_finish._M_first; - } - __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1))); -} - -// Called only if _M_start._M_cur == _M_start._M_first. -template -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(); - __STL_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); - } - __STL_UNWIND((++_M_start, _M_deallocate_node(*(_M_start._M_node - 1)))); -} - -// Called only if _M_start._M_cur == _M_start._M_first. -template -void deque<_Tp,_Alloc>::_M_push_front_aux() -{ - _M_reserve_map_at_front(); - *(_M_start._M_node - 1) = _M_allocate_node(); - __STL_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); - } - __STL_UNWIND((++_M_start, _M_deallocate_node(*(_M_start._M_node - 1)))); -} - -// Called only if _M_finish._M_cur == _M_finish._M_first. -template -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 -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; -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -void deque<_Tp,_Alloc>::insert(iterator __pos, - _InputIterator __first, _InputIterator __last, - input_iterator_tag) -{ - copy(__first, __last, inserter(*this, __pos)); -} - -template template -void -deque<_Tp,_Alloc>::insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) { - size_type __n = 0; - distance(__first, __last, __n); - if (__pos._M_cur == _M_start._M_cur) { - iterator __new_start = _M_reserve_elements_at_front(__n); - __STL_TRY { - uninitialized_copy(__first, __last, __new_start); - _M_start = __new_start; - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - else if (__pos._M_cur == _M_finish._M_cur) { - iterator __new_finish = _M_reserve_elements_at_back(__n); - __STL_TRY { - uninitialized_copy(__first, __last, _M_finish); - _M_finish = __new_finish; - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } - else - _M_insert_aux(__pos, __first, __last, __n); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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(__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 -typename deque<_Tp,_Alloc>::iterator -deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos) -{ - difference_type __index = __pos - _M_start; - if (static_cast(__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 -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; - __STL_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); - } - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - 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; - __STL_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); - } - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -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(__elemsbefore) < __length / 2) { - iterator __new_start = _M_reserve_elements_at_front(__n); - iterator __old_start = _M_start; - __pos = _M_start + __elemsbefore; - __STL_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); - } - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - 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; - __STL_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); - } - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } -} - -#else /* __STL_MEMBER_TEMPLATES */ - -template -void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, - const value_type* __first, - const value_type* __last, - size_type __n) -{ - const difference_type __elemsbefore = __pos - _M_start; - size_type __length = size(); - if (__elemsbefore < __length / 2) { - iterator __new_start = _M_reserve_elements_at_front(__n); - iterator __old_start = _M_start; - __pos = _M_start + __elemsbefore; - __STL_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 { - const value_type* __mid = - __first + (difference_type(__n) - __elemsbefore); - __uninitialized_copy_copy(_M_start, __pos, __first, __mid, - __new_start); - _M_start = __new_start; - copy(__mid, __last, __old_start); - } - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - 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; - __STL_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 { - const value_type* __mid = __first + __elemsafter; - __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish); - _M_finish = __new_finish; - copy(__first, __mid, __pos); - } - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } -} - -template -void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, - const_iterator __first, - const_iterator __last, - size_type __n) -{ - const difference_type __elemsbefore = __pos - _M_start; - size_type __length = size(); - if (__elemsbefore < __length / 2) { - iterator __new_start = _M_reserve_elements_at_front(__n); - iterator __old_start = _M_start; - __pos = _M_start + __elemsbefore; - __STL_TRY { - if (__elemsbefore >= __n) { - iterator __start_n = _M_start + __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 { - const_iterator __mid = __first + (__n - __elemsbefore); - __uninitialized_copy_copy(_M_start, __pos, __first, __mid, - __new_start); - _M_start = __new_start; - copy(__mid, __last, __old_start); - } - } - __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node)); - } - else { - iterator __new_finish = _M_reserve_elements_at_back(__n); - iterator __old_finish = _M_finish; - const difference_type __elemsafter = __length - __elemsbefore; - __pos = _M_finish - __elemsafter; - __STL_TRY { - if (__elemsafter > __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 { - const_iterator __mid = __first + __elemsafter; - __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish); - _M_finish = __new_finish; - copy(__first, __mid, __pos); - } - } - __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1, - __new_finish._M_node + 1)); - } -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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; - __STL_TRY { - for (__i = 1; __i <= __new_nodes; ++__i) - *(_M_start._M_node - __i) = _M_allocate_node(); - } -# ifdef __STL_USE_EXCEPTIONS - catch(...) { - for (size_type __j = 1; __j < __i; ++__j) - _M_deallocate_node(*(_M_start._M_node - __j)); - throw; - } -# endif /* __STL_USE_EXCEPTIONS */ -} - -template -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; - __STL_TRY { - for (__i = 1; __i <= __new_nodes; ++__i) - *(_M_finish._M_node + __i) = _M_allocate_node(); - } -# ifdef __STL_USE_EXCEPTIONS - catch(...) { - for (size_type __j = 1; __j < __i; ++__j) - _M_deallocate_node(*(_M_finish._M_node + __j)); - throw; - } -# endif /* __STL_USE_EXCEPTIONS */ -} - -template -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); -} - - -// Nonmember functions. - -template -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 -inline bool operator<(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__y < __x); -} -template -inline bool operator>=(const deque<_Tp, _Alloc>& __x, - const deque<_Tp, _Alloc>& __y) { - return !(__x < __y); -} - -template -inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) { - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_DEQUE_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_function.h b/libstdc++-v3/bits/stl_function.h deleted file mode 100644 index fcaafac5668..00000000000 --- a/libstdc++-v3/bits/stl_function.h +++ /dev/null @@ -1,732 +0,0 @@ -/* - * - * 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-1998 - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_FUNCTION_H -#define __SGI_STL_INTERNAL_FUNCTION_H - -__STL_BEGIN_NAMESPACE - -template -struct unary_function { - typedef _Arg argument_type; - typedef _Result result_type; -}; - -template -struct binary_function { - typedef _Arg1 first_argument_type; - typedef _Arg2 second_argument_type; - typedef _Result result_type; -}; - -template -struct plus : public binary_function<_Tp,_Tp,_Tp> { - _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } -}; - -template -struct minus : public binary_function<_Tp,_Tp,_Tp> { - _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } -}; - -template -struct multiplies : public binary_function<_Tp,_Tp,_Tp> { - _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } -}; - -template -struct divides : public binary_function<_Tp,_Tp,_Tp> { - _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } -}; - -// identity_element (not part of the C++ standard). - -template inline _Tp identity_element(plus<_Tp>) { - return _Tp(0); -} -template inline _Tp identity_element(multiplies<_Tp>) { - return _Tp(1); -} - -template -struct modulus : public binary_function<_Tp,_Tp,_Tp> -{ - _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } -}; - -template -struct negate : public unary_function<_Tp,_Tp> -{ - _Tp operator()(const _Tp& __x) const { return -__x; } -}; - -template -struct equal_to : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } -}; - -template -struct not_equal_to : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } -}; - -template -struct greater : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } -}; - -template -struct less : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } -}; - -template -struct greater_equal : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } -}; - -template -struct less_equal : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } -}; - -template -struct logical_and : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } -}; - -template -struct logical_or : public binary_function<_Tp,_Tp,bool> -{ - bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } -}; - -template -struct logical_not : public unary_function<_Tp,bool> -{ - bool operator()(const _Tp& __x) const { return !__x; } -}; - -template -class unary_negate - : public unary_function { -protected: - _Predicate _M_pred; -public: - explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {} - bool operator()(const typename _Predicate::argument_type& __x) const { - return !_M_pred(__x); - } -}; - -template -inline unary_negate<_Predicate> -not1(const _Predicate& __pred) -{ - return unary_negate<_Predicate>(__pred); -} - -template -class binary_negate - : public binary_function { -protected: - _Predicate _M_pred; -public: - explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {} - bool operator()(const typename _Predicate::first_argument_type& __x, - const typename _Predicate::second_argument_type& __y) const - { - return !_M_pred(__x, __y); - } -}; - -template -inline binary_negate<_Predicate> -not2(const _Predicate& __pred) -{ - return binary_negate<_Predicate>(__pred); -} - -template -class binder1st - : public unary_function { -protected: - _Operation op; - typename _Operation::first_argument_type value; -public: - binder1st(const _Operation& __x, - const typename _Operation::first_argument_type& __y) - : op(__x), value(__y) {} - typename _Operation::result_type - operator()(const typename _Operation::second_argument_type& __x) const { - return op(value, __x); - } -}; - -template -inline binder1st<_Operation> -bind1st(const _Operation& __fn, const _Tp& __x) -{ - typedef typename _Operation::first_argument_type _Arg1_type; - return binder1st<_Operation>(__fn, _Arg1_type(__x)); -} - -template -class binder2nd - : public unary_function { -protected: - _Operation op; - typename _Operation::second_argument_type value; -public: - binder2nd(const _Operation& __x, - const typename _Operation::second_argument_type& __y) - : op(__x), value(__y) {} - typename _Operation::result_type - operator()(const typename _Operation::first_argument_type& __x) const { - return op(__x, value); - } -}; - -template -inline binder2nd<_Operation> -bind2nd(const _Operation& __fn, const _Tp& __x) -{ - typedef typename _Operation::second_argument_type _Arg2_type; - return binder2nd<_Operation>(__fn, _Arg2_type(__x)); -} - -// unary_compose and binary_compose (extensions, not part of the standard). - -template -class unary_compose - : public unary_function -{ -protected: - _Operation1 _M_fn1; - _Operation2 _M_fn2; -public: - unary_compose(const _Operation1& __x, const _Operation2& __y) - : _M_fn1(__x), _M_fn2(__y) {} - typename _Operation1::result_type - operator()(const typename _Operation2::argument_type& __x) const { - return _M_fn1(_M_fn2(__x)); - } -}; - -template -inline unary_compose<_Operation1,_Operation2> -compose1(const _Operation1& __fn1, const _Operation2& __fn2) -{ - return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); -} - -template -class binary_compose - : public unary_function { -protected: - _Operation1 _M_fn1; - _Operation2 _M_fn2; - _Operation3 _M_fn3; -public: - binary_compose(const _Operation1& __x, const _Operation2& __y, - const _Operation3& __z) - : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } - typename _Operation1::result_type - operator()(const typename _Operation2::argument_type& __x) const { - return _M_fn1(_M_fn2(__x), _M_fn3(__x)); - } -}; - -template -inline binary_compose<_Operation1, _Operation2, _Operation3> -compose2(const _Operation1& __fn1, const _Operation2& __fn2, - const _Operation3& __fn3) -{ - return binary_compose<_Operation1,_Operation2,_Operation3> - (__fn1, __fn2, __fn3); -} - -template -class pointer_to_unary_function : public unary_function<_Arg, _Result> { -protected: - _Result (*_M_ptr)(_Arg); -public: - pointer_to_unary_function() {} - explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {} - _Result operator()(_Arg __x) const { return _M_ptr(__x); } -}; - -template -inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) -{ - return pointer_to_unary_function<_Arg, _Result>(__x); -} - -template -class pointer_to_binary_function : - public binary_function<_Arg1,_Arg2,_Result> { -protected: - _Result (*_M_ptr)(_Arg1, _Arg2); -public: - pointer_to_binary_function() {} - explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) - : _M_ptr(__x) {} - _Result operator()(_Arg1 __x, _Arg2 __y) const { - return _M_ptr(__x, __y); - } -}; - -template -inline pointer_to_binary_function<_Arg1,_Arg2,_Result> -ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { - return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x); -} - -// identity is an extensions: it is not part of the standard. -template -struct _Identity : public unary_function<_Tp,_Tp> { - _Tp& operator()(_Tp& __x) const { return __x; } - const _Tp& operator()(const _Tp& __x) const { return __x; } -}; - -template struct identity : public _Identity<_Tp> {}; - -// select1st and select2nd are extensions: they are not part of the standard. -template -struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { - typename _Pair::first_type& operator()(_Pair& __x) const { - return __x.first; - } - const typename _Pair::first_type& operator()(const _Pair& __x) const { - return __x.first; - } -}; - -template -struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> -{ - typename _Pair::second_type& operator()(_Pair& __x) const { - return __x.second; - } - const typename _Pair::second_type& operator()(const _Pair& __x) const { - return __x.second; - } -}; - -template struct select1st : public _Select1st<_Pair> {}; -template struct select2nd : public _Select2nd<_Pair> {}; - -// project1st and project2nd are extensions: they are not part of the standard -template -struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> { - _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } -}; - -template -struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> { - _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; } -}; - -template -struct project1st : public _Project1st<_Arg1, _Arg2> {}; - -template -struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; - -// constant_void_fun, constant_unary_fun, and constant_binary_fun are -// extensions: they are not part of the standard. (The same, of course, -// is true of the helper functions constant0, constant1, and constant2.) - -template -struct _Constant_void_fun { - typedef _Result result_type; - result_type _M_val; - - _Constant_void_fun(const result_type& __v) : _M_val(__v) {} - const result_type& operator()() const { return _M_val; } -}; - -template -struct _Constant_unary_fun { - typedef _Argument argument_type; - typedef _Result result_type; - result_type _M_val; - - _Constant_unary_fun(const result_type& __v) : _M_val(__v) {} - const result_type& operator()(const _Argument&) const { return _M_val; } -}; - -template -struct _Constant_binary_fun { - typedef _Arg1 first_argument_type; - typedef _Arg2 second_argument_type; - typedef _Result result_type; - _Result _M_val; - - _Constant_binary_fun(const _Result& __v) : _M_val(__v) {} - const result_type& operator()(const _Arg1&, const _Arg2&) const { - return _M_val; - } -}; - -template -struct constant_void_fun : public _Constant_void_fun<_Result> { - constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} -}; - - -template -struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> -{ - constant_unary_fun(const _Result& __v) - : _Constant_unary_fun<_Result, _Argument>(__v) {} -}; - - -template -struct constant_binary_fun - : public _Constant_binary_fun<_Result, _Arg1, _Arg2> -{ - constant_binary_fun(const _Result& __v) - : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} -}; - -template -inline constant_void_fun<_Result> constant0(const _Result& __val) -{ - return constant_void_fun<_Result>(__val); -} - -template -inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) -{ - return constant_unary_fun<_Result,_Result>(__val); -} - -template -inline constant_binary_fun<_Result,_Result,_Result> -constant2(const _Result& __val) -{ - return constant_binary_fun<_Result,_Result,_Result>(__val); -} - -// subtractive_rng is an extension: it is not part of the standard. -// Note: this code assumes that int is 32 bits. -class subtractive_rng : public unary_function { -private: - unsigned int _M_table[55]; - size_t _M_index1; - size_t _M_index2; -public: - unsigned int operator()(unsigned int __limit) { - _M_index1 = (_M_index1 + 1) % 55; - _M_index2 = (_M_index2 + 1) % 55; - _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; - return _M_table[_M_index1] % __limit; - } - - void _M_initialize(unsigned int __seed) - { - unsigned int __k = 1; - _M_table[54] = __seed; - size_t __i; - for (__i = 0; __i < 54; __i++) { - size_t __ii = (21 * (__i + 1) % 55) - 1; - _M_table[__ii] = __k; - __k = __seed - __k; - __seed = _M_table[__ii]; - } - for (int __loop = 0; __loop < 4; __loop++) { - for (__i = 0; __i < 55; __i++) - _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; - } - _M_index1 = 0; - _M_index2 = 31; - } - - subtractive_rng(unsigned int __seed) { _M_initialize(__seed); } - subtractive_rng() { _M_initialize(161803398u); } -}; - - -// Adaptor function objects: pointers to member functions. - -// There are a total of 16 = 2^4 function objects in this family. -// (1) Member functions taking no arguments vs member functions taking -// one argument. -// (2) Call through pointer vs call through reference. -// (3) Member function with void return type vs member function with -// non-void return type. -// (4) Const vs non-const member function. - -// Note that choice (3) is nothing more than a workaround: according -// to the draft, compilers should handle void and non-void the same way. -// This feature is not yet widely implemented, though. You can only use -// member functions returning void if your compiler supports partial -// specialization. - -// All of this complexity is in the function objects themselves. You can -// ignore it by using the helper function mem_fun and mem_fun_ref, -// which create whichever type of adaptor is appropriate. -// (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard, -// but they are provided for backward compatibility.) - - -template -class mem_fun_t : public unary_function<_Tp*,_Ret> { -public: - explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {} - _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); } -private: - _Ret (_Tp::*_M_f)(); -}; - -template -class const_mem_fun_t : public unary_function { -public: - explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {} - _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); } -private: - _Ret (_Tp::*_M_f)() const; -}; - - -template -class mem_fun_ref_t : public unary_function<_Tp,_Ret> { -public: - explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {} - _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); } -private: - _Ret (_Tp::*_M_f)(); -}; - -template -class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> { -public: - explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {} - _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); } -private: - _Ret (_Tp::*_M_f)() const; -}; - -template -class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> { -public: - explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {} - _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } -private: - _Ret (_Tp::*_M_f)(_Arg); -}; - -template -class const_mem_fun1_t : public binary_function { -public: - explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} - _Ret operator()(const _Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } -private: - _Ret (_Tp::*_M_f)(_Arg) const; -}; - -template -class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> { -public: - explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {} - _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } -private: - _Ret (_Tp::*_M_f)(_Arg); -}; - -template -class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> { -public: - explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} - _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } -private: - _Ret (_Tp::*_M_f)(_Arg) const; -}; - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -class mem_fun_t : public unary_function<_Tp*,void> { -public: - explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {} - void operator()(_Tp* __p) const { (__p->*_M_f)(); } -private: - void (_Tp::*_M_f)(); -}; - -template -class const_mem_fun_t : public unary_function { -public: - explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {} - void operator()(const _Tp* __p) const { (__p->*_M_f)(); } -private: - void (_Tp::*_M_f)() const; -}; - -template -class mem_fun_ref_t : public unary_function<_Tp,void> { -public: - explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {} - void operator()(_Tp& __r) const { (__r.*_M_f)(); } -private: - void (_Tp::*_M_f)(); -}; - -template -class const_mem_fun_ref_t : public unary_function<_Tp,void> { -public: - explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {} - void operator()(const _Tp& __r) const { (__r.*_M_f)(); } -private: - void (_Tp::*_M_f)() const; -}; - -template -class mem_fun1_t : public binary_function<_Tp*,_Arg,void> { -public: - explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {} - void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); } -private: - void (_Tp::*_M_f)(_Arg); -}; - -template -class const_mem_fun1_t - : public binary_function { -public: - explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} - void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); } -private: - void (_Tp::*_M_f)(_Arg) const; -}; - -template -class mem_fun1_ref_t - : public binary_function<_Tp,_Arg,void> { -public: - explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {} - void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); } -private: - void (_Tp::*_M_f)(_Arg); -}; - -template -class const_mem_fun1_ref_t - : public binary_function<_Tp,_Arg,void> { -public: - explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} - void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); } -private: - void (_Tp::*_M_f)(_Arg) const; -}; - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// Mem_fun adaptor helper functions. There are only two: -// mem_fun and mem_fun_ref. (mem_fun1 and mem_fun1_ref -// are provided for backward compatibility, but they are no longer -// part of the C++ standard.) - -template -inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)()) - { return mem_fun_t<_Ret,_Tp>(__f); } - -template -inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const) - { return const_mem_fun_t<_Ret,_Tp>(__f); } - -template -inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)()) - { return mem_fun_ref_t<_Ret,_Tp>(__f); } - -template -inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const) - { return const_mem_fun_ref_t<_Ret,_Tp>(__f); } - -template -inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> -mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } - -template -inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> -mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_FUNCTION_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_heap.h b/libstdc++-v3/bits/stl_heap.h deleted file mode 100644 index 3e7eaa456e5..00000000000 --- a/libstdc++-v3/bits/stl_heap.h +++ /dev/null @@ -1,297 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_HEAP_H -#define _CPP_BITS_STL_HEAP_H 1 - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1209 -#endif - -// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap. - -template -void -__push_heap(_RandomAccessIterator __first, - _Distance __holeIndex, _Distance __topIndex, _Tp __value) -{ - _Distance __parent = (__holeIndex - 1) / 2; - while (__holeIndex > __topIndex && *(__first + __parent) < __value) { - *(__first + __holeIndex) = *(__first + __parent); - __holeIndex = __parent; - __parent = (__holeIndex - 1) / 2; - } - *(__first + __holeIndex) = __value; -} - -template -inline void -__push_heap_aux(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Distance*, _Tp*) -{ - __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), - _Tp(*(__last - 1))); -} - -template -inline void -push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type, - _LessThanComparable); - __push_heap_aux(__first, __last, - __DISTANCE_TYPE(__first), __VALUE_TYPE(__first)); -} - -template -void -__push_heap(_RandomAccessIterator __first, _Distance __holeIndex, - _Distance __topIndex, _Tp __value, _Compare __comp) -{ - _Distance __parent = (__holeIndex - 1) / 2; - while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) { - *(__first + __holeIndex) = *(__first + __parent); - __holeIndex = __parent; - __parent = (__holeIndex - 1) / 2; - } - *(__first + __holeIndex) = __value; -} - -template -inline void -__push_heap_aux(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Compare __comp, - _Distance*, _Tp*) -{ - __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), - _Tp(*(__last - 1)), __comp); -} - -template -inline void -push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __push_heap_aux(__first, __last, __comp, - __DISTANCE_TYPE(__first), __VALUE_TYPE(__first)); -} - -template -void -__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, - _Distance __len, _Tp __value) -{ - _Distance __topIndex = __holeIndex; - _Distance __secondChild = 2 * __holeIndex + 2; - while (__secondChild < __len) { - if (*(__first + __secondChild) < *(__first + (__secondChild - 1))) - __secondChild--; - *(__first + __holeIndex) = *(__first + __secondChild); - __holeIndex = __secondChild; - __secondChild = 2 * (__secondChild + 1); - } - if (__secondChild == __len) { - *(__first + __holeIndex) = *(__first + (__secondChild - 1)); - __holeIndex = __secondChild - 1; - } - __push_heap(__first, __holeIndex, __topIndex, __value); -} - -template -inline void -__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _RandomAccessIterator __result, _Tp __value, _Distance*) -{ - *__result = *__first; - __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value); -} - -template -inline void -__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Tp*) -{ - __pop_heap(__first, __last - 1, __last - 1, - _Tp(*(__last - 1)), __DISTANCE_TYPE(__first)); -} - -template -inline void pop_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type, - _LessThanComparable); - __pop_heap_aux(__first, __last, __VALUE_TYPE(__first)); -} - -template -void -__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, - _Distance __len, _Tp __value, _Compare __comp) -{ - _Distance __topIndex = __holeIndex; - _Distance __secondChild = 2 * __holeIndex + 2; - while (__secondChild < __len) { - if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1)))) - __secondChild--; - *(__first + __holeIndex) = *(__first + __secondChild); - __holeIndex = __secondChild; - __secondChild = 2 * (__secondChild + 1); - } - if (__secondChild == __len) { - *(__first + __holeIndex) = *(__first + (__secondChild - 1)); - __holeIndex = __secondChild - 1; - } - __push_heap(__first, __holeIndex, __topIndex, __value, __comp); -} - -template -inline void -__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _RandomAccessIterator __result, _Tp __value, _Compare __comp, - _Distance*) -{ - *__result = *__first; - __adjust_heap(__first, _Distance(0), _Distance(__last - __first), - __value, __comp); -} - -template -inline void -__pop_heap_aux(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Tp*, _Compare __comp) -{ - __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp, - __DISTANCE_TYPE(__first)); -} - -template -inline void -pop_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Compare __comp) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __pop_heap_aux(__first, __last, __VALUE_TYPE(__first), __comp); -} - -template -void -__make_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Tp*, _Distance*) -{ - if (__last - __first < 2) return; - _Distance __len = __last - __first; - _Distance __parent = (__len - 2)/2; - - while (true) { - __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent))); - if (__parent == 0) return; - __parent--; - } -} - -template -inline void -make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type, - _LessThanComparable); - __make_heap(__first, __last, - __VALUE_TYPE(__first), __DISTANCE_TYPE(__first)); -} - -template -void -__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp, _Tp*, _Distance*) -{ - if (__last - __first < 2) return; - _Distance __len = __last - __first; - _Distance __parent = (__len - 2)/2; - - while (true) { - __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)), - __comp); - if (__parent == 0) return; - __parent--; - } -} - -template -inline void -make_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Compare __comp) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __make_heap(__first, __last, __comp, - __VALUE_TYPE(__first), __DISTANCE_TYPE(__first)); -} - -template -void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type, - _LessThanComparable); - while (__last - __first > 1) - pop_heap(__first, __last--); -} - -template -void -sort_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Compare __comp) -{ - __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator); - while (__last - __first > 1) - pop_heap(__first, __last--, __comp); -} - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1209 -#endif - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_HEAP_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_iterator.h b/libstdc++-v3/bits/stl_iterator.h deleted file mode 100644 index ae8b0886653..00000000000 --- a/libstdc++-v3/bits/stl_iterator.h +++ /dev/null @@ -1,1086 +0,0 @@ -/* - * - * 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-1998 - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_ITERATOR_H -#define __SGI_STL_INTERNAL_ITERATOR_H - -__STL_BEGIN_NAMESPACE - - -template -class back_insert_iterator { -protected: - _Container* container; -public: - typedef _Container container_type; - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - explicit back_insert_iterator(_Container& __x) : container(&__x) {} - back_insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { - container->push_back(__value); - return *this; - } - back_insert_iterator<_Container>& operator*() { return *this; } - back_insert_iterator<_Container>& operator++() { return *this; } - back_insert_iterator<_Container>& operator++(int) { return *this; } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline output_iterator_tag -iterator_category(const back_insert_iterator<_Container>&) -{ - return output_iterator_tag(); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline back_insert_iterator<_Container> back_inserter(_Container& __x) { - return back_insert_iterator<_Container>(__x); -} - -template -class front_insert_iterator { -protected: - _Container* container; -public: - typedef _Container container_type; - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - explicit front_insert_iterator(_Container& __x) : container(&__x) {} - front_insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { - container->push_front(__value); - return *this; - } - front_insert_iterator<_Container>& operator*() { return *this; } - front_insert_iterator<_Container>& operator++() { return *this; } - front_insert_iterator<_Container>& operator++(int) { return *this; } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline output_iterator_tag -iterator_category(const front_insert_iterator<_Container>&) -{ - return output_iterator_tag(); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline front_insert_iterator<_Container> front_inserter(_Container& __x) { - return front_insert_iterator<_Container>(__x); -} - -template -class insert_iterator { -protected: - _Container* container; - typename _Container::iterator iter; -public: - typedef _Container container_type; - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - insert_iterator(_Container& __x, typename _Container::iterator __i) - : container(&__x), iter(__i) {} - insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - insert_iterator<_Container>& operator*() { return *this; } - insert_iterator<_Container>& operator++() { return *this; } - insert_iterator<_Container>& operator++(int) { return *this; } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline output_iterator_tag -iterator_category(const insert_iterator<_Container>&) -{ - return output_iterator_tag(); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline -insert_iterator<_Container> inserter(_Container& __x, _Iterator __i) -{ - typedef typename _Container::iterator __iter; - return insert_iterator<_Container>(__x, __iter(__i)); -} - -template -class reverse_bidirectional_iterator { - typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, - _Reference, _Distance> _Self; -protected: - _BidirectionalIterator current; -public: - typedef bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Reference reference; - - reverse_bidirectional_iterator() {} - explicit reverse_bidirectional_iterator(_BidirectionalIterator __x) - : current(__x) {} - _BidirectionalIterator base() const { return current; } - _Reference operator*() const { - _BidirectionalIterator __tmp = current; - return *--__tmp; - } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - _Self& operator++() { - --current; - return *this; - } - _Self operator++(int) { - _Self __tmp = *this; - --current; - return __tmp; - } - _Self& operator--() { - ++current; - return *this; - } - _Self operator--(int) { - _Self __tmp = *this; - ++current; - return __tmp; - } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline bidirectional_iterator_tag -iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator, - _Tp, _Reference, - _Distance>&) -{ - return bidirectional_iterator_tag(); -} - -template -inline _Tp* -value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, - _Reference, _Distance>&) -{ - return (_Tp*) 0; -} - -template -inline _Distance* -distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, - _Tp, - _Reference, _Distance>&) -{ - return (_Distance*) 0; -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline bool operator==( - const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, - const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y) -{ - return __x.base() == __y.base(); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=( - const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, - const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y) -{ - return !(__x == __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -// This is the new version of reverse_iterator, as defined in the -// draft C++ standard. It relies on the iterator_traits template, -// which in turn relies on partial specialization. The class -// reverse_bidirectional_iterator is no longer part of the draft -// standard, but it is retained for backward compatibility. - -template -class reverse_iterator -{ -protected: - _Iterator current; -public: - typedef typename iterator_traits<_Iterator>::iterator_category - iterator_category; - typedef typename iterator_traits<_Iterator>::value_type - value_type; - typedef typename iterator_traits<_Iterator>::difference_type - difference_type; - typedef typename iterator_traits<_Iterator>::pointer - pointer; - typedef typename iterator_traits<_Iterator>::reference - reference; - - typedef _Iterator iterator_type; - typedef reverse_iterator<_Iterator> _Self; - -public: - reverse_iterator() {} - explicit reverse_iterator(iterator_type __x) : current(__x) {} - - reverse_iterator(const _Self& __x) : current(__x.current) {} -#ifdef __STL_MEMBER_TEMPLATES - template - reverse_iterator(const reverse_iterator<_Iter>& __x) - : current(__x.base()) {} -#endif /* __STL_MEMBER_TEMPLATES */ - - iterator_type base() const { return current; } - reference operator*() const { - _Iterator __tmp = current; - return *--__tmp; - } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - - _Self& operator++() { - --current; - return *this; - } - _Self operator++(int) { - _Self __tmp = *this; - --current; - return __tmp; - } - _Self& operator--() { - ++current; - return *this; - } - _Self operator--(int) { - _Self __tmp = *this; - ++current; - return __tmp; - } - - _Self operator+(difference_type __n) const { - return _Self(current - __n); - } - _Self& operator+=(difference_type __n) { - current -= __n; - return *this; - } - _Self operator-(difference_type __n) const { - return _Self(current + __n); - } - _Self& operator-=(difference_type __n) { - current += __n; - return *this; - } - reference operator[](difference_type __n) const { return *(*this + __n); } -}; - -template -inline bool operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return __x.base() == __y.base(); -} - -template -inline bool operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return __y.base() < __x.base(); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -inline typename reverse_iterator<_Iterator>::difference_type -operator-(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) { - return __y.base() - __x.base(); -} - -template -inline reverse_iterator<_Iterator> -operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) { - return reverse_iterator<_Iterator>(__x.base() - __n); -} - -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// This is the old version of reverse_iterator, as found in the original -// HP STL. It does not use partial specialization. - -template -class reverse_iterator { - typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance> - _Self; -protected: - _RandomAccessIterator current; -public: - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Reference reference; - - reverse_iterator() {} - explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) {} - _RandomAccessIterator base() const { return current; } - _Reference operator*() const { return *(current - 1); } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - _Self& operator++() { - --current; - return *this; - } - _Self operator++(int) { - _Self __tmp = *this; - --current; - return __tmp; - } - _Self& operator--() { - ++current; - return *this; - } - _Self operator--(int) { - _Self __tmp = *this; - ++current; - return __tmp; - } - _Self operator+(_Distance __n) const { - return _Self(current - __n); - } - _Self& operator+=(_Distance __n) { - current -= __n; - return *this; - } - _Self operator-(_Distance __n) const { - return _Self(current + __n); - } - _Self& operator-=(_Distance __n) { - current += __n; - return *this; - } - _Reference operator[](_Distance __n) const { return *(*this + __n); } -}; - -template -inline random_access_iterator_tag -iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>&) -{ - return random_access_iterator_tag(); -} - -template -inline _Tp* value_type(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>&) -{ - return (_Tp*) 0; -} - -template -inline _Distance* -distance_type(const reverse_iterator<_RandomAccessIterator, - _Tp, _Reference, _Distance>&) -{ - return (_Distance*) 0; -} - - -template -inline bool -operator==(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) -{ - return __x.base() == __y.base(); -} - -template -inline bool -operator<(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) -{ - return __y.base() < __x.base(); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool -operator!=(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) { - return !(__x == __y); -} - -template -inline bool -operator>(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) { - return __y < __x; -} - -template -inline bool -operator<=(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) { - return !(__y < __x); -} - -template -inline bool -operator>=(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) { - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -inline _Distance -operator-(const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __x, - const reverse_iterator<_RandomAccessIterator, _Tp, - _Reference, _Distance>& __y) -{ - return __y.base() - __x.base(); -} - -template -inline reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist> -operator+(_Dist __n, - const reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>& __x) -{ - return reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>(__x.base() - __n); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -// istream_iterator and ostream_iterator look very different if we're -// using new, templatized iostreams than if we're using the old cfront -// version. - -#ifdef __STL_USE_NEW_IOSTREAMS - -template , - class _Dist = ptrdiff_t> -class istream_iterator { -public: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef basic_istream<_CharT, _Traits> istream_type; - - typedef input_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Dist difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - - istream_iterator() : _M_stream(0), _M_ok(false) {} - istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); } - - reference operator*() const { return _M_value; } - pointer operator->() const { return &(operator*()); } - - istream_iterator& operator++() { - _M_read(); - return *this; - } - istream_iterator operator++(int) { - istream_iterator __tmp = *this; - _M_read(); - return __tmp; - } - - bool _M_equal(const istream_iterator& __x) const - { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } - -private: - istream_type* _M_stream; - _Tp _M_value; - bool _M_ok; - - void _M_read() { - _M_ok = (_M_stream && *_M_stream) ? true : false; - if (_M_ok) { - *_M_stream >> _M_value; - _M_ok = *_M_stream ? true : false; - } - } -}; - -template -inline bool -operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, - const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) { - return __x._M_equal(__y); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool -operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, - const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) { - return !__x._M_equal(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template > -class ostream_iterator { -public: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef basic_ostream<_CharT, _Traits> ostream_type; - - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {} - ostream_iterator(ostream_type& __s, const _CharT* __c) - : _M_stream(&__s), _M_string(__c) {} - ostream_iterator<_Tp>& operator=(const _Tp& __value) { - *_M_stream << __value; - if (_M_string) *_M_stream << _M_string; - return *this; - } - ostream_iterator<_Tp>& operator*() { return *this; } - ostream_iterator<_Tp>& operator++() { return *this; } - ostream_iterator<_Tp>& operator++(int) { return *this; } -private: - ostream_type* _M_stream; - const _CharT* _M_string; -}; - -// The default template argument is declared in iosfwd - -// We do not read any characters until operator* is called. The first -// time operator* is called, it calls getc. Subsequent calls to getc -// return a cached character, and calls to operator++ use snextc. Before -// operator* or operator++ has been called, _M_is_initialized is false. -template -class istreambuf_iterator - : public iterator -{ -public: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename _Traits::int_type int_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_istream<_CharT, _Traits> istream_type; - -public: - istreambuf_iterator(streambuf_type* __p = 0) { this->_M_init(__p); } - istreambuf_iterator(istream_type& __is) { this->_M_init(__is.rdbuf()); } - - char_type operator*() const - { return _M_is_initialized ? _M_c : _M_dereference_aux(); } - - istreambuf_iterator& operator++() { this->_M_nextc(); return *this; } - istreambuf_iterator operator++(int) { - if (!_M_is_initialized) - _M_postincr_aux(); - istreambuf_iterator __tmp = *this; - this->_M_nextc(); - return __tmp; - } - - bool equal(const istreambuf_iterator& __i) const { - return this->_M_is_initialized && __i._M_is_initialized - ? this->_M_eof == __i._M_eof - : this->_M_equal_aux(__i); - } - -private: - void _M_init(streambuf_type* __p) { - _M_buf = __p; - _M_eof = !__p; - _M_is_initialized = _M_eof; - } - - char_type _M_dereference_aux() const; - bool _M_equal_aux(const istreambuf_iterator&) const; - void _M_postincr_aux(); - - void _M_nextc() { - int_type __c = _M_buf->snextc(); - _M_c = traits_type::to_char_type(__c); - _M_eof = traits_type::eq_int_type(__c, traits_type::eof()); - _M_is_initialized = true; - } - - void _M_getc() const { - int_type __c = _M_buf->sgetc(); - _M_c = traits_type::to_char_type(__c); - _M_eof = traits_type::eq_int_type(__c, traits_type::eof()); - _M_is_initialized = true; - } - -private: - streambuf_type* _M_buf; - mutable _CharT _M_c; - mutable bool _M_eof : 1; - mutable bool _M_is_initialized : 1; -}; - -template -_CharT istreambuf_iterator<_CharT, _Traits>::_M_dereference_aux() const -{ - this->_M_getc(); - return _M_c; -} - -template -bool istreambuf_iterator<_CharT, _Traits> - ::_M_equal_aux(const istreambuf_iterator& __i) const -{ - if (!this->_M_is_initialized) - this->_M_getc(); - if (!__i._M_is_initialized) - __i._M_getc(); - - return this->_M_eof == __i._M_eof; -} - -template -void istreambuf_iterator<_CharT, _Traits>::_M_postincr_aux() -{ - this->_M_getc(); -} - -template -inline bool operator==(const istreambuf_iterator<_CharT, _Traits>& __x, - const istreambuf_iterator<_CharT, _Traits>& __y) { - return __x.equal(__y); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const istreambuf_iterator<_CharT, _Traits>& __x, - const istreambuf_iterator<_CharT, _Traits>& __y) { - return !__x.equal(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -// The default template argument is declared in iosfwd -template -class ostreambuf_iterator - : public iterator -{ -public: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename _Traits::int_type int_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_ostream<_CharT, _Traits> ostream_type; - -public: - ostreambuf_iterator(streambuf_type* __buf) : _M_buf(__buf), _M_ok(__buf) {} - ostreambuf_iterator(ostream_type& __o) - : _M_buf(__o.rdbuf()), _M_ok(__o.rdbuf() != 0) {} - - ostreambuf_iterator& operator=(char_type __c) { - _M_ok = _M_ok && !traits_type::eq_int_type(_M_buf->sputc(__c), - traits_type::eof()); - return *this; - } - - ostreambuf_iterator& operator*() { return *this; } - ostreambuf_iterator& operator++() { return *this; } - ostreambuf_iterator& operator++(int) { return *this; } - - bool failed() const { return !_M_ok; } - -private: - streambuf_type* _M_buf; - bool _M_ok; -}; - -#else /* __STL_USE_NEW_IOSTREAMS */ - -template class istream_iterator; - -template -inline bool operator==(const istream_iterator<_Tp, _Dist>&, - const istream_iterator<_Tp, _Dist>&); - -template -class istream_iterator { -#ifdef __STL_TEMPLATE_FRIENDS - template - friend bool operator==(const istream_iterator<_T1, _D1>&, - const istream_iterator<_T1, _D1>&); -#else /* __STL_TEMPLATE_FRIENDS */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const istream_iterator&, - const istream_iterator&); -#endif /* __STL_TEMPLATE_FRIENDS */ - -protected: - istream* _M_stream; - _Tp _M_value; - bool _M_end_marker; - void _M_read() { - _M_end_marker = (*_M_stream) ? true : false; - if (_M_end_marker) *_M_stream >> _M_value; - _M_end_marker = (*_M_stream) ? true : false; - } -public: - typedef input_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Dist difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - - istream_iterator() : _M_stream(&cin), _M_end_marker(false) {} - istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); } - reference operator*() const { return _M_value; } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - istream_iterator<_Tp, _Dist>& operator++() { - _M_read(); - return *this; - } - istream_iterator<_Tp, _Dist> operator++(int) { - istream_iterator<_Tp, _Dist> __tmp = *this; - _M_read(); - return __tmp; - } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline input_iterator_tag -iterator_category(const istream_iterator<_Tp, _Dist>&) -{ - return input_iterator_tag(); -} - -template -inline _Tp* -value_type(const istream_iterator<_Tp, _Dist>&) { return (_Tp*) 0; } - -template -inline _Dist* -distance_type(const istream_iterator<_Tp, _Dist>&) { return (_Dist*)0; } - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline bool operator==(const istream_iterator<_Tp, _Distance>& __x, - const istream_iterator<_Tp, _Distance>& __y) { - return (__x._M_stream == __y._M_stream && - __x._M_end_marker == __y._M_end_marker) || - __x._M_end_marker == false && __y._M_end_marker == false; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const istream_iterator<_Tp, _Distance>& __x, - const istream_iterator<_Tp, _Distance>& __y) { - return !(__x == __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -class ostream_iterator { -protected: - ostream* _M_stream; - const char* _M_string; -public: - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - ostream_iterator(ostream& __s) : _M_stream(&__s), _M_string(0) {} - ostream_iterator(ostream& __s, const char* __c) - : _M_stream(&__s), _M_string(__c) {} - ostream_iterator<_Tp>& operator=(const _Tp& __value) { - *_M_stream << __value; - if (_M_string) *_M_stream << _M_string; - return *this; - } - ostream_iterator<_Tp>& operator*() { return *this; } - ostream_iterator<_Tp>& operator++() { return *this; } - ostream_iterator<_Tp>& operator++(int) { return *this; } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline output_iterator_tag -iterator_category(const ostream_iterator<_Tp>&) { - return output_iterator_tag(); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -#endif /* __STL_USE_NEW_IOSTREAMS */ - -// This iterator adapter is 'normal' in the sense that it does not -// change the semantics of any of the operators of its itererator -// parameter. Its primary purpose is to convert an iterator that is -// not a class, e.g. a pointer, into an iterator that is a class. -// The _Container parameter exists solely so that different containers -// using this template can instantiate different types, even if the -// _Iterator parameter is the same. -template -class __normal_iterator - : public iterator::iterator_category, - iterator_traits<_Iterator>::value_type, - iterator_traits<_Iterator>::difference_type, - iterator_traits<_Iterator>::pointer, - iterator_traits<_Iterator>::reference> -{ - -protected: - _Iterator _M_current; - -public: - typedef __normal_iterator<_Iterator, _Container> normal_iterator_type; - typedef iterator_traits<_Iterator> __traits_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::pointer pointer; - typedef typename __traits_type::reference reference; - - __normal_iterator() : _M_current(_Iterator()) { } - - explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { } - - // Allow iterator to const_iterator conversion - template - inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - : _M_current(__i.base()) { } - - // Forward iterator requirements - reference - operator*() const { return *_M_current; } - - pointer - operator->() const { return _M_current; } - - normal_iterator_type& - operator++() { ++_M_current; return *this; } - - normal_iterator_type - operator++(int) { return __normal_iterator(_M_current++); } - - // Bidirectional iterator requirements - normal_iterator_type& - operator--() { --_M_current; return *this; } - - normal_iterator_type - operator--(int) { return __normal_iterator(_M_current--); } - - // Random access iterator requirements - reference - operator[](const difference_type& __n) const - { return _M_current[__n]; } - - normal_iterator_type& - operator+=(const difference_type& __n) - { _M_current += __n; return *this; } - - normal_iterator_type - operator+(const difference_type& __n) const - { return __normal_iterator(_M_current + __n); } - - normal_iterator_type& - operator-=(const difference_type& __n) - { _M_current -= __n; return *this; } - - normal_iterator_type - operator-(const difference_type& __n) const - { return __normal_iterator(_M_current - __n); } - - difference_type - operator-(const normal_iterator_type& __i) const - { return _M_current - __i._M_current; } - - const _Iterator& - base() const { return _M_current; } -}; - -// forward iterator requirements - -template -inline bool -operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return __lhs.base() == __rhs.base(); } - -template -inline bool -operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return !(__lhs == __rhs); } - -// random access iterator requirements - -template -inline bool -operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return __lhs.base() < __rhs.base(); } - -template -inline bool -operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return __rhs < __lhs; } - -template -inline bool -operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return !(__rhs < __lhs); } - -template -inline bool -operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) -{ return !(__lhs < __rhs); } - -template -inline __normal_iterator<_Iterator, _Container> -operator+(__normal_iterator<_Iterator, _Container>::difference_type __n, - const __normal_iterator<_Iterator, _Container>& __i) -{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_ITERATOR_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_iterator_base.h b/libstdc++-v3/bits/stl_iterator_base.h deleted file mode 100644 index 44a6f8fbfb0..00000000000 --- a/libstdc++-v3/bits/stl_iterator_base.h +++ /dev/null @@ -1,367 +0,0 @@ -/* - * - * 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-1998 - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_ITERATOR_BASE_H -#define __SGI_STL_INTERNAL_ITERATOR_BASE_H - -// This file contains all of the general iterator-related utilities. -// The internal file stl_iterator.h contains predefined iterators, -// such as front_insert_iterator and istream_iterator. - -#include - -__STL_BEGIN_NAMESPACE - -struct input_iterator_tag {}; -struct output_iterator_tag {}; -struct forward_iterator_tag : public input_iterator_tag {}; -struct bidirectional_iterator_tag : public forward_iterator_tag {}; -struct random_access_iterator_tag : public bidirectional_iterator_tag {}; - -// The base classes input_iterator, output_iterator, forward_iterator, -// bidirectional_iterator, and random_access_iterator are not part of -// the C++ standard. (They have been replaced by struct iterator.) -// They are included for backward compatibility with the HP STL. - -template struct input_iterator { - typedef input_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; -}; - -struct output_iterator { - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; -}; - -template struct forward_iterator { - typedef forward_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; -}; - - -template struct bidirectional_iterator { - typedef bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; -}; - -template struct random_access_iterator { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; -}; - -#ifdef __STL_USE_NAMESPACES -template -struct iterator { - typedef _Category iterator_category; - typedef _Tp value_type; - typedef _Distance difference_type; - typedef _Pointer pointer; - typedef _Reference reference; -}; -#endif /* __STL_USE_NAMESPACES */ - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -struct iterator_traits { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; -}; - -template -struct iterator_traits<_Tp*> { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; -}; - -template -struct iterator_traits { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; -}; - -// The overloaded functions iterator_category, distance_type, and -// value_type are not part of the C++ standard. (They have been -// replaced by struct iterator_traits.) They are included for -// backward compatibility with the HP STL. - -// We introduce internal names for these functions. - -template -inline typename iterator_traits<_Iter>::iterator_category -__iterator_category(const _Iter&) -{ - typedef typename iterator_traits<_Iter>::iterator_category _Category; - return _Category(); -} - -template -inline typename iterator_traits<_Iter>::difference_type* -__distance_type(const _Iter&) -{ - return static_cast::difference_type*>(0); -} - -template -inline typename iterator_traits<_Iter>::value_type* -__value_type(const _Iter&) -{ - return static_cast::value_type*>(0); -} - -template -inline typename iterator_traits<_Iter>::iterator_category -iterator_category(const _Iter& __i) { return __iterator_category(__i); } - - -template -inline typename iterator_traits<_Iter>::difference_type* -distance_type(const _Iter& __i) { return __distance_type(__i); } - -template -inline typename iterator_traits<_Iter>::value_type* -value_type(const _Iter& __i) { return __value_type(__i); } - -#define __ITERATOR_CATEGORY(__i) __iterator_category(__i) -#define __DISTANCE_TYPE(__i) __distance_type(__i) -#define __VALUE_TYPE(__i) __value_type(__i) - -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline input_iterator_tag -iterator_category(const input_iterator<_Tp, _Distance>&) - { return input_iterator_tag(); } - -inline output_iterator_tag iterator_category(const output_iterator&) - { return output_iterator_tag(); } - -template -inline forward_iterator_tag -iterator_category(const forward_iterator<_Tp, _Distance>&) - { return forward_iterator_tag(); } - -template -inline bidirectional_iterator_tag -iterator_category(const bidirectional_iterator<_Tp, _Distance>&) - { return bidirectional_iterator_tag(); } - -template -inline random_access_iterator_tag -iterator_category(const random_access_iterator<_Tp, _Distance>&) - { return random_access_iterator_tag(); } - -template -inline random_access_iterator_tag iterator_category(const _Tp*) - { return random_access_iterator_tag(); } - -template -inline _Tp* value_type(const input_iterator<_Tp, _Distance>&) - { return (_Tp*)(0); } - -template -inline _Tp* value_type(const forward_iterator<_Tp, _Distance>&) - { return (_Tp*)(0); } - -template -inline _Tp* value_type(const bidirectional_iterator<_Tp, _Distance>&) - { return (_Tp*)(0); } - -template -inline _Tp* value_type(const random_access_iterator<_Tp, _Distance>&) - { return (_Tp*)(0); } - -template -inline _Tp* value_type(const _Tp*) { return (_Tp*)(0); } - -template -inline _Distance* distance_type(const input_iterator<_Tp, _Distance>&) -{ - return (_Distance*)(0); -} - -template -inline _Distance* distance_type(const forward_iterator<_Tp, _Distance>&) -{ - return (_Distance*)(0); -} - -template -inline _Distance* -distance_type(const bidirectional_iterator<_Tp, _Distance>&) -{ - return (_Distance*)(0); -} - -template -inline _Distance* -distance_type(const random_access_iterator<_Tp, _Distance>&) -{ - return (_Distance*)(0); -} - -template -inline ptrdiff_t* distance_type(const _Tp*) { return (ptrdiff_t*)(0); } - -// Without partial specialization we can't use iterator_traits, so -// we must keep the old iterator query functions around. - -#define __ITERATOR_CATEGORY(__i) iterator_category(__i) -#define __DISTANCE_TYPE(__i) distance_type(__i) -#define __VALUE_TYPE(__i) value_type(__i) - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline void __distance(_InputIterator __first, _InputIterator __last, - _Distance& __n, input_iterator_tag) -{ - while (__first != __last) { ++__first; ++__n; } -} - -template -inline void __distance(_RandomAccessIterator __first, - _RandomAccessIterator __last, - _Distance& __n, random_access_iterator_tag) -{ - __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator); - __n += __last - __first; -} - -template -inline void distance(_InputIterator __first, - _InputIterator __last, _Distance& __n) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - __distance(__first, __last, __n, iterator_category(__first)); -} - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline typename iterator_traits<_InputIterator>::difference_type -__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) -{ - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) { - ++__first; ++__n; - } - return __n; -} - -template -inline typename iterator_traits<_RandomAccessIterator>::difference_type -__distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) { - __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator); - return __last - __first; -} - -template -inline typename iterator_traits<_InputIterator>::difference_type -distance(_InputIterator __first, _InputIterator __last) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _Category; - __STL_REQUIRES(_InputIterator, _InputIterator); - return __distance(__first, __last, _Category()); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -template -inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) { - while (__n--) ++__i; -} - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1183 -#endif - -template -inline void __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) { - __STL_REQUIRES(_BidirectionalIterator, _BidirectionalIterator); - if (__n >= 0) - while (__n--) ++__i; - else - while (__n++) --__i; -} - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1183 -#endif - -template -inline void __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) { - __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator); - __i += __n; -} - -template -inline void advance(_InputIterator& __i, _Distance __n) { - __STL_REQUIRES(_InputIterator, _InputIterator); - __advance(__i, __n, iterator_category(__i)); -} - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_ITERATOR_BASE_H */ - - - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_list.h b/libstdc++-v3/bits/stl_list.h deleted file mode 100644 index 1967a7a933d..00000000000 --- a/libstdc++-v3/bits/stl_list.h +++ /dev/null @@ -1,885 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_LIST_H -#define __SGI_STL_INTERNAL_LIST_H - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -struct _List_node_base { - _List_node_base* _M_next; - _List_node_base* _M_prev; -}; - -template -struct _List_node : public _List_node_base { - _Tp _M_data; -}; - -struct _List_iterator_base { - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef bidirectional_iterator_tag iterator_category; - - _List_node_base* _M_node; - - _List_iterator_base(_List_node_base* __x) : _M_node(__x) {} - _List_iterator_base() {} - - void _M_incr() { _M_node = _M_node->_M_next; } - 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; - } -}; - -template -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 ((_Node*) _M_node)->_M_data; } - -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_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; - } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -inline bidirectional_iterator_tag -iterator_category(const _List_iterator_base&) -{ - return bidirectional_iterator_tag(); -} - -template -inline _Tp* -value_type(const _List_iterator<_Tp, _Ref, _Ptr>&) -{ - return 0; -} - -inline ptrdiff_t* -distance_type(const _List_iterator_base&) -{ - return 0; -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - - -// 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. - -#ifdef __STL_USE_STD_ALLOCATORS - -// Base for general standard-conforming allocators. -template -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. - -template -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: - 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 -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) { - _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(); -}; - -#else /* __STL_USE_STD_ALLOCATORS */ - -template -class _List_base -{ -public: - typedef _Alloc allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _List_base(const allocator_type&) { - _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(); - -protected: - typedef simple_alloc<_List_node<_Tp>, _Alloc> _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; -}; - -#endif /* __STL_USE_STD_ALLOCATORS */ - -template -void -_List_base<_Tp,_Alloc>::clear() -{ - _List_node<_Tp>* __cur = (_List_node<_Tp>*) _M_node->_M_next; - while (__cur != _M_node) { - _List_node<_Tp>* __tmp = __cur; - __cur = (_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 > -class list : protected _List_base<_Tp, _Alloc> { - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - - 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; - allocator_type get_allocator() const { return _Base::get_allocator(); } - -public: - typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator; - typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator; - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - typedef reverse_bidirectional_iterator - const_reverse_iterator; - typedef reverse_bidirectional_iterator - reverse_iterator; -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -protected: -#ifdef __STL_HAS_NAMESPACES - using _Base::_M_node; - using _Base::_M_put_node; - using _Base::_M_get_node; -#endif /* __STL_HAS_NAMESPACES */ - -protected: - _Node* _M_create_node(const _Tp& __x) - { - _Node* __p = _M_get_node(); - __STL_TRY { - _Construct(&__p->_M_data, __x); - } - __STL_UNWIND(_M_put_node(__p)); - return __p; - } - - _Node* _M_create_node() - { - _Node* __p = _M_get_node(); - __STL_TRY { - _Construct(&__p->_M_data); - } - __STL_UNWIND(_M_put_node(__p)); - return __p; - } - -public: - explicit list(const allocator_type& __a = allocator_type()) : _Base(__a) {} - - iterator begin() { return (_Node*)(_M_node->_M_next); } - const_iterator begin() const { return (_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 { - size_type __result = 0; - distance(begin(), end(), __result); - return __result; - } - 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()); } - - void swap(list<_Tp, _Alloc>& __x) { __STD::swap(_M_node, __x._M_node); } - - iterator insert(iterator __position, const _Tp& __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; - } - iterator insert(iterator __position) { return insert(__position, _Tp()); } -#ifdef __STL_MEMBER_TEMPLATES - // Check whether it's an integral type. If so, it's not an iterator. - - template - void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, - __true_type) { - _M_fill_insert(__pos, (size_type) __n, (_Tp) __x); - } - - template - void _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type); - - template - void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); - } - -#else /* __STL_MEMBER_TEMPLATES */ - void insert(iterator __position, const _Tp* __first, const _Tp* __last); - void insert(iterator __position, - const_iterator __first, const_iterator __last); -#endif /* __STL_MEMBER_TEMPLATES */ - 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); } - void push_back() {insert(end());} - - iterator 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 = (_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((_Node*) __next_node); - } - 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()); } - - void pop_front() { erase(begin()); } - 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()); } - -#ifdef __STL_MEMBER_TEMPLATES - - // We don't need any dispatching tricks here, because insert does all of - // that anyway. - template - list(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { insert(begin(), __first, __last); } - -#else /* __STL_MEMBER_TEMPLATES */ - - list(const _Tp* __first, const _Tp* __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { this->insert(begin(), __first, __last); } - list(const_iterator __first, const_iterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { this->insert(begin(), __first, __last); } - -#endif /* __STL_MEMBER_TEMPLATES */ - 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. - - void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); } - - void _M_fill_assign(size_type __n, const _Tp& __val); - -#ifdef __STL_MEMBER_TEMPLATES - - template - void assign(_InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); - } - - template - void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign((size_type) __n, (_Tp) __val); } - - template - void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type); - -#endif /* __STL_MEMBER_TEMPLATES */ - -protected: - void 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; - } - } - -public: - void splice(iterator __position, list& __x) { - if (!__x.empty()) - this->transfer(__position, __x.begin(), __x.end()); - } - void splice(iterator __position, list&, iterator __i) { - iterator __j = __i; - ++__j; - if (__position == __i || __position == __j) return; - this->transfer(__position, __i, __j); - } - void splice(iterator __position, list&, iterator __first, iterator __last) { - if (__first != __last) - this->transfer(__position, __first, __last); - } - void remove(const _Tp& __value); - void unique(); - void merge(list& __x); - void reverse(); - void sort(); - -#ifdef __STL_MEMBER_TEMPLATES - template void remove_if(_Predicate); - template void unique(_BinaryPredicate); - template void merge(list&, _StrictWeakOrdering); - template void sort(_StrictWeakOrdering); -#endif /* __STL_MEMBER_TEMPLATES */ -}; - -template -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) { - ++__i1; - ++__i2; - } - return __i1 == __end1 && __i2 == __end2; -} - -template -inline bool operator<(const list<_Tp,_Alloc>& __x, - const list<_Tp,_Alloc>& __y) -{ - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const list<_Tp,_Alloc>& __x, - const list<_Tp,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const list<_Tp,_Alloc>& __x, - const list<_Tp,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const list<_Tp,_Alloc>& __x, - const list<_Tp,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const list<_Tp,_Alloc>& __x, - const list<_Tp,_Alloc>& __y) { - return !(__x < __y); -} - -template -inline void -swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) -{ - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#ifdef __STL_MEMBER_TEMPLATES - -template template -void -list<_Tp, _Alloc>::_M_insert_dispatch(iterator __position, - _InputIter __first, _InputIter __last, - __false_type) -{ - for ( ; __first != __last; ++__first) - insert(__position, *__first); -} - -#else /* __STL_MEMBER_TEMPLATES */ - -template -void -list<_Tp, _Alloc>::insert(iterator __position, - const _Tp* __first, const _Tp* __last) -{ - for ( ; __first != __last; ++__first) - insert(__position, *__first); -} - -template -void -list<_Tp, _Alloc>::insert(iterator __position, - const_iterator __first, const_iterator __last) -{ - for ( ; __first != __last; ++__first) - insert(__position, *__first); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -void -list<_Tp, _Alloc>::_M_fill_insert(iterator __position, - size_type __n, const _Tp& __x) -{ - for ( ; __n > 0; --__n) - insert(__position, __x); -} - -template -typename list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::erase(iterator __first, - iterator __last) -{ - while (__first != __last) - erase(__first++); - return __last; -} - -template -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 -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 -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()); -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -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); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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 -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 -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; - transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) 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 -inline void list<_Tp, _Alloc>::reverse() -{ - __List_base_reverse(this->_M_node); -} - -template -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]); - } -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -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 template -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 template -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; - transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) transfer(__last1, __first2, __last2); -} - -template template -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]); - } -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_LIST_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_map.h b/libstdc++-v3/bits/stl_map.h deleted file mode 100644 index 0b7a06d4b8b..00000000000 --- a/libstdc++-v3/bits/stl_map.h +++ /dev/null @@ -1,282 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_MAP_H -#define _CPP_BITS_STL_MAP_H 1 - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -template , - class _Alloc = allocator > > -class map { -public: - -// requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Key, _Key); - -// typedefs: - - typedef _Key key_type; - typedef _Tp data_type; - typedef _Tp mapped_type; - typedef pair value_type; - typedef _Compare key_compare; - - class value_compare - : public binary_function { - 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_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) {} - -#ifdef __STL_MEMBER_TEMPLATES - template - map(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - template - map(_InputIterator __first, _InputIterator __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } -#else - map(const value_type* __first, const value_type* __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - map(const value_type* __first, - const value_type* __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } - - map(const_iterator __first, const_iterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - map(const_iterator __first, const_iterator __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } - -#endif /* __STL_MEMBER_TEMPLATES */ - - 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(); } - - iterator begin() { return _M_t.begin(); } - const_iterator begin() const { return _M_t.begin(); } - iterator end() { return _M_t.end(); } - const_iterator end() const { return _M_t.end(); } - reverse_iterator rbegin() { return _M_t.rbegin(); } - const_reverse_iterator rbegin() const { return _M_t.rbegin(); } - reverse_iterator rend() { return _M_t.rend(); } - const_reverse_iterator rend() const { return _M_t.rend(); } - bool empty() const { return _M_t.empty(); } - size_type size() const { return _M_t.size(); } - size_type max_size() const { return _M_t.max_size(); } - _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 - - pair insert(const value_type& __x) - { return _M_t.insert_unique(__x); } - iterator insert(iterator position, const value_type& __x) - { return _M_t.insert_unique(position, __x); } -#ifdef __STL_MEMBER_TEMPLATES - template - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_unique(__first, __last); - } -#else - void insert(const value_type* __first, const value_type* __last) { - _M_t.insert_unique(__first, __last); - } - void insert(const_iterator __first, const_iterator __last) { - _M_t.insert_unique(__first, __last); - } -#endif /* __STL_MEMBER_TEMPLATES */ - - void erase(iterator __position) { _M_t.erase(__position); } - size_type erase(const key_type& __x) { return _M_t.erase(__x); } - void erase(iterator __first, iterator __last) - { _M_t.erase(__first, __last); } - void clear() { _M_t.clear(); } - - // map operations: - - iterator find(const key_type& __x) { return _M_t.find(__x); } - const_iterator find(const key_type& __x) const { return _M_t.find(__x); } - size_type count(const key_type& __x) const { - return _M_t.find(__x) == _M_t.end() ? 0 : 1; - } - iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); } - const_iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); } - const_iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - - pair equal_range(const key_type& __x) { - return _M_t.equal_range(__x); - } - pair equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - -#ifdef __STL_TEMPLATE_FRIENDS - template - friend bool operator== (const map<_K1, _T1, _C1, _A1>&, - const map<_K1, _T1, _C1, _A1>&); - template - friend bool operator< (const map<_K1, _T1, _C1, _A1>&, - const map<_K1, _T1, _C1, _A1>&); -#else /* __STL_TEMPLATE_FRIENDS */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const map&, const map&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const map&, const map&); -#endif /* __STL_TEMPLATE_FRIENDS */ -}; - -template -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 -inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x, - const map<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template -inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x, - map<_Key,_Tp,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_MAP_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_multimap.h b/libstdc++-v3/bits/stl_multimap.h deleted file mode 100644 index 1c5401b378a..00000000000 --- a/libstdc++-v3/bits/stl_multimap.h +++ /dev/null @@ -1,282 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_MULTIMAP_H -#define __SGI_STL_INTERNAL_MULTIMAP_H - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -// Forward declaration of operators < and ==, needed for friend declaration. - -template , - class _Alloc = allocator > > -class multimap; - -template -inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y); - -template -inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y); - -template -class multimap { - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Key, _Key); - -public: - -// typedefs: - - typedef _Key key_type; - typedef _Tp data_type; - typedef _Tp mapped_type; - typedef pair value_type; - typedef _Compare key_compare; - - class value_compare : public binary_function { - 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_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) { } - -#ifdef __STL_MEMBER_TEMPLATES - template - multimap(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - - template - multimap(_InputIterator __first, _InputIterator __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } -#else - multimap(const value_type* __first, const value_type* __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - multimap(const value_type* __first, const value_type* __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } - - multimap(const_iterator __first, const_iterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - multimap(const_iterator __first, const_iterator __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } -#endif /* __STL_MEMBER_TEMPLATES */ - - 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(); } - - iterator begin() { return _M_t.begin(); } - const_iterator begin() const { return _M_t.begin(); } - iterator end() { return _M_t.end(); } - const_iterator end() const { return _M_t.end(); } - reverse_iterator rbegin() { return _M_t.rbegin(); } - const_reverse_iterator rbegin() const { return _M_t.rbegin(); } - reverse_iterator rend() { return _M_t.rend(); } - const_reverse_iterator rend() const { return _M_t.rend(); } - bool empty() const { return _M_t.empty(); } - size_type size() const { return _M_t.size(); } - 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 - - iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); } - iterator insert(iterator __position, const value_type& __x) { - return _M_t.insert_equal(__position, __x); - } -#ifdef __STL_MEMBER_TEMPLATES - template - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_equal(__first, __last); - } -#else - void insert(const value_type* __first, const value_type* __last) { - _M_t.insert_equal(__first, __last); - } - void insert(const_iterator __first, const_iterator __last) { - _M_t.insert_equal(__first, __last); - } -#endif /* __STL_MEMBER_TEMPLATES */ - void erase(iterator __position) { _M_t.erase(__position); } - size_type erase(const key_type& __x) { return _M_t.erase(__x); } - void erase(iterator __first, iterator __last) - { _M_t.erase(__first, __last); } - void clear() { _M_t.clear(); } - - // multimap operations: - - iterator find(const key_type& __x) { return _M_t.find(__x); } - const_iterator find(const key_type& __x) const { return _M_t.find(__x); } - size_type count(const key_type& __x) const { return _M_t.count(__x); } - iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); } - const_iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); } - const_iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - pair equal_range(const key_type& __x) { - return _M_t.equal_range(__x); - } - pair equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - -#ifdef __STL_TEMPLATE_FRIENDS - template - friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&, - const multimap<_K1, _T1, _C1, _A1>&); - template - friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&, - const multimap<_K1, _T1, _C1, _A1>&); -#else /* __STL_TEMPLATE_FRIENDS */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const multimap&, const multimap&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const multimap&, const multimap&); -#endif /* __STL_TEMPLATE_FRIENDS */ -}; - -template -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 -inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, - const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template -inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x, - multimap<_Key,_Tp,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_MULTIMAP_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_multiset.h b/libstdc++-v3/bits/stl_multiset.h deleted file mode 100644 index 7e75ec3cd0a..00000000000 --- a/libstdc++-v3/bits/stl_multiset.h +++ /dev/null @@ -1,274 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_MULTISET_H -#define __SGI_STL_INTERNAL_MULTISET_H - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -// Forward declaration of operators < and ==, needed for friend declaration. - -template , - class _Alloc = allocator<_Key> > -class multiset; - -template -inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y); - -template -inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y); - -template -class multiset { - // requirements: - - __STL_CLASS_REQUIRES(_Key, _Assignable); - __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Key, _Key); - -public: - - // typedefs: - - typedef _Key key_type; - typedef _Key value_type; - typedef _Compare key_compare; - typedef _Compare value_compare; -private: - typedef _Rb_tree, key_compare, _Alloc> _Rep_type; - _Rep_type _M_t; // red-black tree representing multiset -public: - typedef typename _Rep_type::const_pointer pointer; - typedef typename _Rep_type::const_pointer const_pointer; - typedef typename _Rep_type::const_reference reference; - typedef typename _Rep_type::const_reference const_reference; - typedef typename _Rep_type::const_iterator iterator; - typedef typename _Rep_type::const_iterator const_iterator; - typedef typename _Rep_type::const_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 - - multiset() : _M_t(_Compare(), allocator_type()) {} - explicit multiset(const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) {} - -#ifdef __STL_MEMBER_TEMPLATES - - template - multiset(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - - template - multiset(_InputIterator __first, _InputIterator __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } - -#else - - multiset(const value_type* __first, const value_type* __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - - multiset(const value_type* __first, const value_type* __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } - - multiset(const_iterator __first, const_iterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_equal(__first, __last); } - - multiset(const_iterator __first, const_iterator __last, - const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } - -#endif /* __STL_MEMBER_TEMPLATES */ - - multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {} - multiset<_Key,_Compare,_Alloc>& - operator=(const multiset<_Key,_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 _M_t.key_comp(); } - allocator_type get_allocator() const { return _M_t.get_allocator(); } - - iterator begin() const { return _M_t.begin(); } - iterator end() const { return _M_t.end(); } - reverse_iterator rbegin() const { return _M_t.rbegin(); } - reverse_iterator rend() const { return _M_t.rend(); } - bool empty() const { return _M_t.empty(); } - size_type size() const { return _M_t.size(); } - size_type max_size() const { return _M_t.max_size(); } - void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } - - // insert/erase - iterator insert(const value_type& __x) { - return _M_t.insert_equal(__x); - } - iterator insert(iterator __position, const value_type& __x) { - typedef typename _Rep_type::iterator _Rep_iterator; - return _M_t.insert_equal((_Rep_iterator&)__position, __x); - } - -#ifdef __STL_MEMBER_TEMPLATES - template - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_equal(__first, __last); - } -#else - void insert(const value_type* __first, const value_type* __last) { - _M_t.insert_equal(__first, __last); - } - void insert(const_iterator __first, const_iterator __last) { - _M_t.insert_equal(__first, __last); - } -#endif /* __STL_MEMBER_TEMPLATES */ - void erase(iterator __position) { - typedef typename _Rep_type::iterator _Rep_iterator; - _M_t.erase((_Rep_iterator&)__position); - } - size_type erase(const key_type& __x) { - return _M_t.erase(__x); - } - void erase(iterator __first, iterator __last) { - typedef typename _Rep_type::iterator _Rep_iterator; - _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last); - } - void clear() { _M_t.clear(); } - - // multiset operations: - - iterator find(const key_type& __x) const { return _M_t.find(__x); } - size_type count(const key_type& __x) const { return _M_t.count(__x); } - iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - pair equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - -#ifdef __STL_TEMPLATE_FRIENDS - template - friend bool operator== (const multiset<_K1,_C1,_A1>&, - const multiset<_K1,_C1,_A1>&); - template - friend bool operator< (const multiset<_K1,_C1,_A1>&, - const multiset<_K1,_C1,_A1>&); -#else /* __STL_TEMPLATE_FRIENDS */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const multiset&, const multiset&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const multiset&, const multiset&); -#endif /* __STL_TEMPLATE_FRIENDS */ -}; - -template -inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return __x._M_t == __y._M_t; -} - -template -inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const multiset<_Key,_Compare,_Alloc>& __x, - const multiset<_Key,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template -inline void swap(multiset<_Key,_Compare,_Alloc>& __x, - multiset<_Key,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_MULTISET_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_numeric.h b/libstdc++-v3/bits/stl_numeric.h deleted file mode 100644 index 0b1742bc9d9..00000000000 --- a/libstdc++-v3/bits/stl_numeric.h +++ /dev/null @@ -1,255 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - - -#ifndef _CPP_BITS_STL_NUMERIC_H -#define _CPP_BITS_STL_NUMERIC_H 1 - -__STL_BEGIN_NAMESPACE - -template -_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - for ( ; __first != __last; ++__first) - __init = __init + *__first; - return __init; -} - -template -_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, - _BinaryOperation __binary_op) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - for ( ; __first != __last; ++__first) - __init = __binary_op(__init, *__first); - return __init; -} - -template -_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _Tp __init) -{ - __STL_REQUIRES(_InputIterator2, _InputIterator); - __STL_REQUIRES(_InputIterator2, _InputIterator); - for ( ; __first1 != __last1; ++__first1, ++__first2) - __init = __init + (*__first1 * *__first2); - return __init; -} - -template -_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _Tp __init, - _BinaryOperation1 __binary_op1, - _BinaryOperation2 __binary_op2) -{ - __STL_REQUIRES(_InputIterator2, _InputIterator); - __STL_REQUIRES(_InputIterator2, _InputIterator); - for ( ; __first1 != __last1; ++__first1, ++__first2) - __init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); - return __init; -} - -template -_OutputIterator -__partial_sum(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _Tp*) -{ - _Tp __value = *__first; - while (++__first != __last) { - __value = __value + *__first; - *++__result = __value; - } - return ++__result; -} - -template -_OutputIterator -partial_sum(_InputIterator __first, _InputIterator __last, - _OutputIterator __result) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - __STL_REQUIRES(_OutputIterator, _OutputIterator); - if (__first == __last) return __result; - *__result = *__first; - return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first)); -} - -template -_OutputIterator -__partial_sum(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _Tp*, _BinaryOperation __binary_op) -{ - _Tp __value = *__first; - while (++__first != __last) { - __value = __binary_op(__value, *__first); - *++__result = __value; - } - return ++__result; -} - -template -_OutputIterator -partial_sum(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _BinaryOperation __binary_op) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - __STL_REQUIRES(_OutputIterator, _OutputIterator); - if (__first == __last) return __result; - *__result = *__first; - return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first), - __binary_op); -} - -template -_OutputIterator -__adjacent_difference(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _Tp*) -{ - _Tp __value = *__first; - while (++__first != __last) { - _Tp __tmp = *__first; - *++__result = __tmp - __value; - __value = __tmp; - } - return ++__result; -} - -template -_OutputIterator -adjacent_difference(_InputIterator __first, - _InputIterator __last, _OutputIterator __result) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - __STL_REQUIRES(_OutputIterator, _OutputIterator); - if (__first == __last) return __result; - *__result = *__first; - return __adjacent_difference(__first, __last, __result, - __VALUE_TYPE(__first)); -} - -template -_OutputIterator -__adjacent_difference(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _Tp*, - _BinaryOperation __binary_op) { - _Tp __value = *__first; - while (++__first != __last) { - _Tp __tmp = *__first; - *++__result = __binary_op(__tmp, __value); - __value = __tmp; - } - return ++__result; -} - -template -_OutputIterator -adjacent_difference(_InputIterator __first, _InputIterator __last, - _OutputIterator __result, _BinaryOperation __binary_op) -{ - __STL_REQUIRES(_InputIterator, _InputIterator); - __STL_REQUIRES(_OutputIterator, _OutputIterator); - if (__first == __last) return __result; - *__result = *__first; - return __adjacent_difference(__first, __last, __result, - __VALUE_TYPE(__first), - __binary_op); -} - -// Returns __x ** __n, where __n >= 0. _Note that "multiplication" -// is required to be associative, but not necessarily commutative. - - -template -_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) -{ - if (__n == 0) - return identity_element(__monoid_op); - else { - while ((__n & 1) == 0) { - __n >>= 1; - __x = __monoid_op(__x, __x); - } - - _Tp __result = __x; - __n >>= 1; - while (__n != 0) { - __x = __monoid_op(__x, __x); - if ((__n & 1) != 0) - __result = __monoid_op(__result, __x); - __n >>= 1; - } - return __result; - } -} - -template -inline _Tp __power(_Tp __x, _Integer __n) -{ - return __power(__x, __n, multiplies<_Tp>()); -} - -// Alias for the internal name __power. Note that power is an extension, -// not part of the C++ standard. - -template -inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) -{ - return __power(__x, __n, __monoid_op); -} - -template -inline _Tp power(_Tp __x, _Integer __n) -{ - return __power(__x, __n); -} - -// iota is not part of the C++ standard. It is an extension. - -template -void -iota(_ForwardIter __first, _ForwardIter __last, _Tp __value) -{ - __STL_REQUIRES(_ForwardIter, _Mutable_ForwardIterator); - __STL_CONVERTIBLE(_Tp, typename iterator_traits<_ForwardIter>::value_type); - while (__first != __last) - *__first++ = __value++; -} - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_NUMERIC_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_pair.h b/libstdc++-v3/bits/stl_pair.h deleted file mode 100644 index a6155a698e1..00000000000 --- a/libstdc++-v3/bits/stl_pair.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_PAIR_H -#define __SGI_STL_INTERNAL_PAIR_H - -__STL_BEGIN_NAMESPACE - -template -struct pair { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - pair() : first(_T1()), second(_T2()) {} - pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {} - -#ifdef __STL_MEMBER_TEMPLATES - template - pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {} -#endif -}; - -template -inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) -{ - return __x.first == __y.first && __x.second == __y.second; -} - -template -inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) -{ - return __x.first < __y.first || - (!(__y.first < __x.first) && __x.second < __y.second); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -inline pair<_T1, _T2> make_pair(const _T1& __x, const _T2& __y) -{ - return pair<_T1, _T2>(__x, __y); -} - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_PAIR_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_pthread_alloc.h b/libstdc++-v3/bits/stl_pthread_alloc.h deleted file mode 100644 index c1488b1ef6a..00000000000 --- a/libstdc++-v3/bits/stl_pthread_alloc.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 1996-1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_BITS_STL_PTHREAD_ALLOC_H -#define _CPP_BITS_STL_PTHREAD_ALLOC_H 1 - -#include - -#ifdef __STL_USE_NAMESPACES - -using __STD::_Pthread_alloc_template; -using __STD::pthread_alloc; - -#endif /* __STL_USE_NAMESPACES */ - - -#endif /* _CPP_BITS_STL_PTHREAD_ALLOC_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_queue.h b/libstdc++-v3/bits/stl_queue.h deleted file mode 100644 index e42666e5662..00000000000 --- a/libstdc++-v3/bits/stl_queue.h +++ /dev/null @@ -1,242 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_QUEUE_H -#define __SGI_STL_INTERNAL_QUEUE_H - -#include - -__STL_BEGIN_NAMESPACE - -// Forward declarations of operators < and ==, needed for friend declaration. - -template > -class queue; - -template -inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); - -template -inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&); - - -template -class queue { - - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - __STL_CLASS_REQUIRES(_Sequence, _FrontInsertionSequence); - __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence); - typedef typename _Sequence::value_type _Sequence_value_type; - __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type); - - -#ifdef __STL_MEMBER_TEMPLATES - template - friend bool operator== (const queue<_Tp1, _Seq1>&, - const queue<_Tp1, _Seq1>&); - template - friend bool operator< (const queue<_Tp1, _Seq1>&, - const queue<_Tp1, _Seq1>&); -#else /* __STL_MEMBER_TEMPLATES */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const queue&, const queue&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const queue&, const queue&); -#endif /* __STL_MEMBER_TEMPLATES */ - -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: - queue() : c() {} - explicit queue(const _Sequence& __c) : 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 -bool -operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __x.c == __y.c; -} - -template -bool -operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __x.c < __y.c; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -bool -operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__x == __y); -} - -template -bool -operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return __y < __x; -} - -template -bool -operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__y < __x); -} - -template -bool -operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y) -{ - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template ), - class _Compare - __STL_DEPENDENT_DEFAULT_TMPL(less) > -class priority_queue { -public: - - // requirements: - __STL_CLASS_REQUIRES(_Tp, _Assignable); - __STL_CLASS_REQUIRES(_Sequence, _Sequence); - __STL_CLASS_REQUIRES(_Sequence, _RandomAccessContainer); - typedef typename _Sequence::value_type _Sequence_value_type; - __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type); - __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Tp, _Tp); - - 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: - priority_queue() : c() {} - explicit priority_queue(const _Compare& __x) : c(), comp(__x) {} - priority_queue(const _Compare& __x, const _Sequence& __s) - : c(__s), comp(__x) - { make_heap(c.begin(), c.end(), comp); } - -#ifdef __STL_MEMBER_TEMPLATES - template - priority_queue(_InputIterator __first, _InputIterator __last) - : c(__first, __last) { make_heap(c.begin(), c.end(), comp); } - - template - priority_queue(_InputIterator __first, - _InputIterator __last, const _Compare& __x) - : c(__first, __last), comp(__x) - { make_heap(c.begin(), c.end(), comp); } - - template - priority_queue(_InputIterator __first, _InputIterator __last, - const _Compare& __x, const _Sequence& __s) - : c(__s), comp(__x) - { - c.insert(c.end(), __first, __last); - make_heap(c.begin(), c.end(), comp); - } - -#else /* __STL_MEMBER_TEMPLATES */ - priority_queue(const value_type* __first, const value_type* __last) - : c(__first, __last) { make_heap(c.begin(), c.end(), comp); } - - priority_queue(const value_type* __first, const value_type* __last, - const _Compare& __x) - : c(__first, __last), comp(__x) - { make_heap(c.begin(), c.end(), comp); } - - priority_queue(const value_type* __first, const value_type* __last, - const _Compare& __x, const _Sequence& __c) - : c(__c), comp(__x) - { - c.insert(c.end(), __first, __last); - make_heap(c.begin(), c.end(), comp); - } -#endif /* __STL_MEMBER_TEMPLATES */ - - 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) { - __STL_TRY { - c.push_back(__x); - push_heap(c.begin(), c.end(), comp); - } - __STL_UNWIND(c.clear()); - } - void pop() { - __STL_TRY { - pop_heap(c.begin(), c.end(), comp); - c.pop_back(); - } - __STL_UNWIND(c.clear()); - } -}; - -// no equality is provided - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_QUEUE_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_range_errors.h b/libstdc++-v3/bits/stl_range_errors.h deleted file mode 100644 index c5ddfe63cbb..00000000000 --- a/libstdc++-v3/bits/stl_range_errors.h +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 1999 - * Silicon Graphics - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - */ - -#ifndef __STL_RANGE_ERRORS_H -#define __STL_RANGE_ERRORS_H - -// A few places in the STL throw range errors, using standard exception -// classes defined in . This header file provides functions -// to throw those exception objects. - -// __STL_DONT_THROW_RANGE_ERRORS is a hook so that users can disable -// this exception throwing. - -#include - -#if defined(__STL_CAN_THROW_RANGE_ERRORS) && \ - defined(__STL_USE_EXCEPTIONS) && \ - !defined(__STL_DONT_THROW_RANGE_ERRORS) -# define __STL_THROW_RANGE_ERRORS -#endif - -// For the SGI 7.3 compiler, declare these functions here and define them -// elsewhere. -#if defined(__STL_THROW_RANGE_ERRORS) && \ - defined(__sgi) && !defined(__GNUC__) && \ - _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS) \ - || defined(__GNUC__) && defined(__STL_THROW_RANGE_ERRORS) - -__STL_BEGIN_NAMESPACE -void __stl_throw_range_error(const char* __msg); -void __stl_throw_length_error(const char* __msg); -__STL_END_NAMESPACE - -// For other compilers where we're throwing range errors, include the -// stdexcept header and throw the appropriate exceptions directly. -#elif defined(__STL_THROW_RANGE_ERRORS) - -#include - -__STL_BEGIN_NAMESPACE -inline void __stl_throw_range_error(const char* __msg) - { throw range_error(__msg); } -inline void __stl_throw_length_error(const char* __msg) - { throw length_error(__msg); } -__STL_END_NAMESPACE - -// Otherwise, define inline functions that do nothing. -#else - -__STL_BEGIN_NAMESPACE -inline void __stl_throw_range_error(const char*) {} -inline void __stl_throw_length_error(const char*) {} -__STL_END_NAMESPACE - -#endif - -#endif /* __STL_RANGE_ERRORS_H */ - -// Local Variables: -// mode:C++ -// End: - - diff --git a/libstdc++-v3/bits/stl_raw_storage_iter.h b/libstdc++-v3/bits/stl_raw_storage_iter.h deleted file mode 100644 index 007acd032ed..00000000000 --- a/libstdc++-v3/bits/stl_raw_storage_iter.h +++ /dev/null @@ -1,81 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H -#define _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H 1 - -__STL_BEGIN_NAMESPACE - -template -class raw_storage_iterator { -protected: - _ForwardIterator _M_iter; -public: - typedef output_iterator_tag iterator_category; - typedef void value_type; - typedef void difference_type; - typedef void pointer; - typedef void reference; - - explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {} - raw_storage_iterator& operator*() { return *this; } - raw_storage_iterator& operator=(const _Tp& __element) { - construct(&*_M_iter, __element); - return *this; - } - raw_storage_iterator<_ForwardIterator, _Tp>& operator++() { - ++_M_iter; - return *this; - } - raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) { - raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this; - ++_M_iter; - return __tmp; - } -}; - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -inline output_iterator_tag -iterator_category(const raw_storage_iterator<_ForwardIterator, _Tp>&) -{ - return output_iterator_tag(); -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_relops.h b/libstdc++-v3/bits/stl_relops.h deleted file mode 100644 index f0cabdfd544..00000000000 --- a/libstdc++-v3/bits/stl_relops.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * - * 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 - * - * 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. - * - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_RELOPS_H -#define _CPP_BITS_STL_RELOPS_H 1 - -__STL_BEGIN_RELOPS_NAMESPACE - -template -inline bool operator!=(const _Tp& __x, const _Tp& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const _Tp& __x, const _Tp& __y) { - return __y < __x; -} - -template -inline bool operator<=(const _Tp& __x, const _Tp& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const _Tp& __x, const _Tp& __y) { - return !(__x < __y); -} - -__STL_END_RELOPS_NAMESPACE - -#endif /* _CPP_BITS_STL_RELOPS_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_set.h b/libstdc++-v3/bits/stl_set.h deleted file mode 100644 index 435ca38b16e..00000000000 --- a/libstdc++-v3/bits/stl_set.h +++ /dev/null @@ -1,268 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_SET_H -#define __SGI_STL_INTERNAL_SET_H - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -// Forward declarations of operators < and ==, needed for friend declaration. - -template , - class _Alloc = allocator<_Key> > -class set; - -template -inline bool operator==(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y); - -template -inline bool operator<(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y); - - -template -class set { - // requirements: - - __STL_CLASS_REQUIRES(_Key, _Assignable); - __STL_CLASS_BINARY_FUNCTION_CHECK(_Compare, bool, _Key, _Key); - -public: - // typedefs: - - typedef _Key key_type; - typedef _Key value_type; - typedef _Compare key_compare; - typedef _Compare value_compare; -private: - typedef _Rb_tree, key_compare, _Alloc> _Rep_type; - _Rep_type _M_t; // red-black tree representing set -public: - typedef typename _Rep_type::const_pointer pointer; - typedef typename _Rep_type::const_pointer const_pointer; - typedef typename _Rep_type::const_reference reference; - typedef typename _Rep_type::const_reference const_reference; - typedef typename _Rep_type::const_iterator iterator; - typedef typename _Rep_type::const_iterator const_iterator; - typedef typename _Rep_type::const_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 - - set() : _M_t(_Compare(), allocator_type()) {} - explicit set(const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) {} - -#ifdef __STL_MEMBER_TEMPLATES - template - set(_InputIterator __first, _InputIterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - template - set(_InputIterator __first, _InputIterator __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } -#else - set(const value_type* __first, const value_type* __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - set(const value_type* __first, - const value_type* __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } - - set(const_iterator __first, const_iterator __last) - : _M_t(_Compare(), allocator_type()) - { _M_t.insert_unique(__first, __last); } - - set(const_iterator __first, const_iterator __last, const _Compare& __comp, - const allocator_type& __a = allocator_type()) - : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); } -#endif /* __STL_MEMBER_TEMPLATES */ - - set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {} - set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _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 _M_t.key_comp(); } - allocator_type get_allocator() const { return _M_t.get_allocator(); } - - iterator begin() const { return _M_t.begin(); } - iterator end() const { return _M_t.end(); } - reverse_iterator rbegin() const { return _M_t.rbegin(); } - reverse_iterator rend() const { return _M_t.rend(); } - bool empty() const { return _M_t.empty(); } - size_type size() const { return _M_t.size(); } - size_type max_size() const { return _M_t.max_size(); } - void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } - - // insert/erase - pair insert(const value_type& __x) { - pair __p = _M_t.insert_unique(__x); - return pair(__p.first, __p.second); - } - iterator insert(iterator __position, const value_type& __x) { - typedef typename _Rep_type::iterator _Rep_iterator; - return _M_t.insert_unique((_Rep_iterator&)__position, __x); - } -#ifdef __STL_MEMBER_TEMPLATES - template - void insert(_InputIterator __first, _InputIterator __last) { - _M_t.insert_unique(__first, __last); - } -#else - void insert(const_iterator __first, const_iterator __last) { - _M_t.insert_unique(__first, __last); - } - void insert(const value_type* __first, const value_type* __last) { - _M_t.insert_unique(__first, __last); - } -#endif /* __STL_MEMBER_TEMPLATES */ - void erase(iterator __position) { - typedef typename _Rep_type::iterator _Rep_iterator; - _M_t.erase((_Rep_iterator&)__position); - } - size_type erase(const key_type& __x) { - return _M_t.erase(__x); - } - void erase(iterator __first, iterator __last) { - typedef typename _Rep_type::iterator _Rep_iterator; - _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last); - } - void clear() { _M_t.clear(); } - - // set operations: - - iterator find(const key_type& __x) const { return _M_t.find(__x); } - size_type count(const key_type& __x) const { - return _M_t.find(__x) == _M_t.end() ? 0 : 1; - } - iterator lower_bound(const key_type& __x) const { - return _M_t.lower_bound(__x); - } - iterator upper_bound(const key_type& __x) const { - return _M_t.upper_bound(__x); - } - pair equal_range(const key_type& __x) const { - return _M_t.equal_range(__x); - } - -#ifdef __STL_TEMPLATE_FRIENDS - template - friend bool operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&); - template - friend bool operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&); -#else /* __STL_TEMPLATE_FRIENDS */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const set&, const set&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const set&, const set&); -#endif /* __STL_TEMPLATE_FRIENDS */ -}; - -template -inline bool operator==(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return __x._M_t == __y._M_t; -} - -template -inline bool operator<(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return __x._M_t < __y._M_t; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool operator!=(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool operator>(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool operator<=(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool operator>=(const set<_Key,_Compare,_Alloc>& __x, - const set<_Key,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - -template -inline void swap(set<_Key,_Compare,_Alloc>& __x, - set<_Key,_Compare,_Alloc>& __y) { - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_SET_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_stack.h b/libstdc++-v3/bits/stl_stack.h deleted file mode 100644 index aa80f8730ee..00000000000 --- a/libstdc++-v3/bits/stl_stack.h +++ /dev/null @@ -1,143 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_STACK_H -#define __SGI_STL_INTERNAL_STACK_H - -#include - -__STL_BEGIN_NAMESPACE - -// Forward declarations of operators == and <, needed for friend declaration. - -template > -class stack; - -template -bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y); - -template -bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y); - - -template -class stack { - - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence); - typedef typename _Sequence::value_type _Sequence_value_type; - __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type); - - -#ifdef __STL_MEMBER_TEMPLATES - template - friend bool operator== (const stack<_Tp1, _Seq1>&, - const stack<_Tp1, _Seq1>&); - template - friend bool operator< (const stack<_Tp1, _Seq1>&, - const stack<_Tp1, _Seq1>&); -#else /* __STL_MEMBER_TEMPLATES */ - friend bool __STD_QUALIFIER - operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&); - friend bool __STD_QUALIFIER - operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&); -#endif /* __STL_MEMBER_TEMPLATES */ - -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 -bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __x.c == __y.c; -} - -template -bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __x.c < __y.c; -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__x == __y); -} - -template -bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return __y < __x; -} - -template -bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__y < __x); -} - -template -bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y) -{ - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_STACK_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_string_fwd.h b/libstdc++-v3/bits/stl_string_fwd.h deleted file mode 100644 index 46845b9870c..00000000000 --- a/libstdc++-v3/bits/stl_string_fwd.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef __SGI_STL_STRING_FWD_H -#define __SGI_STL_STRING_FWD_H - -#include -#include -#include - -__STL_BEGIN_NAMESPACE - -template , - class _Alloc = allocator<_CharT> > -class basic_string; - -typedef basic_string string; -#ifdef _GLIBCPP_USE_WCHAR_T -typedef basic_string wstring; -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_STRING_FWD_H */ - -// Local Variables: -// mode:C++ -// End: - - - - - - - diff --git a/libstdc++-v3/bits/stl_tempbuf.h b/libstdc++-v3/bits/stl_tempbuf.h deleted file mode 100644 index cdc0dd27df0..00000000000 --- a/libstdc++-v3/bits/stl_tempbuf.h +++ /dev/null @@ -1,161 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_TEMPBUF_H -#define __SGI_STL_INTERNAL_TEMPBUF_H - -__STL_BEGIN_NAMESPACE - -template -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*) malloc((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); -} - -#ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS - -template -inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) { - return __get_temporary_buffer(__len, (_Tp*) 0); -} - -#endif /* __STL_EXPLICIT_FUNCTION_TMPL_ARGS */ - -// This overload is not required by the standard; it is an extension. -// It is supported for backward compatibility with the HP STL, and -// because not all compilers support the language feature (explicit -// function template arguments) that is required for the standard -// version of get_temporary_buffer. -template -inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len, _Tp*) { - return __get_temporary_buffer(__len, (_Tp*) 0); -} - -template -void return_temporary_buffer(_Tp* __p) { - free(__p); -} - -template -class _Temporary_buffer { -private: - ptrdiff_t _M_original_len; - ptrdiff_t _M_len; - _Tp* _M_buffer; - - void _M_allocate_buffer() { - _M_original_len = _M_len; - _M_buffer = 0; - - if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp))) - _M_len = INT_MAX / sizeof(_Tp); - - while (_M_len > 0) { - _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp)); - if (_M_buffer) - break; - _M_len /= 2; - } - } - - void _M_initialize_buffer(const _Tp&, __true_type) {} - void _M_initialize_buffer(const _Tp& val, __false_type) { - uninitialized_fill_n(_M_buffer, _M_len, val); - } - -public: - ptrdiff_t size() const { return _M_len; } - ptrdiff_t requested_size() const { return _M_original_len; } - _Tp* begin() { return _M_buffer; } - _Tp* end() { return _M_buffer + _M_len; } - - _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) { - // Workaround for a __type_traits bug in the pre-7.3 compiler. -# if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION < 730 - typedef typename __type_traits<_Tp>::is_POD_type _Trivial; -# else - typedef typename __type_traits<_Tp>::has_trivial_default_constructor - _Trivial; -# endif - - __STL_TRY { - _M_len = 0; - distance(__first, __last, _M_len); - _M_allocate_buffer(); - if (_M_len > 0) - _M_initialize_buffer(*__first, _Trivial()); - } - __STL_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0); - } - - ~_Temporary_buffer() { - destroy(_M_buffer, _M_buffer + _M_len); - free(_M_buffer); - } - -private: - // Disable copy constructor and assignment operator. - _Temporary_buffer(const _Temporary_buffer&) {} - void operator=(const _Temporary_buffer&) {} -}; - -// Class temporary_buffer is not part of the standard. It is an extension. - -template ::value_type -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - > -struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp> -{ - temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) - : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {} - ~temporary_buffer() {} -}; - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_TEMPBUF_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_threads.h b/libstdc++-v3/bits/stl_threads.h deleted file mode 100644 index 5f5b451e3d1..00000000000 --- a/libstdc++-v3/bits/stl_threads.h +++ /dev/null @@ -1,379 +0,0 @@ -/* - * Copyright (c) 1997-1999 - * 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. - */ - -// WARNING: This is an internal header file, included by other C++ -// standard library headers. You should not attempt to use this header -// file directly. -// Stl_config.h should be included before this file. - -#ifndef __SGI_STL_INTERNAL_THREADS_H -#define __SGI_STL_INTERNAL_THREADS_H - -// Supported threading models are native SGI, pthreads, uithreads -// (similar to pthreads, but based on an earlier draft of the Posix -// threads standard), and Win32 threads. Uithread support by Jochen -// Schlick, 1999. - -#if defined(__STL_SGI_THREADS) -#include -#include -#elif defined(__STL_PTHREADS) -#include -#elif defined(__STL_UITHREADS) -#include -#include -#elif defined(__STL_WIN32THREADS) -#include -#endif - -__STL_BEGIN_NAMESPACE - - -// Class _Refcount_Base provides a type, _RC_t, a data member, -// _M_ref_count, and member functions _M_incr and _M_decr, which perform -// atomic preincrement/predecrement. The constructor initializes -// _M_ref_count. - -// Hack for SGI o32 compilers. -#if defined(__STL_SGI_THREADS) && !defined(__add_and_fetch) && \ - (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64))) -# define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v) -# define __test_and_set(__l,__v) test_and_set(__l,__v) -#endif /* o32 */ - -struct _Refcount_Base -{ - // The type _RC_t -# ifdef __STL_WIN32THREADS - typedef long _RC_t; -# else - typedef size_t _RC_t; -#endif - - // The data member _M_ref_count - volatile _RC_t _M_ref_count; - - // Constructor -# ifdef __STL_PTHREADS - pthread_mutex_t _M_ref_count_lock; - _Refcount_Base(_RC_t __n) : _M_ref_count(__n) - { pthread_mutex_init(&_M_ref_count_lock, 0); } -# elif defined(__STL_UITHREADS) - mutex_t _M_ref_count_lock; - _Refcount_Base(_RC_t __n) : _M_ref_count(__n) - { mutex_init(&_M_ref_count_lock, USYNC_THREAD, 0); } -# else - _Refcount_Base(_RC_t __n) : _M_ref_count(__n) {} -# endif - - // _M_incr and _M_decr -# ifdef __STL_SGI_THREADS - void _M_incr() { __add_and_fetch(&_M_ref_count, 1); } - _RC_t _M_decr() { return __add_and_fetch(&_M_ref_count, (size_t) -1); } -# elif defined (__STL_WIN32THREADS) - void _M_incr() { InterlockedIncrement((_RC_t*)&_M_ref_count); } - _RC_t _M_decr() { return InterlockedDecrement((_RC_t*)&_M_ref_count); } -# elif defined(__STL_PTHREADS) - void _M_incr() { - pthread_mutex_lock(&_M_ref_count_lock); - ++_M_ref_count; - pthread_mutex_unlock(&_M_ref_count_lock); - } - _RC_t _M_decr() { - pthread_mutex_lock(&_M_ref_count_lock); - volatile _RC_t __tmp = --_M_ref_count; - pthread_mutex_unlock(&_M_ref_count_lock); - return __tmp; - } -# elif defined(__STL_UITHREADS) - void _M_incr() { - mutex_lock(&_M_ref_count_lock); - ++_M_ref_count; - mutex_unlock(&_M_ref_count_lock); - } - _RC_t _M_decr() { - mutex_lock(&_M_ref_count_lock); - /*volatile*/ _RC_t __tmp = --_M_ref_count; - mutex_unlock(&_M_ref_count_lock); - return __tmp; - } -# else /* No threads */ - void _M_incr() { ++_M_ref_count; } - _RC_t _M_decr() { return --_M_ref_count; } -# endif -}; - -// Atomic swap on unsigned long -// This is guaranteed to behave as though it were atomic only if all -// possibly concurrent updates use _Atomic_swap. -// In some cases the operation is emulated with a lock. -# ifdef __STL_SGI_THREADS - inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { -# if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) - return test_and_set(__p, __q); -# else - return __test_and_set(__p, (unsigned long)__q); -# endif - } -# elif defined(__STL_WIN32THREADS) - inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { - return (unsigned long) InterlockedExchange((LPLONG)__p, (LONG)__q); - } -# elif defined(__STL_PTHREADS) - // We use a template here only to get a unique initialized instance. - template - struct _Swap_lock_struct { - static pthread_mutex_t _S_swap_lock; - }; - - template - pthread_mutex_t - _Swap_lock_struct<__dummy>::_S_swap_lock = PTHREAD_MUTEX_INITIALIZER; - - // This should be portable, but performance is expected - // to be quite awful. This really needs platform specific - // code. - inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { - pthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock); - unsigned long __result = *__p; - *__p = __q; - pthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock); - return __result; - } -# elif defined(__STL_UITHREADS) - // We use a template here only to get a unique initialized instance. - template - struct _Swap_lock_struct { - static mutex_t _S_swap_lock; - }; - - template - mutex_t - _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX; - - // This should be portable, but performance is expected - // to be quite awful. This really needs platform specific - // code. - inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { - mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock); - unsigned long __result = *__p; - *__p = __q; - mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock); - return __result; - } -# elif defined (__STL_SOLARIS_THREADS) - // any better solutions ? - // We use a template here only to get a unique initialized instance. - template - struct _Swap_lock_struct { - static mutex_t _S_swap_lock; - }; - -# if ( __STL_STATIC_TEMPLATE_DATA > 0 ) - template - mutex_t - _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX; -# else - __DECLARE_INSTANCE(mutex_t, _Swap_lock_struct<__dummy>::_S_swap_lock, - =DEFAULTMUTEX); -# endif /* ( __STL_STATIC_TEMPLATE_DATA > 0 ) */ - - // This should be portable, but performance is expected - // to be quite awful. This really needs platform specific - // code. - inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { - mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock); - unsigned long __result = *__p; - *__p = __q; - mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock); - return __result; - } -# else - static inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) { - unsigned long __result = *__p; - *__p = __q; - return __result; - } -# endif - -// Locking class. Note that this class *does not have a constructor*. -// It must be initialized either statically, with __STL_MUTEX_INITIALIZER, -// or dynamically, by explicitly calling the _M_initialize member function. -// (This is similar to the ways that a pthreads mutex can be initialized.) -// There are explicit member functions for acquiring and releasing the lock. - -// There is no constructor because static initialization is essential for -// some uses, and only a class aggregate (see section 8.5.1 of the C++ -// standard) can be initialized that way. That means we must have no -// constructors, no base classes, no virtual functions, and no private or -// protected members. - -// Helper struct. This is a workaround for various compilers that don't -// handle static variables in inline functions properly. -template -struct _STL_mutex_spin { - enum { __low_max = 30, __high_max = 1000 }; - // Low if we suspect uniprocessor, high for multiprocessor. - - static unsigned __max; - static unsigned __last; -}; - -template -unsigned _STL_mutex_spin<__inst>::__max = _STL_mutex_spin<__inst>::__low_max; - -template -unsigned _STL_mutex_spin<__inst>::__last = 0; - -struct _STL_mutex_lock -{ -#if defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS) - // It should be relatively easy to get this to work on any modern Unix. - volatile unsigned long _M_lock; - void _M_initialize() { _M_lock = 0; } - static void _S_nsec_sleep(int __log_nsec) { -# ifdef __STL_SGI_THREADS - struct timespec __ts; - /* Max sleep is 2**27nsec ~ 60msec */ - __ts.tv_sec = 0; - __ts.tv_nsec = 1 << __log_nsec; - nanosleep(&__ts, 0); -# elif defined(__STL_WIN32THREADS) - if (__log_nsec <= 20) { - Sleep(0); - } else { - Sleep(1 << (__log_nsec - 20)); - } -# else -# error unimplemented -# endif - } - void _M_acquire_lock() { - volatile unsigned long* __lock = &this->_M_lock; - - if (!_Atomic_swap((unsigned long*)__lock, 1)) { - return; - } - unsigned __my_spin_max = _STL_mutex_spin<0>::__max; - unsigned __my_last_spins = _STL_mutex_spin<0>::__last; - volatile unsigned __junk = 17; // Value doesn't matter. - unsigned __i; - for (__i = 0; __i < __my_spin_max; __i++) { - if (__i < __my_last_spins/2 || *__lock) { - __junk *= __junk; __junk *= __junk; - __junk *= __junk; __junk *= __junk; - continue; - } - if (!_Atomic_swap((unsigned long*)__lock, 1)) { - // got it! - // Spinning worked. Thus we're probably not being scheduled - // against the other process with which we were contending. - // Thus it makes sense to spin longer the next time. - _STL_mutex_spin<0>::__last = __i; - _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__high_max; - return; - } - } - // We are probably being scheduled against the other process. Sleep. - _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__low_max; - for (__i = 0 ;; ++__i) { - int __log_nsec = __i + 6; - - if (__log_nsec > 27) __log_nsec = 27; - if (!_Atomic_swap((unsigned long *)__lock, 1)) { - return; - } - _S_nsec_sleep(__log_nsec); - } - } - void _M_release_lock() { - volatile unsigned long* __lock = &_M_lock; -# if defined(__STL_SGI_THREADS) && defined(__GNUC__) && __mips >= 3 - asm("sync"); - *__lock = 0; -# elif defined(__STL_SGI_THREADS) && __mips >= 3 \ - && (defined (_ABIN32) || defined(_ABI64)) - __lock_release(__lock); -# else - *__lock = 0; - // This is not sufficient on many multiprocessors, since - // writes to protected variables and the lock may be reordered. -# endif - } - -// We no longer use win32 critical sections. -// They appear to be slower in the contention-free case, -// and they appear difficult to initialize without introducing a race. - -#elif defined(__STL_PTHREADS) - pthread_mutex_t _M_lock; - void _M_initialize() { pthread_mutex_init(&_M_lock, NULL); } - void _M_acquire_lock() { pthread_mutex_lock(&_M_lock); } - void _M_release_lock() { pthread_mutex_unlock(&_M_lock); } -#elif defined(__STL_UITHREADS) - mutex_t _M_lock; - void _M_initialize() { mutex_init(&_M_lock, USYNC_THREAD, 0); } - void _M_acquire_lock() { mutex_lock(&_M_lock); } - void _M_release_lock() { mutex_unlock(&_M_lock); } -#else /* No threads */ - void _M_initialize() {} - void _M_acquire_lock() {} - void _M_release_lock() {} -#endif -}; - -#ifdef __STL_PTHREADS -// Pthreads locks must be statically initialized to something other than -// the default value of zero. -# define __STL_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER } -#elif defined(__STL_UITHREADS) -// UIthreads locks must be statically initialized to something other than -// the default value of zero. -# define __STL_MUTEX_INITIALIZER = { DEFAULTMUTEX } -#elif defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS) -# define __STL_MUTEX_INITIALIZER = { 0 } -#else -# define __STL_MUTEX_INITIALIZER -#endif - - -// A locking class that uses _STL_mutex_lock. The constructor takes a -// reference to an _STL_mutex_lock, and acquires a lock. The -// destructor releases the lock. It's not clear that this is exactly -// the right functionality. It will probably change in the future. - -struct _STL_auto_lock -{ - _STL_mutex_lock& _M_lock; - - _STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock) - { _M_lock._M_acquire_lock(); } - ~_STL_auto_lock() { _M_lock._M_release_lock(); } - -private: - void operator=(const _STL_auto_lock&); - _STL_auto_lock(const _STL_auto_lock&); -}; - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_THREADS_H */ - -// Local Variables: -// mode:C++ -// End: - - - - - diff --git a/libstdc++-v3/bits/stl_tree.h b/libstdc++-v3/bits/stl_tree.h deleted file mode 100644 index 1c78fd2aa45..00000000000 --- a/libstdc++-v3/bits/stl_tree.h +++ /dev/null @@ -1,1370 +0,0 @@ -/* - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - * Copyright (c) 1994 - * Hewlett-Packard Company - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Hewlett-Packard Company makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - * - * - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_TREE_H -#define __SGI_STL_INTERNAL_TREE_H - -/* - -Red-black tree class, designed for use in implementing STL -associative containers (set, multiset, map, and multimap). The -insertion and deletion algorithms are based on those in Cormen, -Leiserson, and Rivest, Introduction to Algorithms (MIT Press, 1990), -except that - -(1) the header cell is maintained with links not only to the root -but also to the leftmost node of the tree, to enable constant time -begin(), and to the rightmost node of the tree, to enable linear time -performance when used with the generic set algorithms (set_union, -etc.); - -(2) when a node being deleted has two children its successor node is -relinked into its place, rather than copied, so that the only -iterators invalidated are those referring to the deleted node. - -*/ - -#include -#include -#include -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1375 -#endif - -typedef bool _Rb_tree_Color_type; -const _Rb_tree_Color_type _S_rb_tree_red = false; -const _Rb_tree_Color_type _S_rb_tree_black = true; - -struct _Rb_tree_node_base -{ - typedef _Rb_tree_Color_type _Color_type; - typedef _Rb_tree_node_base* _Base_ptr; - - _Color_type _M_color; - _Base_ptr _M_parent; - _Base_ptr _M_left; - _Base_ptr _M_right; - - static _Base_ptr _S_minimum(_Base_ptr __x) - { - while (__x->_M_left != 0) __x = __x->_M_left; - return __x; - } - - static _Base_ptr _S_maximum(_Base_ptr __x) - { - while (__x->_M_right != 0) __x = __x->_M_right; - return __x; - } -}; - -template -struct _Rb_tree_node : public _Rb_tree_node_base -{ - typedef _Rb_tree_node<_Value>* _Link_type; - _Value _M_value_field; -}; - - -struct _Rb_tree_base_iterator -{ - typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; - typedef bidirectional_iterator_tag iterator_category; - typedef ptrdiff_t difference_type; - _Base_ptr _M_node; - - void _M_increment() - { - if (_M_node->_M_right != 0) { - _M_node = _M_node->_M_right; - while (_M_node->_M_left != 0) - _M_node = _M_node->_M_left; - } - else { - _Base_ptr __y = _M_node->_M_parent; - while (_M_node == __y->_M_right) { - _M_node = __y; - __y = __y->_M_parent; - } - if (_M_node->_M_right != __y) - _M_node = __y; - } - } - - void _M_decrement() - { - if (_M_node->_M_color == _S_rb_tree_red && - _M_node->_M_parent->_M_parent == _M_node) - _M_node = _M_node->_M_right; - else if (_M_node->_M_left != 0) { - _Base_ptr __y = _M_node->_M_left; - while (__y->_M_right != 0) - __y = __y->_M_right; - _M_node = __y; - } - else { - _Base_ptr __y = _M_node->_M_parent; - while (_M_node == __y->_M_left) { - _M_node = __y; - __y = __y->_M_parent; - } - _M_node = __y; - } - } -}; - -template -struct _Rb_tree_iterator : public _Rb_tree_base_iterator -{ - typedef _Value value_type; - typedef _Ref reference; - typedef _Ptr pointer; - typedef _Rb_tree_iterator<_Value, _Value&, _Value*> - iterator; - typedef _Rb_tree_iterator<_Value, const _Value&, const _Value*> - const_iterator; - typedef _Rb_tree_iterator<_Value, _Ref, _Ptr> - _Self; - typedef _Rb_tree_node<_Value>* _Link_type; - - _Rb_tree_iterator() {} - _Rb_tree_iterator(_Link_type __x) { _M_node = __x; } - _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; } - - reference operator*() const { return _Link_type(_M_node)->_M_value_field; } -#ifndef __SGI_STL_NO_ARROW_OPERATOR - pointer operator->() const { return &(operator*()); } -#endif /* __SGI_STL_NO_ARROW_OPERATOR */ - - _Self& operator++() { _M_increment(); return *this; } - _Self operator++(int) { - _Self __tmp = *this; - _M_increment(); - return __tmp; - } - - _Self& operator--() { _M_decrement(); return *this; } - _Self operator--(int) { - _Self __tmp = *this; - _M_decrement(); - return __tmp; - } -}; - -template -inline bool operator==(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x, - const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) { - return __x._M_node == __y._M_node; -} - -template -inline bool operator!=(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x, - const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) { - return __x._M_node != __y._M_node; -} - -#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION - -inline bidirectional_iterator_tag -iterator_category(const _Rb_tree_base_iterator&) { - return bidirectional_iterator_tag(); -} - -inline _Rb_tree_base_iterator::difference_type* -distance_type(const _Rb_tree_base_iterator&) { - return (_Rb_tree_base_iterator::difference_type*) 0; -} - -template -inline _Value* value_type(const _Rb_tree_iterator<_Value, _Ref, _Ptr>&) { - return (_Value*) 0; -} - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -inline void -_Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root) -{ - _Rb_tree_node_base* __y = __x->_M_right; - __x->_M_right = __y->_M_left; - if (__y->_M_left !=0) - __y->_M_left->_M_parent = __x; - __y->_M_parent = __x->_M_parent; - - if (__x == __root) - __root = __y; - else if (__x == __x->_M_parent->_M_left) - __x->_M_parent->_M_left = __y; - else - __x->_M_parent->_M_right = __y; - __y->_M_left = __x; - __x->_M_parent = __y; -} - -inline void -_Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root) -{ - _Rb_tree_node_base* __y = __x->_M_left; - __x->_M_left = __y->_M_right; - if (__y->_M_right != 0) - __y->_M_right->_M_parent = __x; - __y->_M_parent = __x->_M_parent; - - if (__x == __root) - __root = __y; - else if (__x == __x->_M_parent->_M_right) - __x->_M_parent->_M_right = __y; - else - __x->_M_parent->_M_left = __y; - __y->_M_right = __x; - __x->_M_parent = __y; -} - -inline void -_Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root) -{ - __x->_M_color = _S_rb_tree_red; - while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) { - if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) { - _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right; - if (__y && __y->_M_color == _S_rb_tree_red) { - __x->_M_parent->_M_color = _S_rb_tree_black; - __y->_M_color = _S_rb_tree_black; - __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red; - __x = __x->_M_parent->_M_parent; - } - else { - if (__x == __x->_M_parent->_M_right) { - __x = __x->_M_parent; - _Rb_tree_rotate_left(__x, __root); - } - __x->_M_parent->_M_color = _S_rb_tree_black; - __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root); - } - } - else { - _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left; - if (__y && __y->_M_color == _S_rb_tree_red) { - __x->_M_parent->_M_color = _S_rb_tree_black; - __y->_M_color = _S_rb_tree_black; - __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red; - __x = __x->_M_parent->_M_parent; - } - else { - if (__x == __x->_M_parent->_M_left) { - __x = __x->_M_parent; - _Rb_tree_rotate_right(__x, __root); - } - __x->_M_parent->_M_color = _S_rb_tree_black; - __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root); - } - } - } - __root->_M_color = _S_rb_tree_black; -} - -inline _Rb_tree_node_base* -_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z, - _Rb_tree_node_base*& __root, - _Rb_tree_node_base*& __leftmost, - _Rb_tree_node_base*& __rightmost) -{ - _Rb_tree_node_base* __y = __z; - _Rb_tree_node_base* __x = 0; - _Rb_tree_node_base* __x_parent = 0; - if (__y->_M_left == 0) // __z has at most one non-null child. y == z. - __x = __y->_M_right; // __x might be null. - else - if (__y->_M_right == 0) // __z has exactly one non-null child. y == z. - __x = __y->_M_left; // __x is not null. - else { // __z has two non-null children. Set __y to - __y = __y->_M_right; // __z's successor. __x might be null. - while (__y->_M_left != 0) - __y = __y->_M_left; - __x = __y->_M_right; - } - if (__y != __z) { // relink y in place of z. y is z's successor - __z->_M_left->_M_parent = __y; - __y->_M_left = __z->_M_left; - if (__y != __z->_M_right) { - __x_parent = __y->_M_parent; - if (__x) __x->_M_parent = __y->_M_parent; - __y->_M_parent->_M_left = __x; // __y must be a child of _M_left - __y->_M_right = __z->_M_right; - __z->_M_right->_M_parent = __y; - } - else - __x_parent = __y; - if (__root == __z) - __root = __y; - else if (__z->_M_parent->_M_left == __z) - __z->_M_parent->_M_left = __y; - else - __z->_M_parent->_M_right = __y; - __y->_M_parent = __z->_M_parent; - __STD::swap(__y->_M_color, __z->_M_color); - __y = __z; - // __y now points to node to be actually deleted - } - else { // __y == __z - __x_parent = __y->_M_parent; - if (__x) __x->_M_parent = __y->_M_parent; - if (__root == __z) - __root = __x; - else - if (__z->_M_parent->_M_left == __z) - __z->_M_parent->_M_left = __x; - else - __z->_M_parent->_M_right = __x; - if (__leftmost == __z) - if (__z->_M_right == 0) // __z->_M_left must be null also - __leftmost = __z->_M_parent; - // makes __leftmost == _M_header if __z == __root - else - __leftmost = _Rb_tree_node_base::_S_minimum(__x); - if (__rightmost == __z) - if (__z->_M_left == 0) // __z->_M_right must be null also - __rightmost = __z->_M_parent; - // makes __rightmost == _M_header if __z == __root - else // __x == __z->_M_left - __rightmost = _Rb_tree_node_base::_S_maximum(__x); - } - if (__y->_M_color != _S_rb_tree_red) { - while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black)) - if (__x == __x_parent->_M_left) { - _Rb_tree_node_base* __w = __x_parent->_M_right; - if (__w->_M_color == _S_rb_tree_red) { - __w->_M_color = _S_rb_tree_black; - __x_parent->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_left(__x_parent, __root); - __w = __x_parent->_M_right; - } - if ((__w->_M_left == 0 || - __w->_M_left->_M_color == _S_rb_tree_black) && - (__w->_M_right == 0 || - __w->_M_right->_M_color == _S_rb_tree_black)) { - __w->_M_color = _S_rb_tree_red; - __x = __x_parent; - __x_parent = __x_parent->_M_parent; - } else { - if (__w->_M_right == 0 || - __w->_M_right->_M_color == _S_rb_tree_black) { - if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black; - __w->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_right(__w, __root); - __w = __x_parent->_M_right; - } - __w->_M_color = __x_parent->_M_color; - __x_parent->_M_color = _S_rb_tree_black; - if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black; - _Rb_tree_rotate_left(__x_parent, __root); - break; - } - } else { // same as above, with _M_right <-> _M_left. - _Rb_tree_node_base* __w = __x_parent->_M_left; - if (__w->_M_color == _S_rb_tree_red) { - __w->_M_color = _S_rb_tree_black; - __x_parent->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_right(__x_parent, __root); - __w = __x_parent->_M_left; - } - if ((__w->_M_right == 0 || - __w->_M_right->_M_color == _S_rb_tree_black) && - (__w->_M_left == 0 || - __w->_M_left->_M_color == _S_rb_tree_black)) { - __w->_M_color = _S_rb_tree_red; - __x = __x_parent; - __x_parent = __x_parent->_M_parent; - } else { - if (__w->_M_left == 0 || - __w->_M_left->_M_color == _S_rb_tree_black) { - if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black; - __w->_M_color = _S_rb_tree_red; - _Rb_tree_rotate_left(__w, __root); - __w = __x_parent->_M_left; - } - __w->_M_color = __x_parent->_M_color; - __x_parent->_M_color = _S_rb_tree_black; - if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black; - _Rb_tree_rotate_right(__x_parent, __root); - break; - } - } - if (__x) __x->_M_color = _S_rb_tree_black; - } - return __y; -} - -// Base class to encapsulate the differences between old SGI-style -// allocators and standard-conforming allocators. In order to avoid -// having an empty base class, we arbitrarily move one of rb_tree's -// data members into the base class. - -#ifdef __STL_USE_STD_ALLOCATORS - -// _Base for general standard-conforming allocators. -template -class _Rb_tree_alloc_base { -public: - typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type; - allocator_type get_allocator() const { return _M_node_allocator; } - - _Rb_tree_alloc_base(const allocator_type& __a) - : _M_node_allocator(__a), _M_header(0) {} - -protected: - typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::allocator_type - _M_node_allocator; - _Rb_tree_node<_Tp>* _M_header; - - _Rb_tree_node<_Tp>* _M_get_node() - { return _M_node_allocator.allocate(1); } - void _M_put_node(_Rb_tree_node<_Tp>* __p) - { _M_node_allocator.deallocate(__p, 1); } -}; - -// Specialization for instanceless allocators. -template -class _Rb_tree_alloc_base<_Tp, _Alloc, true> { -public: - typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {} - -protected: - _Rb_tree_node<_Tp>* _M_header; - - typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type - _Alloc_type; - - _Rb_tree_node<_Tp>* _M_get_node() - { return _Alloc_type::allocate(1); } - void _M_put_node(_Rb_tree_node<_Tp>* __p) - { _Alloc_type::deallocate(__p, 1); } -}; - -template -struct _Rb_tree_base - : public _Rb_tree_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> -{ - typedef _Rb_tree_alloc_base<_Tp, _Alloc, - _Alloc_traits<_Tp, _Alloc>::_S_instanceless> - _Base; - typedef typename _Base::allocator_type allocator_type; - - _Rb_tree_base(const allocator_type& __a) - : _Base(__a) { _M_header = _M_get_node(); } - ~_Rb_tree_base() { _M_put_node(_M_header); } - -}; - -#else /* __STL_USE_STD_ALLOCATORS */ - -template -struct _Rb_tree_base -{ - typedef _Alloc allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Rb_tree_base(const allocator_type&) - : _M_header(0) { _M_header = _M_get_node(); } - ~_Rb_tree_base() { _M_put_node(_M_header); } - -protected: - _Rb_tree_node<_Tp>* _M_header; - - typedef simple_alloc<_Rb_tree_node<_Tp>, _Alloc> _Alloc_type; - - _Rb_tree_node<_Tp>* _M_get_node() - { return _Alloc_type::allocate(1); } - void _M_put_node(_Rb_tree_node<_Tp>* __p) - { _Alloc_type::deallocate(__p, 1); } -}; - -#endif /* __STL_USE_STD_ALLOCATORS */ - -template > -class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> { - typedef _Rb_tree_base<_Value, _Alloc> _Base; -protected: - typedef _Rb_tree_node_base* _Base_ptr; - typedef _Rb_tree_node<_Value> _Rb_tree_node; - typedef _Rb_tree_Color_type _Color_type; -public: - typedef _Key key_type; - typedef _Value value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef _Rb_tree_node* _Link_type; - 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(); } - -protected: -#ifdef __STL_USE_NAMESPACES - using _Base::_M_get_node; - using _Base::_M_put_node; - using _Base::_M_header; -#endif /* __STL_USE_NAMESPACES */ - -protected: - - _Link_type _M_create_node(const value_type& __x) - { - _Link_type __tmp = _M_get_node(); - __STL_TRY { - construct(&__tmp->_M_value_field, __x); - } - __STL_UNWIND(_M_put_node(__tmp)); - return __tmp; - } - - _Link_type _M_clone_node(_Link_type __x) - { - _Link_type __tmp = _M_create_node(__x->_M_value_field); - __tmp->_M_color = __x->_M_color; - __tmp->_M_left = 0; - __tmp->_M_right = 0; - return __tmp; - } - - void destroy_node(_Link_type __p) - { - destroy(&__p->_M_value_field); - _M_put_node(__p); - } - -protected: - size_type _M_node_count; // keeps track of size of tree - _Compare _M_key_compare; - - _Link_type& _M_root() const - { return (_Link_type&) _M_header->_M_parent; } - _Link_type& _M_leftmost() const - { return (_Link_type&) _M_header->_M_left; } - _Link_type& _M_rightmost() const - { return (_Link_type&) _M_header->_M_right; } - - static _Link_type& _S_left(_Link_type __x) - { return (_Link_type&)(__x->_M_left); } - static _Link_type& _S_right(_Link_type __x) - { return (_Link_type&)(__x->_M_right); } - static _Link_type& _S_parent(_Link_type __x) - { return (_Link_type&)(__x->_M_parent); } - static reference _S_value(_Link_type __x) - { return __x->_M_value_field; } - static const _Key& _S_key(_Link_type __x) - { return _KeyOfValue()(_S_value(__x)); } - static _Color_type& _S_color(_Link_type __x) - { return (_Color_type&)(__x->_M_color); } - - static _Link_type& _S_left(_Base_ptr __x) - { return (_Link_type&)(__x->_M_left); } - static _Link_type& _S_right(_Base_ptr __x) - { return (_Link_type&)(__x->_M_right); } - static _Link_type& _S_parent(_Base_ptr __x) - { return (_Link_type&)(__x->_M_parent); } - static reference _S_value(_Base_ptr __x) - { return ((_Link_type)__x)->_M_value_field; } - static const _Key& _S_key(_Base_ptr __x) - { return _KeyOfValue()(_S_value(_Link_type(__x)));} - static _Color_type& _S_color(_Base_ptr __x) - { return (_Color_type&)(_Link_type(__x)->_M_color); } - - static _Link_type _S_minimum(_Link_type __x) - { return (_Link_type) _Rb_tree_node_base::_S_minimum(__x); } - - static _Link_type _S_maximum(_Link_type __x) - { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); } - -public: - typedef _Rb_tree_iterator iterator; - typedef _Rb_tree_iterator - const_iterator; - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - typedef reverse_bidirectional_iterator - reverse_iterator; - typedef reverse_bidirectional_iterator - const_reverse_iterator; -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -private: - iterator _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v); - _Link_type _M_copy(_Link_type __x, _Link_type __p); - void _M_erase(_Link_type __x); - -public: - // allocation/deallocation - _Rb_tree() - : _Base(allocator_type()), _M_node_count(0), _M_key_compare() - { _M_empty_initialize(); } - - _Rb_tree(const _Compare& __comp) - : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp) - { _M_empty_initialize(); } - - _Rb_tree(const _Compare& __comp, const allocator_type& __a) - : _Base(__a), _M_node_count(0), _M_key_compare(__comp) - { _M_empty_initialize(); } - - _Rb_tree(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x) - : _Base(__x.get_allocator()), - _M_node_count(0), _M_key_compare(__x._M_key_compare) - { - if (__x._M_root() == 0) - _M_empty_initialize(); - else { - _S_color(_M_header) = _S_rb_tree_red; - _M_root() = _M_copy(__x._M_root(), _M_header); - _M_leftmost() = _S_minimum(_M_root()); - _M_rightmost() = _S_maximum(_M_root()); - } - _M_node_count = __x._M_node_count; - } - ~_Rb_tree() { clear(); } - _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& - operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x); - -private: - void _M_empty_initialize() { - _S_color(_M_header) = _S_rb_tree_red; // used to distinguish header from - // __root, in iterator.operator++ - _M_root() = 0; - _M_leftmost() = _M_header; - _M_rightmost() = _M_header; - } - -public: - // accessors: - _Compare key_comp() const { return _M_key_compare; } - iterator begin() { return _M_leftmost(); } - const_iterator begin() const { return _M_leftmost(); } - iterator end() { return _M_header; } - const_iterator end() const { return _M_header; } - 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_count == 0; } - size_type size() const { return _M_node_count; } - size_type max_size() const { return size_type(-1); } - - void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) { - __STD::swap(_M_header, __t._M_header); - __STD::swap(_M_node_count, __t._M_node_count); - __STD::swap(_M_key_compare, __t._M_key_compare); - } - -public: - // insert/erase - pair insert_unique(const value_type& __x); - iterator insert_equal(const value_type& __x); - - iterator insert_unique(iterator __position, const value_type& __x); - iterator insert_equal(iterator __position, const value_type& __x); - -#ifdef __STL_MEMBER_TEMPLATES - template - void insert_unique(_InputIterator __first, _InputIterator __last); - template - void insert_equal(_InputIterator __first, _InputIterator __last); -#else /* __STL_MEMBER_TEMPLATES */ - void insert_unique(const_iterator __first, const_iterator __last); - void insert_unique(const value_type* __first, const value_type* __last); - void insert_equal(const_iterator __first, const_iterator __last); - void insert_equal(const value_type* __first, const value_type* __last); -#endif /* __STL_MEMBER_TEMPLATES */ - - void erase(iterator __position); - size_type erase(const key_type& __x); - void erase(iterator __first, iterator __last); - void erase(const key_type* __first, const key_type* __last); - void clear() { - if (_M_node_count != 0) { - _M_erase(_M_root()); - _M_leftmost() = _M_header; - _M_root() = 0; - _M_rightmost() = _M_header; - _M_node_count = 0; - } - } - -public: - // set operations: - iterator find(const key_type& __x); - const_iterator find(const key_type& __x) const; - size_type count(const key_type& __x) const; - iterator lower_bound(const key_type& __x); - const_iterator lower_bound(const key_type& __x) const; - iterator upper_bound(const key_type& __x); - const_iterator upper_bound(const key_type& __x) const; - pair equal_range(const key_type& __x); - pair equal_range(const key_type& __x) const; - -public: - // Debugging. - bool __rb_verify() const; -}; - -template -inline bool -operator==(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) -{ - return __x.size() == __y.size() && - equal(__x.begin(), __x.end(), __y.begin()); -} - -template -inline bool -operator<(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) -{ - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline bool -operator!=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool -operator>(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) { - return __y < __x; -} - -template -inline bool -operator<=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool -operator>=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) { - return !(__x < __y); -} - - -template -inline void -swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x, - _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) -{ - __x.swap(__y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - - -template -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x) -{ - if (this != &__x) { - // Note that _Key may be a constant type. - clear(); - _M_node_count = 0; - _M_key_compare = __x._M_key_compare; - if (__x._M_root() == 0) { - _M_root() = 0; - _M_leftmost() = _M_header; - _M_rightmost() = _M_header; - } - else { - _M_root() = _M_copy(__x._M_root(), _M_header); - _M_leftmost() = _S_minimum(_M_root()); - _M_rightmost() = _S_maximum(_M_root()); - _M_node_count = __x._M_node_count; - } - } - return *this; -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v) -{ - _Link_type __x = (_Link_type) __x_; - _Link_type __y = (_Link_type) __y_; - _Link_type __z; - - if (__y == _M_header || __x != 0 || - _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) { - __z = _M_create_node(__v); - _S_left(__y) = __z; // also makes _M_leftmost() = __z - // when __y == _M_header - if (__y == _M_header) { - _M_root() = __z; - _M_rightmost() = __z; - } - else if (__y == _M_leftmost()) - _M_leftmost() = __z; // maintain _M_leftmost() pointing to min node - } - else { - __z = _M_create_node(__v); - _S_right(__y) = __z; - if (__y == _M_rightmost()) - _M_rightmost() = __z; // maintain _M_rightmost() pointing to max node - } - _S_parent(__z) = __y; - _S_left(__z) = 0; - _S_right(__z) = 0; - _Rb_tree_rebalance(__z, _M_header->_M_parent); - ++_M_node_count; - return iterator(__z); -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::insert_equal(const _Value& __v) -{ - _Link_type __y = _M_header; - _Link_type __x = _M_root(); - while (__x != 0) { - __y = __x; - __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ? - _S_left(__x) : _S_right(__x); - } - return _M_insert(__x, __y, __v); -} - - -template -pair::iterator, - bool> -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::insert_unique(const _Value& __v) -{ - _Link_type __y = _M_header; - _Link_type __x = _M_root(); - bool __comp = true; - while (__x != 0) { - __y = __x; - __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)); - __x = __comp ? _S_left(__x) : _S_right(__x); - } - iterator __j = iterator(__y); - if (__comp) - if (__j == begin()) - return pair(_M_insert(__x, __y, __v), true); - else - --__j; - if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v))) - return pair(_M_insert(__x, __y, __v), true); - return pair(__j, false); -} - - -template -typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator -_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc> - ::insert_unique(iterator __position, const _Val& __v) -{ - if (__position._M_node == _M_header->_M_left) { // begin() - if (size() > 0 && - _M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) - return _M_insert(__position._M_node, __position._M_node, __v); - // first argument just needs to be non-null - else - return insert_unique(__v).first; - } else if (__position._M_node == _M_header) { // end() - if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v))) - return _M_insert(0, _M_rightmost(), __v); - else - return insert_unique(__v).first; - } else { - iterator __before = __position; - --__before; - if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v)) - && _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node))) { - if (_S_right(__before._M_node) == 0) - return _M_insert(0, __before._M_node, __v); - else - return _M_insert(__position._M_node, __position._M_node, __v); - // first argument just needs to be non-null - } else - return insert_unique(__v).first; - } -} - -template -typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc> - ::insert_equal(iterator __position, const _Val& __v) -{ - if (__position._M_node == _M_header->_M_left) { // begin() - if (size() > 0 && - !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) - return _M_insert(__position._M_node, __position._M_node, __v); - // first argument just needs to be non-null - else - return insert_equal(__v); - } else if (__position._M_node == _M_header) {// end() - if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost()))) - return _M_insert(0, _M_rightmost(), __v); - else - return insert_equal(__v); - } else { - iterator __before = __position; - --__before; - if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node)) - && !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) { - if (_S_right(__before._M_node) == 0) - return _M_insert(0, __before._M_node, __v); - else - return _M_insert(__position._M_node, __position._M_node, __v); - // first argument just needs to be non-null - } else - return insert_equal(__v); - } -} - -#ifdef __STL_MEMBER_TEMPLATES - -template - template -void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_equal(_II __first, _II __last) -{ - for ( ; __first != __last; ++__first) - insert_equal(*__first); -} - -template - template -void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_unique(_II __first, _II __last) { - for ( ; __first != __last; ++__first) - insert_unique(*__first); -} - -#else /* __STL_MEMBER_TEMPLATES */ - -template -void -_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_equal(const _Val* __first, const _Val* __last) -{ - for ( ; __first != __last; ++__first) - insert_equal(*__first); -} - -template -void -_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_equal(const_iterator __first, const_iterator __last) -{ - for ( ; __first != __last; ++__first) - insert_equal(*__first); -} - -template -void -_Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_unique(const _Val* __first, const _Val* __last) -{ - for ( ; __first != __last; ++__first) - insert_unique(*__first); -} - -template -void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc> - ::insert_unique(const_iterator __first, const_iterator __last) -{ - for ( ; __first != __last; ++__first) - insert_unique(*__first); -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::erase(iterator __position) -{ - _Link_type __y = - (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node, - _M_header->_M_parent, - _M_header->_M_left, - _M_header->_M_right); - destroy_node(__y); - --_M_node_count; -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x) -{ - pair __p = equal_range(__x); - size_type __n = 0; - distance(__p.first, __p.second, __n); - erase(__p.first, __p.second); - return __n; -} - -template -typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type -_Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc> - ::_M_copy(_Link_type __x, _Link_type __p) -{ - // structural copy. __x and __p must be non-null. - _Link_type __top = _M_clone_node(__x); - __top->_M_parent = __p; - - __STL_TRY { - if (__x->_M_right) - __top->_M_right = _M_copy(_S_right(__x), __top); - __p = __top; - __x = _S_left(__x); - - while (__x != 0) { - _Link_type __y = _M_clone_node(__x); - __p->_M_left = __y; - __y->_M_parent = __p; - if (__x->_M_right) - __y->_M_right = _M_copy(_S_right(__x), __y); - __p = __y; - __x = _S_left(__x); - } - } - __STL_UNWIND(_M_erase(__top)); - - return __top; -} - -template -void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::_M_erase(_Link_type __x) -{ - // erase without rebalancing - while (__x != 0) { - _M_erase(_S_right(__x)); - _Link_type __y = _S_left(__x); - destroy_node(__x); - __x = __y; - } -} - -template -void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::erase(iterator __first, iterator __last) -{ - if (__first == begin() && __last == end()) - clear(); - else - while (__first != __last) erase(__first++); -} - -template -void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::erase(const _Key* __first, const _Key* __last) -{ - while (__first != __last) erase(*__first++); -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) -{ - _Link_type __y = _M_header; // Last node which is not less than __k. - _Link_type __x = _M_root(); // Current node. - - while (__x != 0) - if (!_M_key_compare(_S_key(__x), __k)) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - - iterator __j = iterator(__y); - return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ? - end() : __j; -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) const -{ - _Link_type __y = _M_header; /* Last node which is not less than __k. */ - _Link_type __x = _M_root(); /* Current node. */ - - while (__x != 0) { - if (!_M_key_compare(_S_key(__x), __k)) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - } - const_iterator __j = const_iterator(__y); - return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ? - end() : __j; -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::count(const _Key& __k) const -{ - pair __p = equal_range(__k); - size_type __n = 0; - distance(__p.first, __p.second, __n); - return __n; -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::lower_bound(const _Key& __k) -{ - _Link_type __y = _M_header; /* Last node which is not less than __k. */ - _Link_type __x = _M_root(); /* Current node. */ - - while (__x != 0) - if (!_M_key_compare(_S_key(__x), __k)) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - - return iterator(__y); -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::lower_bound(const _Key& __k) const -{ - _Link_type __y = _M_header; /* Last node which is not less than __k. */ - _Link_type __x = _M_root(); /* Current node. */ - - while (__x != 0) - if (!_M_key_compare(_S_key(__x), __k)) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - - return const_iterator(__y); -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::upper_bound(const _Key& __k) -{ - _Link_type __y = _M_header; /* Last node which is greater than __k. */ - _Link_type __x = _M_root(); /* Current node. */ - - while (__x != 0) - if (_M_key_compare(__k, _S_key(__x))) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - - return iterator(__y); -} - -template -typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::upper_bound(const _Key& __k) const -{ - _Link_type __y = _M_header; /* Last node which is greater than __k. */ - _Link_type __x = _M_root(); /* Current node. */ - - while (__x != 0) - if (_M_key_compare(__k, _S_key(__x))) - __y = __x, __x = _S_left(__x); - else - __x = _S_right(__x); - - return const_iterator(__y); -} - -template -inline -pair::iterator, - typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator> -_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> - ::equal_range(const _Key& __k) -{ - return pair(lower_bound(__k), upper_bound(__k)); -} - -template -inline -pair::const_iterator, - typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator> -_Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc> - ::equal_range(const _Key& __k) const -{ - return pair(lower_bound(__k), - upper_bound(__k)); -} - -inline int -__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root) -{ - if (__node == 0) - return 0; - int __sum = 0; - do { - if (__node->_M_color == _S_rb_tree_black) - ++__sum; - if (__node == __root) - break; - __node = __node->_M_parent; - } while (1); - return __sum; -} - -template -bool _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const -{ - if (_M_node_count == 0 || begin() == end()) - return _M_node_count == 0 && begin() == end() && - _M_header->_M_left == _M_header && _M_header->_M_right == _M_header; - - int __len = __black_count(_M_leftmost(), _M_root()); - for (const_iterator __it = begin(); __it != end(); ++__it) { - _Link_type __x = (_Link_type) __it._M_node; - _Link_type __L = _S_left(__x); - _Link_type __R = _S_right(__x); - - if (__x->_M_color == _S_rb_tree_red) - if ((__L && __L->_M_color == _S_rb_tree_red) || - (__R && __R->_M_color == _S_rb_tree_red)) - return false; - - if (__L && _M_key_compare(_S_key(__x), _S_key(__L))) - return false; - if (__R && _M_key_compare(_S_key(__R), _S_key(__x))) - return false; - - if (!__L && !__R && __black_count(__x, _M_root()) != __len) - return false; - } - - if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root())) - return false; - if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root())) - return false; - - return true; -} - -// Class rb_tree is not part of the C++ standard. It is provided for -// compatibility with the HP STL. - -template > -struct rb_tree : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> -{ - typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base; - typedef typename _Base::allocator_type allocator_type; - - rb_tree(const _Compare& __comp = _Compare(), - const allocator_type& __a = allocator_type()) - : _Base(__comp, __a) {} - - ~rb_tree() {} -}; - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_TREE_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_uninitialized.h b/libstdc++-v3/bits/stl_uninitialized.h deleted file mode 100644 index a9b196be347..00000000000 --- a/libstdc++-v3/bits/stl_uninitialized.h +++ /dev/null @@ -1,281 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef _CPP_BITS_STL_UNINITIALIZED_H -#define _CPP_BITS_STL_UNINITIALIZED_H 1 - -#include - -__STL_BEGIN_NAMESPACE - -// uninitialized_copy - -// Valid if copy construction is equivalent to assignment, and if the -// destructor is trivial. -template -inline _ForwardIter -__uninitialized_copy_aux(_InputIter __first, _InputIter __last, - _ForwardIter __result, - __true_type) -{ - return copy(__first, __last, __result); -} - -template -_ForwardIter -__uninitialized_copy_aux(_InputIter __first, _InputIter __last, - _ForwardIter __result, - __false_type) -{ - _ForwardIter __cur = __result; - __STL_TRY { - for ( ; __first != __last; ++__first, ++__cur) - _Construct(&*__cur, *__first); - return __cur; - } - __STL_UNWIND(_Destroy(__result, __cur)); -} - - -template -inline _ForwardIter -__uninitialized_copy(_InputIter __first, _InputIter __last, - _ForwardIter __result, _Tp*) -{ - typedef typename __type_traits<_Tp>::is_POD_type _Is_POD; - return __uninitialized_copy_aux(__first, __last, __result, _Is_POD()); -} - -template -inline _ForwardIter - uninitialized_copy(_InputIter __first, _InputIter __last, - _ForwardIter __result) -{ - return __uninitialized_copy(__first, __last, __result, - __VALUE_TYPE(__result)); -} - -inline char* uninitialized_copy(const char* __first, const char* __last, - char* __result) { - memmove(__result, __first, __last - __first); - return __result + (__last - __first); -} - -inline wchar_t* -uninitialized_copy(const wchar_t* __first, const wchar_t* __last, - wchar_t* __result) -{ - memmove(__result, __first, sizeof(wchar_t) * (__last - __first)); - return __result + (__last - __first); -} - -// uninitialized_copy_n (not part of the C++ standard) - -template -pair<_InputIter, _ForwardIter> -__uninitialized_copy_n(_InputIter __first, _Size __count, - _ForwardIter __result, - input_iterator_tag) -{ - _ForwardIter __cur = __result; - __STL_TRY { - for ( ; __count > 0 ; --__count, ++__first, ++__cur) - _Construct(&*__cur, *__first); - return pair<_InputIter, _ForwardIter>(__first, __cur); - } - __STL_UNWIND(_Destroy(__result, __cur)); -} - -template -inline pair<_RandomAccessIter, _ForwardIter> -__uninitialized_copy_n(_RandomAccessIter __first, _Size __count, - _ForwardIter __result, - random_access_iterator_tag) { - _RandomAccessIter __last = __first + __count; - return pair<_RandomAccessIter, _ForwardIter>( - __last, - uninitialized_copy(__first, __last, __result)); -} - -template -inline pair<_InputIter, _ForwardIter> -__uninitialized_copy_n(_InputIter __first, _Size __count, - _ForwardIter __result) { - return __uninitialized_copy_n(__first, __count, __result, - __ITERATOR_CATEGORY(__first)); -} - -template -inline pair<_InputIter, _ForwardIter> -uninitialized_copy_n(_InputIter __first, _Size __count, - _ForwardIter __result) { - return __uninitialized_copy_n(__first, __count, __result, - __ITERATOR_CATEGORY(__first)); -} - -// Valid if copy construction is equivalent to assignment, and if the -// destructor is trivial. -template -inline void -__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, - const _Tp& __x, __true_type) -{ - fill(__first, __last, __x); -} - -template -void -__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, - const _Tp& __x, __false_type) -{ - _ForwardIter __cur = __first; - __STL_TRY { - for ( ; __cur != __last; ++__cur) - _Construct(&*__cur, __x); - } - __STL_UNWIND(_Destroy(__first, __cur)); -} - -template -inline void __uninitialized_fill(_ForwardIter __first, - _ForwardIter __last, const _Tp& __x, _Tp1*) -{ - typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD; - __uninitialized_fill_aux(__first, __last, __x, _Is_POD()); - -} - -template -inline void uninitialized_fill(_ForwardIter __first, - _ForwardIter __last, - const _Tp& __x) -{ - __uninitialized_fill(__first, __last, __x, __VALUE_TYPE(__first)); -} - -// Valid if copy construction is equivalent to assignment, and if the -// destructor is trivial. -template -inline _ForwardIter -__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n, - const _Tp& __x, __true_type) -{ - return fill_n(__first, __n, __x); -} - -template -_ForwardIter -__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n, - const _Tp& __x, __false_type) -{ - _ForwardIter __cur = __first; - __STL_TRY { - for ( ; __n > 0; --__n, ++__cur) - _Construct(&*__cur, __x); - return __cur; - } - __STL_UNWIND(_Destroy(__first, __cur)); -} - -template -inline _ForwardIter -__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*) -{ - typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD; - return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD()); -} - -template -inline _ForwardIter -uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x) -{ - return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first)); -} - -// Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill, -// __uninitialized_fill_copy. - -// __uninitialized_copy_copy -// Copies [first1, last1) into [result, result + (last1 - first1)), and -// copies [first2, last2) into -// [result, result + (last1 - first1) + (last2 - first2)). - -template -inline _ForwardIter -__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1, - _InputIter2 __first2, _InputIter2 __last2, - _ForwardIter __result) -{ - _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result); - __STL_TRY { - return uninitialized_copy(__first2, __last2, __mid); - } - __STL_UNWIND(_Destroy(__result, __mid)); -} - -// __uninitialized_fill_copy -// Fills [result, mid) with x, and copies [first, last) into -// [mid, mid + (last - first)). -template -inline _ForwardIter -__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid, - const _Tp& __x, - _InputIter __first, _InputIter __last) -{ - uninitialized_fill(__result, __mid, __x); - __STL_TRY { - return uninitialized_copy(__first, __last, __mid); - } - __STL_UNWIND(_Destroy(__result, __mid)); -} - -// __uninitialized_copy_fill -// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and -// fills [first2 + (last1 - first1), last2) with x. -template -inline void -__uninitialized_copy_fill(_InputIter __first1, _InputIter __last1, - _ForwardIter __first2, _ForwardIter __last2, - const _Tp& __x) -{ - _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2); - __STL_TRY { - uninitialized_fill(__mid2, __last2, __x); - } - __STL_UNWIND(_Destroy(__first2, __mid2)); -} - -__STL_END_NAMESPACE - -#endif /* _CPP_BITS_STL_UNINITIALIZED_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/stl_vector.h b/libstdc++-v3/bits/stl_vector.h deleted file mode 100644 index 0727df6fac1..00000000000 --- a/libstdc++-v3/bits/stl_vector.h +++ /dev/null @@ -1,879 +0,0 @@ -/* - * - * 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. - */ - -/* NOTE: This is an internal header file, included by other STL headers. - * You should not attempt to use it directly. - */ - -#ifndef __SGI_STL_INTERNAL_VECTOR_H -#define __SGI_STL_INTERNAL_VECTOR_H - -#include - -#include - -__STL_BEGIN_NAMESPACE - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma set woff 1174 -#pragma set woff 1375 -#endif - -// 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. - -#ifdef __STL_USE_STD_ALLOCATORS - -// Base class for ordinary allocators. -template -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 _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 -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); } -}; - -#else /* __STL_USE_STD_ALLOCATORS */ - -template -class _Vector_base { -public: - typedef _Alloc allocator_type; - allocator_type get_allocator() const { return allocator_type(); } - - _Vector_base(const _Alloc&) - : _M_start(0), _M_finish(0), _M_end_of_storage(0) {} - _Vector_base(size_t __n, const _Alloc&) - : _M_start(0), _M_finish(0), _M_end_of_storage(0) - { - _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); } - -protected: - _Tp* _M_start; - _Tp* _M_finish; - _Tp* _M_end_of_storage; - - typedef simple_alloc<_Tp, _Alloc> _M_data_allocator; - _Tp* _M_allocate(size_t __n) - { return _M_data_allocator::allocate(__n); } - void _M_deallocate(_Tp* __p, size_t __n) - { _M_data_allocator::deallocate(__p, __n); } -}; - -#endif /* __STL_USE_STD_ALLOCATORS */ - -template > -class vector : protected _Vector_base<_Tp, _Alloc> -{ - // requirements: - - __STL_CLASS_REQUIRES(_Tp, _Assignable); - -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 __normal_iterator iterator; - typedef __normal_iterator 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(); } - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator - reverse_iterator; -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -protected: -#ifdef __STL_HAS_NAMESPACES - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_M_start; - using _Base::_M_finish; - using _Base::_M_end_of_storage; -#endif /* __STL_HAS_NAMESPACES */ - -protected: - void _M_insert_aux(iterator __position, const _Tp& __x); - void _M_insert_aux(iterator __position); - -public: - iterator begin() { return iterator (_M_start); } - const_iterator begin() const - { return const_iterator (_M_start); } - iterator end() { return iterator (_M_finish); } - const_iterator end() const { return const_iterator (_M_finish); } - - 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()); } - - size_type size() const - { return size_type(end() - begin()); } - size_type max_size() const - { return size_type(-1) / sizeof(_Tp); } - size_type capacity() const - { return size_type(const_iterator(_M_end_of_storage) - begin()); } - bool empty() const - { return begin() == end(); } - - reference operator[](size_type __n) { return *(begin() + __n); } - const_reference operator[](size_type __n) const { return *(begin() + __n); } - -#ifdef __STL_THROW_RANGE_ERRORS - void _M_range_check(size_type __n) const { - if (__n >= this->size()) - __out_of_range("vector"); - } - - 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]; } -#endif /* __STL_THROW_RANGE_ERRORS */ - - 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); } - -#ifdef __STL_MEMBER_TEMPLATES - // Check whether it's an integral type. If so, it's not an iterator. - template - 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 - 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 - void _M_initialize_aux(_InputIterator __first, _InputIterator __last, - __false_type) { - _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first)); - } - -#else - vector(const _Tp* __first, const _Tp* __last, - const allocator_type& __a = allocator_type()) - : _Base(__last - __first, __a) - { _M_finish = uninitialized_copy(__first, __last, _M_start); } -#endif /* __STL_MEMBER_TEMPLATES */ - - ~vector() { destroy(_M_start, _M_finish); } - - vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x); - void reserve(size_type __n) { - if (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. - - void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); } - void _M_fill_assign(size_type __n, const _Tp& __val); - -#ifdef __STL_MEMBER_TEMPLATES - - template - void assign(_InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_assign_dispatch(__first, __last, _Integral()); - } - - template - void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign((size_type) __n, (_Tp) __val); } - - template - void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type) - { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); } - - template - void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template - void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - -#endif /* __STL_MEMBER_TEMPLATES */ - - reference front() { return *begin(); } - const_reference front() const { return *begin(); } - reference back() { return *(end() - 1); } - const_reference back() const { return *(end() - 1); } - - 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); - } - void push_back() { - if (_M_finish != _M_end_of_storage) { - construct(_M_finish); - ++_M_finish; - } - else - _M_insert_aux(end()); - } - 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); - } - - 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; - } - 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; - } -#ifdef __STL_MEMBER_TEMPLATES - // Check whether it's an integral type. If so, it's not an iterator. - template - void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { - typedef typename _Is_integer<_InputIterator>::_Integral _Integral; - _M_insert_dispatch(__pos, __first, __last, _Integral()); - } - - template - void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, - __true_type) - { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); } - - template - void _M_insert_dispatch(iterator __pos, - _InputIterator __first, _InputIterator __last, - __false_type) { - _M_range_insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first)); - } -#else /* __STL_MEMBER_TEMPLATES */ - void insert(iterator __position, - const_iterator __first, const_iterator __last); -#endif /* __STL_MEMBER_TEMPLATES */ - - 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 pop_back() { - --_M_finish; - destroy(_M_finish); - } - iterator erase(iterator __position) { - if (__position + 1 != end()) - copy(__position + 1, end(), __position); - --_M_finish; - destroy(_M_finish); - return __position; - } - iterator erase(iterator __first, iterator __last) { - iterator __i(copy(__last, end(), __first)); - destroy(__i, end()); - _M_finish = _M_finish - (__last - __first); - return __first; - } - - 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); - } - void resize(size_type __new_size) { resize(__new_size, _Tp()); } - void clear() { erase(begin(), end()); } - -protected: - -#ifdef __STL_MEMBER_TEMPLATES - template - pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first, - _ForwardIterator __last) -{ - pointer __result = _M_allocate(__n); - __STL_TRY { - uninitialized_copy(__first, __last, __result); - return __result; - } - __STL_UNWIND(_M_deallocate(__result, __n)); - } -#else /* __STL_MEMBER_TEMPLATES */ - pointer _M_allocate_and_copy(size_type __n, const_iterator __first, - const_iterator __last) - { - iterator __result(_M_allocate(__n)); - __STL_TRY { - uninitialized_copy(__first, __last, __result); - return __result; - } - __STL_UNWIND(_M_deallocate(__result, __n)); - } -#endif /* __STL_MEMBER_TEMPLATES */ - - -#ifdef __STL_MEMBER_TEMPLATES - template - 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 - void _M_range_initialize(_ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag) - { - size_type __n = 0; - distance(__first, __last, __n); - _M_start = _M_allocate(__n); - _M_end_of_storage = _M_start + __n; - _M_finish = uninitialized_copy(__first, __last, _M_start); - } - - template - void _M_range_insert(iterator __pos, - _InputIterator __first, _InputIterator __last, - input_iterator_tag); - - template - void _M_range_insert(iterator __pos, - _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); - -#endif /* __STL_MEMBER_TEMPLATES */ -}; - -template -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 -inline bool -operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) -{ - return lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); -} - -#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER - -template -inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) -{ - __x.swap(__y); -} - -template -inline bool -operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__x == __y); -} - -template -inline bool -operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return __y < __x; -} - -template -inline bool -operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__y < __x); -} - -template -inline bool -operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { - return !(__x < __y); -} - -#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ - -template -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 -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()); -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -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 template -void -vector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last, - forward_iterator_tag) { - size_type __len = 0; - distance(__first, __last, __len); - - 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); - } -} - -#endif /* __STL_MEMBER_TEMPLATES */ - -template -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); - __STL_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); - } - __STL_UNWIND((destroy(__new_start,__new_finish), - _M_deallocate(__new_start.base(),__len))); - 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 -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; - __STL_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); - } - __STL_UNWIND((destroy(__new_start,__new_finish), - _M_deallocate(__new_start,__len))); - 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 -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); - __STL_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); - } - __STL_UNWIND((destroy(__new_start,__new_finish), - _M_deallocate(__new_start.base(),__len))); - 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; - } - } -} - -#ifdef __STL_MEMBER_TEMPLATES - -template template -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 template -void -vector<_Tp, _Alloc>::_M_range_insert(iterator __position, - _ForwardIterator __first, - _ForwardIterator __last, - forward_iterator_tag) -{ - if (__first != __last) { - size_type __n = 0; - distance(__first, __last, __n); - 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); - __STL_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); - } - __STL_UNWIND((destroy(__new_start,__new_finish), - _M_deallocate(__new_start.base(),__len))); - 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; - } - } -} - -#else /* __STL_MEMBER_TEMPLATES */ - -template -void -vector<_Tp, _Alloc>::insert(iterator __position, - const_iterator __first, - const_iterator __last) -{ - if (__first != __last) { - size_type __n = 0; - distance(__first, __last, __n); - if (size_type(_M_end_of_storage - _M_finish) >= __n) { - const size_type __elems_after = _M_finish - __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 { - uninitialized_copy(__first + __elems_after, __last, _M_finish); - _M_finish += __n - __elems_after; - uninitialized_copy(__position, __old_finish, _M_finish); - _M_finish += __elems_after; - copy(__first, __first + __elems_after, __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); - __STL_TRY { - __new_finish = uninitialized_copy(_M_start, __position, __new_start); - __new_finish = uninitialized_copy(__first, __last, __new_finish); - __new_finish - = uninitialized_copy(__position, _M_finish, __new_finish); - } - __STL_UNWIND((destroy(__new_start,__new_finish), - _M_deallocate(__new_start,__len))); - destroy(_M_start, _M_finish); - _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 /* __STL_MEMBER_TEMPLATES */ - -#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -#pragma reset woff 1174 -#pragma reset woff 1375 -#endif - -__STL_END_NAMESPACE - -#endif /* __SGI_STL_INTERNAL_VECTOR_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/streambuf.tcc b/libstdc++-v3/bits/streambuf.tcc deleted file mode 100644 index d03b7bca104..00000000000 --- a/libstdc++-v3/bits/streambuf.tcc +++ /dev/null @@ -1,261 +0,0 @@ -// Stream buffer classes -*- C++ -*- - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 27.5 Stream buffers -// - -#ifndef _CPP_BITS_STREAMBUF_TCC -#define _CPP_BITS_STREAMBUF_TCC 1 - -namespace std { - - template - basic_streambuf<_CharT, _Traits>::int_type - basic_streambuf<_CharT, _Traits>:: - sbumpc() - { - int_type __ret; - if (_M_in_cur && _M_in_cur < _M_in_end) - { - char_type __c = *gptr(); - ++_M_in_cur; - if (_M_buf_unified && _M_mode & ios_base::out) - ++_M_out_cur; - __ret = traits_type::to_int_type(__c); - } - else - __ret = this->uflow(); - return __ret; - } - - template - basic_streambuf<_CharT, _Traits>::int_type - basic_streambuf<_CharT, _Traits>:: - sputbackc(char_type __c) - { - 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) - __ret = pbackfail(traits_type::to_int_type(__c)); - else - { - --_M_in_cur; - if (_M_buf_unified && _M_mode & ios_base::out) - --_M_out_cur; - __ret = traits_type::to_int_type(*this->gptr()); - } - return __ret; - } - - template - basic_streambuf<_CharT, _Traits>::int_type - basic_streambuf<_CharT, _Traits>:: - sungetc() - { - int_type __ret; - if (_M_in_cur && _M_in_beg < _M_in_cur) - { - --_M_in_cur; - if (_M_buf_unified && _M_mode & ios_base::out) - --_M_out_cur; - __ret = traits_type::to_int_type(*_M_in_cur); - } - else - __ret = this->pbackfail(); - return __ret; - } - - // Don't test against _M_buf + _M_buf_size, because _M_buf reflects - // allocated space, and on certain (rare but entirely legal) - // situations, there will be no allocated space yet the internal - // buffers will still be valid. (This happens if setp is used to set - // the internal buffer to say some externally-allocated sequence.) - template - basic_streambuf<_CharT, _Traits>::int_type - basic_streambuf<_CharT, _Traits>:: - sputc(char_type __c) - { - int_type __ret; - - if (_M_out_cur && _M_out_cur < _M_out_beg + _M_buf_size) - { - *_M_out_cur = __c; - _M_out_cur_move(1); - __ret = traits_type::to_int_type(__c); - } - else - __ret = this->overflow(traits_type::to_int_type(__c)); - return __ret; - } - - template - streamsize - basic_streambuf<_CharT, _Traits>:: - xsgetn(char_type* __s, streamsize __n) - { - bool __testout = _M_mode & ios_base::out; - streamsize __ret = 0; - - if (__n) - { - while (__ret < __n) - { - if (_M_in_cur < _M_in_end) - { - size_t __len; - if (_M_in_cur + __n - __ret <= _M_in_end) - __len = __n - __ret; - else - __len = _M_in_end - _M_in_cur; - traits_type::copy(__s, _M_in_cur, __len); - __ret += __len; - __s += __len; - _M_in_cur += __len; - if (_M_buf_unified && __testout) - _M_out_cur += __len; - } - - if (__ret != __n) - { - int_type __c = this->uflow(); - if (traits_type::eq_int_type(__c, traits_type::eof())) - break; - - traits_type::assign(*__s++, traits_type::to_char_type(__c)); - ++__ret; - } - } - } - return __ret; - } - - // Don't test against _M_buf + _M_buf_size, because _M_buf reflects - // allocated space, and on certain (rare but entirely legal) - // situations, there will be no allocated space yet the internal - // buffers will still be valid. (This happens if setp is used to set - // the internal buffer to say some externally-allocated sequence.) - template - streamsize - basic_streambuf<_CharT, _Traits>:: - xsputn(const char_type* __s, streamsize __n) - { - streamsize __ret = 0; - - if (__n) - { - while (__ret < __n) - { - bool __testput = _M_out_cur < _M_out_beg + _M_buf_size; - bool __testout = _M_mode & ios_base::out; - if (!(__testput && __testout)) - { - int_type __c = traits_type::to_int_type(*__s); - int_type __overfc = this->overflow(__c); - if (traits_type::eq_int_type(__c, __overfc)) - { - ++__ret; - ++__s; - } - else - break; - } - - if (__ret != __n) - { - size_t __len; - if (_M_out_cur + __n - __ret <= _M_out_beg + _M_buf_size) - __len = __n - __ret; - else - __len = _M_out_beg + _M_buf_size - _M_out_cur; - traits_type::copy(_M_out_cur, __s, __len); - __ret += __len; - __s += __len; - _M_out_cur_move(__len); - } - } - } - return __ret; - } - - - // Conceivably, this could be used to implement buffer-to-buffer - // copies, if this was ever desired in an un-ambiguous way by the - // standard. If so, then checks for __ios being zero would be - // necessary. - template - streamsize - _S_copy_streambufs(basic_ios<_CharT, _Traits>& __ios, - 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 __testout = __sbin->_M_mode & ios_base::out; - bool __testput = __sbout->_M_mode & ios_base::out; - try { - while (__testput && __bufsize != -1) - { - __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize); - __ret += __xtrct; - __sbin->_M_in_cur += __xtrct; - if (__testout && __sbin->_M_buf_unified) - __sbin->_M_out_cur += __xtrct; - if (__xtrct == __bufsize) - { - int_type __c = __sbin->sgetc(); - if (__c == _Traits::eof()) - { - __ios.setstate(ios_base::eofbit); - break; - } - __bufsize = __sbin->in_avail(); - } - else - break; - } - } - catch(exception& __fail) { - if ((__ios.exceptions() & ios_base::failbit) != 0) - throw; - } - return __ret; - } - -} // namespace std - -#endif // _CPP_BITS_STREAMBUF_TCC - - - - diff --git a/libstdc++-v3/bits/string.tcc b/libstdc++-v3/bits/string.tcc deleted file mode 100644 index 82a5a7af8ff..00000000000 --- a/libstdc++-v3/bits/string.tcc +++ /dev/null @@ -1,856 +0,0 @@ -// Components for manipulating sequences of characters -*- C++ -*- - -// Copyright (C) 2000, 1999, 1998, 1997 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// -// ISO C++ 14882: 21 Strings library -// - -// This file is included by . It is not meant to be included -// separately. - -// Written by Jason Merrill based upon the specification by Takanori Adachi -// in ANSI X3J16/94-0013R2. Rewritten by Nathan Myers to ISO-14882. - -#ifndef _CPP_BITS_STRING_TCC -#define _CPP_BITS_STRING_TCC 1 - -namespace std -{ - - template - _CharT - basic_string<_CharT, _Traits, _Alloc>:: - _Rep::_S_terminal = _CharT(); - - template - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - _Rep::_S_max_size = (((npos - sizeof(_Rep))/sizeof(_CharT)) - 1) / 4; - - template - const basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>::npos; - - // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string) - // at static init time (before static ctors are run). - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep_storage[ - (sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)]; - - // NB: This is the special case for Input Iterators, used in - // istreambuf_iterators, etc. - // Input Iterators have a cost structure very different from - // pointers, calling for a different coding style. - template - template - _CharT* - basic_string<_CharT, _Traits, _Alloc>:: - _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a, - input_iterator_tag) - { - if (__beg == __end && __a == _Alloc()) - return _S_empty_rep()._M_refcopy(); - // Avoid reallocation for common case. - _CharT __buf[100]; - size_type __i = 0; - while (__beg != __end && __i < sizeof(__buf) / sizeof(_CharT)) - { - __buf[__i++] = *__beg; - ++__beg; - } - _Rep* __r = _Rep::_S_create(__i, __a); - traits_type::copy(__r->_M_refdata(), __buf, __i); - __r->_M_length = __i; - try { - // NB: this loop looks precisely this way because - // it avoids comparing __beg != __end any more - // than strictly necessary; != might be expensive! - for (;;) - { - _CharT* __p = __r->_M_refdata() + __r->_M_length; - _CharT* __last = __r->_M_refdata() + __r->_M_capacity; - for (;;) - { - if (__beg == __end) - { - __r->_M_length = __p - __r->_M_refdata(); - *__p = _Rep::_S_terminal; // grrr. - return __r->_M_refdata(); - } - if (__p == __last) - break; - *__p++ = *__beg; - ++__beg; - } - // Allocate more space. - size_type __len = __p - __r->_M_refdata(); - _Rep* __another = _Rep::_S_create(__len + 1, __a); - traits_type::copy(__another->_M_refdata(), - __r->_M_refdata(), __len); - __r->_M_destroy(__a); - __r = __another; - __r->_M_length = __len; - } - } - catch (...) { - __r->_M_destroy(__a); - throw; - } - return 0; - } - - template - template - _CharT* - basic_string<_CharT,_Traits,_Alloc>:: - _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a, - forward_iterator_tag) - { - size_type __dnew = static_cast(distance(__beg, __end)); - - if (__beg == __end && __a == _Alloc()) - return _S_empty_rep()._M_refcopy(); - - // Check for out_of_range and length_error exceptions. - _Rep* __r = _Rep::_S_create(__dnew, __a); - try { - _S_copy_chars(__r->_M_refdata(), __beg, __end); - } - catch (...) { - __r->_M_destroy(__a); - throw; - } - __r->_M_length = __dnew; - - __r->_M_refdata()[__dnew] = _Rep::_S_terminal; // grrr. - return __r->_M_refdata(); - } - - template - _CharT* - basic_string<_CharT,_Traits, _Alloc>:: - _S_construct(size_type __n, _CharT __c, const _Alloc& __a) - { - if (__n == 0 && __a == _Alloc()) - return _S_empty_rep()._M_refcopy(); - - // Check for out_of_range and length_error exceptions. - _Rep* __r = _Rep::_S_create(__n, __a); - try { - if (__n) - traits_type::assign(__r->_M_refdata(), __n, __c); - } - catch (...) { - __r->_M_destroy(__a); - throw; - } - __r->_M_length = __n; - __r->_M_refdata()[__n] = _Rep::_S_terminal; // grrr - return __r->_M_refdata(); - } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const basic_string& __str) - : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(), __str.get_allocator()), - __str.get_allocator()) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const _Alloc& __a) - : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const basic_string& __str, size_type __pos, size_type __n) - : _M_dataplus(_S_construct(__str._M_check(__pos), - __str._M_fold(__pos, __n), _Alloc()), _Alloc()) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const basic_string& __str, size_type __pos, - size_type __n, const _Alloc& __a) - : _M_dataplus(_S_construct(__str._M_check(__pos), - __str._M_fold(__pos, __n), __a), __a) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const _CharT* __s, size_type __n, const _Alloc& __a) - : _M_dataplus(_S_construct(__s, __s + __n, __a), __a) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(const _CharT* __s, const _Alloc& __a) - : _M_dataplus(_S_construct(__s, __s + traits_type::length(__s), __a), __a) - { } - - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(size_type __n, _CharT __c, const _Alloc& __a) - : _M_dataplus(_S_construct(__n, __c, __a), __a) - { } - - template - template - basic_string<_CharT, _Traits, _Alloc>:: - basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a) - : _M_dataplus(_S_construct(__beg, __end, __a), __a) - { } - - template - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>::assign(const basic_string& __str) - { - if (_M_rep() != __str._M_rep()) - { - // XXX MT - allocator_type __a = this->get_allocator(); - _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator()); - _M_rep()->_M_dispose(__a); - _M_data(__tmp); - } - return *this; - } - - template - void - basic_string<_CharT, _Traits, _Alloc>::_Rep:: - _M_destroy(const _Alloc& __a) throw () - { - size_type __size = sizeof(_Rep) + (_M_capacity + 1) * sizeof(_CharT); - _Raw_bytes_alloc(__a).deallocate(reinterpret_cast(this), __size); - } - - template - void - basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard() - { - if (_M_rep()->_M_is_shared()) - _M_mutate(0, 0, 0); - _M_rep()->_M_set_leaked(); - } - - template - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_mutate(size_type __pos, size_type __len1, size_type __len2) - { - size_type __old_size = this->size(); - const size_type __new_size = __old_size + __len2 - __len1; - const _CharT* __src = _M_data() + __pos + __len1; - const size_type __how_much = __old_size - __pos - __len1; - - if (_M_rep()->_M_is_shared() || __new_size > capacity()) - { - // Must reallocate. - allocator_type __a = get_allocator(); - _Rep* __r = _Rep::_S_create(__new_size, __a); - try { - if (__pos) - traits_type::copy(__r->_M_refdata(), _M_data(), __pos); - if (__how_much) - traits_type::copy(__r->_M_refdata() + __pos + __len2, - __src, __how_much); - } - catch (...) { - __r->_M_dispose(get_allocator()); - throw; - } - _M_rep()->_M_dispose(__a); - _M_data(__r->_M_refdata()); - } - else if (__how_much && __len1 != __len2) - { - // Work in-place - traits_type::move(_M_data() + __pos + __len2, __src, __how_much); - } - _M_rep()->_M_set_sharable(); - _M_rep()->_M_length = __new_size; - _M_data()[__new_size] = _Rep::_S_terminal; // grrr. (per 21.3.4) - // You cannot leave those LWG people alone for a second. - } - - template - void - basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res) - { - if (__res > this->capacity() || _M_rep()->_M_is_shared()) - { - __LENGTHERROR(__res > this->max_size()); - allocator_type __a = get_allocator(); - _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size()); - _M_rep()->_M_dispose(__a); - _M_data(__tmp); - } - } - - template - void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s) - { - if (_M_rep()->_M_is_leaked()) - _M_rep()->_M_set_sharable(); - if (__s._M_rep()->_M_is_leaked()) - __s._M_rep()->_M_set_sharable(); - if (this->get_allocator() == __s.get_allocator()) - { - _CharT* __tmp = _M_data(); - _M_data(__s._M_data()); - __s._M_data(__tmp); - } - // The code below can usually be optimized away. - else - { - basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator()); - basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), - this->get_allocator()); - *this = __tmp2; - __s = __tmp1; - } - } - -#ifdef _GLIBCPP_ALLOC_CONTROL - template - bool (*basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_excess_slop) - (size_t, size_t) = - basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_default_excess; -#endif - - template - basic_string<_CharT, _Traits, _Alloc>::_Rep* - basic_string<_CharT, _Traits, _Alloc>::_Rep:: - _S_create(size_t __capacity, const _Alloc& __alloc) - { -#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS - // 83. String::npos vs. string::max_size() - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - __LENGTHERROR(__capacity > _S_max_size); -#else - __LENGTHERROR(__capacity == npos); -#endif - - // NB: Need an array of char_type[__capacity], plus a - // terminating null char_type() element, plus enough for the - // _Rep data structure. Whew. Seemingly so needy, yet so elemental. - size_t __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); - // NB: Might throw, but no worries about a leak, mate: _Rep() - // does not throw. - void* __place = _Raw_bytes_alloc(__alloc).allocate(__size); - _Rep *__p = new (__place) _Rep; - __p->_M_capacity = __capacity; - __p->_M_set_sharable(); // one reference - __p->_M_length = 0; - return __p; - } - - template - _CharT* - basic_string<_CharT, _Traits, _Alloc>::_Rep:: - _M_clone(const _Alloc& __alloc, size_type __res) - { - _Rep* __r = _Rep::_S_create(_M_length + __res, __alloc); - if (_M_length) - { - try { - traits_type::copy(__r->_M_refdata(), _M_refdata(), _M_length); - } - catch (...) { - __r->_M_destroy(__alloc); - throw; - } - } - __r->_M_length = _M_length; - return __r->_M_refdata(); - } - - template - inline bool -#ifdef _GLIBCPP_ALLOC_CONTROL - basic_string<_CharT, _Traits, _Alloc>::_Rep:: - _S_default_excess(size_t __s, size_t __r) -#else - basic_string<_CharT, _Traits, _Alloc>::_Rep:: - _S_excess_slop(size_t __s, size_t __r) -#endif - { - return 2 * (__s <= 16 ? 16 : __s) < __r; - } - - template - void - basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c) - { - __LENGTHERROR(__n > max_size()); - size_type __size = this->size(); - if (__size < __n) - this->append(__n - __size, __c); - else if (__n < __size) - this->erase(__n); - // else nothing (in particular, avoid calling _M_mutate() unnecessarily.) - } - - template - template - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace(iterator __i1, iterator __i2, _InputIter __k1, - _InputIter __k2, input_iterator_tag) - { - basic_string __s(__k1, __k2); - return this->replace(__i1, __i2, __s._M_ibegin(), __s._M_iend()); - } - - template - template - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace(iterator __i1, iterator __i2, _ForwardIter __k1, - _ForwardIter __k2, forward_iterator_tag) - { - size_type __dold = __i2 - __i1; - size_type __dmax = this->max_size(); - size_type __dnew = static_cast(distance(__k1, __k2)); - - __LENGTHERROR(__dmax <= __dnew); - size_type __off = __i1 - _M_ibegin(); - _M_mutate(__off, __dold, __dnew); - // Invalidated __i1, __i2 - if (__dnew) - _S_copy_chars(_M_data() + __off, __k1, __k2); - - return *this; - } - - template - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - replace(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2) - { - return this->replace(_M_check(__pos1), _M_fold(__pos1, __n1), - __str._M_check(__pos2), - __str._M_fold(__pos2, __n2)); - } - - template - basic_string<_CharT,_Traits,_Alloc>& - basic_string<_CharT,_Traits,_Alloc>:: - append(const basic_string& __str) - { - // Iff appending itself, string needs to pre-reserve the - // correct size so that _M_mutate does not clobber the - // iterators formed here. - size_type __size = __str.size(); - size_type __len = __size + this->size(); - if (__len > this->capacity()) - this->reserve(__len); - return this->replace(_M_iend(), _M_iend(), __str._M_ibegin(), - __str._M_iend()); - } - - template - basic_string<_CharT,_Traits,_Alloc>& - basic_string<_CharT,_Traits,_Alloc>:: - append(const basic_string& __str, size_type __pos, size_type __n) - { - // 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(); - if (__len > this->capacity()) - this->reserve(__len); - return this->replace(_M_iend(), _M_iend(), __str._M_check(__pos), - __str._M_fold(__pos, __n)); - } - - template - basic_string<_CharT,_Traits,_Alloc>& - basic_string<_CharT,_Traits,_Alloc>:: - append(const _CharT* __s, size_type __n) - { - size_type __len = __n + this->size(); - if (__len > this->capacity()) - this->reserve(__len); - return this->replace(_M_iend(), _M_iend(), __s, __s + __n); - } - - template - basic_string<_CharT,_Traits,_Alloc>& - basic_string<_CharT,_Traits,_Alloc>:: - append(size_type __n, _CharT __c) - { - size_type __len = __n + this->size(); - if (__len > this->capacity()) - this->reserve(__len); - return this->replace(_M_iend(), _M_iend(), __n, __c); - } - - template - basic_string<_CharT,_Traits,_Alloc> - operator+(const _CharT* __lhs, - const basic_string<_CharT,_Traits,_Alloc>& __rhs) - { - typedef basic_string<_CharT,_Traits,_Alloc> __string_type; - typedef typename __string_type::size_type __size_type; - __size_type __len = _Traits::length(__lhs); - __string_type __str; - __str.reserve(__len + __rhs.size()); - __str.append(__lhs, __lhs + __len); - __str.append(__rhs); - return __str; - } - - template - basic_string<_CharT,_Traits,_Alloc> - operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs) - { - typedef basic_string<_CharT,_Traits,_Alloc> __string_type; - typedef typename __string_type::size_type __size_type; - __string_type __str; - __size_type __len = __rhs.size(); - __str.reserve(__len + 1); - __str.append(__string_type::size_type(1), __lhs); - __str.append(__rhs); - return __str; - } - - template - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - replace(iterator __i1, iterator __i2, size_type __n2, _CharT __c) - { - size_type __n1 = __i2 - __i1; - size_type __off1 = __i1 - _M_ibegin(); - __LENGTHERROR(max_size() - (this->size() - __n1) <= __n2); - _M_mutate (__off1, __n1, __n2); - // Invalidated __i1, __i2 - if (__n2) - traits_type::assign(_M_data() + __off1, __n2, __c); - return *this; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - copy(_CharT* __s, size_type __n, size_type __pos) const - { - __OUTOFRANGE(__pos > this->size()); - - if (__n > this->size() - __pos) - __n = this->size() - __pos; - - traits_type::copy(__s, _M_data() + __pos, __n); - // 21.3.5.7 par 3: do not append null. (good.) - return __n; - } - - // String operations - // NB: This is specialized for the standard char_traits - // specialization to use the same optimizations as strchr. - template - const _CharT* - basic_string<_CharT, _Traits, _Alloc>:: - _S_find(const _CharT* __beg, const _CharT* __end, _CharT __c) - { - return find_if(__beg, __end, _Char_traits_match<_CharT, _Traits>(__c)); - } - - // Specialization for char, definitions in src/string-inst.cc. - template<> - const char* - string::_S_find(const char* __beg, const char* __end, char __c); - - // Specialization for wchar_t. -#ifdef _GLIBCPP_USE_WCHAR_T - template<> - const wchar_t* - wstring::_S_find(const wchar_t* __beg, const wchar_t* __end, wchar_t __c); -#endif - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find(const _CharT* __s, size_type __pos, size_type __n) const - { - size_t __xpos = __pos; - const _CharT* __data = _M_data(); - for (; __xpos + __n <= this->size(); ++__xpos) - if (traits_type::compare(__data + __xpos, __s, __n) == 0) - return __xpos; - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find(_CharT __c, size_type __pos) const - { - size_type __size = this->size(); - size_type __ret = npos; - if (__pos < __size) - { - const _CharT* __data = _M_data(); - const _CharT* __end = __data + __size; - const _CharT* __p = _S_find(__data + __pos, __end, __c); - if (__p != __end) - __ret = __p - __data; - } - return __ret; - } - - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - rfind(const _CharT* __s, size_type __pos, size_type __n) const - { - size_type __size = this->size(); - if (__n <= __size) - { - __pos = std::min(__size - __n ,__pos); - const _CharT* __data = _M_data(); - do - { - if (traits_type::compare(__data + __pos, __s, __n) == 0) - return __pos; - } - while (__pos-- > 0); - } - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - rfind(_CharT __c, size_type __pos) const - { - size_type __size = this->size(); - if (__size) - { - size_t __xpos = __size - 1; - if (__xpos > __pos) - __xpos = __pos; - - for (++__xpos; __xpos-- > 0; ) - if (traits_type::eq(_M_data()[__xpos], __c)) - return __xpos; - } - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_of(const _CharT* __s, size_type __pos, size_type __n) const - { - const _CharT* __end = __s + __n; - for (; __n && __pos < this->size(); ++__pos) - { - const _CharT* __p = _S_find(__s, __end, _M_data()[__pos]); - if (__p != __end) - return __pos; - } - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_of(const _CharT* __s, size_type __pos, size_type __n) const - { - size_type __size = this->size(); - if (__size && __n) - { - if (--__size > __pos) - __size = __pos; - do - { - const _CharT* __p = _S_find(__s, __s + __n, _M_data()[__size]); - if (__p != __s + __n) - return __size; - } - while (__size-- != 0); - } - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const - { - size_t __xpos = __pos; - for (; __n && __xpos < this->size(); ++__xpos) - if (_S_find(__s, __s + __n, _M_data()[__xpos]) == __s + __n) - return __xpos; - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_not_of(_CharT __c, size_type __pos) const - { - size_t __xpos = __pos; - for (; __xpos < size(); ++__xpos) - if (!traits_type::eq(_M_data()[__xpos], __c)) - return __xpos; - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const - { - size_type __size = this->size(); - if (__size && __n) - { - if (--__size > __pos) - __size = __pos; - do - { - if (_S_find(__s, __s + __n, _M_data()[__size]) == __s + __n) - return __size; - } - while (__size--); - } - return npos; - } - - template - basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_not_of(_CharT __c, size_type __pos) const - { - size_type __size = this->size(); - if (__size) - { - if (--__size > __pos) - __size = __pos; - do - { - if (!traits_type::eq(_M_data()[__size], __c)) - return __size; - } - while (__size--); - } - return npos; - } - - template - int - basic_string<_CharT, _Traits, _Alloc>:: - compare(size_type __pos, size_type __n, const basic_string& __str) const - { - size_type __size = this->size(); - size_type __osize = __str.size(); - __OUTOFRANGE(__pos > __size); - - size_type __rsize= min(__size - __pos, __n); - size_type __len = min(__rsize, __osize); - int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); - if (!__r) - __r = __rsize - __osize; - return __r; - } - - template - int - basic_string<_CharT, _Traits, _Alloc>:: - compare(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2) const - { - size_type __size = this->size(); - size_type __osize = __str.size(); - __OUTOFRANGE(__pos1 > __size); - __OUTOFRANGE(__pos2 > __osize); - - size_type __rsize = min(__size - __pos1, __n1); - size_type __rosize = min(__osize - __pos2, __n2); - size_type __len = min(__rsize, __rosize); - int __r = traits_type::compare(_M_data() + __pos1, - __str.data() + __pos2, __len); - if (!__r) - __r = __rsize - __rosize; - return __r; - } - - - template - int - basic_string<_CharT, _Traits, _Alloc>:: - compare(const _CharT* __s) const - { - size_type __size = this->size(); - int __r = traits_type::compare(_M_data(), __s, __size); - if (!__r) - __r = __size - traits_type::length(__s); - return __r; - } - - - template - int - basic_string <_CharT,_Traits,_Alloc>:: - compare(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2) const - { - size_type __size = this->size(); - __OUTOFRANGE(__pos > __size); - - size_type __osize = min(traits_type::length(__s), __n2); - size_type __rsize = min(__size - __pos, __n1); - size_type __len = min(__rsize, __osize); - int __r = traits_type::compare(_M_data() + __pos, __s, __len); - if (!__r) - __r = __rsize - __osize; - return __r; - } - - template - void - _S_string_copy(const basic_string<_CharT, _Traits, _Alloc>& __str, - _CharT* __buf, typename _Alloc::size_type __bufsiz) - { - typedef typename _Alloc::size_type size_type; - size_type __strsize = __str.size(); - size_type __bytes = min(__strsize, __bufsiz - 1); - _Traits::copy(__buf, __str.data(), __bytes); - __buf[__bytes] = _CharT(); - } - -} // std:: - -#endif /* _CPP_BITS_STRING_TCC */ diff --git a/libstdc++-v3/bits/type_traits.h b/libstdc++-v3/bits/type_traits.h deleted file mode 100644 index dbcaa2a619f..00000000000 --- a/libstdc++-v3/bits/type_traits.h +++ /dev/null @@ -1,387 +0,0 @@ -/* - * - * Copyright (c) 1997 - * Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies and - * that both that copyright notice and this permission notice appear - * in supporting documentation. Silicon Graphics makes no - * representations about the suitability of this software for any - * purpose. It is provided "as is" without express or implied warranty. - */ - -#ifndef _CPP_BITS_TYPE_TRAITS_H -#define _CPP_BITS_TYPE_TRAITS_H 1 - -#ifndef _CPP_BITS_STL_CONFIG_H -#include -#endif - -/* -This header file provides a framework for allowing compile time dispatch -based on type attributes. This is useful when writing template code. -For example, when making a copy of an array of an unknown type, it helps -to know if the type has a trivial copy constructor or not, to help decide -if a memcpy can be used. - -The class template __type_traits provides a series of typedefs each of -which is either __true_type or __false_type. The argument to -__type_traits can be any type. The typedefs within this template will -attain their correct values by one of these means: - 1. The general instantiation contain conservative values which work - for all types. - 2. Specializations may be declared to make distinctions between types. - 3. Some compilers (such as the Silicon Graphics N32 and N64 compilers) - will automatically provide the appropriate specializations for all - types. - -EXAMPLE: - -//Copy an array of elements which have non-trivial copy constructors -template void - copy(_Tp* __source,_Tp* __destination,int __n,__false_type); -//Copy an array of elements which have trivial copy constructors. Use memcpy. -template void - copy(_Tp* __source,_Tp* __destination,int __n,__true_type); - -//Copy an array of any type by using the most efficient copy mechanism -template inline void copy(_Tp* __source,_Tp* __destination,int __n) { - copy(__source,__destination,__n, - typename __type_traits<_Tp>::has_trivial_copy_constructor()); -} -*/ - - -template struct _Bool {}; -typedef _Bool __true_type; -typedef _Bool __false_type; - -template -struct __type_traits { - typedef __true_type this_dummy_member_must_be_first; - /* Do not remove this member. It informs a compiler which - automatically specializes __type_traits that this - __type_traits template is special. It just makes sure that - things work if an implementation is using a template - called __type_traits for something unrelated. */ - - /* The following restrictions should be observed for the sake of - compilers which automatically produce type specific specializations - of this class: - - You may reorder the members below if you wish - - You may remove any of the members below if you wish - - You must not rename members without making the corresponding - name change in the compiler - - Members you add will be treated like regular members unless - you add the appropriate support in the compiler. */ - - - typedef __false_type has_trivial_default_constructor; - typedef __false_type has_trivial_copy_constructor; - typedef __false_type has_trivial_assignment_operator; - typedef __false_type has_trivial_destructor; - typedef __false_type is_POD_type; -}; - - - -// Provide some specializations. This is harmless for compilers that -// have built-in __types_traits support, and essential for compilers -// that don't. - -#ifndef __STL_NO_BOOL - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#endif /* __STL_NO_BOOL */ - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#ifdef __STL_HAS_WCHAR_T - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#endif /* __STL_HAS_WCHAR_T */ - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#ifdef __STL_LONG_LONG - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#endif /* __STL_LONG_LONG */ - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION - -template -struct __type_traits<_Tp*> { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -__STL_TEMPLATE_NULL struct __type_traits { - typedef __true_type has_trivial_default_constructor; - typedef __true_type has_trivial_copy_constructor; - typedef __true_type has_trivial_assignment_operator; - typedef __true_type has_trivial_destructor; - typedef __true_type is_POD_type; -}; - -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ - - -// The following could be written in terms of numeric_limits. -// We're doing it separately to reduce the number of dependencies. - -template struct _Is_integer { - typedef __false_type _Integral; -}; - -#ifndef __STL_NO_BOOL - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -#endif /* __STL_NO_BOOL */ - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -#ifdef __STL_HAS_WCHAR_T - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -#endif /* __STL_HAS_WCHAR_T */ - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -#ifdef __STL_LONG_LONG - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -__STL_TEMPLATE_NULL struct _Is_integer { - typedef __true_type _Integral; -}; - -#endif /* __STL_LONG_LONG */ - -template struct _Is_normal_iterator { - typedef __false_type _Normal; -}; - -// Forward declaration hack, should really include this from somewhere. -namespace std { - template class __normal_iterator; -}; - -template -struct _Is_normal_iterator< std::__normal_iterator<_Iterator, _Container> > { - typedef __true_type _Normal; -}; - -#endif /* _CPP_BITS_TYPE_TRAITS_H */ - -// Local Variables: -// mode:C++ -// End: diff --git a/libstdc++-v3/bits/valarray_array.h b/libstdc++-v3/bits/valarray_array.h deleted file mode 100644 index 2c88877bd28..00000000000 --- a/libstdc++-v3/bits/valarray_array.h +++ /dev/null @@ -1,575 +0,0 @@ -// The template and inlines for the -*- C++ -*- internal _Array helper class. - -// Copyright (C) 1997-2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_ARRAY_H -#define _CPP_BITS_ARRAY_H 1 - -#include -#include -#include -#include -#include - -namespace std -{ - - // - // Helper functions on raw pointers - // - - // We get memory by the old fashion way - inline void* - __valarray_get_memory(size_t __n) - { return operator new(__n); } - - template - inline _Tp*__restrict__ - __valarray_get_storage(size_t __n) - { - return static_cast<_Tp*__restrict__> - (__valarray_get_memory(__n * sizeof(_Tp))); - } - - // Return memory to the system - inline void - __valarray_release_memory(void* __p) - { operator delete(__p); } - - // Turn a raw-memory into an array of _Tp filled with _Tp() - // This is required in 'valarray v(n);' - template - struct _Array_default_ctor - { - // Please note that this isn't exception safe. But - // valarrays aren't required to be exception safe. - inline static void - _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { while (__b != __e) new(__b++) _Tp(); } - }; - - template - struct _Array_default_ctor<_Tp, true> - { - // For fundamental types, it suffices to say 'memset()' - inline static void - _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { memset(__b, 0, (__e - __b)*sizeof(_Tp)); } - }; - - template - inline void - __valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { - _Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: - _S_do_it(__b, __e); - } - - // Turn a raw-memory into an array of _Tp filled with __t - // This is the required in valarray v(n, t). Also - // used in valarray<>::resize(). - template - struct _Array_init_ctor - { - // Please note that this isn't exception safe. But - // valarrays aren't required to be exception safe. - inline static void - _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) - { while (__b != __e) new(__b++) _Tp(__t); } - }; - - template - struct _Array_init_ctor<_Tp, true> - { - inline static void - _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) - { while (__b != __e) *__b++ = __t; } - }; - - template - inline void - __valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e, - const _Tp __t) - { - _Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: - _S_do_it(__b, __e, __t); - } - - // - // copy-construct raw array [__o, *) from plain array [__b, __e) - // We can't just say 'memcpy()' - // - template - struct _Array_copy_ctor - { - // Please note that this isn't exception safe. But - // valarrays aren't required to be exception safe. - inline static void - _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, - _Tp* __restrict__ __o) - { while (__b != __e) new(__o++) _Tp(*__b++); } - }; - - template - struct _Array_copy_ctor<_Tp, true> - { - inline static void - _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, - _Tp* __restrict__ __o) - { memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); } - }; - - template - inline void - __valarray_copy_construct(const _Tp* __restrict__ __b, - const _Tp* __restrict__ __e, - _Tp* __restrict__ __o) - { - _Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: - _S_do_it(__b, __e, __o); - } - - // copy-construct raw array [__o, *) from strided array __a[<__n : __s>] - template - inline void - __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n, - size_t __s, _Tp* __restrict__ __o) - { - if (__is_fundamental<_Tp>::_M_type) - while (__n--) { *__o++ = *__a; __a += __s; } - else - while (__n--) { new(__o++) _Tp(*__a); __a += __s; } - } - - // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]] - template - inline void - __valarray_copy_construct (const _Tp* __restrict__ __a, - const size_t* __restrict__ __i, - _Tp* __restrict__ __o, size_t __n) - { - if (__is_fundamental<_Tp>::_M_type) - while (__n--) *__o++ = __a[*__i++]; - else - while (__n--) new (__o++) _Tp(__a[*__i++]); - } - - // Do the necessary cleanup when we're done with arrays. - template - inline void - __valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { - if (!__is_fundamental<_Tp>::_M_type) - while (__b != __e) { __b->~_Tp(); ++__b; } - } - - // fill plain array __a[<__n>] with __t - template - void - __valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t) - { while (__n--) *__a++ = __t; } - - // fill strided array __a[<__n-1 : __s>] with __t - template - inline void - __valarray_fill (_Tp* __restrict__ __a, size_t __n, - size_t __s, const _Tp& __t) - { for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; } - - // fill indir ect array __a[__i[<__n>]] with __i - template - inline void - __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i, - size_t __n, const _Tp& __t) - { for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; } - - // copy plain array __a[<__n>] in __b[<__n>] - // For non-fundamental types, it is wrong to say 'memcpy()' - template - struct _Array_copier - { - inline static void - _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) - { while (__n--) *__b++ = *__a++; } - }; - - template - struct _Array_copier<_Tp, true> - { - inline static void - _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) - { memcpy (__b, __a, __n * sizeof (_Tp)); } - }; - - template - inline void - __valarray_copy (const _Tp* __restrict__ __a, size_t __n, - _Tp* __restrict__ __b) - { - _Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>:: - _S_do_it(__a, __n, __b); - } - - // copy strided array __a[<__n : __s>] in plain __b[<__n>] - template - inline void - __valarray_copy (const _Tp* __restrict__ __a, size_t __n, size_t __s, - _Tp* __restrict__ __b) - { for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; } - - // copy plain __a[<__n>] in strided __b[<__n : __s>] - template - inline void - __valarray_copy (const _Tp* __restrict__ __a, _Tp* __restrict__ __b, - size_t __n, size_t __s) - { for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; } - - // copy indexed __a[__i[<__n>]] in plain __b[<__n>] - template - inline void - __valarray_copy (const _Tp* __restrict__ __a, - const size_t* __restrict__ __i, - _Tp* __restrict__ __b, size_t __n) - { for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; } - - // copy plain __a[<__n>] in indexed __b[__i[<__n>]] - template - inline void - __valarray_copy (const _Tp* __restrict__ __a, size_t __n, - _Tp* __restrict__ __b, const size_t* __restrict__ __i) - { for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; } - - - // - // Compute the sum of elements in range [__f, __l) - // This is a naive algorithm. It suffers from cancelling. - // In the future try to specialize - // for _Tp = float, double, long double using a more accurate - // algorithm. - // - template - inline _Tp - __valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l) - { - _Tp __r = _Tp(); - while (__f != __l) __r += *__f++; - return __r; - } - - // Compute the product of all elements in range [__f, __l) - template - inline _Tp - __valarray_product(const _Tp* __restrict__ __f, - const _Tp* __restrict__ __l) - { - _Tp __r = _Tp(1); - while (__f != __l) __r = __r * *__f++; - return __r; - } - - // Compute the min/max of an array-expression - template - inline typename _Ta::value_type - __valarray_min(const _Ta& __a) - { - size_t __s = __a.size(); - typedef typename _Ta::value_type _Value_type; - _Value_type __r = __s == 0 ? _Value_type() : __a[0]; - for (size_t __i = 1; __i < __s; ++__i) - { - _Value_type __t = __a[__i]; - if (__t < __r) - __r = __t; - } - return __r; - } - - template - inline typename _Ta::value_type - __valarray_max(const _Ta& __a) - { - size_t __s = __a.size(); - typedef typename _Ta::value_type _Value_type; - _Value_type __r = __s == 0 ? _Value_type() : __a[0]; - for (size_t __i = 1; __i < __s; ++__i) - { - _Value_type __t = __a[__i]; - if (__t > __r) - __r = __t; - } - return __r; - } - - // - // Helper class _Array, first layer of valarray abstraction. - // All operations on valarray should be forwarded to this class - // whenever possible. -- gdr - // - - template - struct _Array - { - explicit _Array (size_t); - explicit _Array (_Tp* const __restrict__); - explicit _Array (const valarray<_Tp>&); - _Array (const _Tp* __restrict__, size_t); - - _Tp* begin () const; - - _Tp* const __restrict__ _M_data; - }; - - template - inline void - __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) - { __valarray_fill (__a._M_data, __n, __t); } - - template - inline void - __valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) - { __valarray_fill (__a._M_data, __n, __s, __t); } - - template - inline void - __valarray_fill (_Array<_Tp> __a, _Array __i, - size_t __n, const _Tp& __t) - { __valarray_fill (__a._M_data, __i._M_data, __n, __t); } - - template - inline void - __valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) - { __valarray_copy (__a._M_data, __n, __b._M_data); } - - template - inline void - __valarray_copy (_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) - { __valarray_copy(__a._M_data, __n, __s, __b._M_data); } - - template - inline void - __valarray_copy (_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) - { __valarray_copy (__a._M_data, __b._M_data, __n, __s); } - - template - inline void - __valarray_copy (_Array<_Tp> __a, _Array __i, - _Array<_Tp> __b, size_t __n) - { __valarray_copy (__a._M_data, __i._M_data, __b._M_data, __n); } - - template - inline void - __valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, - _Array __i) - { __valarray_copy (__a._M_data, __n, __b._M_data, __i._M_data); } - - template - inline - _Array<_Tp>::_Array (size_t __n) - : _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_default_construct(_M_data, _M_data + __n); } - - template - inline - _Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {} - - template - inline _Array<_Tp>::_Array (const valarray<_Tp>& __v) - : _M_data (__v._M_data) {} - - template - inline - _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s) - : _M_data(__valarray_get_storage<_Tp>(__s)) - { __valarray_copy_construct(__b, __s, _M_data); } - - template - inline _Tp* - _Array<_Tp>::begin () const - { return _M_data; } - -#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t) \ -{ \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p) \ - *__p _Op##= __t; \ -} \ - \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \ -{ \ - _Tp* __p = __a._M_data; \ - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q) \ - *__p _Op##= *__q; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, \ - const _Expr<_Dom,_Tp>& __e, size_t __n) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i]; \ -} \ - \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s, \ - _Array<_Tp> __b) \ -{ \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \ - *__p _Op##= *__q; \ -} \ - \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b, \ - size_t __n, size_t __s) \ -{ \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s) \ - *__p _Op##= *__q; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __s, \ - const _Expr<_Dom,_Tp>& __e, size_t __n) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i]; \ -} \ - \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __i, \ - _Array<_Tp> __b, size_t __n) \ -{ \ - _Tp* __q (__b._M_data); \ - for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q) \ - __a._M_data[*__j] _Op##= *__q; \ -} \ - \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \ - _Array<_Tp> __b, _Array __i) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \ - *__p _Op##= __b._M_data[*__j]; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __i, \ - const _Expr<_Dom, _Tp>& __e, size_t __n) \ -{ \ - size_t* __j (__i._M_data); \ - for (size_t __k=0; __k<__n; ++__k, ++__j) \ - __a._M_data[*__j] _Op##= __e[__k]; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __m, \ - _Array<_Tp> __b, size_t __n) \ -{ \ - bool* ok (__m._M_data); \ - _Tp* __p (__a._M_data); \ - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \ - while (! *ok) { \ - ++ok; \ - ++__p; \ - } \ - *__p _Op##= *__q; \ - } \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \ - _Array<_Tp> __b, _Array __m) \ -{ \ - bool* ok (__m._M_data); \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \ - while (! *ok) { \ - ++ok; \ - ++__q; \ - } \ - *__p _Op##= *__q; \ - } \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __m, \ - const _Expr<_Dom, _Tp>& __e, size_t __n) \ -{ \ - bool* ok(__m._M_data); \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { \ - while (! *ok) { \ - ++ok; \ - ++__p; \ - } \ - *__p _Op##= __e[__i]; \ - } \ -} - -_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) - -#undef _DEFINE_VALARRAY_FUNCTION - -} // std:: - -#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT -# define export -# include -#endif - -#endif /* _CPP_BITS_ARRAY_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/valarray_array.tcc b/libstdc++-v3/bits/valarray_array.tcc deleted file mode 100644 index ab77f4aca1e..00000000000 --- a/libstdc++-v3/bits/valarray_array.tcc +++ /dev/null @@ -1,161 +0,0 @@ -// The template and inlines for the -*- C++ -*- internal _Array helper class. - -// Copyright (C) 1997-1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_BITS_VALARRAY_ARRAY_TCC -#define _CPP_BITS_VALARRAY_ARRAY_TCC 1 - -namespace std -{ - -export template -void -__valarray_fill (_Array<_Tp> __a, size_t __n, _Array __m, const _Tp& __t) -{ - _Tp* __p = __a._M_data; - bool* __ok (__m._M_data); - for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) { - while (! *__ok) { - ++__ok; - ++__p; - } - *__p = __t; - } -} - -export template -void -__valarray_copy (_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) -{ - _Tp* __p (__a._M_data); - bool* __ok (__m._M_data); - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++__ok, ++__p) { - while (! *__ok) { - ++__ok; - ++__p; - } - *__q = *__p; - } -} - -export template -void -__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) -{ - _Tp* __q (__b._M_data); - bool* __ok (__m._M_data); - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++__ok, ++__q) { - while (! *__ok) { - ++__ok; - ++__q; - } - *__q = *__p; - } -} - -export template -void -__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a) -{ - _Tp* __p (__a._M_data); - for (size_t __i=0; __i<__n; ++__i, ++__p) *__p = __e[__i]; -} - -export template -void -__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, - _Array<_Tp> __a, size_t __s) -{ - _Tp* __p (__a._M_data); - for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p = __e[__i]; -} - -export template -void -__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, - _Array<_Tp> __a, _Array __i) -{ - size_t* __j (__i._M_data); - for (size_t __k=0; __k<__n; ++__k, ++__j) __a._M_data[*__j] = __e[__k]; -} - -export template -void -__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, - _Array<_Tp> __a, _Array __m) -{ - bool* __ok (__m._M_data); - _Tp* __p (__a._M_data); - for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) { - while (! *__ok) { - ++__ok; - ++__p; - } - *__p = __e[__i]; - } -} - - -export template -void -__valarray_copy_construct (const _Expr<_Dom, _Tp>& __e, size_t __n, - _Array<_Tp> __a) -{ - _Tp* __p (__a._M_data); - for (size_t __i=0; __i<__n; ++__i, ++__p) new (__p) _Tp(__e[__i]); -} - - -export template -void -__valarray_copy_construct (_Array<_Tp> __a, _Array __m, - _Array<_Tp> __b, size_t __n) -{ - _Tp* __p (__a._M_data); - bool* __ok (__m._M_data); - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++__ok, ++__p) { - while (! *__ok) { - ++__ok; - ++__p; - } - new (__q) _Tp(*__p); - } -} - - - - -} // std:: - -#endif /* _CPP_BITS_VALARRAY_ARRAY_TCC */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/bits/valarray_meta.h b/libstdc++-v3/bits/valarray_meta.h deleted file mode 100644 index e2e65de9c67..00000000000 --- a/libstdc++-v3/bits/valarray_meta.h +++ /dev/null @@ -1,1067 +0,0 @@ -// The template and inlines for the -*- C++ -*- internal _Meta class. - -// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -// Written by Gabriel Dos Reis - -#ifndef _CPP_VALARRAY_META_H -#define _CPP_VALARRAY_META_H 1 - -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 class _Constant; - - // - // Unary function application closure. - // - template 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); - }; - - template class _Meta, class _Dom> - class _UnFunClos; - - template - 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) {} - }; - - template - struct _UnFunClos<_ValArray,_Tp> : _UnFunBase > { - typedef _UnFunBase > _Base; - typedef typename _Base::value_type value_type; - - _UnFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp)) - : _Base (__v, __f) {} - }; - - // - // Binary function application closure. - // - template class _Meta1, - template class Meta2, - class _Dom1, class _Dom2> class _BinFunClos; - - template class _BinFunBase { - public: - typedef typename _Dom1::value_type value_type; - typedef value_type _Vt; - - _BinFunBase (const _Dom1& __e1, const _Dom2& __e2, - _Vt __f (_Vt, _Vt)) - : _M_expr1 (__e1), _M_expr2 (__e2), _M_func (__f) {} - - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1[__i], _M_expr2[__i]); } - size_t size () const { return _M_expr1.size (); } - - private: - const _Dom1& _M_expr1; - const _Dom2& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; - - template class _BinFunBase1 { - public: - typedef typename _Dom::value_type value_type ; - typedef value_type _Vt; - - _BinFunBase1 (const _Vt& __c, const _Dom& __e, _Vt __f(_Vt, _Vt)) - : _M_expr1 (__c), _M_expr2 (__e), _M_func (__f) {} - - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1, _M_expr2[__i]); } - size_t size () const { return _M_expr2.size (); } - - private: - const _Vt& _M_expr1; - const _Dom& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; - - template class _BinFunBase2 { - public: - typedef typename _Dom::value_type value_type; - typedef value_type _Vt; - - _BinFunBase2 (const _Dom& __e, const _Vt& __c, _Vt __f(_Vt, _Vt)) - : _M_expr1 (__e), _M_expr2 (__c), _M_func (__f) {} - - value_type operator[] (size_t __i) const - { return _M_func (_M_expr1[__i], _M_expr2); } - size_t size () const { return _M_expr1.size (); } - - private: - const _Dom& _M_expr1; - const _Vt& _M_expr2; - _Vt (*_M_func)(_Vt, _Vt); - }; - - template - 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; - - _BinFunClos (const _Dom1& __e1, const _Dom2& __e2, - _Tp __f(_Tp, _Tp)) - : _Base (__e1, __e2, __f) {} - }; - - template - struct _BinFunClos<_ValArray,_ValArray,_Tp,_Tp> - : _BinFunBase, valarray<_Tp> > { - typedef _BinFunBase, valarray<_Tp> > _Base; - typedef _Tp value_type; - - _BinFunClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __w, __f) {} - }; - - template - struct _BinFunClos<_Expr,_ValArray,_Dom,typename _Dom::value_type> - : _BinFunBase<_Dom,valarray > { - typedef typename _Dom::value_type _Tp; - typedef _BinFunBase<_Dom,valarray<_Tp> > _Base; - typedef _Tp value_type; - - _BinFunClos (const _Dom& __e, const valarray<_Tp>& __v, - _Tp __f(_Tp, _Tp)) - : _Base (__e, __v, __f) {} - }; - - template - struct _BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom> - : _BinFunBase,_Dom> { - typedef typename _Dom::value_type _Tp; - typedef _BinFunBase<_Dom,valarray<_Tp> > _Base; - typedef _Tp value_type; - - _BinFunClos (const valarray<_Tp>& __v, const _Dom& __e, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __e, __f) {} - }; - - template - 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; - - _BinFunClos (const _Dom& __e, const _Tp& __t, _Tp __f (_Tp, _Tp)) - : _Base (__e, __t, __f) {} - }; - - template - 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; - - _BinFunClos (const _Tp& __t, const _Dom& __e, _Tp __f (_Tp, _Tp)) - : _Base (__t, __e, __f) {} - }; - - template - struct _BinFunClos<_ValArray,_Constant,_Tp,_Tp> - : _BinFunBase2 > { - typedef _BinFunBase2 > _Base; - typedef _Tp value_type; - - _BinFunClos (const valarray<_Tp>& __v, const _Tp& __t, - _Tp __f(_Tp, _Tp)) - : _Base (__v, __t, __f) {} - }; - - template - struct _BinFunClos<_Constant,_ValArray,_Tp,_Tp> - : _BinFunBase1 > { - typedef _BinFunBase1 > _Base; - typedef _Tp value_type; - - _BinFunClos (const _Tp& __t, const valarray<_Tp>& __v, - _Tp __f (_Tp, _Tp)) - : _Base (__t, __v, __f) {} - }; - - // - // Apply function taking a value/const reference closure - // - - template class _FunBase { - public: - typedef typename _Dom::value_type value_type; - - _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]); } - size_t size() const { return _M_expr.size ();} - - private: - const _Dom& _M_expr; - value_type (*_M_func)(_Arg); - }; - - template - 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) {} - }; - - template - struct _ValFunClos<_ValArray,_Tp> - : _FunBase, _Tp> { - typedef _FunBase, _Tp> _Base; - typedef _Tp value_type; - - _ValFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp)) - : _Base (__v, __f) {} - }; - - template - 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) {} - }; - - template - struct _RefFunClos<_ValArray,_Tp> - : _FunBase, const _Tp&> { - typedef _FunBase, const _Tp&> _Base; - typedef _Tp value_type; - - _RefFunClos (const valarray<_Tp>& __v, _Tp __f(const _Tp&)) - : _Base (__e, __f) {} - }; - - // - // Unary expression closure. - // - - template class _Oper, typename _Arg> - class _UnBase { - public: - typedef _Oper _Op; - typedef typename _Op::result_type value_type; - - _UnBase (const _Arg& __e) : _M_expr(__e) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr.size (); } - - private: - const _Arg& _M_expr; - }; - - template 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 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, 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. - // - - template class _Oper, - typename _FirstArg, typename _SecondArg> - class _BinBase { - public: - typedef _Oper _Op; - typedef typename _Op::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 (); } - - private: - const _FirstArg& _M_expr1; - const _SecondArg& _M_expr2; - }; - - template 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 class _Oper, class _Clos> - class _BinBase2 { - public: - typedef typename _Clos::value_type _Vt; - typedef _Oper<_Vt> _Op; - typedef typename _Op::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 (); } - - private: - const _Clos& _M_expr1; - const _Vt& _M_expr2; - }; - - template 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); } - - - 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; - - _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 (); } - - private: - const _Vt& _M_expr1; - const _Clos& _M_expr2; - }; - - template 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 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) {} - }; - - 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; - - _BinClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w) - : _Base (__v, __w) {} - }; - - template class _Oper, class _Dom> - struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type> - : _BinBase<_Oper,_Dom,valarray > { - 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,_ValArray,_Expr,typename _Dom::value_type,_Dom> - : _BinBase<_Oper,valarray,_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 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) {} - }; - - 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) {} - }; - - 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) {} - }; - - 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) {} - }; - - - // - // slice_array closure. - // - template class _SBase { - public: - typedef typename _Dom::value_type value_type; - - _SBase (const _Dom& __e, const slice& __s) - : _M_expr (__e), _M_slice (__s) {} - value_type operator[] (size_t __i) const - { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; } - size_t size() const { return _M_slice.size (); } - - private: - const _Dom& _M_expr; - const slice& _M_slice; - }; - - template class _SBase<_Array<_Tp> > { - public: - typedef _Tp value_type; - - _SBase (_Array<_Tp> __a, const slice& __s) - : _M_array (__a._M_data+__s.start()), _M_size (__s.size()), - _M_stride (__s.stride()) {} - value_type operator[] (size_t __i) const - { return _M_array._M_data[__i * _M_stride]; } - size_t size() const { return _M_size; } - - private: - const _Array<_Tp> _M_array; - const size_t _M_size; - const size_t _M_stride; - }; - - template struct _SClos<_Expr,_Dom> : _SBase<_Dom> { - typedef _SBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {} - }; - - template - struct _SClos<_ValArray,_Tp> : _SBase<_Array<_Tp> > { - typedef _SBase<_Array<_Tp> > _Base; - typedef _Tp value_type; - - _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {} - }; - - // - // gslice_array closure. - // - template class _GBase { - public: - typedef typename _Dom::value_type value_type; - - _GBase (const _Dom& __e, const valarray& __i) - : _M_expr (__e), _M_index(__i) {} - value_type operator[] (size_t __i) const - { return _M_expr[_M_index[__i]]; } - size_t size () const { return _M_index.size(); } - - private: - const _Dom& _M_expr; - const valarray& _M_index; - }; - - template class _GBase<_Array<_Tp> > { - public: - typedef _Tp value_type; - - _GBase (_Array<_Tp> __a, const valarray& __i) - : _M_array (__a), _M_index(__i) {} - value_type operator[] (size_t __i) const - { return _M_array._M_data[_M_index[__i]]; } - size_t size () const { return _M_index.size(); } - - private: - const _Array<_Tp> _M_array; - const valarray& _M_index; - }; - - template struct _GClos<_Expr,_Dom> : _GBase<_Dom> { - typedef _GBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _GClos (const _Dom& __e, const valarray& __i) - : _Base (__e, __i) {} - }; - - template - struct _GClos<_ValArray,_Tp> : _GBase<_Array<_Tp> > { - typedef _GBase<_Array<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _GClos (_Array<_Tp> __a, const valarray& __i) - : _Base (__a, __i) {} - }; - - // - // indirect_array closure - // - - template class _IBase { - public: - typedef typename _Dom::value_type value_type; - - _IBase (const _Dom& __e, const valarray& __i) - : _M_expr (__e), _M_index (__i) {} - value_type operator[] (size_t __i) const - { return _M_expr[_M_index[__i]]; } - size_t size() const { return _M_index.size(); } - - private: - const _Dom& _M_expr; - const valarray& _M_index; - }; - - template struct _IClos<_Expr,_Dom> : _IBase<_Dom> { - typedef _IBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _IClos (const _Dom& __e, const valarray& __i) - : _Base (__e, __i) {} - }; - - template - struct _IClos<_ValArray,_Tp> : _IBase > { - typedef _IBase > _Base; - typedef _Tp value_type; - - _IClos (const valarray<_Tp>& __a, const valarray& __i) - : _Base (__a, __i) {} - }; - - // - // class _Expr - // - template class _Expr { - public: - typedef _Tp value_type; - - _Expr (const _Clos&); - - const _Clos& operator() () const; - - value_type operator[] (size_t) const; - valarray operator[] (slice) const; - valarray operator[] (const gslice&) const; - valarray operator[] (const valarray&) const; - valarray operator[] (const valarray&) const; - - _Expr<_UnClos<_Unary_plus,_Expr,_Clos>, value_type> - operator+ () const; - - _Expr<_UnClos, value_type> - operator- () const; - - _Expr<_UnClos<_Bitwise_not,_Expr,_Clos>, value_type> - operator~ () const; - - _Expr<_UnClos, bool> - operator! () const; - - size_t size () const; - value_type sum () const; - - valarray shift (int) const; - valarray cshift (int) const; - - value_type min() const; - value_type max() const; - - valarray apply(value_type (*) (const value_type&)) const; - valarray apply(value_type (*) (value_type)) const; - - private: - const _Clos _M_closure; - }; - - template - inline - _Expr<_Clos,_Tp>::_Expr (const _Clos& __c) : _M_closure(__c) {} - - template - inline const _Clos& - _Expr<_Clos,_Tp>::operator() () const - { return _M_closure; } - - template - inline _Tp - _Expr<_Clos,_Tp>::operator[] (size_t __i) const - { return _M_closure[__i]; } - - template - inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (slice __s) const - { return _M_closure[__s]; } - - template - inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const gslice& __gs) const - { return _M_closure[__gs]; } - - template - inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray& __m) const - { return _M_closure[__m]; } - - template - inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray& __i) const - { return _M_closure[__i]; } - - template - inline size_t - _Expr<_Clos,_Tp>::size () const { return _M_closure.size (); } - - template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::shift(int __n) const - { return valarray<_Tp>(_M_closure).shift(__n); } - - template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::cshift(int __n) const - { return valarray<_Tp>(_M_closure).cshift(__n); } - - template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const - { return valarray<_Tp>(_M_closure).apply(__f); } - - template - 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 - inline _Tp - _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; - } - } - - template - inline _Tp - _Expr<_Clos, _Tp>::min() const - { return __valarray_min(_M_closure); } - - template - inline _Tp - _Expr<_Clos, _Tp>::max() const - { return __valarray_max(_M_closure); } - - template - inline _Expr<_UnClos, bool> - _Expr<_Dom,_Tp>::operator! () const - { - typedef _UnClos _Closure; - return _Expr<_Closure,_Tp> (_Closure(this->_M_closure)); - } - -#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ -template \ -inline _Expr<_UnClos<_Name,_Expr,_Dom>,_Tp> \ -_Expr<_Dom,_Tp>::operator _Op () const \ -{ \ - typedef _UnClos<_Name,_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) - -#undef _DEFINE_EXPR_UNARY_OPERATOR - - -#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ -template \ -inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \ - typename _Name::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 _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \ - return _Expr<_Closure,_Value> (_Closure (__v (), __w ())); \ -} \ - \ -template \ -inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>, \ - typename _Name::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)); \ -} \ - \ -template \ -inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Name::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 ())); \ -} \ - \ -template \ -inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \ - typename _Name::result_type> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \ - const valarray& __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)); \ -} \ - \ -template \ -inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Name::result_type> \ -operator _Op (const valarray& __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 ())); \ -} - - _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) - -#undef _DEFINE_EXPR_BINARY_OPERATOR - -#define _DEFINE_EXPR_RELATIONAL_OPERATOR(_Op, _Name) \ -template \ -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 \ -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 \ -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 \ -inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \ - bool> \ -operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \ - const valarray& __v) \ -{ \ - typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Tp> _Closure; \ - return _Expr<_Closure,bool> (_Closure (__e (), __v)); \ -} \ - \ -template \ -inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - bool> \ -operator _Op (const valarray& __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 \ -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 \ -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_EXPR_UNARY_FUNCTION(abs) - _DEFINE_EXPR_UNARY_FUNCTION(cos) - _DEFINE_EXPR_UNARY_FUNCTION(acos) - _DEFINE_EXPR_UNARY_FUNCTION(cosh) - _DEFINE_EXPR_UNARY_FUNCTION(sin) - _DEFINE_EXPR_UNARY_FUNCTION(asin) - _DEFINE_EXPR_UNARY_FUNCTION(sinh) - _DEFINE_EXPR_UNARY_FUNCTION(tan) - _DEFINE_EXPR_UNARY_FUNCTION(tanh) - _DEFINE_EXPR_UNARY_FUNCTION(atan) - _DEFINE_EXPR_UNARY_FUNCTION(exp) - _DEFINE_EXPR_UNARY_FUNCTION(log) - _DEFINE_EXPR_UNARY_FUNCTION(log10) - _DEFINE_EXPR_UNARY_FUNCTION(sqrt) - -#undef _DEFINE_EXPR_UNARY_FUNCTION - - -#define _DEFINE_EXPR_BINARY_FUNCTION(_Name) \ -template \ -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 \ -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& __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 \ -inline _Expr<_BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom>, \ - typename _Dom::value_type> \ -_Name (const 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 \ -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 \ -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 \ -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 \ -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 \ -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_EXPR_BINARY_FUNCTION(atan2) -_DEFINE_EXPR_BINARY_FUNCTION(pow) - -#undef _DEFINE_EXPR_BINARY_FUNCTION - -} // std:: - - -#endif /* _CPP_VALARRAY_META_H */ - -// Local Variables: -// mode:c++ -// End: diff --git a/libstdc++-v3/std/algorithm b/libstdc++-v3/std/algorithm deleted file mode 100644 index eebcdf22977..00000000000 --- a/libstdc++-v3/std/algorithm +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_ALGORITHM -#include -#endif diff --git a/libstdc++-v3/std/bitset b/libstdc++-v3/std/bitset deleted file mode 100644 index e334ec96451..00000000000 --- a/libstdc++-v3/std/bitset +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_BITSET -#include -#endif diff --git a/libstdc++-v3/std/cassert b/libstdc++-v3/std/cassert deleted file mode 100644 index bee254d55f1..00000000000 --- a/libstdc++-v3/std/cassert +++ /dev/null @@ -1,3 +0,0 @@ -// This one should not have include guards. -#include - diff --git a/libstdc++-v3/std/cctype b/libstdc++-v3/std/cctype deleted file mode 100644 index d888a3f80ed..00000000000 --- a/libstdc++-v3/std/cctype +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CCTYPE -#include -#endif diff --git a/libstdc++-v3/std/cerrno b/libstdc++-v3/std/cerrno deleted file mode 100644 index 5d2cf1f61a4..00000000000 --- a/libstdc++-v3/std/cerrno +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CERRNO -#include -#endif diff --git a/libstdc++-v3/std/cfloat b/libstdc++-v3/std/cfloat deleted file mode 100644 index c6cb35731a8..00000000000 --- a/libstdc++-v3/std/cfloat +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CFLOAT -#include -#endif diff --git a/libstdc++-v3/std/ciso646 b/libstdc++-v3/std/ciso646 deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/libstdc++-v3/std/climits b/libstdc++-v3/std/climits deleted file mode 100644 index b7614847bbe..00000000000 --- a/libstdc++-v3/std/climits +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CLIMITS -#include -#endif diff --git a/libstdc++-v3/std/clocale b/libstdc++-v3/std/clocale deleted file mode 100644 index 6ac636f8786..00000000000 --- a/libstdc++-v3/std/clocale +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CLOCALE -#include -#endif diff --git a/libstdc++-v3/std/cmath b/libstdc++-v3/std/cmath deleted file mode 100644 index 783e76af1c5..00000000000 --- a/libstdc++-v3/std/cmath +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CMATH -#include -#endif diff --git a/libstdc++-v3/std/complex b/libstdc++-v3/std/complex deleted file mode 100644 index 2cc52f5531d..00000000000 --- a/libstdc++-v3/std/complex +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_COMPLEX -#include -#endif diff --git a/libstdc++-v3/std/csetjmp b/libstdc++-v3/std/csetjmp deleted file mode 100644 index 79531e3607a..00000000000 --- a/libstdc++-v3/std/csetjmp +++ /dev/null @@ -1,4 +0,0 @@ - -#ifndef _CPP_CSETJMP -#include -#endif diff --git a/libstdc++-v3/std/csignal b/libstdc++-v3/std/csignal deleted file mode 100644 index e5c1837a4a5..00000000000 --- a/libstdc++-v3/std/csignal +++ /dev/null @@ -1,4 +0,0 @@ - -#ifndef _CPP_CSIGNAL -#include -#endif diff --git a/libstdc++-v3/std/cstdarg b/libstdc++-v3/std/cstdarg deleted file mode 100644 index 37b2459f6a5..00000000000 --- a/libstdc++-v3/std/cstdarg +++ /dev/null @@ -1,4 +0,0 @@ - -#ifndef _CPP_CSTDARG -#include -#endif diff --git a/libstdc++-v3/std/cstddef b/libstdc++-v3/std/cstddef deleted file mode 100644 index fab421423ba..00000000000 --- a/libstdc++-v3/std/cstddef +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CSTDDEF -#include -#endif diff --git a/libstdc++-v3/std/cstdio b/libstdc++-v3/std/cstdio deleted file mode 100644 index f2a0135e65a..00000000000 --- a/libstdc++-v3/std/cstdio +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CSTDIO -#include -#endif diff --git a/libstdc++-v3/std/cstdlib b/libstdc++-v3/std/cstdlib deleted file mode 100644 index 98230261186..00000000000 --- a/libstdc++-v3/std/cstdlib +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CSTDLIB -#include -#endif diff --git a/libstdc++-v3/std/cstring b/libstdc++-v3/std/cstring deleted file mode 100644 index b6a3bd9b53f..00000000000 --- a/libstdc++-v3/std/cstring +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CSTRING -#include -#endif diff --git a/libstdc++-v3/std/ctime b/libstdc++-v3/std/ctime deleted file mode 100644 index 838fd4360ef..00000000000 --- a/libstdc++-v3/std/ctime +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CTIME -#include -#endif diff --git a/libstdc++-v3/std/cwchar b/libstdc++-v3/std/cwchar deleted file mode 100644 index 2cfc330637c..00000000000 --- a/libstdc++-v3/std/cwchar +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CWCHAR -#include -#endif diff --git a/libstdc++-v3/std/cwctype b/libstdc++-v3/std/cwctype deleted file mode 100644 index ccd49086901..00000000000 --- a/libstdc++-v3/std/cwctype +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_CWCTYPE -#include -#endif diff --git a/libstdc++-v3/std/deque b/libstdc++-v3/std/deque deleted file mode 100644 index 2215fd02de1..00000000000 --- a/libstdc++-v3/std/deque +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_DEQUE -#include -#endif diff --git a/libstdc++-v3/std/exception b/libstdc++-v3/std/exception deleted file mode 100644 index 06653d17e7e..00000000000 --- a/libstdc++-v3/std/exception +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_EXCEPTION -#include -#endif diff --git a/libstdc++-v3/std/fstream b/libstdc++-v3/std/fstream deleted file mode 100644 index afe99e98da9..00000000000 --- a/libstdc++-v3/std/fstream +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_FSTREAM -#include -#endif diff --git a/libstdc++-v3/std/functional b/libstdc++-v3/std/functional deleted file mode 100644 index 700c211ba23..00000000000 --- a/libstdc++-v3/std/functional +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_FUNCTIONAL -#include -#endif diff --git a/libstdc++-v3/std/iomanip b/libstdc++-v3/std/iomanip deleted file mode 100644 index d3c2aa84177..00000000000 --- a/libstdc++-v3/std/iomanip +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_IOMANIP -#include -#endif diff --git a/libstdc++-v3/std/ios b/libstdc++-v3/std/ios deleted file mode 100644 index 7132eadfa33..00000000000 --- a/libstdc++-v3/std/ios +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_IOS -#include -#endif diff --git a/libstdc++-v3/std/iosfwd b/libstdc++-v3/std/iosfwd deleted file mode 100644 index 6a97d3d2d32..00000000000 --- a/libstdc++-v3/std/iosfwd +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_IOSFWD -#include -#endif diff --git a/libstdc++-v3/std/iostream b/libstdc++-v3/std/iostream deleted file mode 100644 index f94fd058a55..00000000000 --- a/libstdc++-v3/std/iostream +++ /dev/null @@ -1,5 +0,0 @@ -#ifndef _CPP_IOSTREAM -#include -#endif - - diff --git a/libstdc++-v3/std/istream b/libstdc++-v3/std/istream deleted file mode 100644 index 9594261aa61..00000000000 --- a/libstdc++-v3/std/istream +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_ISTREAM -#include -#endif diff --git a/libstdc++-v3/std/iterator b/libstdc++-v3/std/iterator deleted file mode 100644 index eb22c69746c..00000000000 --- a/libstdc++-v3/std/iterator +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_ITERATOR -#include -#endif diff --git a/libstdc++-v3/std/limits b/libstdc++-v3/std/limits deleted file mode 100644 index ba86fe0cba7..00000000000 --- a/libstdc++-v3/std/limits +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_LIMITS -#include -#endif diff --git a/libstdc++-v3/std/list b/libstdc++-v3/std/list deleted file mode 100644 index ea1883639fa..00000000000 --- a/libstdc++-v3/std/list +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_LIST -#include -#endif diff --git a/libstdc++-v3/std/locale b/libstdc++-v3/std/locale deleted file mode 100644 index 5452ae81040..00000000000 --- a/libstdc++-v3/std/locale +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_LOCALE -#include -#endif diff --git a/libstdc++-v3/std/map b/libstdc++-v3/std/map deleted file mode 100644 index 16d24f8ee61..00000000000 --- a/libstdc++-v3/std/map +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_MAP -#include -#endif diff --git a/libstdc++-v3/std/memory b/libstdc++-v3/std/memory deleted file mode 100644 index f905b4d1d51..00000000000 --- a/libstdc++-v3/std/memory +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_MEMORY -#include -#endif diff --git a/libstdc++-v3/std/new b/libstdc++-v3/std/new deleted file mode 100644 index dac53f8e7fc..00000000000 --- a/libstdc++-v3/std/new +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_NEW -#include -#endif diff --git a/libstdc++-v3/std/numeric b/libstdc++-v3/std/numeric deleted file mode 100644 index b3817a838cb..00000000000 --- a/libstdc++-v3/std/numeric +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_NUMERIC -#include -#endif diff --git a/libstdc++-v3/std/ostream b/libstdc++-v3/std/ostream deleted file mode 100644 index beed8c58a3d..00000000000 --- a/libstdc++-v3/std/ostream +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_OSTREAM -#include -#endif diff --git a/libstdc++-v3/std/queue b/libstdc++-v3/std/queue deleted file mode 100644 index 278270cfdff..00000000000 --- a/libstdc++-v3/std/queue +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_QUEUE -#include -#endif diff --git a/libstdc++-v3/std/set b/libstdc++-v3/std/set deleted file mode 100644 index 7aa6a388d41..00000000000 --- a/libstdc++-v3/std/set +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_SET -#include -#endif diff --git a/libstdc++-v3/std/sstream b/libstdc++-v3/std/sstream deleted file mode 100644 index 92c57cb46bf..00000000000 --- a/libstdc++-v3/std/sstream +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_SSTREAM -#include -#endif diff --git a/libstdc++-v3/std/stack b/libstdc++-v3/std/stack deleted file mode 100644 index db3771e7adb..00000000000 --- a/libstdc++-v3/std/stack +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_STACK -#include -#endif diff --git a/libstdc++-v3/std/stdexcept b/libstdc++-v3/std/stdexcept deleted file mode 100644 index da75270e682..00000000000 --- a/libstdc++-v3/std/stdexcept +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_STDEXCEPT -#include -#endif diff --git a/libstdc++-v3/std/streambuf b/libstdc++-v3/std/streambuf deleted file mode 100644 index 0a58fbdd8ff..00000000000 --- a/libstdc++-v3/std/streambuf +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_STREAMBUF -#include -#endif diff --git a/libstdc++-v3/std/string b/libstdc++-v3/std/string deleted file mode 100644 index 8e3cd42715e..00000000000 --- a/libstdc++-v3/std/string +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_STRING -#include -#endif diff --git a/libstdc++-v3/std/strstream b/libstdc++-v3/std/strstream deleted file mode 100644 index 53267144434..00000000000 --- a/libstdc++-v3/std/strstream +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_STRSTREAM -#include -#endif diff --git a/libstdc++-v3/std/typeinfo b/libstdc++-v3/std/typeinfo deleted file mode 100644 index 26526f33693..00000000000 --- a/libstdc++-v3/std/typeinfo +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_TYPEINFO -#include -#endif diff --git a/libstdc++-v3/std/utility b/libstdc++-v3/std/utility deleted file mode 100644 index 924a85398cb..00000000000 --- a/libstdc++-v3/std/utility +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_UTILITY -#include -#endif diff --git a/libstdc++-v3/std/valarray b/libstdc++-v3/std/valarray deleted file mode 100644 index e98bbcef168..00000000000 --- a/libstdc++-v3/std/valarray +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_VALARRAY -#include -#endif diff --git a/libstdc++-v3/std/vector b/libstdc++-v3/std/vector deleted file mode 100644 index c074b77a886..00000000000 --- a/libstdc++-v3/std/vector +++ /dev/null @@ -1,3 +0,0 @@ -#ifndef _CPP_VECTOR -#include -#endif -- 2.30.2