procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR libstdc++/30085 (switch debug mode hash containers from ext to tr1)

Browse source 
2007-10-18  Benjamin Kosnik  <bkoz@redhat.com>

	* include/ext/hash_map: To...
	* include/backward/hash_map: ...here. Remove debug mode.
	* include/ext/hash_set: To...
	* include/backward/hash_set: ...here. Remove debug mode.
	* include/ext/hash_fun.h: To...
	* include/backward/hash_fun.h: ...here.
	* include/ext/hashtable.h: To...
	* include/backward/hashtable.h: ...here.
	
	* include/bits/c++config: Remove __gnu_cxx namespace from debug mode.
	* include/debug/debug.h: Same.
		
	* include/debug/hash_map: Remove.
	* include/debug/hash_multimap.h: Remove.
	* include/debug/hash_set.h: Remove.
	* include/debug/hash_set: Remove.
	* include/debug/hash_multiset.h: Remove.
	* include/debug/hash_map.h: Remove.
	
	* include/Makefile.am (ext_headers): Move hash_set, hash_map to
	backward.
	(debug_headers): Remove hash_map, hash_set, hash_map.h,
	hash_map.h, hash_multiset.h, hash_multimap.h.	
	* include/Makefile.in: Regenerate.

	* docs/html/debug.html: Update.
	* docs/html/ext/howto.html: Same.
	* docs/html/faq/index.html: Same.
	* docs/doxygen/Intro.3: Same.
	* docs/doxygen/user.cfg.in: Adjust includes.
	* testsuite/ext/hash_map: Move to...
	* testsuite/backward/hash_map: ...here.
	* testsuite/ext/hash_set: Move to...
	* testsuite/backward/hash_set: ...here.
	
2007-10-18  Benjamin Kosnik  <bkoz@redhat.com>
        
	Removal of pre-ISO C++ items from include/backwards.
	* include/Makefile.am (backward_headers): Remove all but strstream,
	backward_warning.h.
	* include/Makefile.in: Regenerate.
	* include/backward/new.h: Remove.
	* include/backward/iterator.h: Same.
	* include/backward/alloc.h: Same.
	* include/backward/set.h: Same.
	* include/backward/hashtable.h: Same.
	* include/backward/hash_set.h: Same.
	* include/backward/fstream.h: Same.
	* include/backward/tempbuf.h: Same.
	* include/backward/istream.h: Same.
	* include/backward/bvector.h: Same.
	* include/backward/stack.h: Same.
	* include/backward/rope.h: Same.
	* include/backward/complex.h: Same.
	* include/backward/ostream.h: Same.
	* include/backward/heap.h: Same.
	* include/backward/iostream.h: Same.
	* include/backward/function.h: Same.
	* include/backward/multimap.h: Same.
	* include/backward/pair.h: Same.
	* include/backward/stream.h: Same.
	* include/backward/iomanip.h: Same.
	* include/backward/slist.h: Same.
	* include/backward/tree.h: Same.
	* include/backward/vector.h: Same.
	* include/backward/deque.h: Same.
	* include/backward/multiset.h: Same.
	* include/backward/defalloc.h: Same.
	* include/backward/list.h: Same.
	* include/backward/map.h: Same.
	* include/backward/algobase.h: Same.
	* include/backward/hash_map.h: Same.
	* include/backward/algo.h: Same.
	* include/backward/queue.h: Same.
	* include/backward/streambuf.h: Same.
	* testsuite/backward/header_hash_set_h.cc: Same.
	* testsuite/backward/header_slist_h.cc: Same.
	* testsuite/backward/header_hash_map_h.cc: Same.
	* testsuite/backward/header_tempbuf_h.cc: Same.
	* testsuite/backward/header_deque_h.cc: Same.
	* testsuite/backward/header_rope_h.cc: Same.
	* testsuite/backward/header_iterator_h.cc: Same.
	* testsuite/backward/header_hashtable_h.cc: Same.

2007-10-18  Benjamin Kosnik  <bkoz@redhat.com>

	PR libstdc++/30085
	* include/debug/unordered_map: New.
	* include/debug/unordered_set: New.
	* include/debug/safe_association.h: New.	
	* include/std/unordered_map: Include debug header if _GLIBCXX_DEBUG.
	* include/std/unordered_set: Same.
	* include/Makefile.am (debug_headers): Add unordered_map,
	unordered_set, safe_association.h.
	* include/Makefile.in: Regenerate.
	* testsuite/23_containers/unordered_map/requirements/debug.cc: New.
	* testsuite/23_containers/unordered_multimap/requirements/
	debug.cc: New.
	* testsuite/23_containers/unordered_set/requirements/debug.cc: New.
	* testsuite/23_containers/unordered_multiset/requirements/
	debug.cc: New.

2007-10-18  Benjamin Kosnik  <bkoz@redhat.com>
	
	* testsuite/util/native_type/assoc/native_hash_multimap.hpp: Remove
	hash_map include.

From-SVN: r129442
This commit is contained in:
Benjamin Kosnik 2007-10-18 15:22:58 +00:00 • committed by Benjamin Kosnik
parent e445a2ff97
commit e63637ea90
76 changed files with 1843 additions and 4791 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

109
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,112 @@
2007-10-18 Benjamin Kosnik <bkoz@redhat.com>
* include/ext/hash_map: To...
* include/backward/hash_map: ...here. Remove debug mode.
* include/ext/hash_set: To...
* include/backward/hash_set: ...here. Remove debug mode.
* include/ext/hash_fun.h: To...
* include/backward/hash_fun.h: ...here.
* include/ext/hashtable.h: To...
* include/backward/hashtable.h: ...here.
* include/bits/c++config: Remove __gnu_cxx namespace from debug mode.
* include/debug/debug.h: Same.
* include/debug/hash_map: Remove.
* include/debug/hash_multimap.h: Remove.
* include/debug/hash_set.h: Remove.
* include/debug/hash_set: Remove.
* include/debug/hash_multiset.h: Remove.
* include/debug/hash_map.h: Remove.
* include/Makefile.am (ext_headers): Move hash_set, hash_map to
backward.
(debug_headers): Remove hash_map, hash_set, hash_map.h,
hash_map.h, hash_multiset.h, hash_multimap.h.
* include/Makefile.in: Regenerate.
* docs/html/debug.html: Update.
* docs/html/ext/howto.html: Same.
* docs/html/faq/index.html: Same.
* docs/doxygen/Intro.3: Same.
* docs/doxygen/user.cfg.in: Adjust includes.
* testsuite/ext/hash_map: Move to...
* testsuite/backward/hash_map: ...here.
* testsuite/ext/hash_set: Move to...
* testsuite/backward/hash_set: ...here.
2007-10-18 Benjamin Kosnik <bkoz@redhat.com>
Removal of pre-ISO C++ items from include/backwards.
* include/Makefile.am (backward_headers): Remove all but strstream,
backward_warning.h.
* include/Makefile.in: Regenerate.
* include/backward/new.h: Remove.
* include/backward/iterator.h: Same.
* include/backward/alloc.h: Same.
* include/backward/set.h: Same.
* include/backward/hashtable.h: Same.
* include/backward/hash_set.h: Same.
* include/backward/fstream.h: Same.
* include/backward/tempbuf.h: Same.
* include/backward/istream.h: Same.
* include/backward/bvector.h: Same.
* include/backward/stack.h: Same.
* include/backward/rope.h: Same.
* include/backward/complex.h: Same.
* include/backward/ostream.h: Same.
* include/backward/heap.h: Same.
* include/backward/iostream.h: Same.
* include/backward/function.h: Same.
* include/backward/multimap.h: Same.
* include/backward/pair.h: Same.
* include/backward/stream.h: Same.
* include/backward/iomanip.h: Same.
* include/backward/slist.h: Same.
* include/backward/tree.h: Same.
* include/backward/vector.h: Same.
* include/backward/deque.h: Same.
* include/backward/multiset.h: Same.
* include/backward/defalloc.h: Same.
* include/backward/list.h: Same.
* include/backward/map.h: Same.
* include/backward/algobase.h: Same.
* include/backward/hash_map.h: Same.
* include/backward/algo.h: Same.
* include/backward/queue.h: Same.
* include/backward/streambuf.h: Same.
* testsuite/backward/header_hash_set_h.cc: Same.
* testsuite/backward/header_slist_h.cc: Same.
* testsuite/backward/header_hash_map_h.cc: Same.
* testsuite/backward/header_tempbuf_h.cc: Same.
* testsuite/backward/header_deque_h.cc: Same.
* testsuite/backward/header_rope_h.cc: Same.
* testsuite/backward/header_iterator_h.cc: Same.
* testsuite/backward/header_hashtable_h.cc: Same.
2007-10-18 Benjamin Kosnik <bkoz@redhat.com>
PR libstdc++/30085
* include/debug/unordered_map: New.
* include/debug/unordered_set: New.
* include/debug/safe_association.h: New.
* include/std/unordered_map: Include debug header if _GLIBCXX_DEBUG.
* include/std/unordered_set: Same.
* include/Makefile.am (debug_headers): Add unordered_map,
unordered_set, safe_association.h.
* include/Makefile.in: Regenerate.
* testsuite/23_containers/unordered_map/requirements/debug.cc: New.
* testsuite/23_containers/unordered_multimap/requirements/
debug.cc: New.
* testsuite/23_containers/unordered_set/requirements/debug.cc: New.
* testsuite/23_containers/unordered_multiset/requirements/
debug.cc: New.
2007-10-18 Benjamin Kosnik <bkoz@redhat.com>
* testsuite/util/native_type/assoc/native_hash_multimap.hpp: Remove
hash_map include.
2007-10-18 Paolo Carlini <pcarlini@suse.de>
PR libstdc++/33807

3
libstdc++-v3/config.h.in
View file

@ -84,6 +84,9 @@
/* Define if ENOTRECOVERABLE exists. */
#undef HAVE_ENOTRECOVERABLE
/* Define if EOVERFLOW exists. */
#undef HAVE_EOVERFLOW
/* Define if EOWNERDEAD exists. */
#undef HAVE_EOWNERDEAD

11
libstdc++-v3/docs/doxygen/Intro.3
View file

@ -77,15 +77,7 @@ read FAQ 5.4 and use a
prefix.
.TS
lB lB lB lB.
<algo.h> <hash_map.h> <map.h> <slist.h>
<algobase.h> <hash_set.h> <multimap.h> <stack.h>
<alloc.h> <hashtable.h> <multiset.h> <stream.h>
<bvector.h> <heap.h> <new.h> <streambuf.h>
<complex.h> <iomanip.h> <ostream.h> <strstream>
<defalloc.h> <iostream.h> <pair.h> <strstream.h>
<deque.h> <istream.h> <queue.h> <tempbuf.h>
<fstream.h> <iterator.h> <rope.h> <tree.h>
<function.h> <list.h> <set.h> <vector.h>
<strstream>
.TE
.SS Extension Headers
These headers will only be found automatically if you include the leading
@ -98,7 +90,6 @@ lB lB.
<ext/algorithm> <ext/numeric>
<ext/functional> <ext/iterator>
<ext/slist> <ext/rb_tree>
<ext/hash_map> <ext/hash_set>
<ext/rope> <ext/memory>
<ext/bitmap_allocator.h> <ext/debug_allocator.h>
<ext/malloc_allocator.h> <ext/mt_allocator.h>

6
libstdc++-v3/docs/doxygen/user.cfg.in
View file

@ -542,10 +542,10 @@ INPUT = @srcdir@/docs/doxygen/doxygroups.cc \
include/utility \
include/valarray \
include/vector \
include/backward/hash_map \
include/backward/hash_set \
include/debug/bitset \
include/debug/deque \
include/debug/hash_map \
include/debug/hash_set \
include/debug/list \
include/debug/map \
include/debug/set \
@ -553,8 +553,6 @@ INPUT = @srcdir@/docs/doxygen/doxygroups.cc \
include/debug/vector \
include/ext/algorithm \
include/ext/functional \
include/ext/hash_map \
include/ext/hash_set \
include/ext/iterator \
include/ext/memory \
include/ext/numeric \

47
libstdc++-v3/docs/html/debug.html
View file

@ -231,29 +231,36 @@
<td>__gnu_debug::vector</td>
<td>&lt;debug/vector&gt;</td>
</tr>
</table>
<p>In addition, when compiling in C++0x mode, these additional
containers have additional debug capability.
</p>
<table>
<tr>
<td>__gnu_cxx::hash_map</td>
<td>&lt;ext/hash_map&gt;</td>
<td>__gnu_debug::hash_map</td>
<td>&lt;debug/hash_map&gt;</td>
<td>std::unordered_map</td>
<td>&lt;unordered_map&gt;</td>
<td>__gnu_debug::unordered_map</td>
<td>&lt;debug/unordered_map&gt;</td>
</tr>
<tr>
<td>__gnu_cxx::hash_multimap</td>
<td>&lt;ext/hash_map&gt;</td>
<td>__gnu_debug::hash_multimap</td>
<td>&lt;debug/hash_map&gt;</td>
<td>std::unordered_multimap</td>
<td>&lt;unordered_map&gt;</td>
<td>__gnu_debug::unordered_multimap</td>
<td>&lt;debug/unordered_map&gt;</td>
</tr>
<tr>
<td>__gnu_cxx::hash_set</td>
<td>&lt;ext/hash_set&gt;</td>
<td>__gnu_debug::hash_set</td>
<td>&lt;debug/hash_set&gt;</td>
<td>std::unordered_set</td>
<td>&lt;unordered_set&gt;</td>
<td>__gnu_debug::unordered_set</td>
<td>&lt;debug/unordered_set&gt;</td>
</tr>
<tr>
<td>__gnu_cxx::hash_multiset</td>
<td>&lt;ext/hash_set&gt;</td>
<td>__gnu_debug::hash_multiset</td>
<td>&lt;debug/hash_set&gt;</td>
<td>std::unordered_multiset</td>
<td>&lt;unordered_set&gt;</td>
<td>__gnu_debug::unordered_multiset</td>
<td>&lt;debug/unordered_set&gt;</td>
</tr>
</table>
@ -308,10 +315,10 @@
<li><code>std::multiset</code></li>
<li><code>std::set</code></li>
<li><code>std::vector</code></li>
<li><code>__gnu_cxx::hash_map</code></li>
<li><code>__gnu_cxx::hash_multimap</code></li>
<li><code>__gnu_cxx::hash_multiset</code></li>
<li><code>__gnu_cxx::hash_set</code></li>
<li><code>std::unordered_map</code></li>
<li><code>std::unordered_multimap</code></li>
<li><code>std::unordered_set</code></li>
<li><code>std::unordered_multiset</code></li>
</ul>

27
libstdc++-v3/docs/html/ext/howto.html
View file

@ -63,27 +63,28 @@
<h2><a name="1">Ropes and trees and hashes, oh my!</a></h2>
<p>The SGI headers</p>
<pre>
&lt;bvector&gt;
&lt;hash_map&gt;
&lt;hash_set&gt;
&lt;rope&gt;
&lt;slist&gt;
&lt;tree&gt;
&lt;rb_tree&gt;
</pre>
<p>are all here; <code>&lt;bvector&gt;</code> exposes the old bit_vector
class that was used before specialization of vector&lt;bool&gt; was
available (it's actually a typedef for the specialization now).
<p>are all here;
<code>&lt;hash_map&gt;</code> and <code>&lt;hash_set&gt;</code>
are discussed further below. <code>&lt;rope&gt;</code> is the SGI
specialization for large strings (&quot;rope,&quot; &quot;large
strings,&quot; get it? love those SGI folks).
are deprecated but available as backwards-compatible extensions,
as discussed further below. <code>&lt;rope&gt;</code> is the
SGI specialization for large strings (&quot;rope,&quot;
&quot;large strings,&quot; get it? love those SGI folks).
<code>&lt;slist&gt;</code> is a singly-linked list, for when the
doubly-linked <code>list&lt;&gt;</code> is too much space overhead, and
<code>&lt;tree&gt;</code> exposes the red-black tree classes used in the
implementation of the standard maps and sets.
doubly-linked <code>list&lt;&gt;</code> is too much space
overhead, and <code>&lt;rb_tree&gt;</code> exposes the red-black
tree classes used in the implementation of the standard maps and
sets.
</p>
<p>Okay, about those hashing classes... I'm going to foist most of the
work off onto SGI's own site.
<p>Okay, about those hashing classes... these classes have been
deprecated by the unordered_set, unordered_multiset, unordered_map,
unordered_multimap containers in TR1 and the upcoming C++0x, and
may be removed in future releases.
</p>
<p>Each of the associative containers map, multimap, set, and multiset
have a counterpart which uses a

14
libstdc++-v3/docs/html/faq/index.html
View file

@ -927,7 +927,7 @@ http://clisp.cons.org/~haible/gccinclude-glibc-2.2-compat.diff
<!-- Careful, the leading spaces in PRE show up directly. -->
</p>
<pre>
#include &lt;ext/hash_map&gt; </pre>
#include &lt;backward/hash_map&gt; </pre>
<p>rather than using <code>-I</code> or other options. This is more
portable and forward-compatible. (The situation is the same as
that of other headers whose directories are not searched directly,
@ -950,20 +950,20 @@ http://clisp.cons.org/~haible/gccinclude-glibc-2.2-compat.diff
#ifdef __GNUC__
#if __GNUC__ &lt; 3
#include &lt;hash_map.h&gt;
namespace Sgi { using ::hash_map; }; // inherit globals
namespace extension { using ::hash_map; }; // inherit globals
#else
#include &lt;ext/hash_map&gt;
#include &lt;backward/hash_map&gt;
#if __GNUC_MINOR__ == 0
namespace Sgi = std; // GCC 3.0
namespace extension = std; // GCC 3.0
#else
namespace Sgi = ::__gnu_cxx; // GCC 3.1 and later
namespace extension = ::__gnu_cxx; // GCC 3.1 and later
#endif
#endif
#else // ... there are other compilers, right?
namespace Sgi = std;
namespace extension = std;
#endif
Sgi::hash_map&lt;int,int&gt; my_map; </pre>
extension::hash_map&lt;int,int&gt; my_map; </pre>
<p>This is a bit cleaner than defining typedefs for all the
instantiations you might need.
</p>

52
libstdc++-v3/include/Makefile.am
View file

@ -145,41 +145,11 @@ bits_headers = \
backward_srcdir = ${glibcxx_srcdir}/include/backward
backward_builddir = ./backward
backward_headers = \
${backward_srcdir}/complex.h \
${backward_srcdir}/iomanip.h \
${backward_srcdir}/istream.h \
${backward_srcdir}/ostream.h \
${backward_srcdir}/stream.h \
${backward_srcdir}/streambuf.h \
${backward_srcdir}/algo.h \
${backward_srcdir}/algobase.h \
${backward_srcdir}/alloc.h \
${backward_srcdir}/bvector.h \
${backward_srcdir}/defalloc.h \
${backward_srcdir}/deque.h \
${backward_srcdir}/function.h \
${backward_srcdir}/hash_map.h \
${backward_srcdir}/hash_set.h \
${backward_srcdir}/hashtable.h \
${backward_srcdir}/heap.h \
${backward_srcdir}/iostream.h \
${backward_srcdir}/iterator.h \
${backward_srcdir}/list.h \
${backward_srcdir}/map.h \
${backward_srcdir}/multimap.h \
${backward_srcdir}/new.h \
${backward_srcdir}/multiset.h \
${backward_srcdir}/pair.h \
${backward_srcdir}/queue.h \
${backward_srcdir}/rope.h \
${backward_srcdir}/set.h \
${backward_srcdir}/slist.h \
${backward_srcdir}/stack.h \
${backward_srcdir}/tempbuf.h \
${backward_srcdir}/tree.h \
${backward_srcdir}/vector.h \
${backward_srcdir}/fstream.h \
${backward_srcdir}/strstream \
${backward_srcdir}/hash_map \
${backward_srcdir}/hash_set \
${backward_srcdir}/hash_fun.h \
${backward_srcdir}/hashtable.h \
${backward_srcdir}/backward_warning.h
pb_srcdir = ${glibcxx_srcdir}/include/ext/pb_ds
@ -496,7 +466,6 @@ pb_headers7 = \
${pb_srcdir}/detail/unordered_iterator/point_iterator.hpp
ext_srcdir = ${glibcxx_srcdir}/include/ext
ext_builddir = ./ext
ext_headers = \
@ -511,10 +480,6 @@ ext_headers = \
${ext_srcdir}/stdio_filebuf.h \
${ext_srcdir}/stdio_sync_filebuf.h \
${ext_srcdir}/functional \
${ext_srcdir}/hash_map \
${ext_srcdir}/hash_set \
${ext_srcdir}/hash_fun.h \
${ext_srcdir}/hashtable.h \
${ext_srcdir}/iterator \
${ext_srcdir}/malloc_allocator.h \
${ext_srcdir}/memory \
@ -711,18 +676,13 @@ debug_headers = \
${debug_srcdir}/deque \
${debug_srcdir}/formatter.h \
${debug_srcdir}/functions.h \
${debug_srcdir}/hash_map \
${debug_srcdir}/hash_map.h \
${debug_srcdir}/hash_multimap.h \
${debug_srcdir}/hash_multiset.h \
${debug_srcdir}/hash_set \
${debug_srcdir}/hash_set.h \
${debug_srcdir}/list \
${debug_srcdir}/map \
${debug_srcdir}/macros.h \
${debug_srcdir}/map.h \
${debug_srcdir}/multimap.h \
${debug_srcdir}/multiset.h \
${debug_srcdir}/safe_association.h \
${debug_srcdir}/safe_base.h \
${debug_srcdir}/safe_iterator.h \
${debug_srcdir}/safe_iterator.tcc \
@ -730,6 +690,8 @@ debug_headers = \
${debug_srcdir}/set \
${debug_srcdir}/set.h \
${debug_srcdir}/string \
${debug_srcdir}/unordered_map \
${debug_srcdir}/unordered_set \
${debug_srcdir}/vector
# Parallel mode headers

51
libstdc++-v3/include/Makefile.in
View file

@ -394,41 +394,11 @@ bits_headers = \
backward_srcdir = ${glibcxx_srcdir}/include/backward
backward_builddir = ./backward
backward_headers = \
${backward_srcdir}/complex.h \
${backward_srcdir}/iomanip.h \
${backward_srcdir}/istream.h \
${backward_srcdir}/ostream.h \
${backward_srcdir}/stream.h \
${backward_srcdir}/streambuf.h \
${backward_srcdir}/algo.h \
${backward_srcdir}/algobase.h \
${backward_srcdir}/alloc.h \
${backward_srcdir}/bvector.h \
${backward_srcdir}/defalloc.h \
${backward_srcdir}/deque.h \
${backward_srcdir}/function.h \
${backward_srcdir}/hash_map.h \
${backward_srcdir}/hash_set.h \
${backward_srcdir}/hashtable.h \
${backward_srcdir}/heap.h \
${backward_srcdir}/iostream.h \
${backward_srcdir}/iterator.h \
${backward_srcdir}/list.h \
${backward_srcdir}/map.h \
${backward_srcdir}/multimap.h \
${backward_srcdir}/new.h \
${backward_srcdir}/multiset.h \
${backward_srcdir}/pair.h \
${backward_srcdir}/queue.h \
${backward_srcdir}/rope.h \
${backward_srcdir}/set.h \
${backward_srcdir}/slist.h \
${backward_srcdir}/stack.h \
${backward_srcdir}/tempbuf.h \
${backward_srcdir}/tree.h \
${backward_srcdir}/vector.h \
${backward_srcdir}/fstream.h \
${backward_srcdir}/strstream \
${backward_srcdir}/hash_map \
${backward_srcdir}/hash_set \
${backward_srcdir}/hash_fun.h \
${backward_srcdir}/hashtable.h \
${backward_srcdir}/backward_warning.h
pb_srcdir = ${glibcxx_srcdir}/include/ext/pb_ds
@ -757,10 +727,6 @@ ext_headers = \
${ext_srcdir}/stdio_filebuf.h \
${ext_srcdir}/stdio_sync_filebuf.h \
${ext_srcdir}/functional \
${ext_srcdir}/hash_map \
${ext_srcdir}/hash_set \
${ext_srcdir}/hash_fun.h \
${ext_srcdir}/hashtable.h \
${ext_srcdir}/iterator \
${ext_srcdir}/malloc_allocator.h \
${ext_srcdir}/memory \
@ -949,18 +915,13 @@ debug_headers = \
${debug_srcdir}/deque \
${debug_srcdir}/formatter.h \
${debug_srcdir}/functions.h \
${debug_srcdir}/hash_map \
${debug_srcdir}/hash_map.h \
${debug_srcdir}/hash_multimap.h \
${debug_srcdir}/hash_multiset.h \
${debug_srcdir}/hash_set \
${debug_srcdir}/hash_set.h \
${debug_srcdir}/list \
${debug_srcdir}/map \
${debug_srcdir}/macros.h \
${debug_srcdir}/map.h \
${debug_srcdir}/multimap.h \
${debug_srcdir}/multiset.h \
${debug_srcdir}/safe_association.h \
${debug_srcdir}/safe_base.h \
${debug_srcdir}/safe_iterator.h \
${debug_srcdir}/safe_iterator.tcc \
@ -968,6 +929,8 @@ debug_headers = \
${debug_srcdir}/set \
${debug_srcdir}/set.h \
${debug_srcdir}/string \
${debug_srcdir}/unordered_map \
${debug_srcdir}/unordered_set \
${debug_srcdir}/vector

145
libstdc++-v3/include/backward/algo.h
View file

@ -1,145 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_ALGO_H
#define _BACKWARD_ALGO_H 1
#include "backward_warning.h"
#include "algobase.h"
#include "tempbuf.h"
#include "iterator.h"
#include <bits/stl_algo.h>
#include <bits/stl_numeric.h>
#include <ext/algorithm>
#include <ext/numeric>
// Names from <stl_algo.h>
using std::for_each;
using std::find;
using std::find_if;
using std::adjacent_find;
using std::count;
using std::count_if;
using std::search;
using std::search_n;
using std::swap_ranges;
using std::transform;
using std::replace;
using std::replace_if;
using std::replace_copy;
using std::replace_copy_if;
using std::generate;
using std::generate_n;
using std::remove;
using std::remove_if;
using std::remove_copy;
using std::remove_copy_if;
using std::unique;
using std::unique_copy;
using std::reverse;
using std::reverse_copy;
using std::rotate;
using std::rotate_copy;
using std::random_shuffle;
using std::partition;
using std::stable_partition;
using std::sort;
using std::stable_sort;
using std::partial_sort;
using std::partial_sort_copy;
using std::nth_element;
using std::lower_bound;
using std::upper_bound;
using std::equal_range;
using std::binary_search;
using std::merge;
using std::inplace_merge;
using std::includes;
using std::set_union;
using std::set_intersection;
using std::set_difference;
using std::set_symmetric_difference;
using std::min_element;
using std::max_element;
using std::next_permutation;
using std::prev_permutation;
using std::find_first_of;
using std::find_end;
// Names from stl_heap.h
using std::push_heap;
using std::pop_heap;
using std::make_heap;
using std::sort_heap;
// Names from stl_numeric.h
using std::accumulate;
using std::inner_product;
using std::partial_sum;
using std::adjacent_difference;
// Names from ext/algorithm
using __gnu_cxx::random_sample;
using __gnu_cxx::random_sample_n;
using __gnu_cxx::is_sorted;
using __gnu_cxx::is_heap;
using __gnu_cxx::count; // Extension returning void
using __gnu_cxx::count_if; // Extension returning void
// Names from ext/numeric
using __gnu_cxx::power;
using __gnu_cxx::iota;
#endif /* _BACKWARD_ALGO_H */

91
libstdc++-v3/include/backward/algobase.h
View file

@ -1,91 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_ALGOBASE_H
#define _BACKWARD_ALGOBASE_H 1
#include "backward_warning.h"
#include "pair.h"
#include "iterator.h"
#include <bits/stl_algobase.h>
#include <bits/stl_uninitialized.h>
#include <ext/algorithm>
#include <ext/memory>
// Names from stl_algobase.h
using std::iter_swap;
using std::swap;
using std::min;
using std::max;
using std::copy;
using std::copy_backward;
using std::fill;
using std::fill_n;
using std::mismatch;
using std::equal;
using std::lexicographical_compare;
// Names from stl_uninitialized.h
using std::uninitialized_copy;
using std::uninitialized_fill;
using std::uninitialized_fill_n;
// Names from ext/algorithm
using __gnu_cxx::copy_n;
using __gnu_cxx::lexicographical_compare_3way;
// Names from ext/memory
using __gnu_cxx::uninitialized_copy_n;
#endif /* _BACKWARD_ALGOBASE_H */

52
libstdc++-v3/include/backward/alloc.h
View file

@ -1,52 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001, 2003, 2004 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 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 _BACKWARD_ALLOC_H
#define _BACKWARD_ALLOC_H 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <bits/allocator.h>
using std::allocator;
#endif

16
libstdc++-v3/include/backward/backward_warning.h
View file

@ -1,4 +1,4 @@
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2001, 2007 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
@ -30,10 +30,16 @@
#ifdef __DEPRECATED
#warning This file includes at least one deprecated or antiquated header. \
Please consider using one of the 32 headers found in section 17.4.1.2 of the \
C++ standard. Examples include substituting the <X> header for the <X.h> \
header for C++ includes, or <iostream> instead of the deprecated header \
<iostream.h>. To disable this warning use -Wno-deprecated.
Please consider the use of alternate interfaces as follows: \
<sstream> basic_stringbuf <strstream> strstreambuf \
<sstream> basic_istringstream <strstream> istrstream \
<sstream> basic_ostringstream <strstream> ostrstream \
<sstream> basic_stringstream <strstream> strstream \
<unordered_set> unordered_set <ext/hash_set> hash_set \
<unordered_set> unordered_multiset <ext/hash_set> hash_multiset \
<unordered_map> unordered_map <ext/hash_set> hash_map \
<unordered_map> unordered_multimap <ext/hash_set> hash_multimap \
To disable this warning use -Wno-deprecated.
#endif
#endif

64
libstdc++-v3/include/backward/bvector.h
View file

@ -1,64 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001, 2004 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_BVECTOR_H
#define _BACKWARD_BVECTOR_H 1
#include "backward_warning.h"
#include <vector>
typedef std::vector<bool, std::allocator<bool> > bit_vector;
#endif /* _BACKWARD_BVECTOR_H */

39
libstdc++-v3/include/backward/complex.h
View file

@ -1,39 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_COMPLEX_H
#define _BACKWARD_COMPLEX_H 1
#include "backward_warning.h"
#include <complex>
using std::complex;
typedef complex<float> float_complex;
typedef complex<double> double_complex;
typedef complex<long double> long_double_complex;
#endif

117
libstdc++-v3/include/backward/defalloc.h
View file

@ -1,117 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
// Inclusion of this file is DEPRECATED. This is the original HP
// default allocator. It is provided only for backward compatibility.
// This file WILL BE REMOVED in a future release.
//
// DO NOT USE THIS FILE unless you have an old container implementation
// that requires an allocator with the HP-style interface.
//
// Standard-conforming allocators have a very different interface. The
// standard default allocator is declared in the header <memory>.
#ifndef _BACKWARD_DEFALLOC_H
#define _BACKWARD_DEFALLOC_H 1
#include "backward_warning.h"
#include "new.h"
#include <stddef.h>
#include <stdlib.h>
#include <limits.h>
#include "iostream.h"
#include "algobase.h"
template <class _Tp>
inline _Tp* allocate(ptrdiff_t __size, _Tp*) {
set_new_handler(0);
_Tp* __tmp = (_Tp*)(::operator new((size_t)(__size * sizeof(_Tp))));
if (__tmp == 0) {
cerr << "out of memory" << endl;
exit(1);
}
return __tmp;
}
template <class _Tp>
inline void deallocate(_Tp* __buffer) {
::operator delete(__buffer);
}
template <class _Tp>
class allocator {
public:
typedef _Tp value_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
pointer allocate(size_type __n) {
return ::allocate((difference_type)__n, (pointer)0);
}
void deallocate(pointer __p) { ::deallocate(__p); }
pointer address(reference __x) { return (pointer)&__x; }
const_pointer const_address(const_reference __x) {
return (const_pointer)&__x;
}
size_type init_page_size() {
return max(size_type(1), size_type(4096/sizeof(_Tp)));
}
size_type max_size() const {
return max(size_type(1), size_type(UINT_MAX/sizeof(_Tp)));
}
};
class allocator<void> {
public:
typedef void* pointer;
};
#endif /* _BACKWARD_DEFALLOC_H */

66
libstdc++-v3/include/backward/deque.h
View file

@ -1,66 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_DEQUE_H
#define _BACKWARD_DEQUE_H 1
#include "backward_warning.h"
#include "algobase.h"
#include "alloc.h"
#include <deque>
using std::deque;
#endif /* _BACKWARD_DEQUE_H */

48
libstdc++-v3/include/backward/fstream.h
View file

@ -1,48 +0,0 @@
// Copyright (C) 2000, 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_FSTREAM_H
#define _BACKWARD_FSTREAM_H 1
#include "backward_warning.h"
#include <fstream>
using std::filebuf;
using std::ifstream;
using std::ofstream;
using std::fstream;
using std::streampos;
#ifdef _GLIBCXX_USE_WCHAR_T
using std::wfilebuf;
using std::wifstream;
using std::wofstream;
using std::wfstream;
using std::wstreampos;
#endif
#endif

126
libstdc++-v3/include/backward/function.h
View file

@ -1,126 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_FUNCTION_H
#define _BACKWARD_FUNCTION_H 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <stddef.h>
#include <bits/stl_function.h>
#include <ext/functional>
// Names from stl_function.h
using std::unary_function;
using std::binary_function;
using std::plus;
using std::minus;
using std::multiplies;
using std::divides;
using std::modulus;
using std::negate;
using std::equal_to;
using std::not_equal_to;
using std::greater;
using std::less;
using std::greater_equal;
using std::less_equal;
using std::logical_and;
using std::logical_or;
using std::logical_not;
using std::unary_negate;
using std::binary_negate;
using std::not1;
using std::not2;
using std::binder1st;
using std::binder2nd;
using std::bind1st;
using std::bind2nd;
using std::pointer_to_unary_function;
using std::pointer_to_binary_function;
using std::ptr_fun;
using std::mem_fun_t;
using std::const_mem_fun_t;
using std::mem_fun_ref_t;
using std::const_mem_fun_ref_t;
using std::mem_fun1_t;
using std::const_mem_fun1_t;
using std::mem_fun1_ref_t;
using std::const_mem_fun1_ref_t;
using std::mem_fun;
using std::mem_fun_ref;
// Names from ext/functional
using __gnu_cxx::identity_element;
using __gnu_cxx::unary_compose;
using __gnu_cxx::binary_compose;
using __gnu_cxx::compose1;
using __gnu_cxx::compose2;
using __gnu_cxx::identity;
using __gnu_cxx::select1st;
using __gnu_cxx::select2nd;
using __gnu_cxx::project1st;
using __gnu_cxx::project2nd;
using __gnu_cxx::constant_void_fun;
using __gnu_cxx::constant_unary_fun;
using __gnu_cxx::constant_binary_fun;
using __gnu_cxx::constant0;
using __gnu_cxx::constant1;
using __gnu_cxx::constant2;
using __gnu_cxx::subtractive_rng;
using __gnu_cxx::mem_fun1;
using __gnu_cxx::mem_fun1_ref;
#endif /* _BACKWARD_FUNCTION_H */

2
libstdc++-v3/include/ext/hash_fun.h → libstdc++-v3/include/backward/hash_fun.h
View file

@ -53,7 +53,7 @@
*
*/
/** @file ext/hash_fun.h
/** @file backward/hash_fun.h
* This file is a GNU extension to the Standard C++ Library (possibly
* containing extensions from the HP/SGI STL subset).
*/

13
libstdc++-v3/include/ext/hash_map → libstdc++-v3/include/backward/hash_map
View file

@ -53,7 +53,7 @@
*
*/
/** @file ext/hash_map
/** @file backward/hash_map
* This file is a GNU extension to the Standard C++ Library (possibly
* containing extensions from the HP/SGI STL subset).
*/
@ -61,11 +61,12 @@
#ifndef _HASH_MAP
#define _HASH_MAP 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <ext/hashtable.h>
#include <backward/hashtable.h>
#include <bits/concept_check.h>
_GLIBCXX_BEGIN_NESTED_NAMESPACE(__gnu_cxx, _GLIBCXX_EXT_D)
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
using std::equal_to;
using std::allocator;
@ -497,11 +498,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(__gnu_cxx, _GLIBCXX_EXT_D)
hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
{ __hm1.swap(__hm2); }
_GLIBCXX_END_NESTED_NAMESPACE
#ifdef _GLIBCXX_DEBUG
# include <debug/hash_map>
#endif
_GLIBCXX_END_NAMESPACE
_GLIBCXX_BEGIN_NAMESPACE(std)

68
libstdc++-v3/include/backward/hash_map.h
View file

@ -1,68 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
#ifndef _BACKWARD_HASH_MAP_H
#define _BACKWARD_HASH_MAP_H 1
#include "backward_warning.h"
#include "algobase.h"
#include <ext/hash_map>
using __gnu_cxx::hash;
using __gnu_cxx::hashtable;
using __gnu_cxx::hash_map;
using __gnu_cxx::hash_multimap;
#endif /* _BACKWARD_HASH_MAP_H */

13
libstdc++-v3/include/ext/hash_set → libstdc++-v3/include/backward/hash_set
View file

@ -53,7 +53,7 @@
*
*/
/** @file ext/hash_set
/** @file backward/hash_set
* This file is a GNU extension to the Standard C++ Library (possibly
* containing extensions from the HP/SGI STL subset).
*/
@ -61,11 +61,12 @@
#ifndef _HASH_SET
#define _HASH_SET 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <ext/hashtable.h>
#include <backward/hashtable.h>
#include <bits/concept_check.h>
_GLIBCXX_BEGIN_NESTED_NAMESPACE(__gnu_cxx, _GLIBCXX_EXT_D)
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
using std::equal_to;
using std::allocator;
@ -465,11 +466,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(__gnu_cxx, _GLIBCXX_EXT_D)
hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
{ __hs1.swap(__hs2); }
_GLIBCXX_END_NESTED_NAMESPACE
#ifdef _GLIBCXX_DEBUG
# include <debug/hash_set>
#endif
_GLIBCXX_END_NAMESPACE
_GLIBCXX_BEGIN_NAMESPACE(std)

69
libstdc++-v3/include/backward/hash_set.h
View file

@ -1,69 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
#ifndef _BACKWARD_HASH_SET_H
#define _BACKWARD_HASH_SET_H 1
#include "backward_warning.h"
#include "algobase.h"
#include <ext/hash_set>
using __gnu_cxx::hash;
using __gnu_cxx::hashtable;
using __gnu_cxx::hash_set;
using __gnu_cxx::hash_multiset;
#endif /* _BACKWARD_HASH_SET_H */

1086
libstdc++-v3/include/backward/hashtable.h
View file

File diff suppressed because it is too large Load diff

67
libstdc++-v3/include/backward/heap.h
View file

@ -1,67 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_HEAP_H
#define _BACKWARD_HEAP_H 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <bits/stl_heap.h>
using std::push_heap;
using std::pop_heap;
using std::make_heap;
using std::sort_heap;
#endif /* _BACKWARD_HEAP_H */

66
libstdc++-v3/include/backward/iomanip.h
View file

@ -1,66 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_IOMANIP_H
#define _BACKWARD_IOMANIP_H 1
#include "backward_warning.h"
#include "iostream.h"
#include <iomanip>
// These are from <ios> as per [27.4].
using std::boolalpha;
using std::noboolalpha;
using std::showbase;
using std::noshowbase;
using std::showpoint;
using std::noshowpoint;
using std::showpos;
using std::noshowpos;
using std::skipws;
using std::noskipws;
using std::uppercase;
using std::nouppercase;
using std::internal;
using std::left;
using std::right;
using std::dec;
using std::hex;
using std::oct;
using std::fixed;
using std::scientific;
// These are from <iomanip> as per [27.6]. Manipulators from <istream>
// and <ostream> (e.g., endl) are made available via <iostream.h>.
using std::resetiosflags;
using std::setiosflags;
using std::setbase;
using std::setfill;
using std::setprecision;
using std::setw;
#endif

56
libstdc++-v3/include/backward/iostream.h
View file

@ -1,56 +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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_IOSTREAM_H
#define _BACKWARD_IOSTREAM_H 1
#include "backward_warning.h"
#include <iostream>
using std::iostream;
using std::ostream;
using std::istream;
using std::ios;
using std::streambuf;
using std::cout;
using std::cin;
using std::cerr;
using std::clog;
#ifdef _GLIBCXX_USE_WCHAR_T
using std::wcout;
using std::wcin;
using std::wcerr;
using std::wclog;
#endif
using std::ws;
using std::endl;
using std::ends;
using std::flush;
#endif

34
libstdc++-v3/include/backward/istream.h
View file

@ -1,34 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_ISTREAM_H
#define _BACKWARD_ISTREAM_H 1
#include "backward_warning.h"
#include "iostream.h"
#endif

187
libstdc++-v3/include/backward/iterator.h
View file

@ -1,187 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001, 2004 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_ITERATOR_H
#define _BACKWARD_ITERATOR_H 1
#include "backward_warning.h"
#include "function.h"
#include <stddef.h>
#include "iostream.h"
#include <iterator>
#include <bits/stl_construct.h>
#include <bits/stl_raw_storage_iter.h>
#include <ext/iterator> // For 3-parameter distance extension
// Names from stl_iterator.h
using std::input_iterator_tag;
using std::output_iterator_tag;
using std::forward_iterator_tag;
using std::bidirectional_iterator_tag;
using std::random_access_iterator_tag;
#if 0
using std::iterator;
#endif
// 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<typename _Tp, typename _Distance>
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<typename _Tp, typename _Distance>
struct forward_iterator {
typedef forward_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template<typename _Tp, typename _Distance>
struct bidirectional_iterator {
typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template<typename _Tp, typename _Distance>
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;
};
using std::iterator_traits;
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
iterator_category(const _Iter& __i)
{ return __iterator_category(__i); }
template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
distance_type(const _Iter&)
{ return static_cast<typename iterator_traits<_Iter>::difference_type*>(0); }
template<class _Iter>
inline typename iterator_traits<_Iter>::value_type*
value_type(const _Iter& __i)
{ return static_cast<typename iterator_traits<_Iter>::value_type*>(0); }
using std::distance;
using __gnu_cxx::distance; // 3-parameter extension
using std::advance;
using std::insert_iterator;
using std::front_insert_iterator;
using std::back_insert_iterator;
using std::inserter;
using std::front_inserter;
using std::back_inserter;
using std::reverse_iterator;
using std::istream_iterator;
using std::ostream_iterator;
// Names from stl_construct.h
template<class _T1, class _T2>
inline void
construct(_T1* __p, const _T2& __value)
{ std::_Construct(__p, __value); }
template<class _T1>
inline void
construct(_T1* __p)
{ std::_Construct(__p); }
template <class _Tp>
inline void
destroy(_Tp* __pointer)
{ std::_Destroy(__pointer); }
template <class _ForwardIterator>
inline void
destroy(_ForwardIterator __first, _ForwardIterator __last)
{ std::_Destroy(__first, __last); }
// Names from stl_raw_storage_iter.h
using std::raw_storage_iterator;
#endif /* _BACKWARD_ITERATOR_H */

66
libstdc++-v3/include/backward/list.h
View file

@ -1,66 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_LIST_H
#define _BACKWARD_LIST_H 1
#include "backward_warning.h"
#include "algobase.h"
#include "alloc.h"
#include <list>
using std::list;
#endif /* _BACKWARD_LIST_H */

65
libstdc++-v3/include/backward/map.h
View file

@ -1,65 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_MAP_H
#define _BACKWARD_MAP_H 1
#include "backward_warning.h"
#include "tree.h"
#include <map>
using std::map;
#endif /* _BACKWARD_MAP_H */

65
libstdc++-v3/include/backward/multimap.h
View file

@ -1,65 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_MULTIMAP_H
#define _BACKWARD_MULTIMAP_H 1
#include "backward_warning.h"
#include "tree.h"
#include <map>
using std::multimap;
#endif /* _BACKWARD_MULTIMAP_H */

65
libstdc++-v3/include/backward/multiset.h
View file

@ -1,65 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_MULTISET_H
#define _BACKWARD_MULTISET_H 1
#include "backward_warning.h"
#include "tree.h"
#include <set>
using std::multiset;
#endif /* _BACKWARD_MULTISET_H */

42
libstdc++-v3/include/backward/new.h
View file

@ -1,42 +0,0 @@
// -*- C++ -*- forwarding header.
// Copyright (C) 2000 Free Software Foundation
// This file is part of GCC.
//
// GCC 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.
//
// GCC 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 GCC; see the file COPYING. If not, write to
// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
// Boston, MA 02110-1301, 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 _BACKWARD_NEW_H
#define _BACKWARD_NEW_H 1
#include "backward_warning.h"
#include <new>
using std::bad_alloc;
using std::nothrow_t;
using std::nothrow;
using std::new_handler;
using std::set_new_handler;
#endif

34
libstdc++-v3/include/backward/ostream.h
View file

@ -1,34 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_OSTREAM_H
#define _BACKWARD_OSTREAM_H 1
#include "backward_warning.h"
#include "iostream.h"
#endif

66
libstdc++-v3/include/backward/pair.h
View file

@ -1,66 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_PAIR_H
#define _BACKWARD_PAIR_H 1
#include "backward_warning.h"
#include <bits/c++config.h>
#include <bits/stl_pair.h>
using std::pair;
using std::make_pair;
#endif /* _BACKWARD_PAIR_H */

37
libstdc++-v3/include/backward/queue.h
View file

@ -1,37 +0,0 @@
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_QUEUE_H
#define _BACKWARD_QUEUE_H 1
#include "backward_warning.h"
#include <queue>
using std::queue;
using std::priority_queue;
#endif

56
libstdc++-v3/include/backward/rope.h
View file

@ -1,56 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 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 _BACKWARD_ROPE_H
#define _BACKWARD_ROPE_H 1
#include "backward_warning.h"
#include "hashtable.h"
#include <ext/rope>
using __gnu_cxx::char_producer;
using __gnu_cxx::sequence_buffer;
using __gnu_cxx::rope;
using __gnu_cxx::crope;
using __gnu_cxx::wrope;
#endif /* _BACKWARD_ROPE_H */

65
libstdc++-v3/include/backward/set.h
View file

@ -1,65 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_SET_H
#define _BACKWARD_SET_H 1
#include "backward_warning.h"
#include "tree.h"
#include <set>
using std::set;
#endif /* _BACKWARD_SET_H */

52
libstdc++-v3/include/backward/slist.h
View file

@ -1,52 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 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 _BACKWARD_SLIST_H
#define _BACKWARD_SLIST_H 1
#include "backward_warning.h"
#include <ext/slist>
using __gnu_cxx::slist;
#endif /* _BACKWARD_SLIST_H */

68
libstdc++-v3/include/backward/stack.h
View file

@ -1,68 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_STACK_H
#define _BACKWARD_STACK_H 1
#include "backward_warning.h"
#include "vector.h"
#include "deque.h"
#include "heap.h"
#include "queue.h"
#include <stack>
using std::stack;
#endif /* _BACKWARD_STACK_H */

34
libstdc++-v3/include/backward/stream.h
View file

@ -1,34 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_STREAM_H
#define _BACKWARD_STREAM_H 1
#include "backward_warning.h"
#include "iostream.h"
#endif

36
libstdc++-v3/include/backward/streambuf.h
View file

@ -1,36 +0,0 @@
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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 _BACKWARD_STREAMBUF_H
#define _BACKWARD_STREAMBUF_H 1
#include "backward_warning.h"
#include <streambuf>
using std::streambuf;
#endif

74
libstdc++-v3/include/backward/tempbuf.h
View file

@ -1,74 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_TEMPBUF_H
#define _BACKWARD_TEMPBUF_H 1
#include "backward_warning.h"
#include "pair.h"
#include "iterator.h"
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <bits/cpp_type_traits.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <ext/memory>
using std::get_temporary_buffer;
using std::return_temporary_buffer;
using __gnu_cxx::temporary_buffer;
#endif /* _BACKWARD_TEMPBUF_H */

52
libstdc++-v3/include/backward/tree.h
View file

@ -1,52 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
* Copyright (c) 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 _BACKWARD_TREE
#define _BACKWARD_TREE 1
#include "backward_warning.h"
#include <ext/rb_tree>
using __gnu_cxx::rb_tree;
#endif

66
libstdc++-v3/include/backward/vector.h
View file

@ -1,66 +0,0 @@
// Backward-compat support -*- C++ -*-
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _BACKWARD_VECTOR_H
#define _BACKWARD_VECTOR_H 1
#include "backward_warning.h"
#include "algobase.h"
#include "alloc.h"
#include <vector>
using std::vector;
#endif /* _BACKWARD_VECTOR_H */

42
libstdc++-v3/include/bits/c++config
View file

@ -65,12 +65,6 @@
namespace tr1 { }
}
namespace __gnu_cxx
{
namespace __debug { }
namespace __norm { }
}
*/
// Macros for activating various namespace association modes.
@ -100,9 +94,6 @@
// _GLIBCXX_STD
// _GLIBCXX_STD_D
// _GLIBCXX_STD_P
// _GLIBCXX_EXT
// _GLIBCXX_EXT_D
// _GLIBCXX_EXT_P
//
// Macros for enclosing namepaces and possibly nested namespaces.
@ -116,9 +107,6 @@
# define _GLIBCXX_STD_D _GLIBCXX_STD
# define _GLIBCXX_STD_P _GLIBCXX_STD
# define _GLIBCXX_STD std
# define _GLIBCXX_EXT_D _GLIBCXX_EXT
# define _GLIBCXX_EXT_P _GLIBCXX_EXT
# define _GLIBCXX_EXT __gnu_cxx
# define _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y) _GLIBCXX_BEGIN_NAMESPACE(X)
# define _GLIBCXX_END_NESTED_NAMESPACE _GLIBCXX_END_NAMESPACE
# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY(default) {
@ -129,7 +117,6 @@
# define _GLIBCXX_STD_D _GLIBCXX_STD
# define _GLIBCXX_STD_P _GLIBCXX_STD
# define _GLIBCXX_STD _6
# define _GLIBCXX_EXT _6
# define _GLIBCXX_BEGIN_NAMESPACE(X) _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, _6)
# define _GLIBCXX_END_NAMESPACE _GLIBCXX_END_NESTED_NAMESPACE
# endif
@ -139,9 +126,6 @@
# define _GLIBCXX_STD_D __norm
# define _GLIBCXX_STD_P _GLIBCXX_STD
# define _GLIBCXX_STD __cxx1998
# define _GLIBCXX_EXT_D __norm
# define _GLIBCXX_EXT_P _GLIBCXX_EXT
# define _GLIBCXX_EXT __cxx1998
# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY(default) {
# define _GLIBCXX_END_NAMESPACE }
# define _GLIBCXX_EXTERN_TEMPLATE 0
@ -152,9 +136,6 @@
# define _GLIBCXX_STD_D _GLIBCXX_STD
# define _GLIBCXX_STD_P __norm
# define _GLIBCXX_STD __cxx1998
# define _GLIBCXX_EXT_D _GLIBCXX_EXT
# define _GLIBCXX_EXT_P __norm
# define _GLIBCXX_EXT __cxx1998
# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY(default) {
# define _GLIBCXX_END_NAMESPACE }
# define _GLIBCXX_EXTERN_TEMPLATE 0
@ -165,9 +146,6 @@
# define _GLIBCXX_STD_D __norm
# define _GLIBCXX_STD_P __norm
# define _GLIBCXX_STD __cxx1998
# define _GLIBCXX_EXT_D __norm
# define _GLIBCXX_EXT_P __norm
# define _GLIBCXX_EXT __gnu_cxx
# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY(default) {
# define _GLIBCXX_END_NAMESPACE }
# define _GLIBCXX_EXTERN_TEMPLATE 0
@ -193,16 +171,6 @@ namespace std
using namespace __debug __attribute__ ((strong));
using namespace __cxx1998 __attribute__ ((strong));
}
namespace __gnu_cxx
{
namespace __norm { }
namespace __debug { }
namespace __cxx1998 { }
using namespace __debug __attribute__ ((strong));
using namespace __cxx1998 __attribute__ ((strong));
}
#endif
// Namespace associations for parallel mode.
@ -216,16 +184,6 @@ namespace std
using namespace __parallel __attribute__ ((strong));
using namespace __cxx1998 __attribute__ ((strong));
}
namespace __gnu_cxx
{
namespace __norm { }
namespace __parallel { }
namespace __cxx1998 { }
using namespace __parallel __attribute__ ((strong));
using namespace __cxx1998 __attribute__ ((strong));
}
#endif
// Namespace associations for versioning mode.

6
libstdc++-v3/include/debug/debug.h
View file

@ -49,15 +49,9 @@ namespace std
namespace __debug { }
}
namespace __gnu_cxx
{
namespace __debug { };
}
namespace __gnu_debug
{
using namespace std::__debug;
using namespace __gnu_cxx::__debug;
}
#ifndef _GLIBCXX_DEBUG

42
libstdc++-v3/include/debug/hash_map
View file

@ -1,42 +0,0 @@
// Debugging hash_map/hash_multimap implementation -*- C++ -*-
// Copyright (C) 2003, 2005
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/hash_map
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_MAP
#define _GLIBCXX_DEBUG_HASH_MAP 1
#include <ext/hash_map>
#include <debug/hash_map.h>
#include <debug/hash_multimap.h>
#endif

284
libstdc++-v3/include/debug/hash_map.h
View file

@ -1,284 +0,0 @@
// Debugging hash_map implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2006, 2007
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/hash_map.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_MAP_H
#define _GLIBCXX_DEBUG_HASH_MAP_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
namespace __gnu_cxx
{
namespace __debug
{
template<typename _Value, typename _Tp,
typename _HashFcn = __gnu_cxx::hash<_Value>,
typename _EqualKey = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class hash_map
: public _GLIBCXX_EXT_D::hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>,
public __gnu_debug::_Safe_sequence<hash_map<_Value, _Tp, _HashFcn,
_EqualKey, _Alloc> >
{
typedef _GLIBCXX_EXT_D::hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>
_Base;
typedef __gnu_debug::_Safe_sequence<hash_map> _Safe_base;
public:
typedef typename _Base::key_type key_type;
typedef typename _Base::data_type data_type;
typedef typename _Base::mapped_type mapped_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, hash_map>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_map>
const_iterator;
typedef typename _Base::allocator_type allocator_type;
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
hash_map() { }
explicit hash_map(size_type __n) : _Base(__n) { }
hash_map(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
hash_map(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
template<typename _InputIterator>
hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n) { }
template<typename _InputIterator>
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf) { }
template<typename _InputIterator>
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf,
__eql, __a) { }
hash_map(const _Base& __x) : _Base(__x), _Safe_base() { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
void
swap(hash_map& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
iterator
begin() { return iterator(_Base::begin(), this); }
iterator
end() { return iterator(_Base::end(), this); }
const_iterator
begin() const
{ return const_iterator(_Base::begin(), this); }
const_iterator
end() const
{ return const_iterator(_Base::end(), this); }
std::pair<iterator, bool>
insert(const value_type& __obj)
{
std::pair<typename _Base::iterator, bool> __res = _Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
void
insert(const value_type* __first, const value_type* __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first, __last);
}
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
std::pair<iterator, bool>
insert_noresize(const value_type& __obj)
{
std::pair<typename _Base::iterator, bool> __res =
_Base::insert_noresize(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
iterator
find(const key_type& __key)
{ return iterator(_Base::find(__key), this); }
const_iterator
find(const key_type& __key) const
{ return const_iterator(_Base::find(__key), this); }
using _Base::operator[];
using _Base::count;
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
typedef typename _Base::const_iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
size_type
erase(const key_type& __key)
{
iterator __victim(_Base::find(__key), this);
if (__victim != end())
return this->erase(__victim), 1;
else
return 0;
}
void
erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
for (iterator __tmp = __first; __tmp != __last;)
{
iterator __victim = __tmp++;
__victim._M_invalidate();
}
_Base::erase(__first.base(), __last.base());
}
void
clear()
{
_Base::clear();
this->_M_invalidate_all();
}
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
_Base&
_M_base() { return *this; }
const _Base&
_M_base() const { return *this; }
private:
void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator==(const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator!=(const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline void
swap(hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace __gnu_cxx
#endif

268
libstdc++-v3/include/debug/hash_multimap.h
View file

@ -1,268 +0,0 @@
// Debugging hash_multimap implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2006
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/hash_multimap.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_MULTIMAP_H
#define _GLIBCXX_DEBUG_HASH_MULTIMAP_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
namespace __gnu_cxx
{
namespace __debug
{
template<typename _Value, typename _Tp,
typename _HashFcn = __gnu_cxx::hash<_Value>,
typename _EqualKey = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class hash_multimap
: public _GLIBCXX_EXT_D::hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>,
public __gnu_debug::_Safe_sequence<hash_multimap<_Value, _Tp, _HashFcn,
_EqualKey, _Alloc> >
{
typedef _GLIBCXX_EXT_D::hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>
_Base;
typedef __gnu_debug::_Safe_sequence<hash_multimap> _Safe_base;
public:
typedef typename _Base::key_type key_type;
typedef typename _Base::data_type data_type;
typedef typename _Base::mapped_type mapped_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
hash_multimap> iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_multimap> const_iterator;
typedef typename _Base::allocator_type allocator_type;
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
hash_multimap() { }
explicit hash_multimap(size_type __n) : _Base(__n) { }
hash_multimap(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
hash_multimap(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
template<typename _InputIterator>
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n) { }
template<typename _InputIterator>
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf) { }
template<typename _InputIterator>
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf,
__eql, __a) { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
void
swap(hash_multimap& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
iterator
begin() { return iterator(_Base::begin(), this); }
iterator
end() { return iterator(_Base::end(), this); }
const_iterator
begin() const
{ return const_iterator(_Base::begin(), this); }
const_iterator
end() const
{ return const_iterator(_Base::end(), this); }
iterator
insert(const value_type& __obj)
{ return iterator(_Base::insert(__obj), this); }
template <typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
iterator
insert_noresize(const value_type& __obj)
{ return iterator(_Base::insert_noresize(__obj), this); }
iterator
find(const key_type& __key)
{ return iterator(_Base::find(__key), this); }
const_iterator
find(const key_type& __key) const
{ return const_iterator(_Base::find(__key), this); }
using _Base::count;
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
typedef typename _Base::const_iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
size_type
erase(const key_type& __key)
{
std::pair<iterator, iterator> __victims = this->equal_range(__key);
std::size_t __num_victims = 0;
while (__victims.first != __victims.second)
{
this->erase(__victims.first++);
++__num_victims;
}
return __num_victims;
}
void
erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
for (iterator __tmp = __first; __tmp != __last;)
{
iterator __victim = __tmp++;
__victim._M_invalidate();
}
_Base::erase(__first.base(), __last.base());
}
void
clear()
{
_Base::clear();
this->_M_invalidate_all();
}
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
_Base&
_M_base() { return *this; }
const _Base&
_M_base() const { return *this; }
private:
void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator==(const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __x,
const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator!=(const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __x,
const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline void
swap(hash_multimap<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
hash_multimap<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace __gnu_cxx
#endif

243
libstdc++-v3/include/debug/hash_multiset.h
View file

@ -1,243 +0,0 @@
// Debugging hash_multiset implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2006
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/hash_multiset.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_MULTISET_H
#define _GLIBCXX_DEBUG_HASH_MULTISET_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
namespace __gnu_cxx
{
namespace __debug
{
template<typename _Value,
typename _HashFcn = __gnu_cxx::hash<_Value>,
typename _EqualKey = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class hash_multiset
: public _GLIBCXX_EXT_D::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>,
public __gnu_debug::_Safe_sequence<hash_multiset<_Value, _HashFcn,
_EqualKey, _Alloc> >
{
typedef _GLIBCXX_EXT_D:: hash_multiset<_Value,_HashFcn, _EqualKey,_Alloc>
_Base;
typedef __gnu_debug::_Safe_sequence<hash_multiset> _Safe_base;
public:
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
hash_multiset> iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_multiset> const_iterator;
typedef typename _Base::allocator_type allocator_type;
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
hash_multiset() { }
explicit hash_multiset(size_type __n) : _Base(__n) { }
hash_multiset(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
hash_multiset(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l)
{ }
template<typename _InputIterator>
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n)
{ }
template<typename _InputIterator>
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf)
{ }
template<typename _InputIterator>
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf,
__eql, __a)
{ }
hash_multiset(const _Base& __x) : _Base(__x), _Safe_base() { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
void
swap(hash_multiset& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
iterator begin() const { return iterator(_Base::begin(), this); }
iterator end() const { return iterator(_Base::end(), this); }
iterator
insert(const value_type& __obj)
{ return iterator(_Base::insert(__obj), this); }
template <typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
iterator
insert_noresize(const value_type& __obj)
{ return iterator(_Base::insert_noresize(__obj), this); }
iterator
find(const key_type& __key) const
{ return iterator(_Base::find(__key), this); }
using _Base::count;
std::pair<iterator, iterator>
equal_range(const key_type& __key) const
{
typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
size_type
erase(const key_type& __key)
{
size_type __count = 0;
std::pair<iterator, iterator> __victims = this->equal_range(__key);
while (__victims.first != __victims.second)
{
this->erase(__victims++);
++__count;
}
return __count;
}
void
erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
for (iterator __tmp = __first; __tmp != __last;)
{
iterator __victim = __tmp++;
__victim._M_invalidate();
}
_Base::erase(__first.base(), __last.base());
}
void
clear()
{
_Base::clear();
this->_M_invalidate_all();
}
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
_Base& _M_base() { return *this; }
const _Base& _M_base() const { return *this; }
private:
void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
inline bool
operator==(const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
inline bool
operator!=(const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
inline void
swap(hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace __gnu_cxx
#endif

42
libstdc++-v3/include/debug/hash_set
View file

@ -1,42 +0,0 @@
// Debugging hash_set/hash_multiset implementation -*- C++ -*-
// Copyright (C) 2003, 2005
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/hash_set
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_SET
#define _GLIBCXX_DEBUG_HASH_SET 1
#include <ext/hash_set>
#include <debug/hash_set.h>
#include <debug/hash_multiset.h>
#endif

211
libstdc++-v3/include/debug/hash_set.h → libstdc++-v3/include/debug/safe_association.h
View file

@ -1,6 +1,6 @@
// Debugging hash_set implementation -*- C++ -*-
// Safe associated container base class implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2006, 2007
// Copyright (C) 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@ -28,110 +28,110 @@
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/** @file debug/hash_set.h
/** @file debug/safe_association.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_HASH_SET_H
#define _GLIBCXX_DEBUG_HASH_SET_H 1
#ifndef _GLIBCXX_DEBUG_SAFE_ASSOCIATION_H
#define _GLIBCXX_DEBUG_SAFE_ASSOCIATION_H 1
#include <debug/debug.h>
#include <debug/macros.h>
#include <debug/functions.h>
#include <debug/formatter.h>
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
namespace __gnu_cxx
namespace __gnu_debug
{
namespace __debug
{
template<typename _Value,
typename _HashFcn = __gnu_cxx::hash<_Value>,
typename _EqualKey = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class hash_set
: public _GLIBCXX_EXT_D::hash_set<_Value, _HashFcn, _EqualKey,_Alloc>,
public __gnu_debug::_Safe_sequence<hash_set<_Value, _HashFcn, _EqualKey,
_Alloc> >
/**
* @brief Base class for constructing a "safe" associated container type.
*
* The class template %_Safe_association simplifies the construction of
* "safe" associated containers.
*/
template<typename _Base>
class _Safe_association
: public _Base
{
typedef _GLIBCXX_EXT_D::hash_set<_Value, _HashFcn, _EqualKey,_Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<hash_set> _Safe_base;
public:
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::size_type size_type;
typedef typename _Base::allocator_type allocator_type;
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, hash_set>
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
_Safe_association>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_set>
_Safe_association>
const_iterator;
typedef typename _Base::allocator_type allocator_type;
_Safe_association() { }
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
explicit _Safe_association(size_type __n) : _Base(__n) { }
hash_set() { }
_Safe_association(size_type __n, const hasher& __hf)
: _Base(__n, __hf) { }
explicit hash_set(size_type __n) : _Base(__n) { }
hash_set(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
_Safe_association(size_type __n, const hasher& __hf,
const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
hash_set(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
template<typename _InputIter>
_Safe_association(_InputIter __f, _InputIter __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
template<typename _InputIterator>
hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
template<typename _InputIter>
_Safe_association(_InputIter __f, _InputIter __l, size_type __n)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n) { }
template<typename _InputIterator>
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf) { }
template<typename _InputIter>
_Safe_association(_InputIter __f, _InputIter __l, size_type __n,
const hasher& __hf)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf)
{ }
template<typename _InputIterator>
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf,
__eql, __a) { }
template<typename _InputIter>
_Safe_association(_InputIter __f, _InputIter __l, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__gnu_debug::__check_valid_range(__f, __l),
__l, __n, __hf, __eql, __a)
{ }
hash_set(const _Base& __x) : _Base(__x), _Safe_base() { }
_Safe_association(const _Base& __x) : _Base(__x) { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
using _Base::get_allocator;
using _Base::key_eq;
void
swap(hash_set& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
using _Base::count;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::bucket;
using _Base::bucket_size;
using _Base::load_factor;
iterator
begin() const { return iterator(_Base::begin(), this); }
const_iterator
begin() const { return const_iterator(_Base::begin(), this); }
iterator
end() const { return iterator(_Base::end(), this); }
const_iterator
end() const { return const_iterator(_Base::end(), this); }
std::pair<iterator, bool>
insert(const value_type& __obj)
{
std::pair<typename _Base::iterator, bool> __res =
_Base::insert(__obj);
typedef std::pair<typename _Base::iterator, bool> __pair_type;
__pair_type __res = _Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
@ -142,58 +142,50 @@ namespace __debug
_Base::insert(__first, __last);
}
template<typename _InputIterator>
template<typename _InputIter>
void
insert(_InputIterator __first, _InputIterator __last)
insert(_InputIter __first, _InputIter __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
std::pair<iterator, bool>
insert_noresize(const value_type& __obj)
{
std::pair<typename _Base::iterator, bool> __res =
_Base::insert_noresize(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
iterator
const_iterator
find(const key_type& __key) const
{ return iterator(_Base::find(__key), this); }
{ return const_iterator(_Base::find(__key), this); }
using _Base::count;
std::pair<iterator, iterator>
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
typedef typename _Base::const_iterator _Base_iterator;
typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
__pair_type __res = _Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
size_type
erase(const key_type& __key)
{
size_type __ret(0);
iterator __victim(_Base::find(__key), this);
if (__victim != end())
return this->erase(__victim), 1;
else
return 0;
{
this->erase(__victim);
__ret = 1;
}
return __ret;
}
void
iterator
erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
return iterator(_Base::erase(__it.base()));
}
void
iterator
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
@ -202,7 +194,7 @@ namespace __debug
iterator __victim = __tmp++;
__victim._M_invalidate();
}
_Base::erase(__first.base(), __last.base());
return iterator(_Base::erase(__first.base(), __last.base()));
}
void
@ -212,13 +204,8 @@ namespace __debug
this->_M_invalidate_all();
}
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
_Base&
_M_base() { return *this; }
_M_base() { return *this; }
const _Base&
_M_base() const { return *this; }
@ -232,28 +219,6 @@ namespace __debug
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline bool
operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline bool
operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline void
swap(hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace __gnu_cxx
} // namespace __gnu_debug
#endif

199
libstdc++-v3/include/debug/unordered_map Normal file
View file

@ -0,0 +1,199 @@
// Debugging unordered_map/unordered_multimap implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2007
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/unordered_map
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_UNORDERED_MAP
#define _GLIBCXX_DEBUG_UNORDERED_MAP 1
#ifdef __GXX_EXPERIMENTAL_CXX0X__
# include <unordered_map>
#else
# include <c++0x_warning.h>
#endif
#include <debug/safe_association.h>
#include <debug/safe_iterator.h>
#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
namespace std
{
namespace __debug
{
template<typename _Key, typename _Tp,
typename _Hash = std::hash<_Key>,
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
class unordered_map
: public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
{
typedef typename _GLIBCXX_STD_BASE _Base;
typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
typedef __gnu_debug::_Safe_sequence<unordered_map> _Safe_base;
public:
typedef typename _Safe_assoc::size_type size_type;
typedef typename _Safe_assoc::hasher hasher;
typedef typename _Safe_assoc::key_equal key_equal;
typedef typename _Safe_assoc::allocator_type allocator_type;
explicit
unordered_map(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_map(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
{ }
unordered_map(const _Safe_assoc& __x)
: _Safe_assoc(__x), _Safe_base() { }
void
swap(unordered_map& __x)
{
_Safe_assoc::swap(__x);
_Safe_base::_M_swap(__x);
}
};
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline bool
operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline bool
operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
template<typename _Key, typename _Tp,
typename _Hash = std::hash<_Key>,
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
class unordered_multimap
: public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
{
typedef typename _GLIBCXX_STD_BASE _Base;
typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
typedef __gnu_debug::_Safe_sequence<unordered_multimap> _Safe_base;
public:
typedef typename _Safe_assoc::size_type size_type;
typedef typename _Safe_assoc::hasher hasher;
typedef typename _Safe_assoc::key_equal key_equal;
typedef typename _Safe_assoc::allocator_type allocator_type;
explicit
unordered_multimap(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_multimap(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
{ }
unordered_multimap(const _Safe_assoc& __x)
: _Safe_assoc(__x), _Safe_base() { }
void
swap(unordered_multimap& __x)
{
_Safe_assoc::swap(__x);
_Safe_base::_M_swap(__x);
}
};
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline bool
operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline bool
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace std
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#endif

192
libstdc++-v3/include/debug/unordered_set Normal file
View file

@ -0,0 +1,192 @@
// Debugging unordered_set/unordered_multiset implementation -*- C++ -*-
// Copyright (C) 2003, 2005, 2007
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.
/** @file debug/unordered_set
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_UNORDERED_SET
#define _GLIBCXX_DEBUG_UNORDERED_SET 1
#ifdef __GXX_EXPERIMENTAL_CXX0X__
# include <unordered_set>
#else
# include <c++0x_warning.h>
#endif
#include <debug/safe_association.h>
#include <debug/safe_iterator.h>
#define _GLIBCXX_BASE unordered_set<_Value, _Hash, _Pred, _Alloc>
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
namespace std
{
namespace __debug
{
template<typename _Value,
typename _Hash = std::hash<_Value>,
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_set
: public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
{
typedef typename _GLIBCXX_STD_BASE _Base;
typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
typedef __gnu_debug::_Safe_sequence<unordered_set> _Safe_base;
public:
typedef typename _Safe_assoc::size_type size_type;
typedef typename _Safe_assoc::hasher hasher;
typedef typename _Safe_assoc::key_equal key_equal;
typedef typename _Safe_assoc::allocator_type allocator_type;
explicit
unordered_set(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
{ }
unordered_set(const _Safe_assoc& __x)
: _Safe_assoc(__x), _Safe_base() { }
void
swap(unordered_set& __x)
{
_Safe_assoc::swap(__x);
_Safe_base::_M_swap(__x);
}
};
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline bool
operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline bool
operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc>
template<typename _Value,
typename _Hash = std::hash<_Value>,
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_multiset
: public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
{
typedef typename _GLIBCXX_STD_BASE _Base;
typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
typedef __gnu_debug::_Safe_sequence<unordered_multiset> _Safe_base;
public:
typedef typename _Safe_assoc::size_type size_type;
typedef typename _Safe_assoc::hasher hasher;
typedef typename _Safe_assoc::key_equal key_equal;
typedef typename _Safe_assoc::allocator_type allocator_type;
explicit
unordered_multiset(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__n, __hf, __eql, __a)
{ }
template<typename _InputIterator>
unordered_multiset(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
{ }
unordered_multiset(const _Safe_assoc& __x)
: _Safe_assoc(__x), _Safe_base() { }
void
swap(unordered_multiset& __x)
{
_Safe_assoc::swap(__x);
_Safe_base::_M_swap(__x);
}
};
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline bool
operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline bool
operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
} // namespace __debug
} // namespace std
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#endif

1130
libstdc++-v3/include/ext/hashtable.h
View file

File diff suppressed because it is too large Load diff

8
libstdc++-v3/include/std/unordered_map
View file

@ -58,9 +58,15 @@
# include <tr1_impl/unordered_map>
#else
# define _GLIBCXX_INCLUDE_AS_CXX0X
#if _GLIBCXX_DEBUG
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace _GLIBCXX_STD_D {
# define _GLIBCXX_END_NAMESPACE_TR1 }
# define _GLIBCXX_TR1 _GLIBCXX_STD_D
#else
# define _GLIBCXX_BEGIN_NAMESPACE_TR1
# define _GLIBCXX_END_NAMESPACE_TR1
# define _GLIBCXX_TR1
# define _GLIBCXX_TR1
#endif
# include <tr1_impl/unordered_map>
# undef _GLIBCXX_TR1
# undef _GLIBCXX_END_NAMESPACE_TR1

12
libstdc++-v3/include/std/unordered_set
View file

@ -58,9 +58,15 @@
# include <tr1_impl/unordered_set>
#else
# define _GLIBCXX_INCLUDE_AS_CXX0X
#if _GLIBCXX_DEBUG
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace _GLIBCXX_STD_D {
# define _GLIBCXX_END_NAMESPACE_TR1 }
# define _GLIBCXX_TR1 _GLIBCXX_STD_D
#else
# define _GLIBCXX_BEGIN_NAMESPACE_TR1
# define _GLIBCXX_END_NAMESPACE_TR1
# define _GLIBCXX_TR1
# define _GLIBCXX_TR1
#endif
# include <tr1_impl/unordered_set>
# undef _GLIBCXX_TR1
# undef _GLIBCXX_END_NAMESPACE_TR1
@ -68,4 +74,8 @@
# undef _GLIBCXX_INCLUDE_AS_CXX0X
#endif
#ifdef _GLIBCXX_DEBUG
# include <debug/unordered_set>
#endif
#endif // _GLIBCXX_UNORDERED_SET

28
libstdc++-v3/testsuite/backward/header_deque_h.cc → libstdc++-v3/testsuite/23_containers/unordered_map/requirements/debug.cc
View file

@ -1,6 +1,7 @@
// 2001-09-20 Peter Schmid <schmid@snake.iap.physik.tu-darmstadt.de>
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2007 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
@ -18,14 +19,21 @@
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header deque.h
#include <string>
#include <debug/unordered_map>
#include <deque.h>
#include <testsuite_hooks.h>
using namespace __gnu_debug;
// { dg-options "-Wno-deprecated" }
using std::allocator;
using std::equal_to;
using std::hash;
using std::pair;
using std::string;
int main(void)
{
return 0;
}
template class unordered_map<string, float>;
template class unordered_map<string, int,
hash<string>, equal_to<string>,
allocator<pair<const string, int> > >;
template class unordered_map<string, float,
hash<string>, equal_to<string>,
allocator<char> >;

18
libstdc++-v3/testsuite/backward/header_hashtable_h.cc → libstdc++-v3/testsuite/23_containers/unordered_multimap/requirements/debug.cc
View file

@ -1,6 +1,7 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2007 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
@ -18,14 +19,11 @@
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header hashtable.h
#include <string>
#include <debug/unordered_map>
#include <hashtable.h>
#include <testsuite_hooks.h>
using namespace __gnu_debug;
// { dg-options "-Wno-deprecated" }
using std::string;
int main(void)
{
return 0;
}
template class unordered_multimap<string, float>;

18
libstdc++-v3/testsuite/backward/header_rope_h.cc → libstdc++-v3/testsuite/23_containers/unordered_multiset/requirements/debug.cc
View file

@ -1,6 +1,7 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2007 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
@ -18,14 +19,9 @@
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header rope.h
#include <string>
#include <debug/unordered_set>
#include <rope.h>
#include <testsuite_hooks.h>
using namespace __gnu_debug;
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}
template class unordered_multiset<int>;

29
libstdc++-v3/testsuite/backward/header_slist_h.cc → libstdc++-v3/testsuite/23_containers/unordered_set/requirements/debug.cc
View file

@ -1,31 +1,26 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2001 Free Software Foundation, Inc.
// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor,
// Boston, MA 02110-1301, USA.
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
#include <debug/unordered_set>
// backward header slist.h
using namespace __gnu_debug;
#include <slist.h>
#include <testsuite_hooks.h>
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}
template class unordered_set<int>;

6
libstdc++-v3/testsuite/ext/hash_map/1.cc → libstdc++-v3/testsuite/backward/hash_map/1.cc
View file

@ -1,4 +1,6 @@
// Copyright (C) 2002, 2005 Free Software Foundation, Inc.
// { dg-options "-Wno-deprecated" }
// Copyright (C) 2002, 2005, 2007 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
@ -20,7 +22,7 @@
#include <cstdlib>
#include <string>
#include <ext/hash_map>
#include <hash_map>
#include <testsuite_hooks.h>
namespace __gnu_cxx

6
libstdc++-v3/testsuite/ext/hash_map/14648.cc → libstdc++-v3/testsuite/backward/hash_map/14648.cc
View file

@ -1,4 +1,6 @@
// Copyright (C) 2004, 2005 Free Software Foundation
// { dg-options "-Wno-deprecated" }
// Copyright (C) 2004, 2005, 2007 Free Software Foundation
//
// 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
@ -17,7 +19,7 @@
// USA.
#include <iostream>
#include <ext/hash_map>
#include <hash_map>
#include <ext/rope>
// libstdc++/14648

7
libstdc++-v3/testsuite/ext/hash_map/23528.cc → libstdc++-v3/testsuite/backward/hash_map/23528.cc
View file

@ -1,3 +1,6 @@
// { dg-options "-Wno-deprecated" }
// { dg-do compile }
// Copyright (C) 2005 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@ -16,9 +19,7 @@
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// { dg-do compile }
#include <ext/hash_map>
#include <hash_map>
// libstdc++/23528
void test01()

9
libstdc++-v3/testsuite/ext/hash_map/requirements/explicit_instantiation.cc → libstdc++-v3/testsuite/backward/hash_map/requirements/explicit_instantiation.cc
View file

@ -1,4 +1,7 @@
// Copyright (C) 2004 Free Software Foundation, Inc.
// { dg-options "-Wno-deprecated" }
// { dg-do compile }
// Copyright (C) 2004, 2007 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
@ -27,8 +30,6 @@
// This file tests explicit instantiation of library containers
#include <ext/hash_map>
// { dg-do compile }
#include <hash_map>
template class __gnu_cxx::hash_map<int, char>;

6
libstdc++-v3/testsuite/ext/hash_set/1.cc → libstdc++-v3/testsuite/backward/hash_set/1.cc
View file

@ -1,7 +1,9 @@
// { dg-options "-Wno-deprecated" }
// 2002-04-28 Paolo Carlini <pcarlini@unitus.it>
// Peter Schmid <schmid@snake.iap.physik.tu-darmstadt.de>
// Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
// Copyright (C) 2002, 2004, 2005, 2007 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
@ -21,7 +23,7 @@
// hash_set (SGI extension)
#include <ext/hash_set>
#include <hash_set>
void
test01()

6
libstdc++-v3/testsuite/ext/hash_set/check_construct_destroy.cc → libstdc++-v3/testsuite/backward/hash_set/check_construct_destroy.cc
View file

@ -1,6 +1,8 @@
// { dg-options "-Wno-deprecated" }
// 2004-07-26 Matt Austern <austern@apple.com>
//
// Copyright (C) 2003 Free Software Foundation, Inc.
// Copyright (C) 2003, 2007 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
@ -27,7 +29,7 @@
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#include <ext/hash_set>
#include <hash_set>
#include <functional>
#include <iterator>
#include <testsuite_allocator.h>

9
libstdc++-v3/testsuite/ext/hash_set/requirements/explicit_instantiation.cc → libstdc++-v3/testsuite/backward/hash_set/requirements/explicit_instantiation.cc
View file

@ -1,4 +1,7 @@
// Copyright (C) 2004 Free Software Foundation, Inc.
// { dg-options "-Wno-deprecated" }
// { dg-do compile }
// Copyright (C) 2004, 2007 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
@ -27,8 +30,6 @@
// This file tests explicit instantiation of library containers
#include <ext/hash_set>
// { dg-do compile }
#include <hash_set>
template class __gnu_cxx::hash_set<int>;

31
libstdc++-v3/testsuite/backward/header_hash_map_h.cc
View file

@ -1,31 +0,0 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header hash_map.h
#include <hash_map.h>
#include <testsuite_hooks.h>
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}

31
libstdc++-v3/testsuite/backward/header_hash_set_h.cc
View file

@ -1,31 +0,0 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header hash_set.h
#include <hash_set.h>
#include <testsuite_hooks.h>
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}

31
libstdc++-v3/testsuite/backward/header_iterator_h.cc
View file

@ -1,31 +0,0 @@
// 2001-09-04 Peter Schmid <schmid@snake.iap.physik.tu-darmstadt.de>
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header iterator.h
#include <iterator.h>
#include <testsuite_hooks.h>
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}

31
libstdc++-v3/testsuite/backward/header_tempbuf_h.cc
View file

@ -1,31 +0,0 @@
// 2002-03-15 Philipp Thomas <pthomas@suse.de>
// Copyright (C) 2001 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// backward header tempbuf.h
#include <tempbuf.h>
#include <testsuite_hooks.h>
// { dg-options "-Wno-deprecated" }
int main(void)
{
return 0;
}

1
libstdc++-v3/testsuite/util/native_type/assoc/native_hash_multimap.hpp
View file

@ -49,7 +49,6 @@
#include <string>
#include <tr1/unordered_map>
#include <ext/hash_map>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <native_type/assoc/native_hash_tag.hpp>