OSDN Git Service

2009-04-15 Benjamin Kosnik <bkoz@redhat.com>
authorbkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 16 Apr 2009 02:04:15 +0000 (02:04 +0000)
committerbkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 16 Apr 2009 02:04:15 +0000 (02:04 +0000)
* doc/html: Regenerate, remove un-needed.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@146145 138bc75d-0d04-0410-961f-82ee72b054a4

52 files changed:
libstdc++-v3/doc/html/manual/bk01apas02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apas03.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apas04.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apas05.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apd.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apds02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01apds03.html [deleted file]
libstdc++-v3/doc/html/manual/bk01ape.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch01.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch01s02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch01s03.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch02s03.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch03s02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch03s03.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch03s04.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch03s05.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt01ch03s06.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt02ch04.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt02ch05.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt02ch06.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt02ch06s02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt03ch07.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt04ch09.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt04ch10.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt04ch11.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt04ch12.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt06ch14.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt06ch15.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt07ch16.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt07ch16s02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt07ch17.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt07ch17s02.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt07ch18.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt10ch21.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt10ch22.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt10ch23.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt11ch24.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt11ch25.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt11ch26.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt11ch27.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt11ch28.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch29.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch32.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch33.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch34.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch35.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch36.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch37.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch38.html [deleted file]
libstdc++-v3/doc/html/manual/bk01pt12ch39.html [deleted file]
libstdc++-v3/doc/html/manual/concurrency.html [deleted file]

diff --git a/libstdc++-v3/doc/html/manual/bk01apas02.html b/libstdc++-v3/doc/html/manual/bk01apas02.html
deleted file mode 100644 (file)
index 26f6eb7..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Directory Layout and Source Conventions</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><meta name="keywords" content="&#10;      ISO C++&#10;    , &#10;      library&#10;    " /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="appendix_contributing.html" title="Appendix A. Contributing" /><link rel="prev" href="appendix_contributing.html" title="Appendix A. Contributing" /><link rel="next" href="bk01apas03.html" title="Coding Style" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Directory Layout and Source Conventions</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="appendix_contributing.html">Prev</a> </td><th width="60%" align="center">Appendix A. Contributing</th><td width="20%" align="right"> <a accesskey="n" href="bk01apas03.html">Next</a></td></tr></table><hr /></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="contrib.organization"></a>Directory Layout and Source Conventions</h2></div></div></div><p>
-    The unpacked source directory of libstdc++ contains the files
-    needed to create the GNU C++ Library.
-  </p><div class="literallayout"><p><br />
-It has subdirectories:<br />
-<br />
-  doc<br />
-    Files in HTML and text format that document usage, quirks of the<br />
-    implementation, and contributor checklists.<br />
-<br />
-  include<br />
-    All header files for the C++ library are within this directory,<br />
-    modulo specific runtime-related files that are in the libsupc++<br />
-    directory.<br />
-<br />
-    include/std<br />
-      Files meant to be found by #include &lt;name&gt; directives in<br />
-      standard-conforming user programs.  <br />
-<br />
-    include/c<br />
-      Headers intended to directly include standard C headers. <br />
-      [NB: this can be enabled via --enable-cheaders=c]<br />
-<br />
-    include/c_global <br />
-      Headers intended to include standard C headers in<br />
-      the global namespace, and put select names into the std::<br />
-      namespace.  [NB: this is the default, and is the same as<br />
-      --enable-cheaders=c_global]<br />
-<br />
-    include/c_std <br />
-      Headers intended to include standard C headers<br />
-      already in namespace std, and put select names into the std::<br />
-      namespace.  [NB: this is the same as --enable-cheaders=c_std]<br />
-<br />
-    include/bits<br />
-      Files included by standard headers and by other files in<br />
-      the bits directory. <br />
-<br />
-    include/backward<br />
-      Headers provided for backward compatibility, such as &lt;iostream.h&gt;.<br />
-      They are not used in this library.<br />
-<br />
-    include/ext<br />
-      Headers that define extensions to the standard library.  No<br />
-      standard header refers to any of them.<br />
-<br />
-  scripts<br />
-    Scripts that are used during the configure, build, make, or test<br />
-    process.<br />
-<br />
-  src<br />
-    Files that are used in constructing the library, but are not<br />
-    installed.<br />
-<br />
-  testsuites/[backward, demangle, ext, performance, thread, 17_* to 27_*]<br />
-    Test programs are here, and may be used to begin to exercise the <br />
-    library.  Support for "make check" and "make check-install" is<br />
-    complete, and runs through all the subdirectories here when this<br />
-    command is issued from the build directory.  Please note that<br />
-    "make check" requires DejaGNU 1.4 or later to be installed.  Please<br />
-    note that "make check-script" calls the script mkcheck, which<br />
-    requires bash, and which may need the paths to bash adjusted to<br />
-    work properly, as /bin/bash is assumed.<br />
-<br />
-Other subdirectories contain variant versions of certain files<br />
-that are meant to be copied or linked by the configure script.<br />
-Currently these are:<br />
-<br />
-  config/abi<br />
-  config/cpu<br />
-  config/io<br />
-  config/locale<br />
-  config/os<br />
-<br />
-In addition, a subdirectory holds the convenience library libsupc++.<br />
-<br />
-  libsupc++<br />
-    Contains the runtime library for C++, including exception<br />
-    handling and memory allocation and deallocation, RTTI, terminate<br />
-    handlers, etc.<br />
-<br />
-Note that glibc also has a bits/ subdirectory.  We will either<br />
-need to be careful not to collide with names in its bits/<br />
-directory; or rename bits to (e.g.) cppbits/.<br />
-<br />
-In files throughout the system, lines marked with an "XXX" indicate<br />
-a bug or incompletely-implemented feature.  Lines marked "XXX MT"<br />
-indicate a place that may require attention for multi-thread safety.<br />
-  </p></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="appendix_contributing.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01apas03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Appendix A. Contributing </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> Coding Style</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apas03.html b/libstdc++-v3/doc/html/manual/bk01apas03.html
deleted file mode 100644 (file)
index 947c964..0000000
+++ /dev/null
@@ -1,585 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Coding Style</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><meta name="keywords" content="&#10;      ISO C++&#10;    , &#10;      library&#10;    " /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="appendix_contributing.html" title="Appendix A. Contributing" /><link rel="prev" href="bk01apas02.html" title="Directory Layout and Source Conventions" /><link rel="next" href="bk01apas04.html" title="Documentation Style" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Coding Style</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apas02.html">Prev</a> </td><th width="60%" align="center">Appendix A. Contributing</th><td width="20%" align="right"> <a accesskey="n" href="bk01apas04.html">Next</a></td></tr></table><hr /></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="contrib.coding_style"></a>Coding Style</h2></div></div></div><p>
-  </p><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="coding_style.bad_identifiers"></a>Bad Identifiers</h3></div></div></div><p>
-      Identifiers that conflict and should be avoided.
-    </p><div class="literallayout"><p><br />
-      This is the list of names “<span class="quote">reserved to the<br />
-      implementation</span>” that have been claimed by certain<br />
-      compilers and system headers of interest, and should not be used<br />
-      in the library. It will grow, of course.  We generally are<br />
-      interested in names that are not all-caps, except for those like<br />
-      "_T"<br />
-<br />
-      For Solaris:<br />
-      _B<br />
-      _C<br />
-      _L<br />
-      _N<br />
-      _P<br />
-      _S<br />
-      _U<br />
-      _X<br />
-      _E1<br />
-      ..<br />
-      _E24<br />
-<br />
-      Irix adds:<br />
-      _A<br />
-      _G<br />
-<br />
-      MS adds:<br />
-      _T<br />
-<br />
-      BSD adds:<br />
-      __used<br />
-      __unused<br />
-      __inline<br />
-      _Complex<br />
-      __istype<br />
-      __maskrune<br />
-      __tolower<br />
-      __toupper<br />
-      __wchar_t<br />
-      __wint_t<br />
-      _res<br />
-      _res_ext<br />
-      __tg_*<br />
-<br />
-      SPU adds:<br />
-      __ea<br />
-<br />
-      For GCC:<br />
-<br />
-      [Note that this list is out of date. It applies to the old<br />
-      name-mangling; in G++ 3.0 and higher a different name-mangling is<br />
-      used. In addition, many of the bugs relating to G++ interpreting<br />
-      these names as operators have been fixed.]<br />
-<br />
-      The full set of __* identifiers (combined from gcc/cp/lex.c and<br />
-      gcc/cplus-dem.c) that are either old or new, but are definitely <br />
-      recognized by the demangler, is:<br />
-<br />
-      __aa<br />
-      __aad<br />
-      __ad<br />
-      __addr<br />
-      __adv<br />
-      __aer<br />
-      __als<br />
-      __alshift<br />
-      __amd<br />
-      __ami<br />
-      __aml<br />
-      __amu<br />
-      __aor<br />
-      __apl<br />
-      __array<br />
-      __ars<br />
-      __arshift<br />
-      __as<br />
-      __bit_and<br />
-      __bit_ior<br />
-      __bit_not<br />
-      __bit_xor<br />
-      __call<br />
-      __cl<br />
-      __cm<br />
-      __cn<br />
-      __co<br />
-      __component<br />
-      __compound<br />
-      __cond<br />
-      __convert<br />
-      __delete<br />
-      __dl<br />
-      __dv<br />
-      __eq<br />
-      __er<br />
-      __ge<br />
-      __gt<br />
-      __indirect<br />
-      __le<br />
-      __ls<br />
-      __lt<br />
-      __max<br />
-      __md<br />
-      __method_call<br />
-      __mi<br />
-      __min<br />
-      __minus<br />
-      __ml<br />
-      __mm<br />
-      __mn<br />
-      __mult<br />
-      __mx<br />
-      __ne<br />
-      __negate<br />
-      __new<br />
-      __nop<br />
-      __nt<br />
-      __nw<br />
-      __oo<br />
-      __op<br />
-      __or<br />
-      __pl<br />
-      __plus<br />
-      __postdecrement<br />
-      __postincrement<br />
-      __pp<br />
-      __pt<br />
-      __rf<br />
-      __rm<br />
-      __rs<br />
-      __sz<br />
-      __trunc_div<br />
-      __trunc_mod<br />
-      __truth_andif<br />
-      __truth_not<br />
-      __truth_orif<br />
-      __vc<br />
-      __vd<br />
-      __vn<br />
-<br />
-      SGI badnames:<br />
-      __builtin_alloca<br />
-      __builtin_fsqrt<br />
-      __builtin_sqrt<br />
-      __builtin_fabs<br />
-      __builtin_dabs<br />
-      __builtin_cast_f2i<br />
-      __builtin_cast_i2f<br />
-      __builtin_cast_d2ll<br />
-      __builtin_cast_ll2d<br />
-      __builtin_copy_dhi2i<br />
-      __builtin_copy_i2dhi<br />
-      __builtin_copy_dlo2i<br />
-      __builtin_copy_i2dlo<br />
-      __add_and_fetch<br />
-      __sub_and_fetch<br />
-      __or_and_fetch<br />
-      __xor_and_fetch<br />
-      __and_and_fetch<br />
-      __nand_and_fetch<br />
-      __mpy_and_fetch<br />
-      __min_and_fetch<br />
-      __max_and_fetch<br />
-      __fetch_and_add<br />
-      __fetch_and_sub<br />
-      __fetch_and_or<br />
-      __fetch_and_xor<br />
-      __fetch_and_and<br />
-      __fetch_and_nand<br />
-      __fetch_and_mpy<br />
-      __fetch_and_min<br />
-      __fetch_and_max<br />
-      __lock_test_and_set<br />
-      __lock_release<br />
-      __lock_acquire<br />
-      __compare_and_swap<br />
-      __synchronize<br />
-      __high_multiply<br />
-      __unix<br />
-      __sgi<br />
-      __linux__<br />
-      __i386__<br />
-      __i486__<br />
-      __cplusplus<br />
-      __embedded_cplusplus<br />
-      // long double conversion members mangled as __opr<br />
-      // http://gcc.gnu.org/ml/libstdc++/1999-q4/msg00060.html<br />
-      _opr<br />
-    </p></div></div><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="coding_style.example"></a>By Example</h3></div></div></div><div class="literallayout"><p><br />
-      This library is written to appropriate C++ coding standards. As such,<br />
-      it is intended to precede the recommendations of the GNU Coding<br />
-      Standard, which can be referenced in full here:<br />
-<br />
-      http://www.gnu.org/prep/standards/standards.html#Formatting<br />
-<br />
-      The rest of this is also interesting reading, but skip the "Design<br />
-      Advice" part.<br />
-<br />
-      The GCC coding conventions are here, and are also useful:<br />
-      http://gcc.gnu.org/codingconventions.html<br />
-<br />
-      In addition, because it doesn't seem to be stated explicitly anywhere<br />
-      else, there is an 80 column source limit.<br />
-<br />
-      ChangeLog entries for member functions should use the<br />
-      classname::member function name syntax as follows:<br />
-<br />
-      1999-04-15  Dennis Ritchie  &lt;dr@att.com&gt;<br />
-<br />
-      * src/basic_file.cc (__basic_file::open): Fix thinko in<br />
-      _G_HAVE_IO_FILE_OPEN bits.<br />
-<br />
-      Notable areas of divergence from what may be previous local practice<br />
-      (particularly for GNU C) include:<br />
-<br />
-      01. Pointers and references<br />
-      char* p = "flop";<br />
-      char&amp; c = *p;<br />
-      -NOT-<br />
-      char *p = "flop";  // wrong<br />
-      char &amp;c = *p;      // wrong<br />
-      <br />
-      Reason: In C++, definitions are mixed with executable code. Here,       <br />
-      p is being initialized, not *p. This is near-universal<br />
-      practice among C++ programmers; it is normal for C hackers<br />
-      to switch spontaneously as they gain experience.<br />
-<br />
-      02. Operator names and parentheses<br />
-      operator==(type)<br />
-      -NOT-<br />
-      operator == (type)  // wrong<br />
-      <br />
-      Reason: The == is part of the function name. Separating<br />
-      it makes the declaration look like an expression. <br />
-<br />
-      03. Function names and parentheses<br />
-      void mangle()<br />
-      -NOT-<br />
-      void mangle ()  // wrong<br />
-<br />
-      Reason: no space before parentheses (except after a control-flow<br />
-      keyword) is near-universal practice for C++. It identifies the<br />
-      parentheses as the function-call operator or declarator, as <br />
-      opposed to an expression or other overloaded use of parentheses.<br />
-<br />
-      04. Template function indentation<br />
-      template&lt;typename T&gt;<br />
-      void <br />
-      template_function(args)<br />
-      { }<br />
-      -NOT-<br />
-      template&lt;class T&gt;<br />
-      void template_function(args) {};<br />
-      <br />
-      Reason: In class definitions, without indentation whitespace is<br />
-      needed both above and below the declaration to distinguish<br />
-      it visually from other members. (Also, re: "typename"<br />
-      rather than "class".)  T often could be int, which is <br />
-      not a class. ("class", here, is an anachronism.)<br />
-<br />
-      05. Template class indentation<br />
-      template&lt;typename _CharT, typename _Traits&gt;<br />
-      class basic_ios : public ios_base<br />
-      {<br />
-      public:<br />
-      // Types:<br />
-      };<br />
-      -NOT-<br />
-      template&lt;class _CharT, class _Traits&gt;<br />
-      class basic_ios : public ios_base<br />
-      {<br />
-      public:<br />
-      // Types:<br />
-      };<br />
-      -NOT-<br />
-      template&lt;class _CharT, class _Traits&gt;<br />
-      class basic_ios : public ios_base<br />
-      {<br />
-      public:<br />
-      // Types:<br />
-      };<br />
-<br />
-      06. Enumerators<br />
-      enum<br />
-      {<br />
-      space = _ISspace,<br />
-      print = _ISprint,<br />
-      cntrl = _IScntrl<br />
-      };<br />
-      -NOT-<br />
-      enum { space = _ISspace, print = _ISprint, cntrl = _IScntrl };<br />
-<br />
-      07. Member initialization lists<br />
-      All one line, separate from class name.<br />
-<br />
-      gribble::gribble() <br />
-      : _M_private_data(0), _M_more_stuff(0), _M_helper(0);<br />
-      { }<br />
-      -NOT-<br />
-      gribble::gribble() : _M_private_data(0), _M_more_stuff(0), _M_helper(0);<br />
-      { }<br />
-<br />
-      08. Try/Catch blocks<br />
-      try <br />
-      {<br />
-      //<br />
-      }   <br />
-      catch (...)<br />
-      {<br />
-      //<br />
-      }   <br />
-      -NOT-<br />
-      try {<br />
-      // <br />
-      } catch(...) { <br />
-      //<br />
-      }<br />
-<br />
-      09. Member functions declarations and definitions<br />
-      Keywords such as extern, static, export, explicit, inline, etc<br />
-      go on the line above the function name. Thus<br />
-<br />
-      virtual int   <br />
-      foo()<br />
-      -NOT-<br />
-      virtual int foo()<br />
-<br />
-      Reason: GNU coding conventions dictate return types for functions<br />
-      are on a separate line than the function name and parameter list<br />
-      for definitions. For C++, where we have member functions that can<br />
-      be either inline definitions or declarations, keeping to this<br />
-      standard allows all member function names for a given class to be<br />
-      aligned to the same margin, increasing readability.<br />
-<br />
-<br />
-      10. Invocation of member functions with "this-&gt;"<br />
-      For non-uglified names, use this-&gt;name to call the function.<br />
-<br />
-      this-&gt;sync()<br />
-      -NOT-<br />
-      sync()<br />
-<br />
-      Reason: Koenig lookup.<br />
-<br />
-      11. Namespaces<br />
-      namespace std<br />
-      {<br />
-      blah blah blah;<br />
-      } // namespace std<br />
-<br />
-      -NOT-<br />
-<br />
-      namespace std {<br />
-      blah blah blah;<br />
-      } // namespace std<br />
-<br />
-      12. Spacing under protected and private in class declarations:<br />
-      space above, none below<br />
-      i.e.<br />
-<br />
-      public:<br />
-      int foo;<br />
-<br />
-      -NOT-<br />
-      public:<br />
-      <br />
-      int foo;<br />
-<br />
-      13. Spacing WRT return statements.<br />
-      no extra spacing before returns, no parenthesis<br />
-      i.e.<br />
-<br />
-      }<br />
-      return __ret;<br />
-<br />
-      -NOT-<br />
-      }<br />
-<br />
-      return __ret;<br />
-<br />
-      -NOT-<br />
-<br />
-      }<br />
-      return (__ret);<br />
-<br />
-<br />
-      14. Location of global variables.<br />
-      All global variables of class type, whether in the "user visible"<br />
-      space (e.g., cin) or the implementation namespace, must be defined<br />
-      as a character array with the appropriate alignment and then later<br />
-      re-initialized to the correct value.<br />
-<br />
-      This is due to startup issues on certain platforms, such as AIX.<br />
-      For more explanation and examples, see src/globals.cc. All such<br />
-      variables should be contained in that file, for simplicity.<br />
-<br />
-      15. Exception abstractions<br />
-      Use the exception abstractions found in functexcept.h, which allow<br />
-      C++ programmers to use this library with -fno-exceptions. (Even if<br />
-      that is rarely advisable, it's a necessary evil for backwards<br />
-      compatibility.)<br />
-<br />
-      16. Exception error messages<br />
-      All start with the name of the function where the exception is<br />
-      thrown, and then (optional) descriptive text is added. Example:<br />
-<br />
-      __throw_logic_error(__N("basic_string::_S_construct NULL not valid"));<br />
-<br />
-      Reason: The verbose terminate handler prints out exception::what(),<br />
-      as well as the typeinfo for the thrown exception. As this is the<br />
-      default terminate handler, by putting location info into the<br />
-      exception string, a very useful error message is printed out for<br />
-      uncaught exceptions. So useful, in fact, that non-programmers can<br />
-      give useful error messages, and programmers can intelligently<br />
-      speculate what went wrong without even using a debugger.<br />
-<br />
-      17. The doxygen style guide to comments is a separate document,<br />
-      see index.<br />
-<br />
-      The library currently has a mixture of GNU-C and modern C++ coding<br />
-      styles. The GNU C usages will be combed out gradually.<br />
-<br />
-      Name patterns:<br />
-<br />
-      For nonstandard names appearing in Standard headers, we are constrained <br />
-      to use names that begin with underscores. This is called "uglification".<br />
-      The convention is:<br />
-<br />
-      Local and argument names:  __[a-z].*<br />
-<br />
-      Examples:  __count  __ix  __s1  <br />
-<br />
-      Type names and template formal-argument names: _[A-Z][^_].*<br />
-<br />
-      Examples:  _Helper  _CharT  _N <br />
-<br />
-      Member data and function names: _M_.*<br />
-<br />
-      Examples:  _M_num_elements  _M_initialize ()<br />
-<br />
-      Static data members, constants, and enumerations: _S_.*<br />
-<br />
-      Examples: _S_max_elements  _S_default_value<br />
-<br />
-      Don't use names in the same scope that differ only in the prefix, <br />
-      e.g. _S_top and _M_top. See BADNAMES for a list of forbidden names.<br />
-      (The most tempting of these seem to be and "_T" and "__sz".)<br />
-<br />
-      Names must never have "__" internally; it would confuse name<br />
-      unmanglers on some targets. Also, never use "__[0-9]", same reason.<br />
-<br />
-      --------------------------<br />
-<br />
-      [BY EXAMPLE]<br />
-      <br />
-      #ifndef  _HEADER_<br />
-      #define  _HEADER_ 1<br />
-<br />
-      namespace std<br />
-      {<br />
-      class gribble<br />
-      {<br />
-      public:<br />
-      gribble() throw();<br />
-<br />
-      gribble(const gribble&amp;);<br />
-<br />
-      explicit <br />
-      gribble(int __howmany);<br />
-<br />
-      gribble&amp; <br />
-      operator=(const gribble&amp;);<br />
-<br />
-      virtual <br />
-      ~gribble() throw ();<br />
-<br />
-      // Start with a capital letter, end with a period.<br />
-      inline void  <br />
-      public_member(const char* __arg) const;<br />
-<br />
-      // In-class function definitions should be restricted to one-liners.<br />
-      int <br />
-      one_line() { return 0 }<br />
-<br />
-      int <br />
-      two_lines(const char* arg) <br />
-      { return strchr(arg, 'a'); }<br />
-<br />
-      inline int <br />
-      three_lines();  // inline, but defined below.<br />
-<br />
-      // Note indentation.<br />
-      template&lt;typename _Formal_argument&gt;<br />
-      void <br />
-      public_template() const throw();<br />
-<br />
-      template&lt;typename _Iterator&gt;<br />
-      void <br />
-      other_template();<br />
-<br />
-      private:<br />
-      class _Helper;<br />
-<br />
-      int _M_private_data;<br />
-      int _M_more_stuff;<br />
-      _Helper* _M_helper;<br />
-      int _M_private_function();<br />
-<br />
-      enum _Enum <br />
-      { <br />
-      _S_one, <br />
-      _S_two <br />
-      };<br />
-<br />
-      static void <br />
-      _S_initialize_library();<br />
-      };<br />
-<br />
-      // More-or-less-standard language features described by lack, not presence.<br />
-      # ifndef _G_NO_LONGLONG<br />
-      extern long long _G_global_with_a_good_long_name;  // avoid globals!<br />
-      # endif<br />
-<br />
-      // Avoid in-class inline definitions, define separately;<br />
-      // likewise for member class definitions:<br />
-      inline int<br />
-      gribble::public_member() const<br />
-      { int __local = 0; return __local; }<br />
-<br />
-      class gribble::_Helper<br />
-      {<br />
-      int _M_stuff;<br />
-<br />
-      friend class gribble;<br />
-      };<br />
-      }<br />
-<br />
-      // Names beginning with "__": only for arguments and<br />
-      //   local variables; never use "__" in a type name, or<br />
-      //   within any name; never use "__[0-9]".<br />
-<br />
-      #endif /* _HEADER_ */<br />
-<br />
-<br />
-      namespace std <br />
-      {<br />
-      template&lt;typename T&gt;  // notice: "typename", not "class", no space<br />
-      long_return_value_type&lt;with_many, args&gt;  <br />
-      function_name(char* pointer,               // "char *pointer" is wrong.<br />
-      char* argument, <br />
-      const Reference&amp; ref)<br />
-      {<br />
-      // int a_local;  /* wrong; see below. */<br />
-      if (test) <br />
-      { <br />
-      nested code <br />
-      }<br />
-      <br />
-      int a_local = 0;  // declare variable at first use.<br />
-<br />
-      //  char a, b, *p;   /* wrong */<br />
-      char a = 'a';<br />
-      char b = a + 1;<br />
-      char* c = "abc";  // each variable goes on its own line, always.<br />
-<br />
-      // except maybe here...<br />
-      for (unsigned i = 0, mask = 1; mask; ++i, mask &lt;&lt;= 1) {<br />
-      // ...<br />
-      }<br />
-      }<br />
-      <br />
-      gribble::gribble()<br />
-      : _M_private_data(0), _M_more_stuff(0), _M_helper(0);<br />
-      { }<br />
-<br />
-      inline int <br />
-      gribble::three_lines()<br />
-      {<br />
-      // doesn't fit in one line.<br />
-      }<br />
-      } // namespace std<br />
-    </p></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apas02.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01apas04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Directory Layout and Source Conventions </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> Documentation Style</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apas04.html b/libstdc++-v3/doc/html/manual/bk01apas04.html
deleted file mode 100644 (file)
index 09a6f97..0000000
+++ /dev/null
@@ -1,227 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Documentation Style</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><meta name="keywords" content="&#10;      ISO C++&#10;    , &#10;      library&#10;    " /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="appendix_contributing.html" title="Appendix A. Contributing" /><link rel="prev" href="bk01apas03.html" title="Coding Style" /><link rel="next" href="bk01apas05.html" title="Design Notes" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Documentation Style</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apas03.html">Prev</a> </td><th width="60%" align="center">Appendix A. Contributing</th><td width="20%" align="right"> <a accesskey="n" href="bk01apas05.html">Next</a></td></tr></table><hr /></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="contrib.doc_style"></a>Documentation Style</h2></div></div></div><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="doc_style.doxygen"></a>Doxygen</h3></div></div></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.prereq"></a>Prerequisites</h4></div></div></div><p>
-       Prerequisite tools are Bash 2.x,
-       <a class="ulink" href="http://www.doxygen.org/" target="_top">Doxygen</a>, and
-       the <a class="ulink" href="http://www.gnu.org/software/coreutils/" target="_top">GNU
-       coreutils</a>. (GNU versions of find, xargs, and possibly
-       sed and grep are used, just because the GNU versions make
-       things very easy.)
-      </p><p>
-       To generate the pretty pictures and hierarchy
-       graphs, the
-       <a class="ulink" href="http://www.research.att.com/sw/tools/graphviz/download.html" target="_top">Graphviz</a>
-       package will need to be installed. 
-      </p></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.rules"></a>Generating the Doxygen Files</h4></div></div></div><p>
-       The following Makefile rules run Doxygen to generate HTML
-       docs, XML docs, and the man pages.
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-html-doxygen</code></strong></pre><p>
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-xml-doxygen</code></strong></pre><p>
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-man-doxygen</code></strong></pre><p>
-      </p><p>
-       Careful observers will see that the Makefile rules simply call
-       a script from the source tree, <code class="filename">run_doxygen</code>, which
-       does the actual work of running Doxygen and then (most
-       importantly) massaging the output files. If for some reason
-       you prefer to not go through the Makefile, you can call this
-       script directly. (Start by passing <code class="literal">--help</code>.)
-      </p><p>
-       If you wish to tweak the Doxygen settings, do so by editing
-       <code class="filename">doc/doxygen/user.cfg.in</code>. Notes to fellow
-       library hackers are written in triple-# comments.
-      </p></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.markup"></a>Markup</h4></div></div></div><p>
-       In general, libstdc++ files should be formatted according to
-       the rules found in the
-       <a class="link" href="bk01apas03.html" title="Coding Style">Coding Standard</a>. Before
-       any doxygen-specific formatting tweaks are made, please try to
-       make sure that the initial formatting is sound.
-      </p><p>
-       Adding Doxygen markup to a file (informally called
-       “<span class="quote">doxygenating</span>”) is very simple. The Doxygen manual can be
-       found
-       <a class="ulink" href="http://www.stack.nl/~dimitri/doxygen/download.html#latestman" target="_top">here</a>.
-       We try to use a very-recent version of Doxygen.
-      </p><p>
-       For classes, use
-       <code class="classname">deque</code>/<code class="classname">vector</code>/<code class="classname">list</code>
-       and <code class="classname">std::pair</code> as examples.  For
-       functions, see their member functions, and the free functions
-       in <code class="filename">stl_algobase.h</code>. Member functions of
-       other container-like types should read similarly to these
-       member functions.
-      </p><p>
-       These points accompany the first list in section 3.1 of the
-       Doxygen manual:
-      </p><div class="orderedlist"><ol type="1"><li><p>Use the Javadoc style...</p></li><li><p>
-           ...not the Qt style. The intermediate *'s are preferred.
-         </p></li><li><p>
-           Use the triple-slash style only for one-line comments (the
-           “<span class="quote">brief</span>” mode).  Very recent versions of Doxygen permit
-           full-mode comments in triple-slash blocks, but the
-           formatting still comes out wonky.
-         </p></li><li><p>
-           This is disgusting. Don't do this.
-         </p></li></ol></div><p>
-       Use the @-style of commands, not the !-style. Please be
-       careful about whitespace in your markup comments. Most of the
-       time it doesn't matter; doxygen absorbs most whitespace, and
-       both HTML and *roff are agnostic about whitespace. However,
-       in &lt;pre&gt; blocks and @code/@endcode sections, spacing can
-       have “<span class="quote">interesting</span>” effects.
-      </p><p>
-       Use either kind of grouping, as
-       appropriate. <code class="filename">doxygroups.cc</code> exists for this
-       purpose. See <code class="filename">stl_iterator.h</code> for a good example
-       of the “<span class="quote">other</span>” kind of grouping.
-      </p><p>
-       Please use markup tags like @p and @a when referring to things
-       such as the names of function parameters. Use @e for emphasis
-       when necessary. Use @c to refer to other standard names.
-       (Examples of all these abound in the present code.)
-      </p></div></div><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="doc_style.docbook"></a>Docbook</h3></div></div></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.prereq"></a>Prerequisites</h4></div></div></div><p>
-       Editing the DocBook sources requires an XML editor. Many
-       exist: some notable options
-       include <span class="command"><strong>emacs</strong></span>, <span class="application">Kate</span>,
-       or <span class="application">Conglomerate</span>.
-      </p><p>
-       Some editors support special “<span class="quote">XML Validation</span>”
-       modes that can validate the file as it is
-       produced. Recommended is the <span class="command"><strong>nXML Mode</strong></span>
-       for <span class="command"><strong>emacs</strong></span>.
-      </p><p>
-       Besides an editor, additional DocBook files and XML tools are
-       also required.
-      </p><p>
-       Access to the DocBook stylesheets and DTD is required. The
-       stylesheets are usually packaged by vendor, in something
-       like <code class="filename">docbook-style-xsl</code>. To exactly match
-       generated output, please use a version of the stylesheets
-       equivalent
-       to <code class="filename">docbook-style-xsl-1.74.0-5</code>. The
-       installation directory for this package corresponds to
-       the <code class="literal">XSL_STYLE_DIR</code>
-       in <code class="filename">doc/Makefile.am</code> and defaults
-       to <code class="filename">/usr/share/sgml/docbook/xsl-stylesheets</code>.
-      </p><p>
-       For processing XML, an XML processor and some style
-       sheets are necessary. Defaults are <span class="command"><strong>xsltproc</strong></span>
-       provided by <code class="filename">libxslt</code>.
-      </p><p>
-       For validating the XML document, you'll need
-       something like <span class="command"><strong>xmllint</strong></span> and access to the
-       DocBook DTD. These are provided
-       by a vendor package like <code class="filename">lixml2</code>.
-      </p><p>
-       For PDF output, something that transforms valid XML to PDF is
-       required. Possible solutions include <span class="command"><strong>xmlto</strong></span>,
-       <a class="ulink" href="http://xmlgraphics.apache.org/fop/" target="_top">Apache
-       FOP</a>, or <span class="command"><strong>prince</strong></span>. Other options are
-       listed on the DocBook web <a class="ulink" href="http://wiki.docbook.org/topic/DocBookPublishingTools" target="_top">pages</a>. Please
-       consult the <code class="email">&lt;<a class="email" href="mailto:libstdc++@gcc.gnu.org">libstdc++@gcc.gnu.org</a>&gt;</code> list when
-       preparing printed manuals for current best practice and suggestions.
-      </p><p>
-       Make sure that the XML documentation and markup is valid for
-       any change. This can be done easily, with the validation rules
-       in the <code class="filename">Makefile</code>, which is equivalent to doing: 
-      </p><pre class="screen">
-         <strong class="userinput"><code>
-xmllint --noout --valid <code class="filename">xml/index.xml</code>
-         </code></strong>
-       </pre></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.rules"></a>Generating the DocBook Files</h4></div></div></div><p>
-       The following Makefile rules generate (in order): an HTML
-       version of all the documentation, a PDF version of the same, a
-       single XML document, and the result of validating the entire XML
-       document.
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-html</code></strong></pre><p>
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-pdf</code></strong></pre><p>
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-xml-single</code></strong></pre><p>
-      </p><p>
-      </p><pre class="screen"><strong class="userinput"><code>make doc-xml-validate</code></strong></pre><p>
-      </p></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.examples"></a>File Organization and Basics</h4></div></div></div><div class="literallayout"><p><br />
-      <span class="emphasis"><em>Which files are important</em></span><br />
-<br />
-      All Docbook files are in the directory<br />
-      libstdc++-v3/doc/xml<br />
-<br />
-      Inside this directory, the files of importance:<br />
-      spine.xml        - index to documentation set<br />
-      manual/spine.xml  - index to manual<br />
-      manual/*.xml     - individual chapters and sections of the manual<br />
-      faq.xml                  - index to FAQ<br />
-      api.xml                  - index to source level / API <br />
-<br />
-      All *.txml files are template xml files, i.e., otherwise empty files with<br />
-      the correct structure, suitable for filling in with new information.<br />
-<br />
-      <span class="emphasis"><em>Canonical Writing Style</em></span><br />
-<br />
-      class template<br />
-      function template<br />
-      member function template<br />
-      (via C++ Templates, Vandevoorde)<br />
-<br />
-      class in namespace std: allocator, not std::allocator<br />
-<br />
-      header file: iostream, not &lt;iostream&gt;<br />
-<br />
-<br />
-      <span class="emphasis"><em>General structure</em></span><br />
-<br />
-      &lt;set&gt;<br />
-      &lt;book&gt;<br />
-      &lt;/book&gt;<br />
-<br />
-      &lt;book&gt;<br />
-      &lt;chapter&gt;<br />
-      &lt;/chapter&gt;<br />
-      &lt;/book&gt;<br />
-<br />
-      &lt;book&gt;       <br />
-      &lt;part&gt;<br />
-      &lt;chapter&gt;<br />
-      &lt;section&gt;<br />
-      &lt;/section&gt;<br />
-<br />
-      &lt;sect1&gt;<br />
-      &lt;/sect1&gt;<br />
-<br />
-      &lt;sect1&gt;<br />
-      &lt;sect2&gt;<br />
-      &lt;/sect2&gt;<br />
-      &lt;/sect1&gt;<br />
-      &lt;/chapter&gt;<br />
-<br />
-      &lt;chapter&gt;<br />
-      &lt;/chapter&gt;<br />
-      &lt;/part&gt;  <br />
-      &lt;/book&gt;<br />
-<br />
-      &lt;/set&gt;<br />
-    </p></div></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.markup"></a>Markup By Example</h4></div></div></div><p>
-Complete details on Docbook markup can be found in the DocBook Element
-Reference, <a class="ulink" href="http://www.docbook.org/tdg/en/html/part2.html" target="_top">online</a>. An
-incomplete reference for HTML to Docbook conversion is detailed in the
-table below.
-</p><div class="table"><a id="id552441"></a><p class="title"><b>Table A.1. HTML to Docbook XML markup comparison</b></p><div class="table-contents"><table summary="HTML to Docbook XML markup comparison" border="1"><colgroup><col align="left" /><col align="left" /></colgroup><thead><tr><th align="left">HTML</th><th align="left">XML</th></tr></thead><tbody><tr><td align="left">&lt;p&gt;</td><td align="left">&lt;para&gt;</td></tr><tr><td align="left">&lt;pre&gt;</td><td align="left">&lt;computeroutput&gt;, &lt;programlisting&gt;, 
-       &lt;literallayout&gt;</td></tr><tr><td align="left">&lt;ul&gt;</td><td align="left">&lt;itemizedlist&gt;</td></tr><tr><td align="left">&lt;ol&gt;</td><td align="left">&lt;orderedlist&gt;</td></tr><tr><td align="left">&lt;il&gt;</td><td align="left">&lt;listitem&gt;</td></tr><tr><td align="left">&lt;dl&gt;</td><td align="left">&lt;variablelist&gt;</td></tr><tr><td align="left">&lt;dt&gt;</td><td align="left">&lt;term&gt;</td></tr><tr><td align="left">&lt;dd&gt;</td><td align="left">&lt;listitem&gt;</td></tr><tr><td align="left">&lt;a href=""&gt;</td><td align="left">&lt;ulink url=""&gt;</td></tr><tr><td align="left">&lt;code&gt;</td><td align="left">&lt;literal&gt;, &lt;programlisting&gt;</td></tr><tr><td align="left">&lt;strong&gt;</td><td align="left">&lt;emphasis&gt;</td></tr><tr><td align="left">&lt;em&gt;</td><td align="left">&lt;emphasis&gt;</td></tr><tr><td align="left">"</td><td align="left">&lt;quote&gt;</td></tr></tbody></table></div></div><br class="table-break" /><p>
-  And examples of detailed markup for which there are no real HTML
-  equivalents are listed in the table below.
-</p><div class="table"><a id="id554436"></a><p class="title"><b>Table A.2. Docbook XML Element Use</b></p><div class="table-contents"><table summary="Docbook XML Element Use" border="1"><colgroup><col align="left" /><col align="left" /></colgroup><thead><tr><th align="left">Element</th><th align="left">Use</th></tr></thead><tbody><tr><td align="left">&lt;structname&gt;</td><td align="left">&lt;structname&gt;char_traits&lt;/structname&gt;</td></tr><tr><td align="left">&lt;classname&gt;</td><td align="left">&lt;classname&gt;string&lt;/classname&gt;</td></tr><tr><td align="left">&lt;function&gt;</td><td align="left">
-       <p>&lt;function&gt;clear()&lt;/function&gt;</p>
-       <p>&lt;function&gt;fs.clear()&lt;/function&gt;</p>
-      </td></tr><tr><td align="left">&lt;type&gt;</td><td align="left">&lt;type&gt;long long&lt;/type&gt;</td></tr><tr><td align="left">&lt;varname&gt;</td><td align="left">&lt;varname&gt;fs&lt;/varname&gt;</td></tr><tr><td align="left">&lt;literal&gt;</td><td align="left">
-       <p>&lt;literal&gt;-Weffc++&lt;/literal&gt;</p>
-       <p>&lt;literal&gt;rel_ops&lt;/literal&gt;</p>
-      </td></tr><tr><td align="left">&lt;constant&gt;</td><td align="left">
-       <p>&lt;constant&gt;_GNU_SOURCE&lt;/constant&gt;</p>
-       <p>&lt;constant&gt;3.0&lt;/constant&gt;</p>
-      </td></tr><tr><td align="left">&lt;command&gt;</td><td align="left">&lt;command&gt;g++&lt;/command&gt;</td></tr><tr><td align="left">&lt;errortext&gt;</td><td align="left">&lt;errortext&gt;In instantiation of&lt;/errortext&gt;</td></tr><tr><td align="left">&lt;filename&gt;</td><td align="left">
-       <p>&lt;filename class="headerfile"&gt;ctype.h&lt;/filename&gt;</p>
-       <p>&lt;filename class="directory"&gt;/home/gcc/build&lt;/filename&gt;</p>
-      </td></tr></tbody></table></div></div><br class="table-break" /></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apas03.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01apas05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Coding Style </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> Design Notes</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apas05.html b/libstdc++-v3/doc/html/manual/bk01apas05.html
deleted file mode 100644 (file)
index 635b39c..0000000
+++ /dev/null
@@ -1,857 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Design Notes</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><meta name="keywords" content="&#10;      ISO C++&#10;    , &#10;      library&#10;    " /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="appendix_contributing.html" title="Appendix A. Contributing" /><link rel="prev" href="bk01apas04.html" title="Documentation Style" /><link rel="next" href="appendix_porting.html" title="Appendix B. Porting and Maintenance" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Design Notes</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apas04.html">Prev</a> </td><th width="60%" align="center">Appendix A. Contributing</th><td width="20%" align="right"> <a accesskey="n" href="appendix_porting.html">Next</a></td></tr></table><hr /></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="contrib.design_notes"></a>Design Notes</h2></div></div></div><p>
-  </p><div class="literallayout"><p><br />
-<br />
-    The Library<br />
-    -----------<br />
-<br />
-    This paper is covers two major areas:<br />
-<br />
-    - Features and policies not mentioned in the standard that<br />
-    the quality of the library implementation depends on, including<br />
-    extensions and "implementation-defined" features;<br />
-<br />
-    - Plans for required but unimplemented library features and<br />
-    optimizations to them.<br />
-<br />
-    Overhead<br />
-    --------<br />
-<br />
-    The standard defines a large library, much larger than the standard<br />
-    C library. A naive implementation would suffer substantial overhead<br />
-    in compile time, executable size, and speed, rendering it unusable<br />
-    in many (particularly embedded) applications. The alternative demands<br />
-    care in construction, and some compiler support, but there is no<br />
-    need for library subsets.<br />
-<br />
-    What are the sources of this overhead?  There are four main causes:<br />
-<br />
-    - The library is specified almost entirely as templates, which<br />
-    with current compilers must be included in-line, resulting in<br />
-    very slow builds as tens or hundreds of thousands of lines<br />
-    of function definitions are read for each user source file.<br />
-    Indeed, the entire SGI STL, as well as the dos Reis valarray,<br />
-    are provided purely as header files, largely for simplicity in<br />
-    porting. Iostream/locale is (or will be) as large again.<br />
-<br />
-    - The library is very flexible, specifying a multitude of hooks<br />
-    where users can insert their own code in place of defaults.<br />
-    When these hooks are not used, any time and code expended to<br />
-    support that flexibility is wasted.<br />
-<br />
-    - Templates are often described as causing to "code bloat". In<br />
-    practice, this refers (when it refers to anything real) to several<br />
-    independent processes. First, when a class template is manually<br />
-    instantiated in its entirely, current compilers place the definitions<br />
-    for all members in a single object file, so that a program linking<br />
-    to one member gets definitions of all. Second, template functions<br />
-    which do not actually depend on the template argument are, under<br />
-    current compilers, generated anew for each instantiation, rather<br />
-    than being shared with other instantiations. Third, some of the<br />
-    flexibility mentioned above comes from virtual functions (both in<br />
-    regular classes and template classes) which current linkers add<br />
-    to the executable file even when they manifestly cannot be called.<br />
-<br />
-    - The library is specified to use a language feature, exceptions,<br />
-    which in the current gcc compiler ABI imposes a run time and<br />
-    code space cost to handle the possibility of exceptions even when<br />
-    they are not used. Under the new ABI (accessed with -fnew-abi),<br />
-    there is a space overhead and a small reduction in code efficiency<br />
-    resulting from lost optimization opportunities associated with<br />
-    non-local branches associated with exceptions.<br />
-<br />
-    What can be done to eliminate this overhead?  A variety of coding<br />
-    techniques, and compiler, linker and library improvements and<br />
-    extensions may be used, as covered below. Most are not difficult,<br />
-    and some are already implemented in varying degrees.<br />
-<br />
-    Overhead: Compilation Time<br />
-    --------------------------<br />
-<br />
-    Providing "ready-instantiated" template code in object code archives<br />
-    allows us to avoid generating and optimizing template instantiations<br />
-    in each compilation unit which uses them. However, the number of such<br />
-    instantiations that are useful to provide is limited, and anyway this<br />
-    is not enough, by itself, to minimize compilation time. In particular,<br />
-    it does not reduce time spent parsing conforming headers.<br />
-<br />
-    Quicker header parsing will depend on library extensions and compiler<br />
-    improvements.  One approach is some variation on the techniques<br />
-    previously marketed as "pre-compiled headers", now standardized as<br />
-    support for the "export" keyword. "Exported" template definitions<br />
-    can be placed (once) in a "repository" -- really just a library, but<br />
-    of template definitions rather than object code -- to be drawn upon<br />
-    at link time when an instantiation is needed, rather than placed in<br />
-    header files to be parsed along with every compilation unit.<br />
-<br />
-    Until "export" is implemented we can put some of the lengthy template<br />
-    definitions in #if guards or alternative headers so that users can skip<br />
-    over the full definitions when they need only the ready-instantiated<br />
-    specializations.<br />
-<br />
-    To be precise, this means that certain headers which define<br />
-    templates which users normally use only for certain arguments<br />
-    can be instrumented to avoid exposing the template definitions<br />
-    to the compiler unless a macro is defined. For example, in<br />
-    &lt;string&gt;, we might have:<br />
-<br />
-    template &lt;class _CharT, ... &gt; class basic_string {<br />
-    ... // member declarations<br />
-    };<br />
-    ... // operator declarations<br />
-<br />
-    #ifdef _STRICT_ISO_<br />
-    # if _G_NO_TEMPLATE_EXPORT<br />
-    #   include &lt;bits/std_locale.h&gt;  // headers needed by definitions<br />
-    #   ...<br />
-    #   include &lt;bits/string.tcc&gt;  // member and global template definitions.<br />
-    # endif<br />
-    #endif<br />
-<br />
-    Users who compile without specifying a strict-ISO-conforming flag<br />
-    would not see many of the template definitions they now see, and rely<br />
-    instead on ready-instantiated specializations in the library. This<br />
-    technique would be useful for the following substantial components:<br />
-    string, locale/iostreams, valarray. It would *not* be useful or<br />
-    usable with the following: containers, algorithms, iterators,<br />
-    allocator. Since these constitute a large (though decreasing)<br />
-    fraction of the library, the benefit the technique offers is<br />
-    limited.<br />
-<br />
-    The language specifies the semantics of the "export" keyword, but<br />
-    the gcc compiler does not yet support it. When it does, problems<br />
-    with large template inclusions can largely disappear, given some<br />
-    minor library reorganization, along with the need for the apparatus<br />
-    described above.<br />
-<br />
-    Overhead: Flexibility Cost<br />
-    --------------------------<br />
-<br />
-    The library offers many places where users can specify operations<br />
-    to be performed by the library in place of defaults. Sometimes<br />
-    this seems to require that the library use a more-roundabout, and<br />
-    possibly slower, way to accomplish the default requirements than<br />
-    would be used otherwise.<br />
-<br />
-    The primary protection against this overhead is thorough compiler<br />
-    optimization, to crush out layers of inline function interfaces.<br />
-    Kuck &amp; Associates has demonstrated the practicality of this kind<br />
-    of optimization.<br />
-<br />
-    The second line of defense against this overhead is explicit<br />
-    specialization. By defining helper function templates, and writing<br />
-    specialized code for the default case, overhead can be eliminated<br />
-    for that case without sacrificing flexibility. This takes full<br />
-    advantage of any ability of the optimizer to crush out degenerate<br />
-    code.<br />
-<br />
-    The library specifies many virtual functions which current linkers<br />
-    load even when they cannot be called. Some minor improvements to the<br />
-    compiler and to ld would eliminate any such overhead by simply<br />
-    omitting virtual functions that the complete program does not call.<br />
-    A prototype of this work has already been done. For targets where<br />
-    GNU ld is not used, a "pre-linker" could do the same job.<br />
-<br />
-    The main areas in the standard interface where user flexibility<br />
-    can result in overhead are:<br />
-<br />
-    - Allocators:  Containers are specified to use user-definable<br />
-    allocator types and objects, making tuning for the container<br />
-    characteristics tricky.<br />
-<br />
-    - Locales: the standard specifies locale objects used to implement<br />
-    iostream operations, involving many virtual functions which use<br />
-    streambuf iterators.<br />
-<br />
-    - Algorithms and containers: these may be instantiated on any type,<br />
-    frequently duplicating code for identical operations.<br />
-<br />
-    - Iostreams and strings: users are permitted to use these on their<br />
-    own types, and specify the operations the stream must use on these<br />
-    types.<br />
-<br />
-    Note that these sources of overhead are _avoidable_. The techniques<br />
-    to avoid them are covered below.<br />
-<br />
-    Code Bloat<br />
-    ----------<br />
-<br />
-    In the SGI STL, and in some other headers, many of the templates<br />
-    are defined "inline" -- either explicitly or by their placement<br />
-    in class definitions -- which should not be inline. This is a<br />
-    source of code bloat. Matt had remarked that he was relying on<br />
-    the compiler to recognize what was too big to benefit from inlining,<br />
-    and generate it out-of-line automatically. However, this also can<br />
-    result in code bloat except where the linker can eliminate the extra<br />
-    copies.<br />
-<br />
-    Fixing these cases will require an audit of all inline functions<br />
-    defined in the library to determine which merit inlining, and moving<br />
-    the rest out of line. This is an issue mainly in chapters 23, 25, and<br />
-    27. Of course it can be done incrementally, and we should generally<br />
-    accept patches that move large functions out of line and into ".tcc"<br />
-    files, which can later be pulled into a repository. Compiler/linker<br />
-    improvements to recognize very large inline functions and move them<br />
-    out-of-line, but shared among compilation units, could make this<br />
-    work unnecessary.<br />
-<br />
-    Pre-instantiating template specializations currently produces large<br />
-    amounts of dead code which bloats statically linked programs. The<br />
-    current state of the static library, libstdc++.a, is intolerable on<br />
-    this account, and will fuel further confused speculation about a need<br />
-    for a library "subset". A compiler improvement that treats each<br />
-    instantiated function as a separate object file, for linking purposes,<br />
-    would be one solution to this problem. An alternative would be to<br />
-    split up the manual instantiation files into dozens upon dozens of<br />
-    little files, each compiled separately, but an abortive attempt at<br />
-    this was done for &lt;string&gt; and, though it is far from complete, it<br />
-    is already a nuisance. A better interim solution (just until we have<br />
-    "export") is badly needed.<br />
-<br />
-    When building a shared library, the current compiler/linker cannot<br />
-    automatically generate the instantiations needed. This creates a<br />
-    miserable situation; it means any time something is changed in the<br />
-    library, before a shared library can be built someone must manually<br />
-    copy the declarations of all templates that are needed by other parts<br />
-    of the library to an "instantiation" file, and add it to the build<br />
-    system to be compiled and linked to the library. This process is<br />
-    readily automated, and should be automated as soon as possible.<br />
-    Users building their own shared libraries experience identical<br />
-    frustrations.<br />
-<br />
-    Sharing common aspects of template definitions among instantiations<br />
-    can radically reduce code bloat. The compiler could help a great<br />
-    deal here by recognizing when a function depends on nothing about<br />
-    a template parameter, or only on its size, and giving the resulting<br />
-    function a link-name "equate" that allows it to be shared with other<br />
-    instantiations. Implementation code could take advantage of the<br />
-    capability by factoring out code that does not depend on the template<br />
-    argument into separate functions to be merged by the compiler.<br />
-<br />
-    Until such a compiler optimization is implemented, much can be done<br />
-    manually (if tediously) in this direction. One such optimization is<br />
-    to derive class templates from non-template classes, and move as much<br />
-    implementation as possible into the base class. Another is to partial-<br />
-    specialize certain common instantiations, such as vector&lt;T*&gt;, to share<br />
-    code for instantiations on all types T. While these techniques work,<br />
-    they are far from the complete solution that a compiler improvement<br />
-    would afford.<br />
-<br />
-    Overhead: Expensive Language Features<br />
-    -------------------------------------<br />
-<br />
-    The main "expensive" language feature used in the standard library<br />
-    is exception support, which requires compiling in cleanup code with<br />
-    static table data to locate it, and linking in library code to use<br />
-    the table. For small embedded programs the amount of such library<br />
-    code and table data is assumed by some to be excessive. Under the<br />
-    "new" ABI this perception is generally exaggerated, although in some<br />
-    cases it may actually be excessive.<br />
-<br />
-    To implement a library which does not use exceptions directly is<br />
-    not difficult given minor compiler support (to "turn off" exceptions<br />
-    and ignore exception constructs), and results in no great library<br />
-    maintenance difficulties. To be precise, given "-fno-exceptions",<br />
-    the compiler should treat "try" blocks as ordinary blocks, and<br />
-    "catch" blocks as dead code to ignore or eliminate. Compiler<br />
-    support is not strictly necessary, except in the case of "function<br />
-    try blocks"; otherwise the following macros almost suffice:<br />
-<br />
-    #define throw(X)<br />
-    #define try      if (true)<br />
-    #define catch(X) else if (false)<br />
-<br />
-    However, there may be a need to use function try blocks in the<br />
-    library implementation, and use of macros in this way can make<br />
-    correct diagnostics impossible. Furthermore, use of this scheme<br />
-    would require the library to call a function to re-throw exceptions<br />
-    from a try block. Implementing the above semantics in the compiler<br />
-    is preferable.<br />
-<br />
-    Given the support above (however implemented) it only remains to<br />
-    replace code that "throws" with a call to a well-documented "handler"<br />
-    function in a separate compilation unit which may be replaced by<br />
-    the user. The main source of exceptions that would be difficult<br />
-    for users to avoid is memory allocation failures, but users can<br />
-    define their own memory allocation primitives that never throw.<br />
-    Otherwise, the complete list of such handlers, and which library<br />
-    functions may call them, would be needed for users to be able to<br />
-    implement the necessary substitutes. (Fortunately, they have the<br />
-    source code.)<br />
-<br />
-    Opportunities<br />
-    -------------<br />
-<br />
-    The template capabilities of C++ offer enormous opportunities for<br />
-    optimizing common library operations, well beyond what would be<br />
-    considered "eliminating overhead". In particular, many operations<br />
-    done in Glibc with macros that depend on proprietary language<br />
-    extensions can be implemented in pristine Standard C++. For example,<br />
-    the chapter 25 algorithms, and even C library functions such as strchr,<br />
-    can be specialized for the case of static arrays of known (small) size.<br />
-<br />
-    Detailed optimization opportunities are identified below where<br />
-    the component where they would appear is discussed. Of course new<br />
-    opportunities will be identified during implementation.<br />
-<br />
-    Unimplemented Required Library Features<br />
-    ---------------------------------------<br />
-<br />
-    The standard specifies hundreds of components, grouped broadly by<br />
-    chapter. These are listed in excruciating detail in the CHECKLIST<br />
-    file.<br />
-<br />
-    17 general<br />
-    18 support<br />
-    19 diagnostics<br />
-    20 utilities<br />
-    21 string<br />
-    22 locale<br />
-    23 containers<br />
-    24 iterators<br />
-    25 algorithms<br />
-    26 numerics<br />
-    27 iostreams<br />
-    Annex D  backward compatibility<br />
-<br />
-    Anyone participating in implementation of the library should obtain<br />
-    a copy of the standard, ISO 14882.  People in the U.S. can obtain an<br />
-    electronic copy for US$18 from ANSI's web site. Those from other<br />
-    countries should visit http://www.iso.ch/ to find out the location<br />
-    of their country's representation in ISO, in order to know who can<br />
-    sell them a copy.<br />
-<br />
-    The emphasis in the following sections is on unimplemented features<br />
-    and optimization opportunities.<br />
-<br />
-    Chapter 17  General<br />
-    -------------------<br />
-<br />
-    Chapter 17 concerns overall library requirements.<br />
-<br />
-    The standard doesn't mention threads. A multi-thread (MT) extension<br />
-    primarily affects operators new and delete (18), allocator (20),<br />
-    string (21), locale (22), and iostreams (27). The common underlying<br />
-    support needed for this is discussed under chapter 20.<br />
-<br />
-    The standard requirements on names from the C headers create a<br />
-    lot of work, mostly done. Names in the C headers must be visible<br />
-    in the std:: and sometimes the global namespace; the names in the<br />
-    two scopes must refer to the same object. More stringent is that<br />
-    Koenig lookup implies that any types specified as defined in std::<br />
-    really are defined in std::. Names optionally implemented as<br />
-    macros in C cannot be macros in C++. (An overview may be read at<br />
-    &lt;http://www.cantrip.org/cheaders.html&gt;). The scripts "inclosure"<br />
-    and "mkcshadow", and the directories shadow/ and cshadow/, are the<br />
-    beginning of an effort to conform in this area.<br />
-<br />
-    A correct conforming definition of C header names based on underlying<br />
-    C library headers, and practical linking of conforming namespaced<br />
-    customer code with third-party C libraries depends ultimately on<br />
-    an ABI change, allowing namespaced C type names to be mangled into<br />
-    type names as if they were global, somewhat as C function names in a<br />
-    namespace, or C++ global variable names, are left unmangled. Perhaps<br />
-    another "extern" mode, such as 'extern "C-global"' would be an<br />
-    appropriate place for such type definitions. Such a type would<br />
-    affect mangling as follows:<br />
-<br />
-    namespace A {<br />
-    struct X {};<br />
-    extern "C-global" {  // or maybe just 'extern "C"'<br />
-    struct Y {};<br />
-    };<br />
-    }<br />
-    void f(A::X*);  // mangles to f__FPQ21A1X<br />
-    void f(A::Y*);  // mangles to f__FP1Y<br />
-<br />
-    (It may be that this is really the appropriate semantics for regular<br />
-    'extern "C"', and 'extern "C-global"', as an extension, would not be<br />
-    necessary.) This would allow functions declared in non-standard C headers<br />
-    (and thus fixable by neither us nor users) to link properly with functions<br />
-    declared using C types defined in properly-namespaced headers. The<br />
-    problem this solves is that C headers (which C++ programmers do persist<br />
-    in using) frequently forward-declare C struct tags without including<br />
-    the header where the type is defined, as in<br />
-<br />
-    struct tm;<br />
-    void munge(tm*);<br />
-<br />
-    Without some compiler accommodation, munge cannot be called by correct<br />
-    C++ code using a pointer to a correctly-scoped tm* value.<br />
-<br />
-    The current C headers use the preprocessor extension "#include_next",<br />
-    which the compiler complains about when run "-pedantic".<br />
-    (Incidentally, it appears that "-fpedantic" is currently ignored,<br />
-    probably a bug.)  The solution in the C compiler is to use<br />
-    "-isystem" rather than "-I", but unfortunately in g++ this seems<br />
-    also to wrap the whole header in an 'extern "C"' block, so it's<br />
-    unusable for C++ headers. The correct solution appears to be to<br />
-    allow the various special include-directory options, if not given<br />
-    an argument, to affect subsequent include-directory options additively,<br />
-    so that if one said<br />
-<br />
-    -pedantic -iprefix $(prefix) \<br />
-    -idirafter -ino-pedantic -ino-extern-c -iwithprefix -I g++-v3 \<br />
-    -iwithprefix -I g++-v3/ext<br />
-<br />
-    the compiler would search $(prefix)/g++-v3 and not report<br />
-    pedantic warnings for files found there, but treat files in<br />
-    $(prefix)/g++-v3/ext pedantically. (The undocumented semantics<br />
-    of "-isystem" in g++ stink. Can they be rescinded?  If not it<br />
-    must be replaced with something more rationally behaved.)<br />
-<br />
-    All the C headers need the treatment above; in the standard these<br />
-    headers are mentioned in various chapters. Below, I have only<br />
-    mentioned those that present interesting implementation issues.<br />
-<br />
-    The components identified as "mostly complete", below, have not been<br />
-    audited for conformance. In many cases where the library passes<br />
-    conformance tests we have non-conforming extensions that must be<br />
-    wrapped in #if guards for "pedantic" use, and in some cases renamed<br />
-    in a conforming way for continued use in the implementation regardless<br />
-    of conformance flags.<br />
-<br />
-    The STL portion of the library still depends on a header<br />
-    stl/bits/stl_config.h full of #ifdef clauses. This apparatus<br />
-    should be replaced with autoconf/automake machinery.<br />
-<br />
-    The SGI STL defines a type_traits&lt;&gt; template, specialized for<br />
-    many types in their code including the built-in numeric and<br />
-    pointer types and some library types, to direct optimizations of<br />
-    standard functions. The SGI compiler has been extended to generate<br />
-    specializations of this template automatically for user types,<br />
-    so that use of STL templates on user types can take advantage of<br />
-    these optimizations. Specializations for other, non-STL, types<br />
-    would make more optimizations possible, but extending the gcc<br />
-    compiler in the same way would be much better. Probably the next<br />
-    round of standardization will ratify this, but probably with<br />
-    changes, so it probably should be renamed to place it in the<br />
-    implementation namespace.<br />
-<br />
-    The SGI STL also defines a large number of extensions visible in<br />
-    standard headers. (Other extensions that appear in separate headers<br />
-    have been sequestered in subdirectories ext/ and backward/.)  All<br />
-    these extensions should be moved to other headers where possible,<br />
-    and in any case wrapped in a namespace (not std!), and (where kept<br />
-    in a standard header) girded about with macro guards. Some cannot be<br />
-    moved out of standard headers because they are used to implement<br />
-    standard features.  The canonical method for accommodating these<br />
-    is to use a protected name, aliased in macro guards to a user-space<br />
-    name. Unfortunately C++ offers no satisfactory template typedef<br />
-    mechanism, so very ad-hoc and unsatisfactory aliasing must be used<br />
-    instead.<br />
-<br />
-    Implementation of a template typedef mechanism should have the highest<br />
-    priority among possible extensions, on the same level as implementation<br />
-    of the template "export" feature.<br />
-<br />
-    Chapter 18  Language support<br />
-    ----------------------------<br />
-<br />
-    Headers: &lt;limits&gt; &lt;new&gt; &lt;typeinfo&gt; &lt;exception&gt;<br />
-    C headers: &lt;cstddef&gt; &lt;climits&gt; &lt;cfloat&gt;  &lt;cstdarg&gt; &lt;csetjmp&gt;<br />
-    &lt;ctime&gt;   &lt;csignal&gt; &lt;cstdlib&gt; (also 21, 25, 26)<br />
-<br />
-    This defines the built-in exceptions, rtti, numeric_limits&lt;&gt;,<br />
-    operator new and delete. Much of this is provided by the<br />
-    compiler in its static runtime library.<br />
-<br />
-    Work to do includes defining numeric_limits&lt;&gt; specializations in<br />
-    separate files for all target architectures. Values for integer types<br />
-    except for bool and wchar_t are readily obtained from the C header<br />
-    &lt;limits.h&gt;, but values for the remaining numeric types (bool, wchar_t,<br />
-    float, double, long double) must be entered manually. This is<br />
-    largely dog work except for those members whose values are not<br />
-    easily deduced from available documentation. Also, this involves<br />
-    some work in target configuration to identify the correct choice of<br />
-    file to build against and to install.<br />
-<br />
-    The definitions of the various operators new and delete must be<br />
-    made thread-safe, which depends on a portable exclusion mechanism,<br />
-    discussed under chapter 20.  Of course there is always plenty of<br />
-    room for improvements to the speed of operators new and delete.<br />
-<br />
-    &lt;cstdarg&gt;, in Glibc, defines some macros that gcc does not allow to<br />
-    be wrapped into an inline function. Probably this header will demand<br />
-    attention whenever a new target is chosen. The functions atexit(),<br />
-    exit(), and abort() in cstdlib have different semantics in C++, so<br />
-    must be re-implemented for C++.<br />
-<br />
-    Chapter 19  Diagnostics<br />
-    -----------------------<br />
-<br />
-    Headers: &lt;stdexcept&gt;<br />
-    C headers: &lt;cassert&gt; &lt;cerrno&gt;<br />
-<br />
-    This defines the standard exception objects, which are "mostly complete".<br />
-    Cygnus has a version, and now SGI provides a slightly different one.<br />
-    It makes little difference which we use.<br />
-<br />
-    The C global name "errno", which C allows to be a variable or a macro,<br />
-    is required in C++ to be a macro. For MT it must typically result in<br />
-    a function call.<br />
-<br />
-    Chapter 20  Utilities<br />
-    ---------------------<br />
-    Headers: &lt;utility&gt; &lt;functional&gt; &lt;memory&gt;<br />
-    C header: &lt;ctime&gt; (also in 18)<br />
-<br />
-    SGI STL provides "mostly complete" versions of all the components<br />
-    defined in this chapter. However, the auto_ptr&lt;&gt; implementation<br />
-    is known to be wrong. Furthermore, the standard definition of it<br />
-    is known to be unimplementable as written. A minor change to the<br />
-    standard would fix it, and auto_ptr&lt;&gt; should be adjusted to match.<br />
-<br />
-    Multi-threading affects the allocator implementation, and there must<br />
-    be configuration/installation choices for different users' MT<br />
-    requirements. Anyway, users will want to tune allocator options<br />
-    to support different target conditions, MT or no.<br />
-<br />
-    The primitives used for MT implementation should be exposed, as an<br />
-    extension, for users' own work. We need cross-CPU "mutex" support,<br />
-    multi-processor shared-memory atomic integer operations, and single-<br />
-    processor uninterruptible integer operations, and all three configurable<br />
-    to be stubbed out for non-MT use, or to use an appropriately-loaded<br />
-    dynamic library for the actual runtime environment, or statically<br />
-    compiled in for cases where the target architecture is known.<br />
-<br />
-    Chapter 21  String<br />
-    ------------------<br />
-    Headers: &lt;string&gt;<br />
-    C headers: &lt;cctype&gt; &lt;cwctype&gt; &lt;cstring&gt; &lt;cwchar&gt; (also in 27)<br />
-    &lt;cstdlib&gt; (also in 18, 25, 26)<br />
-<br />
-    We have "mostly-complete" char_traits&lt;&gt; implementations. Many of the<br />
-    char_traits&lt;char&gt; operations might be optimized further using existing<br />
-    proprietary language extensions.<br />
-<br />
-    We have a "mostly-complete" basic_string&lt;&gt; implementation. The work<br />
-    to manually instantiate char and wchar_t specializations in object<br />
-    files to improve link-time behavior is extremely unsatisfactory,<br />
-    literally tripling library-build time with no commensurate improvement<br />
-    in static program link sizes. It must be redone. (Similar work is<br />
-    needed for some components in chapters 22 and 27.)<br />
-<br />
-    Other work needed for strings is MT-safety, as discussed under the<br />
-    chapter 20 heading.<br />
-<br />
-    The standard C type mbstate_t from &lt;cwchar&gt; and used in char_traits&lt;&gt;<br />
-    must be different in C++ than in C, because in C++ the default constructor<br />
-    value mbstate_t() must be the "base" or "ground" sequence state.<br />
-    (According to the likely resolution of a recently raised Core issue,<br />
-    this may become unnecessary. However, there are other reasons to<br />
-    use a state type not as limited as whatever the C library provides.)<br />
-    If we might want to provide conversions from (e.g.) internally-<br />
-    represented EUC-wide to externally-represented Unicode, or vice-<br />
-    versa, the mbstate_t we choose will need to be more accommodating<br />
-    than what might be provided by an underlying C library.<br />
-<br />
-    There remain some basic_string template-member functions which do<br />
-    not overload properly with their non-template brethren. The infamous<br />
-    hack akin to what was done in vector&lt;&gt; is needed, to conform to<br />
-    23.1.1 para 10. The CHECKLIST items for basic_string marked 'X',<br />
-    or incomplete, are so marked for this reason.<br />
-<br />
-    Replacing the string iterators, which currently are simple character<br />
-    pointers, with class objects would greatly increase the safety of the<br />
-    client interface, and also permit a "debug" mode in which range,<br />
-    ownership, and validity are rigorously checked. The current use of<br />
-    raw pointers as string iterators is evil. vector&lt;&gt; iterators need the<br />
-    same treatment. Note that the current implementation freely mixes<br />
-    pointers and iterators, and that must be fixed before safer iterators<br />
-    can be introduced.<br />
-<br />
-    Some of the functions in &lt;cstring&gt; are different from the C version.<br />
-    generally overloaded on const and non-const argument pointers. For<br />
-    example, in &lt;cstring&gt; strchr is overloaded. The functions isupper<br />
-    etc. in &lt;cctype&gt; typically implemented as macros in C are functions<br />
-    in C++, because they are overloaded with others of the same name<br />
-    defined in &lt;locale&gt;.<br />
-<br />
-    Many of the functions required in &lt;cwctype&gt; and &lt;cwchar&gt; cannot be<br />
-    implemented using underlying C facilities on intended targets because<br />
-    such facilities only partly exist.<br />
-<br />
-    Chapter 22  Locale<br />
-    ------------------<br />
-    Headers: &lt;locale&gt;<br />
-    C headers: &lt;clocale&gt;<br />
-<br />
-    We have a "mostly complete" class locale, with the exception of<br />
-    code for constructing, and handling the names of, named locales.<br />
-    The ways that locales are named (particularly when categories<br />
-    (e.g. LC_TIME, LC_COLLATE) are different) varies among all target<br />
-    environments. This code must be written in various versions and<br />
-    chosen by configuration parameters.<br />
-<br />
-    Members of many of the facets defined in &lt;locale&gt; are stubs. Generally,<br />
-    there are two sets of facets: the base class facets (which are supposed<br />
-    to implement the "C" locale) and the "byname" facets, which are supposed<br />
-    to read files to determine their behavior. The base ctype&lt;&gt;, collate&lt;&gt;,<br />
-    and numpunct&lt;&gt; facets are "mostly complete", except that the table of<br />
-    bitmask values used for "is" operations, and corresponding mask values,<br />
-    are still defined in libio and just included/linked. (We will need to<br />
-    implement these tables independently, soon, but should take advantage<br />
-    of libio where possible.)  The num_put&lt;&gt;::put members for integer types<br />
-    are "mostly complete".<br />
-<br />
-    A complete list of what has and has not been implemented may be<br />
-    found in CHECKLIST. However, note that the current definition of<br />
-    codecvt&lt;wchar_t,char,mbstate_t&gt; is wrong. It should simply write<br />
-    out the raw bytes representing the wide characters, rather than<br />
-    trying to convert each to a corresponding single "char" value.<br />
-<br />
-    Some of the facets are more important than others. Specifically,<br />
-    the members of ctype&lt;&gt;, numpunct&lt;&gt;, num_put&lt;&gt;, and num_get&lt;&gt; facets<br />
-    are used by other library facilities defined in &lt;string&gt;, &lt;istream&gt;,<br />
-    and &lt;ostream&gt;, and the codecvt&lt;&gt; facet is used by basic_filebuf&lt;&gt;<br />
-    in &lt;fstream&gt;, so a conforming iostream implementation depends on<br />
-    these.<br />
-<br />
-    The "long long" type eventually must be supported, but code mentioning<br />
-    it should be wrapped in #if guards to allow pedantic-mode compiling.<br />
-<br />
-    Performance of num_put&lt;&gt; and num_get&lt;&gt; depend critically on<br />
-    caching computed values in ios_base objects, and on extensions<br />
-    to the interface with streambufs.<br />
-<br />
-    Specifically: retrieving a copy of the locale object, extracting<br />
-    the needed facets, and gathering data from them, for each call to<br />
-    (e.g.) operator&lt;&lt; would be prohibitively slow.  To cache format<br />
-    data for use by num_put&lt;&gt; and num_get&lt;&gt; we have a _Format_cache&lt;&gt;<br />
-    object stored in the ios_base::pword() array. This is constructed<br />
-    and initialized lazily, and is organized purely for utility. It<br />
-    is discarded when a new locale with different facets is imbued.<br />
-<br />
-    Using only the public interfaces of the iterator arguments to the<br />
-    facet functions would limit performance by forbidding "vector-style"<br />
-    character operations. The streambuf iterator optimizations are<br />
-    described under chapter 24, but facets can also bypass the streambuf<br />
-    iterators via explicit specializations and operate directly on the<br />
-    streambufs, and use extended interfaces to get direct access to the<br />
-    streambuf internal buffer arrays. These extensions are mentioned<br />
-    under chapter 27. These optimizations are particularly important<br />
-    for input parsing.<br />
-<br />
-    Unused virtual members of locale facets can be omitted, as mentioned<br />
-    above, by a smart linker.<br />
-<br />
-    Chapter 23  Containers<br />
-    ----------------------<br />
-    Headers: &lt;deque&gt; &lt;list&gt; &lt;queue&gt; &lt;stack&gt; &lt;vector&gt; &lt;map&gt; &lt;set&gt; &lt;bitset&gt;<br />
-<br />
-    All the components in chapter 23 are implemented in the SGI STL.<br />
-    They are "mostly complete"; they include a large number of<br />
-    nonconforming extensions which must be wrapped. Some of these<br />
-    are used internally and must be renamed or duplicated.<br />
-<br />
-    The SGI components are optimized for large-memory environments. For<br />
-    embedded targets, different criteria might be more appropriate. Users<br />
-    will want to be able to tune this behavior. We should provide<br />
-    ways for users to compile the library with different memory usage<br />
-    characteristics.<br />
-<br />
-    A lot more work is needed on factoring out common code from different<br />
-    specializations to reduce code size here and in chapter 25. The<br />
-    easiest fix for this would be a compiler/ABI improvement that allows<br />
-    the compiler to recognize when a specialization depends only on the<br />
-    size (or other gross quality) of a template argument, and allow the<br />
-    linker to share the code with similar specializations. In its<br />
-    absence, many of the algorithms and containers can be partial-<br />
-    specialized, at least for the case of pointers, but this only solves<br />
-    a small part of the problem. Use of a type_traits-style template<br />
-    allows a few more optimization opportunities, more if the compiler<br />
-    can generate the specializations automatically.<br />
-<br />
-    As an optimization, containers can specialize on the default allocator<br />
-    and bypass it, or take advantage of details of its implementation<br />
-    after it has been improved upon.<br />
-<br />
-    Replacing the vector iterators, which currently are simple element<br />
-    pointers, with class objects would greatly increase the safety of the<br />
-    client interface, and also permit a "debug" mode in which range,<br />
-    ownership, and validity are rigorously checked. The current use of<br />
-    pointers for iterators is evil.<br />
-<br />
-    As mentioned for chapter 24, the deque iterator is a good example of<br />
-    an opportunity to implement a "staged" iterator that would benefit<br />
-    from specializations of some algorithms.<br />
-<br />
-    Chapter 24  Iterators<br />
-    ---------------------<br />
-    Headers: &lt;iterator&gt;<br />
-<br />
-    Standard iterators are "mostly complete", with the exception of<br />
-    the stream iterators, which are not yet templatized on the<br />
-    stream type. Also, the base class template iterator&lt;&gt; appears<br />
-    to be wrong, so everything derived from it must also be wrong,<br />
-    currently.<br />
-<br />
-    The streambuf iterators (currently located in stl/bits/std_iterator.h,<br />
-    but should be under bits/) can be rewritten to take advantage of<br />
-    friendship with the streambuf implementation.<br />
-<br />
-    Matt Austern has identified opportunities where certain iterator<br />
-    types, particularly including streambuf iterators and deque<br />
-    iterators, have a "two-stage" quality, such that an intermediate<br />
-    limit can be checked much more quickly than the true limit on<br />
-    range operations. If identified with a member of iterator_traits,<br />
-    algorithms may be specialized for this case. Of course the<br />
-    iterators that have this quality can be identified by specializing<br />
-    a traits class.<br />
-<br />
-    Many of the algorithms must be specialized for the streambuf<br />
-    iterators, to take advantage of block-mode operations, in order<br />
-    to allow iostream/locale operations' performance not to suffer.<br />
-    It may be that they could be treated as staged iterators and<br />
-    take advantage of those optimizations.<br />
-<br />
-    Chapter 25  Algorithms<br />
-    ----------------------<br />
-    Headers: &lt;algorithm&gt;<br />
-    C headers: &lt;cstdlib&gt; (also in 18, 21, 26))<br />
-<br />
-    The algorithms are "mostly complete". As mentioned above, they<br />
-    are optimized for speed at the expense of code and data size.<br />
-<br />
-    Specializations of many of the algorithms for non-STL types would<br />
-    give performance improvements, but we must use great care not to<br />
-    interfere with fragile template overloading semantics for the<br />
-    standard interfaces. Conventionally the standard function template<br />
-    interface is an inline which delegates to a non-standard function<br />
-    which is then overloaded (this is already done in many places in<br />
-    the library). Particularly appealing opportunities for the sake of<br />
-    iostream performance are for copy and find applied to streambuf<br />
-    iterators or (as noted elsewhere) for staged iterators, of which<br />
-    the streambuf iterators are a good example.<br />
-<br />
-    The bsearch and qsort functions cannot be overloaded properly as<br />
-    required by the standard because gcc does not yet allow overloading<br />
-    on the extern-"C"-ness of a function pointer.<br />
-<br />
-    Chapter 26  Numerics<br />
-    --------------------<br />
-    Headers: &lt;complex&gt; &lt;valarray&gt; &lt;numeric&gt;<br />
-    C headers: &lt;cmath&gt;, &lt;cstdlib&gt; (also 18, 21, 25)<br />
-<br />
-    Numeric components: Gabriel dos Reis's valarray, Drepper's complex,<br />
-    and the few algorithms from the STL are "mostly done".  Of course<br />
-    optimization opportunities abound for the numerically literate. It<br />
-    is not clear whether the valarray implementation really conforms<br />
-    fully, in the assumptions it makes about aliasing (and lack thereof)<br />
-    in its arguments.<br />
-<br />
-    The C div() and ldiv() functions are interesting, because they are the<br />
-    only case where a C library function returns a class object by value.<br />
-    Since the C++ type div_t must be different from the underlying C type<br />
-    (which is in the wrong namespace) the underlying functions div() and<br />
-    ldiv() cannot be re-used efficiently. Fortunately they are trivial to<br />
-    re-implement.<br />
-<br />
-    Chapter 27  Iostreams<br />
-    ---------------------<br />
-    Headers: &lt;iosfwd&gt; &lt;streambuf&gt; &lt;ios&gt; &lt;ostream&gt; &lt;istream&gt; &lt;iostream&gt;<br />
-    &lt;iomanip&gt; &lt;sstream&gt; &lt;fstream&gt;<br />
-    C headers: &lt;cstdio&gt; &lt;cwchar&gt; (also in 21)<br />
-<br />
-    Iostream is currently in a very incomplete state. &lt;iosfwd&gt;, &lt;iomanip&gt;,<br />
-    ios_base, and basic_ios&lt;&gt; are "mostly complete". basic_streambuf&lt;&gt; and<br />
-    basic_ostream&lt;&gt; are well along, but basic_istream&lt;&gt; has had little work<br />
-    done. The standard stream objects, &lt;sstream&gt; and &lt;fstream&gt; have been<br />
-    started; basic_filebuf&lt;&gt; "write" functions have been implemented just<br />
-    enough to do "hello, world".<br />
-<br />
-    Most of the istream and ostream operators &lt;&lt; and &gt;&gt; (with the exception<br />
-    of the op&lt;&lt;(integer) ones) have not been changed to use locale primitives,<br />
-    sentry objects, or char_traits members.<br />
-<br />
-    All these templates should be manually instantiated for char and<br />
-    wchar_t in a way that links only used members into user programs.<br />
-<br />
-    Streambuf is fertile ground for optimization extensions. An extended<br />
-    interface giving iterator access to its internal buffer would be very<br />
-    useful for other library components.<br />
-<br />
-    Iostream operations (primarily operators &lt;&lt; and &gt;&gt;) can take advantage<br />
-    of the case where user code has not specified a locale, and bypass locale<br />
-    operations entirely. The current implementation of op&lt;&lt;/num_put&lt;&gt;::put,<br />
-    for the integer types, demonstrates how they can cache encoding details<br />
-    from the locale on each operation. There is lots more room for<br />
-    optimization in this area.<br />
-<br />
-    The definition of the relationship between the standard streams<br />
-    cout et al. and stdout et al. requires something like a "stdiobuf".<br />
-    The SGI solution of using double-indirection to actually use a<br />
-    stdio FILE object for buffering is unsatisfactory, because it<br />
-    interferes with peephole loop optimizations.<br />
-<br />
-    The &lt;sstream&gt; header work has begun. stringbuf can benefit from<br />
-    friendship with basic_string&lt;&gt; and basic_string&lt;&gt;::_Rep to use<br />
-    those objects directly as buffers, and avoid allocating and making<br />
-    copies.<br />
-<br />
-    The basic_filebuf&lt;&gt; template is a complex beast. It is specified to<br />
-    use the locale facet codecvt&lt;&gt; to translate characters between native<br />
-    files and the locale character encoding. In general this involves<br />
-    two buffers, one of "char" representing the file and another of<br />
-    "char_type", for the stream, with codecvt&lt;&gt; translating. The process<br />
-    is complicated by the variable-length nature of the translation, and<br />
-    the need to seek to corresponding places in the two representations.<br />
-    For the case of basic_filebuf&lt;char&gt;, when no translation is needed,<br />
-    a single buffer suffices. A specialized filebuf can be used to reduce<br />
-    code space overhead when no locale has been imbued. Matt Austern's<br />
-    work at SGI will be useful, perhaps directly as a source of code, or<br />
-    at least as an example to draw on.<br />
-<br />
-    Filebuf, almost uniquely (cf. operator new), depends heavily on<br />
-    underlying environmental facilities. In current releases iostream<br />
-    depends fairly heavily on libio constant definitions, but it should<br />
-    be made independent.  It also depends on operating system primitives<br />
-    for file operations. There is immense room for optimizations using<br />
-    (e.g.) mmap for reading. The shadow/ directory wraps, besides the<br />
-    standard C headers, the libio.h and unistd.h headers, for use mainly<br />
-    by filebuf. These wrappings have not been completed, though there<br />
-    is scaffolding in place.<br />
-<br />
-    The encapsulation of certain C header &lt;cstdio&gt; names presents an<br />
-    interesting problem. It is possible to define an inline std::fprintf()<br />
-    implemented in terms of the 'extern "C"' vfprintf(), but there is no<br />
-    standard vfscanf() to use to implement std::fscanf(). It appears that<br />
-    vfscanf but be re-implemented in C++ for targets where no vfscanf<br />
-    extension has been defined. This is interesting in that it seems<br />
-    to be the only significant case in the C library where this kind of<br />
-    rewriting is necessary. (Of course Glibc provides the vfscanf()<br />
-    extension.)  (The functions related to exit() must be rewritten<br />
-    for other reasons.)<br />
-<br />
-<br />
-    Annex D<br />
-    -------<br />
-    Headers: &lt;strstream&gt;<br />
-<br />
-    Annex D defines many non-library features, and many minor<br />
-    modifications to various headers, and a complete header.<br />
-    It is "mostly done", except that the libstdc++-2 &lt;strstream&gt;<br />
-    header has not been adopted into the library, or checked to<br />
-    verify that it matches the draft in those details that were<br />
-    clarified by the committee. Certainly it must at least be<br />
-    moved into the std namespace.<br />
-<br />
-    We still need to wrap all the deprecated features in #if guards<br />
-    so that pedantic compile modes can detect their use.<br />
-<br />
-    Nonstandard Extensions<br />
-    ----------------------<br />
-    Headers: &lt;iostream.h&gt; &lt;strstream.h&gt; &lt;hash&gt; &lt;rbtree&gt;<br />
-    &lt;pthread_alloc&gt; &lt;stdiobuf&gt; (etc.)<br />
-<br />
-    User code has come to depend on a variety of nonstandard components<br />
-    that we must not omit. Much of this code can be adopted from<br />
-    libstdc++-v2 or from the SGI STL. This particularly includes<br />
-    &lt;iostream.h&gt;, &lt;strstream.h&gt;, and various SGI extensions such<br />
-    as &lt;hash_map.h&gt;. Many of these are already placed in the<br />
-    subdirectories ext/ and backward/. (Note that it is better to<br />
-    include them via "&lt;backward/hash_map.h&gt;" or "&lt;ext/hash_map&gt;" than<br />
-    to search the subdirectory itself via a "-I" directive.<br />
-  </p></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apas04.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="appendix_porting.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Documentation Style </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> Appendix B. Porting and Maintenance</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apd.html b/libstdc++-v3/doc/html/manual/bk01apd.html
deleted file mode 100644 (file)
index 72f1d7e..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Appendix D. GNU General Public License</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="spine.html" title="The GNU C++ Library" /><link rel="prev" href="appendix_free.html" title="Appendix C. Free Software Needs Free Documentation" /><link rel="next" href="bk01apds02.html" title="TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Appendix D. GNU General Public License</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="appendix_free.html">Prev</a> </td><th width="60%" align="center">The GNU C++ Library</th><td width="20%" align="right"> <a accesskey="n" href="bk01apds02.html">Next</a></td></tr></table><hr /></div><div class="appendix" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="appendix.gpl-2.0"></a>Appendix D. GNU General Public License</h2></div><div><p class="releaseinfo">Version 2, June 1991</p></div><div><p class="copyright">Copyright © 1989, 1991 Free Software Foundation, Inc.</p></div><div><div class="legalnotice"><a id="gpl-legalnotice"></a><p>
-       </p><div class="address"><p>Free Software Foundation, Inc. <br />
-         <span class="street">51 Franklin Street, Fifth Floor</span>, <br />
-         <span class="city">Boston</span>, <span class="state">MA</span> <span class="postcode">02110-1301</span><br />
-         <span class="country">USA</span><br />
-       </p></div><p>
-      </p><p>Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.</p></div></div><div><p class="pubdate">Version 2, June 1991</p></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="bk01apd.html#gpl-1">Preamble</a></span></dt><dt><span class="section"><a href="bk01apds02.html">TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</a></span></dt><dd><dl><dt><span class="section"><a href="bk01apds02.html#gpl-2-0">Section 0</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-1">Section 1</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-2">Section 2</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-3">Section 3</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-4">Section 4</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-5">Section 5</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-6">Section 6</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-7">Section 7</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-8">Section 8</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-9">Section 9</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-10">Section 10</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-11">NO WARRANTY Section 11</a></span></dt><dt><span class="section"><a href="bk01apds02.html#gpl-2-12">Section 12</a></span></dt></dl></dd><dt><span class="section"><a href="bk01apds03.html">How to Apply These Terms to Your New Programs</a></span></dt></dl></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="gpl-1"></a>Preamble</h2></div></div></div><p>The licenses for most software are designed to take away your 
-      freedom to share and change it. By contrast, the GNU General Public License is 
-      intended to guarantee your freedom to share and change 
-      free software - to make sure the software is free for all its users. 
-      This General Public License applies to most of the Free Software 
-      Foundation's software and to any other program whose authors commit 
-      to using it. (Some other Free Software Foundation software is covered 
-      by the GNU Library General Public License instead.) You can apply it 
-      to your programs, too.</p><p>When we speak of free software, we are referring to freedom, not price. 
-      Our General Public Licenses are designed to make sure that you have the 
-      freedom to distribute copies of free software (and charge for this 
-      service if you wish), that you receive source code or can get it if you 
-      want it, that you can change the software or use pieces of it in new free 
-      programs; and that you know you can do these things.</p><p>To protect your rights, we need to make restrictions that forbid anyone 
-      to deny you these rights or to ask you to surrender the rights. These 
-      restrictions translate to certain responsibilities for you if you distribute 
-      copies of the software, or if you modify it.</p><p>For example, if you distribute copies of such a program, whether gratis or 
-      for a fee, you must give the recipients all the rights that you have. You 
-      must make sure that they, too, receive or can get the source code. And you 
-      must show them these terms so they know their rights.</p><p>We protect your rights with two steps:
-      </p><div class="orderedlist"><ol type="1"><li><p>copyright the software, and</p></li><li><p>offer you this license which gives you legal permission to copy, 
-           distribute and/or modify the software.</p></li></ol></div><p>
-    </p><p>Also, for each author's protection and ours, we want to make certain that 
-      everyone understands that there is no warranty for this free software. If 
-      the software is modified by someone else and passed on, we want its 
-      recipients to know that what they have is not the original, so that any 
-      problems introduced by others will not reflect on the original authors' 
-      reputations.</p><p>Finally, any free program is threatened constantly by software patents. 
-      We wish to avoid the danger that redistributors of a free program will 
-      individually obtain patent licenses, in effect making the program 
-      proprietary. To prevent this, we have made it clear that any patent must be 
-      licensed for everyone's free use or not licensed at all.</p><p>The precise terms and conditions for copying, distribution and modification 
-      follow.</p></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="appendix_free.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="spine.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01apds02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Appendix C. Free Software Needs Free Documentation </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apds02.html b/libstdc++-v3/doc/html/manual/bk01apds02.html
deleted file mode 100644 (file)
index 2a0af92..0000000
+++ /dev/null
@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="bk01apd.html" title="Appendix D. GNU General Public License" /><link rel="prev" href="bk01apd.html" title="Appendix D. GNU General Public License" /><link rel="next" href="bk01apds03.html" title="How to Apply These Terms to Your New Programs" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apd.html">Prev</a> </td><th width="60%" align="center">Appendix D. GNU General Public License</th><td width="20%" align="right"> <a accesskey="n" href="bk01apds03.html">Next</a></td></tr></table><hr /></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="gpl-2"></a>TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</h2></div></div></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-0"></a>Section 0</h3></div></div></div><p>This License applies to any program or other work which contains a notice 
-       placed by the copyright holder saying it may be distributed under the terms 
-       of this General Public License. The “<span class="quote">Program</span>”, below, refers to any such 
-       program or work, and a 
-       “<span class="quote">work based on the Program</span>” means either 
-       the Program or any derivative work under copyright law: that is to say, a 
-       work containing the Program or a portion of it, either verbatim or with 
-       modifications and/or translated into another language. (Hereinafter, translation 
-       is included without limitation in the term 
-       “<span class="quote">modification</span>”.) Each licensee is addressed as “<span class="quote">you</span>”.</p><p>Activities other than copying, distribution and modification are not covered by 
-       this License; they are outside its scope. The act of running the Program is not 
-       restricted, and the output from the Program is covered only if its contents 
-       constitute a work based on the Program (independent of having been made by running 
-       the Program). Whether that is true depends on what the Program does.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-1"></a>Section 1</h3></div></div></div><p>You may copy and distribute verbatim copies of the Program's source code as you 
-       receive it, in any medium, provided that you conspicuously and appropriately 
-       publish on each copy an appropriate copyright notice and disclaimer of warranty; 
-       keep intact all the notices that refer to this License and to the absence of any 
-       warranty; and give any other recipients of the Program a copy of this License 
-       along with the Program.</p><p>You may charge a fee for the physical act of transferring a copy, and you may at 
-       your option offer warranty protection in exchange for a fee.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-2"></a>Section 2</h3></div></div></div><p>You may modify your copy or copies of the Program or any portion of it, thus 
-       forming a work based on the Program, and copy and distribute such modifications 
-       or work under the terms of 
-       <a class="link" href="bk01apds02.html#gpl-2-1" title="Section 1">Section 1</a> above, provided 
-       that you also meet all of these conditions:
-       </p><div class="orderedlist"><ol type="a"><li><p>You must cause the modified files to carry prominent notices stating that 
-             you changed the files and the date of any change.</p></li><li><p>You must cause any work that you distribute or publish, that in whole or 
-             in part contains or is derived from the Program or any part thereof, to be 
-             licensed as a whole at no charge to all third parties under the terms of 
-             this License.</p></li><li><p>If the modified program normally reads commands interactively when run, you 
-             must cause it, when started running for such interactive use in the most 
-             ordinary way, to print or display an announcement including an appropriate 
-             copyright notice and a notice that there is no warranty (or else, saying 
-             that you provide a warranty) and that users may redistribute the program 
-             under these conditions, and telling the user how to view a copy of this 
-             License. (Exception: If the Program itself is interactive but does not 
-              normally print such an announcement, your work based on the Program is not 
-              required to print an   announcement.)</p></li></ol></div><p>
-      </p><p>These requirements apply to the modified work as a whole. If identifiable sections 
-       of that work are not derived from the Program, and can be reasonably considered 
-       independent and separate works in themselves, then this License, and its terms, 
-       do not apply to those sections when you distribute them as separate works. But when 
-       you distribute the same sections as part of a whole which is a work based on the 
-       Program, the distribution of the whole must be on the terms of this License, whose 
-       permissions for other licensees extend to the entire whole, and thus to each and 
-       every part regardless of who wrote it.</p><p>Thus, it is not the intent of this section to claim rights or contest your rights 
-       to work written entirely by you; rather, the intent is to exercise the right to control 
-       the distribution of derivative or collective works based on the Program.</p><p>In addition, mere aggregation of another work not based on the Program with the Program 
-       (or with a work based on the Program) on a volume of a storage or distribution medium 
-       does not bring the other work under the scope of this License.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-3"></a>Section 3</h3></div></div></div><p>You may copy and distribute the Program (or a work based on it, under 
-       <a class="link" href="bk01apds02.html#gpl-2-2" title="Section 2">Section 2</a> in object code or executable form under the terms of 
-       <a class="link" href="bk01apds02.html#gpl-2-1" title="Section 1">Sections 1</a> and 
-       <a class="link" href="bk01apds02.html#gpl-2-2" title="Section 2">2</a> above provided that you also do one of the following:
-       </p><div class="orderedlist"><ol type="a"><li><p>Accompany it with the complete corresponding machine-readable source code, which 
-             must be distributed under the terms of Sections 1 and 2 above on a medium 
-             customarily used for software interchange; or,</p></li><li><p>Accompany it with a written offer, valid for at least three years, to give any 
-             third party, for a charge no more than your cost of physically performing source 
-             distribution, a complete machine-readable copy of the corresponding source code, 
-             to be distributed under the terms of Sections 1 and 2 above on a medium customarily 
-             used for software interchange; or,</p></li><li><p>Accompany it with the information you received as to the offer to distribute 
-             corresponding source code. (This alternative is allowed only for noncommercial 
-             distribution and only if you received the program in object code or executable form 
-             with such an offer, in accord with Subsection b above.)</p></li></ol></div><p>
-      </p><p>The source code for a work means the preferred form of the work for making modifications 
-       to it. For an executable work, complete source code means all the source code for all modules 
-       it contains, plus any associated interface definition files, plus the scripts used to control 
-       compilation and installation of the executable. However, as a special exception, the source 
-       code distributed need not include anything that is normally distributed (in either source or 
-       binary form) with the major components (compiler, kernel, and so on) of the operating system 
-       on which the executable runs, unless that component itself accompanies the executable.</p><p>If distribution of executable or object code is made by offering access to copy from a 
-       designated place, then offering equivalent access to copy the source code from the same place 
-       counts as distribution of the source code, even though third parties are not compelled to 
-       copy the source along with the object code.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-4"></a>Section 4</h3></div></div></div><p>You may not copy, modify, sublicense, or distribute the Program except as expressly provided 
-       under this License. Any attempt otherwise to copy, modify, sublicense or distribute the 
-       Program is void, and will automatically terminate your rights under this License. However, 
-       parties who have received copies, or rights, from you under this License will not have their 
-       licenses terminated so long as such parties remain in full compliance.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-5"></a>Section 5</h3></div></div></div><p>You are not required to accept this License, since you have not signed it. However, nothing 
-       else grants you permission to modify or distribute the Program or its derivative works. 
-       These actions are prohibited by law if you do not accept this License. Therefore, by modifying 
-       or distributing the Program (or any work based on the Program), you indicate your acceptance 
-       of this License to do so, and all its terms and conditions for copying, distributing or 
-       modifying the Program or works based on it.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-6"></a>Section 6</h3></div></div></div><p>Each time you redistribute the Program (or any work based on the Program), the recipient 
-       automatically receives a license from the original licensor to copy, distribute or modify 
-       the Program subject to these terms and conditions. You may not impose any further restrictions 
-       on the recipients' exercise of the rights granted herein. You are not responsible for enforcing 
-       compliance by third parties to this License.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-7"></a>Section 7</h3></div></div></div><p>If, as a consequence of a court judgment or allegation of patent infringement or for any other 
-       reason (not limited to patent issues), conditions are imposed on you (whether by court order, 
-       agreement or otherwise) that contradict the conditions of this License, they do not excuse you 
-       from the conditions of this License. If you cannot distribute so as to satisfy simultaneously 
-       your obligations under this License and any other pertinent obligations, then as a consequence 
-       you may not distribute the Program at all. For example, if a patent license would not permit 
-       royalty-free redistribution of the Program by all those who receive copies directly or 
-       indirectly through you, then the only way you could satisfy both it and this License would be 
-       to refrain entirely from distribution of the Program.</p><p>If any portion of this section is held invalid or unenforceable under any particular circumstance, 
-       the balance of the section is intended to apply and the section as a whole is intended to apply 
-       in other circumstances.</p><p>It is not the purpose of this section to induce you to infringe any patents or other property 
-       right claims or to contest validity of any such claims; this section has the sole purpose of 
-       protecting the integrity of the free software distribution system, which is implemented by public 
-       license practices. Many people have made generous contributions to the wide range of software 
-       distributed through that system in reliance on consistent application of that system; it is up 
-       to the author/donor to decide if he or she is willing to distribute software through any other 
-       system and a licensee cannot impose that choice.</p><p>This section is intended to make thoroughly clear what is believed to be a consequence of the 
-       rest of this License.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-8"></a>Section 8</h3></div></div></div><p>If the distribution and/or use of the Program is restricted in certain countries either by patents 
-       or by copyrighted interfaces, the original copyright holder who places the Program under this License 
-       may add an explicit geographical distribution limitation excluding those countries, so that 
-       distribution is permitted only in or among countries not thus excluded. In such case, this License 
-       incorporates the limitation as if written in the body of this License.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-9"></a>Section 9</h3></div></div></div><p>The Free Software Foundation may publish revised and/or new versions of the General Public License 
-       from time to time. Such new versions will be similar in spirit to the present version, but may differ 
-       in detail to address new problems or concerns.</p><p>Each version is given a distinguishing version number. If the Program specifies a version number of 
-       this License which applies to it and “<span class="quote">any later version</span>”, you have the option of following the terms 
-       and conditions either of that version or of any later version published by the Free Software 
-       Foundation. If the Program does not specify a version number of this License, you may choose any 
-       version ever published by the Free Software Foundation.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-10"></a>Section 10</h3></div></div></div><p>If you wish to incorporate parts of the Program into other free programs whose distribution 
-       conditions are different, write to the author to ask for permission. For software which is copyrighted 
-       by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions 
-       for this. Our decision will be guided by the two goals of preserving the free status of all 
-       derivatives of our free software and of promoting the sharing and reuse of software generally.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-11"></a>NO WARRANTY Section 11</h3></div></div></div><p>BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT 
-       PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR 
-       OTHER PARTIES PROVIDE THE PROGRAM “<span class="quote">AS IS</span>” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, 
-       INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
-       PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE 
-       PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.</p></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="gpl-2-12"></a>Section 12</h3></div></div></div><p>IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR 
-       ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU 
-       FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 
-       USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED 
-       INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH 
-       ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 
-       DAMAGES.</p><p>END OF TERMS AND CONDITIONS</p></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apd.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="bk01apd.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01apds03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Appendix D. GNU General Public License </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> How to Apply These Terms to Your New Programs</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01apds03.html b/libstdc++-v3/doc/html/manual/bk01apds03.html
deleted file mode 100644 (file)
index d95dfd7..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>How to Apply These Terms to Your New Programs</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="bk01apd.html" title="Appendix D. GNU General Public License" /><link rel="prev" href="bk01apds02.html" title="TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION" /><link rel="next" href="bk01ape.html" title="Appendix E. GNU Free Documentation License" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">How to Apply These Terms to Your New Programs</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apds02.html">Prev</a> </td><th width="60%" align="center">Appendix D. GNU General Public License</th><td width="20%" align="right"> <a accesskey="n" href="bk01ape.html">Next</a></td></tr></table><hr /></div><div class="section" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="gpl-3"></a>How to Apply These Terms to Your New Programs</h2></div></div></div><p>If you develop a new program, and you want it to be of the greatest
-      possible use to the public, the best way to achieve this is to make it
-      free software which everyone can redistribute and change under these terms.</p><p>To do so, attach the following notices to the program.  It is safest
-      to attach them to the start of each source file to most effectively
-      convey the exclusion of warranty; and each file should have at least
-      the “<span class="quote">copyright</span>” line and a pointer to where the full notice is found.</p><p>&lt;one line to give the program's name and a brief idea of what it does.&gt;
-      Copyright (C) &lt;year&gt;    &lt;name of author&gt;</p><p>This program 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 of the License, or
-      (at your option) any later version.</p><p>This program 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.</p><p>You should have received a copy of the GNU General Public License
-      along with this program; if not, write to the Free Software
-      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA</p><p>Also add information on how to contact you by electronic and paper mail.</p><p>If the program is interactive, make it output a short notice like this
-      when it starts in an interactive mode:</p><p>Gnomovision version 69, Copyright (C) year name of author
-      Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type “<span class="quote">show w</span>”.
-      This is free software, and you are welcome to redistribute it
-      under certain conditions; type “<span class="quote">show c</span>” for details.</p><p>The hypothetical commands “<span class="quote">show w</span>” and “<span class="quote">show c</span>” should 
-      show the appropriate parts of the General Public License.  Of course, the commands you 
-      use may be called something other than “<span class="quote">show w</span>” and “<span class="quote">show c</span>”; 
-      they could even be mouse-clicks or menu items--whatever suits your program.</p><p>You should also get your employer (if you work as a programmer) or your
-      school, if any, to sign a “<span class="quote">copyright disclaimer</span>” for the program, if
-      necessary.  Here is a sample; alter the names:</p><p>Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-      “<span class="quote">Gnomovision</span>” (which makes passes at compilers) written by James Hacker.</p><p>&lt;signature of Ty Coon&gt;, 1 April 1989
-      Ty Coon, President of Vice</p><p>This General Public License does not permit incorporating your program into
-      proprietary programs.  If your program is a subroutine library, you may
-      consider it more useful to permit linking proprietary applications with the
-      library.  If this is what you want to do, use the GNU Library General
-      Public License instead of this License.</p></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apds02.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="bk01apd.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="bk01ape.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> Appendix E. GNU Free Documentation License</td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01ape.html b/libstdc++-v3/doc/html/manual/bk01ape.html
deleted file mode 100644 (file)
index 6b3403b..0000000
+++ /dev/null
@@ -1,393 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Appendix E. GNU Free Documentation License</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="spine.html" title="The GNU C++ Library" /><link rel="prev" href="bk01apds03.html" title="How to Apply These Terms to Your New Programs" /><link rel="next" href="../bk02.html" title="" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Appendix E. GNU Free Documentation License</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="bk01apds03.html">Prev</a> </td><th width="60%" align="center">The GNU C++ Library</th><td width="20%" align="right"> <a accesskey="n" href="../bk02.html">Next</a></td></tr></table><hr /></div><div class="appendix" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="appendix.gfdl-1.2"></a>Appendix E. GNU Free Documentation License</h2></div></div></div><p>
-    Copyright (C) 2000, 2001, 2002 Free Software Foundation,
-    <abbr class="abbrev">Inc.</abbr> 51 Franklin <abbr class="abbrev">St</abbr>, Fifth Floor,
-    Boston, <abbr class="abbrev">MA</abbr> 02110-1301 <abbr class="abbrev">USA</abbr>.  Everyone is permitted to copy and
-    distribute verbatim copies of this license document, but changing it is
-    not allowed.
-  </p><h2><a id="Preamble"></a>
-    0. PREAMBLE
-  </h2><p>
-    The purpose of this License is to make a manual, textbook, or other
-    functional and useful document "free" in the sense of freedom: to assure
-    everyone the effective freedom to copy and redistribute it, with or
-    without modifying it, either commercially or noncommercially.
-    Secondarily, this License preserves for the author and publisher a way to
-    get credit for their work, while not being considered responsible for
-    modifications made by others.
-  </p><p>
-    This License is a kind of "copyleft", which means that derivative works of
-    the document must themselves be free in the same sense.  It complements
-    the GNU General Public License, which is a copyleft license designed for
-    free software.
-  </p><p>
-    We have designed this License in order to use it for manuals for free
-    software, because free software needs free documentation: a free program
-    should come with manuals providing the same freedoms that the software
-    does.  But this License is not limited to software manuals; it can be used
-    for any textual work, regardless of subject matter or whether it is
-    published as a printed book.  We recommend this License principally for
-    works whose purpose is instruction or reference.</p><h2><a id="Definitions"></a>
-    1. APPLICABILITY AND DEFINITIONS
-  </h2><p>
-    This License applies to any manual or other work, in any medium, that
-    contains a notice placed by the copyright holder saying it can be
-    distributed under the terms of this License.  Such a notice grants a
-    world-wide, royalty-free license, unlimited in duration, to use that work
-    under the conditions stated herein.  The "Document", below, refers to any
-    such manual or work.  Any member of the public is a licensee, and is
-    addressed as "you".  You accept the license if you copy, modify or
-    distribute the work in a way requiring permission under copyright
-    law.
-  </p><p>
-    A "Modified Version" of the Document means any work containing the
-    Document or a portion of it, either copied verbatim, or with modifications
-    and/or translated into another language.
-  </p><p>
-    A "Secondary Section" is a named appendix or a front-matter section of the
-    Document that deals exclusively with the relationship of the publishers or
-    authors of the Document to the Document's overall subject (or to related
-    matters) and contains nothing that could fall directly within that overall
-    subject.  (Thus, if the Document is in part a textbook of mathematics, a
-    Secondary Section may not explain any mathematics.)  The relationship
-    could be a matter of historical connection with the subject or with
-    related matters, or of legal, commercial, philosophical, ethical or
-    political position regarding them.
-  </p><p>
-    The "Invariant Sections" are certain Secondary Sections whose titles are
-    designated, as being those of Invariant Sections, in the notice that says
-    that the Document is released under this License.  If a section does not
-    fit the above definition of Secondary then it is not allowed to be
-    designated as Invariant.  The Document may contain zero Invariant
-    Sections.  If the Document does not identify any Invariant Sections then
-    there are none.
-  </p><p>
-    The "Cover Texts" are certain short passages of text that are listed, as
-    Front-Cover Texts or Back-Cover Texts, in the notice that says that the
-    Document is released under this License.  A Front-Cover Text may be at
-    most 5 words, and a Back-Cover Text may be at most 25 words.
-  </p><p>
-    A "Transparent" copy of the Document means a machine-readable copy,
-    represented in a format whose specification is available to the general
-    public, that is suitable for revising the document straightforwardly with
-    generic text editors or (for images composed of pixels) generic paint
-    programs or (for drawings) some widely available drawing editor, and that
-    is suitable for input to text formatters or for automatic translation to a
-    variety of formats suitable for input to text formatters.  A copy made in
-    an otherwise Transparent file format whose markup, or absence of markup,
-    has been arranged to thwart or discourage subsequent modification by
-    readers is not Transparent.  An image format is not Transparent if used
-    for any substantial amount of text.  A copy that is not "Transparent" is
-    called "Opaque".
-  </p><p>
-    Examples of suitable formats for Transparent copies include plain ASCII
-    without markup, Texinfo input format, LaTeX input format, SGML or XML
-    using a publicly available DTD, and standard-conforming simple HTML,
-    PostScript or PDF designed for human modification.  Examples of
-    transparent image formats include PNG, XCF and JPG.  Opaque formats
-    include proprietary formats that can be read and edited only by
-    proprietary word processors, SGML or XML for which the DTD and/or
-    processing tools are not generally available, and the machine-generated
-    HTML, PostScript or PDF produced by some word processors for output
-    purposes only.
-  </p><p>
-    The "Title Page" means, for a printed book, the title page itself, plus
-    such following pages as are needed to hold, legibly, the material this
-    License requires to appear in the title page.  For works in formats which
-    do not have any title page as such, "Title Page" means the text near the
-    most prominent appearance of the work's title, preceding the beginning of
-    the body of the text.
-  </p><p>
-    A section "Entitled XYZ" means a named subunit of the Document whose title
-    either is precisely XYZ or contains XYZ in parentheses following text that
-    translates XYZ in another language.  (Here XYZ stands for a specific
-    section name mentioned below, such as "Acknowledgements", "Dedications",
-    "Endorsements", or "History".)  To "Preserve the Title" of such a section
-    when you modify the Document means that it remains a section "Entitled
-    XYZ" according to this definition.
-  </p><p>
-    The Document may include Warranty Disclaimers next to the notice which
-    states that this License applies to the Document.  These Warranty
-    Disclaimers are considered to be included by reference in this License,
-    but only as regards disclaiming warranties: any other implication that
-    these Warranty Disclaimers may have is void and has no effect on the
-    meaning of this License.
-  </p><h2><a id="VerbatimCopying"></a>
-    2. VERBATIM COPYING
-  </h2><p>
-    You may copy and distribute the Document in any medium, either
-    commercially or noncommercially, provided that this License, the copyright
-    notices, and the license notice saying this License applies to the
-    Document are reproduced in all copies, and that you add no other
-    conditions whatsoever to those of this License.  You may not use technical
-    measures to obstruct or control the reading or further copying of the
-    copies you make or distribute.  However, you may accept compensation in
-    exchange for copies.  If you distribute a large enough number of copies
-    you must also follow the conditions in section 3.
-  </p><p>
-    You may also lend copies, under the same conditions stated above, and you
-    may publicly display copies.
-  </p><h2><a id="QuantityCopying"></a>
-    3. COPYING IN QUANTITY
-  </h2><p>
-    If you publish printed copies (or copies in media that commonly have
-    printed covers) of the Document, numbering more than 100, and the
-    Document's license notice requires Cover Texts, you must enclose the
-    copies in covers that carry, clearly and legibly, all these Cover Texts:
-    Front-Cover Texts on the front cover, and Back-Cover Texts on the back
-    cover.  Both covers must also clearly and legibly identify you as the
-    publisher of these copies.  The front cover must present the full title
-    with all words of the title equally prominent and visible.  You may add
-    other material on the covers in addition.  Copying with changes limited to
-    the covers, as long as they preserve the title of the Document and satisfy
-    these conditions, can be treated as verbatim copying in other
-    respects.
-  </p><p>
-    If the required texts for either cover are too voluminous to fit legibly,
-    you should put the first ones listed (as many as fit reasonably) on the
-    actual cover, and continue the rest onto adjacent pages.
-  </p><p>
-    If you publish or distribute Opaque copies of the Document numbering more
-    than 100, you must either include a machine-readable Transparent copy
-    along with each Opaque copy, or state in or with each Opaque copy a
-    computer-network location from which the general network-using public has
-    access to download using public-standard network protocols a complete
-    Transparent copy of the Document, free of added material.  If you use the
-    latter option, you must take reasonably prudent steps, when you begin
-    distribution of Opaque copies in quantity, to ensure that this Transparent
-    copy will remain thus accessible at the stated location until at least one
-    year after the last time you distribute an Opaque copy (directly or
-    through your agents or retailers) of that edition to the public.
-  </p><p>
-    It is requested, but not required, that you contact the authors of the
-    Document well before redistributing any large number of copies, to give
-    them a chance to provide you with an updated version of the
-    Document.
-  </p><h2><a id="Modifications"></a>
-    4. MODIFICATIONS
-  </h2><p>
-    You may copy and distribute a Modified Version of the Document under the
-    conditions of sections 2 and 3 above, provided that you release the
-    Modified Version under precisely this License, with the Modified Version
-    filling the role of the Document, thus licensing distribution and
-    modification of the Modified Version to whoever possesses a copy of it.
-    In addition, you must do these things in the Modified Version:
-  </p><div class="orderedlist"><ol type="A"><li>
-        Use in the Title Page (and on the covers, if any) a title distinct
-        from that of the Document, and from those of previous versions (which
-        should, if there were any, be listed in the History section of the
-        Document).  You may use the same title as a previous version if the
-        original publisher of that version gives permission.
-        </li><li>
-        List on the Title Page, as authors, one or more persons or entities
-        responsible for authorship of the modifications in the Modified
-        Version, together with at least five of the principal authors of the
-        Document (all of its principal authors, if it has fewer than five),
-        unless they release you from this requirement.
-      </li><li>
-        State on the Title page the name of the publisher of the Modified
-        Version, as the publisher.
-      </li><li>
-        Preserve all the copyright notices of the Document.
-      </li><li>
-        Add an appropriate copyright notice for your modifications adjacent to
-        the other copyright notices.
-      </li><li>
-        Include, immediately after the copyright notices, a license notice
-        giving the public permission to use the Modified Version under the
-        terms of this License, in the form shown in the Addendum below.
-      </li><li>
-        Preserve in that license notice the full lists of Invariant Sections
-        and required Cover Texts given in the Document's license notice.
-      </li><li>
-        Include an unaltered copy of this License.
-      </li><li>
-        Preserve the section Entitled "History", Preserve its Title, and add
-        to it an item stating at least the title, year, new authors, and
-        publisher of the Modified Version as given on the Title Page.  If
-        there is no section Entitled "History" in the Document, create one
-        stating the title, year, authors, and publisher of the Document as
-        given on its Title Page, then add an item describing the Modified
-        Version as stated in the previous sentence.
-      </li><li>
-        Preserve the network location, if any, given in the Document for
-        public access to a Transparent copy of the Document, and likewise the
-        network locations given in the Document for previous versions it was
-        based on.  These may be placed in the "History" section.  You may omit
-        a network location for a work that was published at least four years
-        before the Document itself, or if the original publisher of the
-        version it refers to gives permission.
-      </li><li>
-        For any section Entitled "Acknowledgements" or "Dedications", Preserve
-        the Title of the section, and preserve in the section all the
-        substance and tone of each of the contributor acknowledgements and/or
-        dedications given therein.
-      </li><li>
-        Preserve all the Invariant Sections of the Document, unaltered in
-        their text and in their titles.  Section numbers or the equivalent are
-        not considered part of the section titles.
-      </li><li>
-        Delete any section Entitled "Endorsements".  Such a section may not be
-        included in the Modified Version.
-      </li><li>
-        Do not retitle any existing section to be Entitled "Endorsements" or
-        to conflict in title with any Invariant Section.
-      </li><li>
-        Preserve any Warranty Disclaimers.
-      </li></ol></div><p>
-    If the Modified Version includes new front-matter sections or appendices
-    that qualify as Secondary Sections and contain no material copied from the
-    Document, you may at your option designate some or all of these sections
-    as invariant.  To do this, add their titles to the list of Invariant
-    Sections in the Modified Version's license notice.  These titles must be
-    distinct from any other section titles.
-  </p><p>
-    You may add a section Entitled "Endorsements", provided it contains
-    nothing but endorsements of your Modified Version by various parties--for
-    example, statements of peer review or that the text has been approved by
-    an organization as the authoritative definition of a standard.
-  </p><p>
-    You may add a passage of up to five words as a Front-Cover Text, and a
-    passage of up to 25 words as a Back-Cover Text, to the end of the list of
-    Cover Texts in the Modified Version.  Only one passage of Front-Cover Text
-    and one of Back-Cover Text may be added by (or through arrangements made
-    by) any one entity.  If the Document already includes a cover text for the
-    same cover, previously added by you or by arrangement made by the same
-    entity you are acting on behalf of, you may not add another; but you may
-    replace the old one, on explicit permission from the previous publisher
-    that added the old one.
-  </p><p>
-    The author(s) and publisher(s) of the Document do not by this License give
-    permission to use their names for publicity for or to assert or imply
-    endorsement of any Modified Version.
-  </p><h2><a id="Combining"></a>
-    5. COMBINING DOCUMENTS
-  </h2><p>
-    You may combine the Document with other documents released under this
-    License, under the terms defined in section 4 above for modified versions,
-    provided that you include in the combination all of the Invariant Sections
-    of all of the original documents, unmodified, and list them all as
-    Invariant Sections of your combined work in its license notice, and that
-    you preserve all their Warranty Disclaimers.
-  </p><p>
-    The combined work need only contain one copy of this License, and multiple
-    identical Invariant Sections may be replaced with a single copy.  If there
-    are multiple Invariant Sections with the same name but different contents,
-    make the title of each such section unique by adding at the end of it, in
-    parentheses, the name of the original author or publisher of that section
-    if known, or else a unique number.  Make the same adjustment to the
-    section titles in the list of Invariant Sections in the license notice of
-    the combined work.
-  </p><p>
-    In the combination, you must combine any sections Entitled "History" in
-    the various original documents, forming one section Entitled "History";
-    likewise combine any sections Entitled "Acknowledgements", and any
-    sections Entitled "Dedications".  You must delete all sections Entitled
-    "Endorsements".
-  </p><h2><a id="Collections"></a>
-    6. COLLECTIONS OF DOCUMENTS
-  </h2><p>
-    You may make a collection consisting of the Document and other documents
-    released under this License, and replace the individual copies of this
-    License in the various documents with a single copy that is included in
-    the collection, provided that you follow the rules of this License for
-    verbatim copying of each of the documents in all other respects.
-  </p><p>
-    You may extract a single document from such a collection, and distribute
-    it individually under this License, provided you insert a copy of this
-    License into the extracted document, and follow this License in all other
-    respects regarding verbatim copying of that document.
-  </p><h2><a id="Aggregation"></a>
-    7. AGGREGATION WITH INDEPENDENT WORKS
-  </h2><p>
-    A compilation of the Document or its derivatives with other separate and
-    independent documents or works, in or on a volume of a storage or
-    distribution medium, is called an "aggregate" if the copyright resulting
-    from the compilation is not used to limit the legal rights of the
-    compilation's users beyond what the individual works permit.  When the
-    Document is included in an aggregate, this License does not apply to the
-    other works in the aggregate which are not themselves derivative works of
-    the Document.
-  </p><p>
-    If the Cover Text requirement of section 3 is applicable to these copies
-    of the Document, then if the Document is less than one half of the entire
-    aggregate, the Document's Cover Texts may be placed on covers that bracket
-    the Document within the aggregate, or the electronic equivalent of covers
-    if the Document is in electronic form.  Otherwise they must appear on
-    printed covers that bracket the whole aggregate.
-  </p><h2><a id="Translation"></a>
-    8. TRANSLATION
-  </h2><p>
-    Translation is considered a kind of modification, so you may distribute
-    translations of the Document under the terms of section 4.  Replacing
-    Invariant Sections with translations requires special permission from
-    their copyright holders, but you may include translations of some or all
-    Invariant Sections in addition to the original versions of these Invariant
-    Sections.  You may include a translation of this License, and all the
-    license notices in the Document, and any Warranty Disclaimers, provided
-    that you also include the original English version of this License and the
-    original versions of those notices and disclaimers.  In case of a
-    disagreement between the translation and the original version of this
-    License or a notice or disclaimer, the original version will prevail.
-  </p><p>
-    If a section in the Document is Entitled "Acknowledgements",
-    "Dedications", or "History", the requirement (section 4) to Preserve its
-    Title (section 1) will typically require changing the actual title.
-  </p><h2><a id="Termination"></a>
-    9. TERMINATION
-  </h2><p>
-    You may not copy, modify, sublicense, or distribute the Document except as
-    expressly provided for under this License.  Any other attempt to copy,
-    modify, sublicense or distribute the Document is void, and will
-    automatically terminate your rights under this License.  However, parties
-    who have received copies, or rights, from you under this License will not
-    have their licenses terminated so long as such parties remain in full
-    compliance.
-  </p><h2><a id="FutureRevisions"></a>
-    10. FUTURE REVISIONS OF THIS LICENSE
-  </h2><p>
-    The Free Software Foundation may publish new, revised versions of the GNU
-    Free Documentation License from time to time.  Such new versions will be
-    similar in spirit to the present version, but may differ in detail to
-    address new problems or concerns.  See <a class="ulink" href="http://www.gnu.org/copyleft/" target="_top">http://www.gnu.org/copyleft/</a>.
-  </p><p>
-    Each version of the License is given a distinguishing version number.  If
-    the Document specifies that a particular numbered version of this License
-    "or any later version" applies to it, you have the option of following the
-    terms and conditions either of that specified version or of any later
-    version that has been published (not as a draft) by the Free Software
-    Foundation.  If the Document does not specify a version number of this
-    License, you may choose any version ever published (not as a draft) by the
-    Free Software Foundation.
-  </p><h2><a id="HowToUse"></a>
-    ADDENDUM: How to use this License for your documents
-  </h2><p>
-    To use this License in a document you have written, include a copy of the
-    License in the document and put the following copyright and license
-    notices just after the title page:
-  </p><div class="blockquote"><blockquote class="blockquote"><p>
-      Copyright (C) YEAR YOUR NAME.
-    </p><p>
-      Permission is granted to copy, distribute and/or modify this document
-      under the terms of the GNU Free Documentation License, Version 1.2 or
-      any later version published by the Free Software Foundation; with no
-      Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A
-      copy of the license is included in the section entitled "GNU Free
-      Documentation License".
-    </p></blockquote></div><p>
-    If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
-    replace the "with...Texts." line with this:
-  </p><div class="blockquote"><blockquote class="blockquote"><p>
-      with the Invariant Sections being LIST THEIR TITLES, with the
-      Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
-    </p></blockquote></div><p>
-    If you have Invariant Sections without Cover Texts, or some other
-    combination of the three, merge those two alternatives to suit the
-    situation.
-  </p><p>
-    If your document contains nontrivial examples of program code, we
-    recommend releasing these examples in parallel under your choice of free
-    software license, such as the GNU General Public License, to permit their
-    use in free software.
-  </p></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="bk01apds03.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="spine.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="../bk02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">How to Apply These Terms to Your New Programs </td><td width="20%" align="center"><a accesskey="h" href="../spine.html">Home</a></td><td width="40%" align="right" valign="top"> </td></tr></table></div></body></html>
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch01.html b/libstdc++-v3/doc/html/manual/bk01pt01ch01.html
deleted file mode 100644 (file)
index 60abfa4..0000000
+++ /dev/null
@@ -1,6131 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Chapter 1. Status</title><meta name="generator" content="DocBook XSL Stylesheets V1.74.0" /><meta name="keywords" content="&#10;      ISO C++&#10;    , &#10;      library&#10;    " /><link rel="home" href="../spine.html" title="The GNU C++ Library Documentation" /><link rel="up" href="intro.html" title="Part I. Introduction" /><link rel="prev" href="intro.html" title="Part I. Introduction" /><link rel="next" href="bk01pt01ch01s02.html" title="License" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter 1. Status</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="intro.html">Prev</a> </td><th width="60%" align="center">Part I. Introduction</th><td width="20%" align="right"> <a accesskey="n" href="bk01pt01ch01s02.html">Next</a></td></tr></table><hr /></div><div class="chapter" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="manual.intro.status"></a>Chapter 1. Status</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="bk01pt01ch01.html#manual.intro.status.standard">Implementation Status</a></span></dt><dd><dl><dt><span class="sect2"><a href="bk01pt01ch01.html#manual.intro.status.standard.1998">C++ 1998</a></span></dt><dt><span class="sect2"><a href="bk01pt01ch01.html#manual.intro.status.standard.tr1">C++ TR1</a></span></dt><dt><span class="sect2"><a href="bk01pt01ch01.html#manual.intro.status.standard.200x">C++ 200x</a></span></dt></dl></dd><dt><span class="sect1"><a href="bk01pt01ch01s02.html">License</a></span></dt><dd><dl><dt><span class="sect2"><a href="bk01pt01ch01s02.html#manual.intro.status.license.gpl">The Code: GPL</a></span></dt><dt><span class="sect2"><a href="bk01pt01ch01s02.html#manual.intro.status.license.fdl">The Documentation: GPL, FDL</a></span></dt></dl></dd><dt><span class="sect1"><a href="bk01pt01ch01s03.html">Bugs</a></span></dt><dd><dl><dt><span class="sect2"><a href="bk01pt01ch01s03.html#manual.intro.status.bugs.impl">Implementation Bugs</a></span></dt><dt><span class="sect2"><a href="bk01pt01ch01s03.html#manual.intro.status.bugs.iso">Standard Bugs</a></span></dt></dl></dd></dl></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="manual.intro.status.standard"></a>Implementation Status</h2></div></div></div><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="manual.intro.status.standard.1998"></a>C++ 1998</h3></div></div></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="standard.1998"></a>Checklist</h4></div></div></div><div class="literallayout"><p><br />
-   Completion Checklist for the Standard C++ Library<br />
-   Updated: 2003-04-25<br />
-<br />
-   Status Code Legend:<br />
-    M - Missing<br />
-    S - Present as stub.<br />
-    X - Partially implemented, or buggy.<br />
-    T - Implemented, pending test/inspection.<br />
-    V - Verified to pass all available test suites.<br />
-    Q - Qualified by inspection for non-testable correctness.<br />
-    P - Portability verified.<br />
-    C - Certified.<br />
-<br />
-   Lexical notes:<br />
-   Only status codes appear in column 0.  Notes relating to conformance<br />
-   issues appear [in brackets].<br />
-<br />
-   Note that this checklist does not (yet) include all emendations<br />
-   recommended by the ISO Library Working Group:<br />
-   http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html<br />
-<br />
-   Detailed explanation of status codes:<br />
-<br />
-    M - Missing:  The name is not visible to programs that include<br />
-        the specified header, either at compile or link stage.<br />
-<br />
-    S - Present as stub:  A program can use the name, but no implementation<br />
-        is provided.  Programs that use the name link correctly, but<br />
-        cannot usefully be run.<br />
-<br />
-    X - Partially implemented, or buggy:  Some implementation has been<br />
-        provided, but it is known or believed not to conform fully.<br />
-        It may have an incorrect base class, wrong namespace, wrong<br />
-        storage class, or simply not fully implement requirements.<br />
-        However, it may be sufficiently usable to help test other<br />
-        components.<br />
-<br />
-    T - Implemented, pending test/inspection:  Implementation believed<br />
-        to be complete, and informal testing suggests it is ready for<br />
-        formal verification.<br />
-<br />
-    V - Verified, passes all test suites:  Verified to satisfy all<br />
-        generically testable conformance requirements.<br />
-<br />
-    Q - Qualified by inspection for non-testable correctness:<br />
-        Inspected, "implementation-defined" documentation accepted,<br />
-        local usability criteria satisfied, formally inspected for<br />
-        other untestable conformance.  (Untestable requirements<br />
-        include exception-safety, thread-safety, worst-case<br />
-        complexity, memory cleanliness, usefulness.)<br />
-<br />
-    P - Portability verified:  Qualified on all primary target platforms.<br />
-<br />
-    C - Certified:  Formally certified to have passed all tests,<br />
-        inspections, qualifications; approved under "signing authority"<br />
-        to be used to satisfy contractual guarantees.<br />
-<br />
-   ----------------------------------------------------------------------<br />
-       &lt;algorithm&gt;    &lt;iomanip&gt;    &lt;list&gt;      &lt;ostream&gt;     &lt;streambuf&gt;<br />
-       &lt;bitset&gt;       &lt;ios&gt;        &lt;locale&gt;    &lt;queue&gt;       &lt;string&gt;<br />
-       &lt;complex&gt;      &lt;iosfwd&gt;     &lt;map&gt;       &lt;set&gt;         &lt;typeinfo&gt;<br />
-X      &lt;deque&gt;        &lt;iostream&gt;   &lt;memory&gt;    &lt;sstream&gt;     &lt;utility&gt;<br />
-       &lt;exception&gt;    &lt;istream&gt;    &lt;new&gt;       &lt;stack&gt;       &lt;valarray&gt;<br />
-       &lt;fstream&gt;      &lt;iterator&gt;   &lt;numeric&gt;   &lt;stdexcept&gt;   &lt;vector&gt;<br />
-       &lt;functional&gt;   &lt;limits&gt;<br />
-<br />
-   [C header names must be in std:: to qualify.  Related to shadow/ dir.]<br />
-           &lt;cassert&gt; &lt;ciso646&gt; &lt;csetjmp&gt; &lt;cstdio&gt;  &lt;ctime&gt;<br />
-           &lt;cctype&gt;  &lt;climits&gt; &lt;csignal&gt; &lt;cstdlib&gt; &lt;cwchar&gt;<br />
-X          &lt;cerrno&gt;  &lt;clocale&gt; &lt;cstdarg&gt; &lt;cstring&gt; &lt;cwctype&gt;<br />
-           &lt;cfloat&gt;  &lt;cmath&gt;   &lt;cstddef&gt;<br />
-<br />
-    Macro:<br />
-X   errno,  declared  or  defined in &lt;cerrno&gt;.<br />
-<br />
-    Macro fn:<br />
-X   setjmp(jmp_buf), declared or defined in &lt;csetjmp&gt;<br />
-X   va_end(va_list), declared or defined in &lt;cstdarg&gt;<br />
-<br />
-    Types:<br />
-X   clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t,<br />
-X   ptrdiff_t, sig_atomic_t, size_t,  time_t,  tm,  va_list,<br />
-X   wctrans_t, wctype_t, and wint_t.<br />
-<br />
-   1 Which  of  the functions in the C++ Standard Library are not reentrant<br />
-    subroutines is implementation-defined.<br />
-<br />
-   18.1  Types                                        [lib.support.types]<br />
-X      &lt;cstddef&gt;<br />
-X      NULL<br />
-X      offsetof<br />
-X      ptrdiff_t<br />
-X      size_t<br />
-<br />
-   18.2  Implementation properties                   [lib.support.limits]<br />
-<br />
-    &lt;limits&gt;, &lt;climits&gt;, and &lt;cfloat&gt;<br />
-<br />
-   18.2.1  Numeric limits                                    [lib.limits]<br />
-<br />
-X   template&lt;class T&gt; class numeric_limits;<br />
-<br />
-T   enum float_round_style;<br />
-T   enum float_denorm_style;<br />
-<br />
-T   template&lt;&gt; class numeric_limits&lt;bool&gt;;<br />
-<br />
-T   template&lt;&gt; class numeric_limits&lt;char&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;signed char&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;unsigned char&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;wchar_t&gt;;<br />
-<br />
-T   template&lt;&gt; class numeric_limits&lt;short&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;int&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;long&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;unsigned short&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;unsigned int&gt;;<br />
-T   template&lt;&gt; class numeric_limits&lt;unsigned long&gt;;<br />
-<br />
-X   template&lt;&gt; class numeric_limits&lt;float&gt;;<br />
-X   template&lt;&gt; class numeric_limits&lt;double&gt;;<br />
-X   template&lt;&gt; class numeric_limits&lt;long double&gt;;<br />
-<br />
-   18.2.1.1  Template class numeric_limits           [lib.numeric.limits]<br />
-T   template&lt;class T&gt; class numeric_limits {<br />
-    public:<br />
-T     static const bool is_specialized = false;<br />
-T     static T min() throw();<br />
-T     static T max() throw();<br />
-T     static const int  digits = 0;<br />
-T     static const int  digits10 = 0;<br />
-T     static const bool is_signed = false;<br />
-T     static const bool is_integer = false;<br />
-T     static const bool is_exact = false;<br />
-T     static const int  radix = 0;<br />
-T     static T epsilon() throw();<br />
-T     static T round_error() throw();<br />
-<br />
-T     static const int  min_exponent = 0;<br />
-T     static const int  min_exponent10 = 0;<br />
-T     static const int  max_exponent = 0;<br />
-T     static const int  max_exponent10 = 0;<br />
-<br />
-T     static const bool has_infinity = false;<br />
-T     static const bool has_quiet_NaN = false;<br />
-T     static const bool has_signaling_NaN = false;<br />
-T     static const float_denorm_style has_denorm = denorm_absent;<br />
-T     static const bool has_denorm_loss = false;<br />
-T     static T infinity() throw();<br />
-T     static T quiet_NaN() throw();<br />
-T     static T signaling_NaN() throw();<br />
-T     static T denorm_min() throw();<br />
-<br />
-T     static const bool is_iec559 = false;<br />
-T     static const bool is_bounded = false;<br />
-T     static const bool is_modulo = false;<br />
-<br />
-T     static const bool traps = false;<br />
-T     static const bool tinyness_before = false;<br />
-T     static const float_round_style round_style = round_toward_zero;<br />
-    };<br />
-<br />
-   18.2.1.3  Type float_round_style                     [lib.round.style]<br />
-<br />
-T   enum float_round_style {<br />
-T     round_indeterminate       = -1,<br />
-T     round_toward_zero         =  0,<br />
-T     round_to_nearest          =  1,<br />
-T     round_toward_infinity     =  2,<br />
-T     round_toward_neg_infinity =  3<br />
-    };<br />
-<br />
-   18.2.1.4  Type float_denorm_style                   [lib.denorm.style]<br />
-<br />
-T   enum float_denorm_style {<br />
-T     denorm_indeterminate = -1;<br />
-T     denorm_absent = 0;<br />
-T     denorm present = 1;<br />
-    };<br />
-<br />
-   18.2.1.5  numeric_limits specializations         [lib.numeric.special]<br />
-   <br />
-   [Note: see Note at 18.2.1.  ]<br />
-<br />
-   18.2.2  C Library                                       [lib.c.limits]<br />
-<br />
-   1 Header &lt;climits&gt; (Table 3):<br />
-      CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX<br />
-X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX<br />
-      CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX<br />
-<br />
-   3 Header &lt;cfloat&gt; (Table 4):<br />
-<br />
-    DBL_DIG          DBL_MIN_EXP      FLT_MIN_10_EXP   LDBL_MAX_10_EXP<br />
-    DBL_EPSILON      FLT_DIG          FLT_MIN_EXP      LDBL_MAX_EXP<br />
-    DBL_MANT_DIG     FLT_EPSILON      FLT_RADIX        LDBL_MIN<br />
-X   DBL_MAX          FLT_MANT_DIG     FLT_ROUNDS       LDBL_MIN_10_EXP<br />
-    DBL_MAX_10_EXP   FLT_MAX          LDBL_DIG         LDBL_MIN_EXP<br />
-    DBL_MAX_EXP      FLT_MAX_10_EXP   LDBL_EPSILON<br />
-    DBL_MIN          FLT_MAX_EXP      LDBL_MANT_DIG<br />
-    DBL_MIN_10_EXP   FLT_MIN          LDBL_MAX<br />
-<br />
-<br />
-        1 Header &lt;cstdlib&gt; (partial), Table 5:<br />
-X             EXIT_FAILURE     EXIT_SUCCESS<br />
-              abort   atexit   exit<br />
-<br />
-S    abort(void)<br />
-S    extern "C" int atexit(void (*f)(void))<br />
-S    extern "C++" int atexit(void (*f)(void))<br />
-S    exit(int status)<br />
-<br />
-   18.4  Dynamic memory management                  [lib.support.dynamic]<br />
-<br />
-   Header &lt;new&gt; synopsis<br />
-<br />
-T    class bad_alloc;<br />
-T    struct nothrow_t {};<br />
-T    extern const nothrow_t nothrow;<br />
-T    typedef void (*new_handler)();<br />
-T    new_handler set_new_handler(new_handler new_p) throw();<br />
-<br />
-T    void* operator new(std::size_t size) throw(std::bad_alloc);<br />
-T    void* operator new(std::size_t size, const std::nothrow_t&amp;) throw();<br />
-T    void  operator delete(void* ptr) throw();<br />
-T    void  operator delete(void* ptr, const std::nothrow_t&amp;) throw();<br />
-T    void* operator new[](std::size_t size) throw(std::bad_alloc);<br />
-T    void* operator new[](std::size_t size, const std::nothrow_t&amp;) throw();<br />
-T    void  operator delete[](void* ptr) throw();<br />
-T    void  operator delete[](void* ptr, const std::nothrow_t&amp;) throw();<br />
-T    void* operator new  (std::size_t size, void* ptr) throw();<br />
-T    void* operator new[](std::size_t size, void* ptr) throw();<br />
-T    void  operator delete  (void* ptr, void*) throw();<br />
-T    void  operator delete[](void* ptr, void*) throw();<br />
-<br />
-   18.4.2.1  Class bad_alloc                              [lib.bad.alloc]<br />
-<br />
-T   class bad_alloc : public exception {<br />
-    public:<br />
-T     bad_alloc() throw();<br />
-T     bad_alloc(const bad_alloc&amp;) throw();<br />
-T     bad_alloc&amp; operator=(const bad_alloc&amp;) throw();<br />
-T     virtual ~bad_alloc() throw();<br />
-T     virtual const char* what() const throw();<br />
-<br />
-<br />
-<br />
-T  new_handler set_new_handler(new_handler new_p) throw();<br />
-<br />
-<br />
-     Header &lt;typeinfo&gt; synopsis<br />
-<br />
-T    class type_info;<br />
-T    class bad_cast;<br />
-T    class bad_typeid;<br />
-<br />
-   18.5.1 - Class type_info [lib.type.info]<br />
-<br />
-T    class type_info {<br />
-    public:<br />
-T      virtual ~type_info();<br />
-T      bool operator==(const type_info&amp; rhs) const;<br />
-T      bool operator!=(const type_info&amp; rhs) const;<br />
-T      bool before(const type_info&amp; rhs) const;<br />
-T      const char* name() const;<br />
-    private:<br />
-T      type_info(const type_info&amp; rhs);<br />
-T      type_info&amp; operator=(const type_info&amp; rhs);<br />
-    };<br />
-<br />
-   18.5.2 - Class bad_cast [lib.bad.cast]<br />
-<br />
-T  bad_cast() throw();<br />
-T  virtual const char* bad_cast::what() const throw();<br />
-<br />
-   18.5.3  Class bad_typeid                              [lib.bad.typeid]<br />
-<br />
-T    class bad_typeid : public exception {<br />
-    public:<br />
-T      bad_typeid() throw();<br />
-T      bad_typeid(const bad_typeid&amp;) throw();<br />
-T      bad_typeid&amp; operator=(const bad_typeid&amp;) throw();<br />
-T      virtual ~bad_typeid() throw();<br />
-T      virtual const char* what() const throw();<br />
-    };<br />
-<br />
-   18.6  Exception handling                       [lib.support.exception]<br />
-<br />
-T      Header &lt;exception&gt; synopsis<br />
-<br />
-T    class exception;<br />
-T    class bad_exception;<br />
-<br />
-T    typedef void (*unexpected_handler)();<br />
-T    unexpected_handler set_unexpected(unexpected_handler f) throw();<br />
-T    void unexpected();<br />
-T    typedef void (*terminate_handler)();<br />
-T    terminate_handler set_terminate(terminate_handler f) throw();<br />
-T    void terminate();<br />
-T    bool uncaught_exception();<br />
-<br />
-   18.6.1  Class exception                                [lib.exception]<br />
-<br />
-T    class exception {<br />
-     public:<br />
-T      exception() throw();<br />
-T      exception(const exception&amp;) throw();<br />
-T      exception&amp; operator=(const exception&amp;) throw();<br />
-T      virtual ~exception() throw();<br />
-T      virtual const char* what() const throw();<br />
-    };<br />
-<br />
-   18.6.2.1  Class bad_exception                      [lib.bad.exception]<br />
-T    class bad_exception : public exception {<br />
-    public:<br />
-T      bad_exception() throw();<br />
-T      bad_exception(const bad_exception&amp;) throw();<br />
-T      bad_exception&amp; operator=(const bad_exception&amp;) throw();<br />
-T      virtual ~bad_exception() throw();<br />
-T      virtual const char* what() const throw();<br />
-    };<br />
-<br />
-   18.7  Other runtime support                      [lib.support.runtime]<br />
-<br />
-   1 Headers &lt;cstdarg&gt; (variable arguments),  &lt;csetjmp&gt;  (nonlocal  jumps),<br />
-    &lt;ctime&gt;  (system  clock clock(), time()), &lt;csignal&gt; (signal handling),<br />
-    and &lt;cstdlib&gt; (runtime environment getenv(), system()).<br />
-<br />
-                    Table 6--Header &lt;cstdarg&gt; synopsis<br />
-                 Macros:   va_arg    va_end   va_start<br />
-X                Type:     va_list<br />
-<br />
-                    Table 7--Header &lt;csetjmp&gt; synopsis<br />
-<br />
-                          Macro:      setjmp |<br />
-X                         Type:       jmp_buf<br />
-                          Function:   longjmp<br />
-<br />
-                     Table 8--Header &lt;ctime&gt; synopsis<br />
-<br />
-                      Macros:      CLOCKS_PER_SEC<br />
-X                     Types:       clock_t<br />
-                      Functions:   clock<br />
-<br />
-                    Table 9--Header &lt;csignal&gt; synopsis<br />
-<br />
-X        Macros:      SIGABRT        SIGILL   SIGSEGV   SIG_DFL<br />
-         SIG_IGN      SIGFPE         SIGINT   SIGTERM   SIG_ERR<br />
-         Type:        sig_atomic_t<br />
-         Functions:   raise          signal<br />
-<br />
-                   Table 10--Header &lt;cstdlib&gt; synopsis<br />
-<br />
-X                     Functions:   getenv   system<br />
-<br />
-   19.1  Exception classes                           [lib.std.exceptions]<br />
-<br />
-   Header &lt;stdexcept&gt; synopsis<br />
-<br />
-T     class logic_error;<br />
-T     class domain_error;<br />
-T     class invalid_argument;<br />
-T     class length_error;<br />
-T     class out_of_range;<br />
-T     class runtime_error;<br />
-T     class range_error;<br />
-T     class overflow_error;<br />
-T     class underflow_error;<br />
-<br />
-   19.1.1  Class logic_error                            [lib.logic.error]<br />
-T   class logic_error : public exception {<br />
-    public:<br />
-T     explicit logic_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-   19.1.2  Class domain_error                          [lib.domain.error]<br />
-<br />
-T   class domain_error : public logic_error {<br />
-    public:<br />
-T     explicit domain_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-   19.1.3  Class invalid_argument                  [lib.invalid.argument]<br />
-<br />
-T   class invalid_argument : public logic_error {<br />
-    public:<br />
-T     explicit invalid_argument(const string&amp; what_arg);<br />
-    };<br />
-<br />
-   19.1.4  Class length_error                          [lib.length.error]<br />
-<br />
-T   class length_error : public logic_error {<br />
-    public:<br />
-T     explicit length_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-   19.1.5  Class out_of_range                          [lib.out.of.range]<br />
-<br />
-T   class out_of_range : public logic_error {<br />
-    public:<br />
-T     explicit out_of_range(const string&amp; what_arg);<br />
-    };<br />
-<br />
-<br />
-   19.1.6  Class runtime_error                        [lib.runtime.error]<br />
-<br />
-T   class runtime_error : public exception {<br />
-    public:<br />
-T     explicit runtime_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-<br />
-   19.1.7  Class range_error                            [lib.range.error]<br />
-<br />
-T   class range_error : public runtime_error {<br />
-    public:<br />
-T     explicit range_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-   19.1.8  Class overflow_error                      [lib.overflow.error]<br />
-<br />
-T   class overflow_error : public runtime_error {<br />
-    public:<br />
-T     explicit overflow_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-<br />
-   19.1.9  Class underflow_error                    [lib.underflow.error]<br />
-<br />
-T   class underflow_error : public runtime_error {<br />
-    public:<br />
-T     explicit underflow_error(const string&amp; what_arg);<br />
-    };<br />
-<br />
-<br />
-   19.2  Assertions                                      [lib.assertions]<br />
-<br />
-                    Table 2--Header &lt;cassert&gt; synopsis<br />
-<br />
-X                         Macro:   assert<br />
-<br />
-   19.3  Error numbers                                        [lib.errno]<br />
-<br />
-                    Table 3--Header &lt;cerrno&gt; synopsis<br />
-<br />
-X                    |Macros:   EDOM   ERANGE   errno |<br />
-<br />
-<br />
-   20.2  Utility components                                 [lib.utility]<br />
-<br />
-   Header &lt;utility&gt; synopsis<br />
-<br />
-    // _lib.operators_, operators:<br />
-T    namespace rel_ops {<br />
-T      template&lt;class T&gt; bool operator!=(const T&amp;, const T&amp;);<br />
-T      template&lt;class T&gt; bool operator&gt; (const T&amp;, const T&amp;);<br />
-T      template&lt;class T&gt; bool operator&lt;=(const T&amp;, const T&amp;);<br />
-T      template&lt;class T&gt; bool operator&gt;=(const T&amp;, const T&amp;);<br />
-    }<br />
-    // _lib.pairs_, pairs:<br />
-T   template &lt;class T1, class T2&gt; struct pair;<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator==(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator&lt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator!=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator&gt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator&gt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt;<br />
-      bool operator&lt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);<br />
-T   template &lt;class T1, class T2&gt; pair&lt;T1,T2&gt; make_pair(const T1&amp;, const T2&amp;);<br />
-<br />
-<br />
-   20.2.2  Pairs                                              [lib.pairs]<br />
-<br />
-T  template &lt;class T1, class T2&gt;<br />
-   struct pair {<br />
-T    typedef T1 first_type;<br />
-T    typedef T2 second_type;<br />
-<br />
-T    T1 first;<br />
-T    T2 second;<br />
-T    pair();<br />
-T    pair(const T1&amp; x, const T2&amp; y);<br />
-T    template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt; &amp;p);<br />
-   };<br />
-<br />
-   20.3  Function objects                          [lib.function.objects]<br />
-<br />
-   Header &lt;functional&gt; synopsis<br />
-<br />
-    // _lib.base_, base:<br />
-V   template &lt;class Arg, class Result&gt; struct unary_function;<br />
-V   template &lt;class Arg1, class Arg2, class Result&gt; struct binary_function;<br />
-<br />
-    // _lib.arithmetic.operations_, arithmetic operations:<br />
-V   template &lt;class T&gt; struct plus;<br />
-V   template &lt;class T&gt; struct minus;<br />
-V   template &lt;class T&gt; struct multiplies;<br />
-V   template &lt;class T&gt; struct divides;<br />
-V   template &lt;class T&gt; struct modulus;<br />
-V   template &lt;class T&gt; struct negate;<br />
-    // _lib.comparisons_, comparisons:<br />
-V   template &lt;class T&gt; struct equal_to;<br />
-V   template &lt;class T&gt; struct not_equal_to;<br />
-V   template &lt;class T&gt; struct greater;<br />
-V   template &lt;class T&gt; struct less;<br />
-V   template &lt;class T&gt; struct greater_equal;<br />
-V   template &lt;class T&gt; struct less_equal;<br />
-    // _lib.logical.operations_, logical operations:<br />
-V   template &lt;class T&gt; struct logical_and;<br />
-V   template &lt;class T&gt; struct logical_or;<br />
-V   template &lt;class T&gt; struct logical_not;<br />
-    // _lib.negators_, negators:<br />
-    template &lt;class Predicate&gt; struct unary_negate;<br />
-V   template &lt;class Predicate&gt;<br />
-      unary_negate&lt;Predicate&gt;  not1(const Predicate&amp;);<br />
-V   template &lt;class Predicate&gt; struct binary_negate;<br />
-V   template &lt;class Predicate&gt;<br />
-      binary_negate&lt;Predicate&gt; not2(const Predicate&amp;);<br />
-    // _lib.binders_, binders:<br />
-V   template &lt;class Operation&gt;  class binder1st;<br />
-V   template &lt;class Operation, class T&gt;<br />
-      binder1st&lt;Operation&gt; bind1st(const Operation&amp;, const T&amp;);<br />
-V   template &lt;class Operation&gt; class binder2nd;<br />
-V   template &lt;class Operation, class T&gt;<br />
-      binder2nd&lt;Operation&gt; bind2nd(const Operation&amp;, const T&amp;);<br />
-    // _lib.function.pointer.adaptors_, adaptors:<br />
-V   template &lt;class Arg, class Result&gt; class pointer_to_unary_function;<br />
-V   template &lt;class Arg, class Result&gt;<br />
-      pointer_to_unary_function&lt;Arg,Result&gt; ptr_fun(Result (*)(Arg));<br />
-V   template &lt;class Arg1, class Arg2, class Result&gt;<br />
-      class pointer_to_binary_function;<br />
-V   template &lt;class Arg1, class Arg2, class Result&gt;<br />
-      pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;<br />
-        ptr_fun(Result (*)(Arg1,Arg2));<br />
-<br />
-    // _lib.member.pointer.adaptors_, adaptors:<br />
-V   template&lt;class S, class T&gt; class mem_fun_t;<br />
-V   template&lt;class S, class T, class A&gt; class mem_fun1_t;<br />
-V   template&lt;class S, class T&gt;<br />
-        mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)());<br />
-V   template&lt;class S, class T, class A&gt;<br />
-        mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A));<br />
-V   template&lt;class S, class T&gt; class mem_fun_ref_t;<br />
-V   template&lt;class S, class T, class A&gt; class mem_fun1_ref_t;<br />
-V   template&lt;class S, class T&gt;<br />
-        mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)());<br />
-V   template&lt;class S, class T, class A&gt;<br />
-        mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A));<br />
-<br />
-V   template &lt;class S, class T&gt; class const_mem_fun_t;<br />
-V   template &lt;class S, class T, class A&gt; class const_mem_fun1_t;<br />
-V   template &lt;class S, class T&gt;<br />
-      const_mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)() const);<br />
-V   template &lt;class S, class T, class A&gt;<br />
-      const_mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A) const);<br />
-V   template &lt;class S, class T&gt; class const_mem_fun_ref_t;<br />
-V   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t;<br />
-V   template &lt;class S, class T&gt;<br />
-      const_mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)() const);<br />
-V   template &lt;class S, class T, class A&gt;<br />
-      const_mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A) const);<br />
-   }<br />
-<br />
-   20.3.1  Base                                                [lib.base]<br />
-<br />
-V   template &lt;class Arg, class Result&gt;<br />
-    struct unary_function {<br />
-V     typedef Arg    argument_type;<br />
-V     typedef Result result_type;<br />
-    };<br />
-V   template &lt;class Arg1, class Arg2, class Result&gt;<br />
-    struct binary_function {<br />
-V     typedef Arg1   first_argument_type;<br />
-V     typedef Arg2   second_argument_type;<br />
-V     typedef Result result_type;<br />
-    };<br />
-<br />
-   20.3.2  Arithmetic operations              [lib.arithmetic.operations]<br />
-<br />
-T  template &lt;class T&gt; struct plus : binary_function&lt;T,T,T&gt; {<br />
-V   T operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct minus : binary_function&lt;T,T,T&gt; {<br />
-V   T operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct multiplies : binary_function&lt;T,T,T&gt; {<br />
-V   T operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct divides : binary_function&lt;T,T,T&gt; {<br />
-V   T operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct modulus : binary_function&lt;T,T,T&gt; {<br />
-V   T operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct negate : unary_function&lt;T,T&gt; {<br />
-V   T operator()(const T&amp; x) const;<br />
-   };<br />
-<br />
-   20.3.3  Comparisons                                  [lib.comparisons]<br />
-<br />
-T  template &lt;class T&gt; struct equal_to : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct not_equal_to : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct greater : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct less : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct greater_equal : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct less_equal : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-   20.3.4  Logical operations                    [lib.logical.operations]<br />
-<br />
-T  template &lt;class T&gt; struct logical_and : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct logical_or : binary_function&lt;T,T,bool&gt; {<br />
-V   bool operator()(const T&amp; x, const T&amp; y) const;<br />
-   };<br />
-<br />
-T  template &lt;class T&gt; struct logical_not : unary_function&lt;T,bool&gt; {<br />
-V   bool operator()(const T&amp; x) const;<br />
-   };<br />
-<br />
-   20.3.5  Negators                                        [lib.negators]<br />
-<br />
-T  template &lt;class Predicate&gt;<br />
-    class unary_negate<br />
-      : public unary_function&lt;typename Predicate::argument_type,bool&gt; {<br />
-   public:<br />
-T   explicit unary_negate(const Predicate&amp; pred);<br />
-V   bool operator()(const typename Predicate::argument_type&amp; x) const;<br />
-   };<br />
-<br />
-T  template &lt;class Predicate&gt;<br />
-    class binary_negate<br />
-      : public binary_function&lt;typename Predicate::first_argument_type,<br />
-          typename Predicate::second_argument_type, bool&gt; {<br />
-    public:<br />
-T     explicit binary_negate(const Predicate&amp; pred);<br />
-V     bool operator()(const typename Predicate::first_argument_type&amp;  x,<br />
-          const typename Predicate::second_argument_type&amp; y) const;<br />
-    };<br />
-<br />
-<br />
-   20.3.6  Binders                                          [lib.binders]<br />
-<br />
-   20.3.6.1  Template class binder1st                    [lib.binder.1st]<br />
-T   template &lt;class Operation&gt;<br />
-    class binder1st<br />
-      : public unary_function&lt;typename Operation::second_argument_type,<br />
-                              typename Operation::result_type&gt; {<br />
-    protected:<br />
-T     Operation                      op;<br />
-T     typename Operation::first_argument_type value;<br />
-    public:<br />
-V     binder1st(const Operation&amp; x,<br />
-                const typename Operation::first_argument_type&amp; y);<br />
-V     typename Operation::result_type<br />
-        operator()(const typename Operation::second_argument_type&amp; x) const;<br />
-    };<br />
-<br />
-   20.3.6.2  bind1st                                       [lib.bind.1st]<br />
-<br />
-V  template &lt;class Operation, class T&gt;<br />
-    binder1st&lt;Operation&gt; bind1st(const Operation&amp; op, const T&amp; x);<br />
-<br />
-   20.3.6.3  Template class binder2nd                    [lib.binder.2nd]<br />
-T   template &lt;class Operation&gt;<br />
-    class binder2nd<br />
-      : public unary_function&lt;typename Operation::first_argument_type,<br />
-                              typename Operation::result_type&gt; {<br />
-    protected:<br />
-T     Operation                       op;<br />
-T     typename Operation::second_argument_type value;<br />
-    public:<br />
-V     binder2nd(const Operation&amp; x,<br />
-                const typename Operation::second_argument_type&amp; y);<br />
-V     typename Operation::result_type<br />
-        operator()(const typename Operation::first_argument_type&amp; x) const;<br />
-    };<br />
-<br />
-   20.3.6.4  bind2nd                                       [lib.bind.2nd]<br />
-<br />
-T  template &lt;class Operation, class T&gt;<br />
-    binder2nd&lt;Operation&gt; bind2nd(const Operation&amp; op, const T&amp; x);<br />
-<br />
-<br />
-   20.3.7  Adaptors for pointers to       [lib.function.pointer.adaptors]<br />
-       functions<br />
-<br />
-   1 To  allow  pointers to (unary and binary) functions to work with func-<br />
-   tion adaptors the library provides:<br />
-<br />
-T   template &lt;class Arg, class Result&gt;<br />
-    class pointer_to_unary_function : public unary_function&lt;Arg, Result&gt; {<br />
-    public:<br />
-T     explicit pointer_to_unary_function(Result (*f)(Arg));<br />
-V     Result operator()(Arg x) const;<br />
-    };<br />
-<br />
-T  template &lt;class Arg, class Result&gt;<br />
-    pointer_to_unary_function&lt;Arg, Result&gt; ptr_fun(Result (*f)(Arg));<br />
-<br />
-T       template &lt;class Arg1, class Arg2, class Result&gt;<br />
-        class pointer_to_binary_function :<br />
-          public binary_function&lt;Arg1,Arg2,Result&gt; {<br />
-        public:<br />
-T         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));<br />
-V         Result operator()(Arg1 x, Arg2 y) const;<br />
-        };<br />
-<br />
-<br />
-   20.3.8  Adaptors for pointers to         [lib.member.pointer.adaptors]<br />
-       members<br />
-<br />
-T  template &lt;class S, class T&gt; class mem_fun_t<br />
-          : public unary_function&lt;T*, S&gt; {<br />
-   public:<br />
-T   explicit mem_fun_t(S (T::*p)());<br />
-V   S operator()(T* p) const;<br />
-   };<br />
-<br />
-T   template &lt;class S, class T, class A&gt; class mem_fun1_t<br />
-          : public binary_function&lt;T*, A, S&gt; {<br />
-    public:<br />
-T     explicit mem_fun1_t(S (T::*p)(A));<br />
-V     S operator()(T* p, A x) const;<br />
-   };<br />
-<br />
-V   template&lt;class S, class T&gt; mem_fun_t&lt;S,T&gt;<br />
-       mem_fun(S (T::*f)());<br />
-V   template&lt;class S, class T, class A&gt; mem_fun1_t&lt;S,T,A&gt;<br />
-       mem_fun(S (T::*f)(A));<br />
-<br />
-T   template &lt;class S, class T&gt; class mem_fun_ref_t<br />
-          : public unary_function&lt;T, S&gt; {<br />
-    public:<br />
-T     explicit mem_fun_ref_t(S (T::*p)());<br />
-V     S operator()(T&amp; p) const;<br />
-   };<br />
-<br />
-T   template &lt;class S, class T, class A&gt; class mem_fun1_ref_t<br />
-          : public binary_function&lt;T, A, S&gt; {<br />
-    public:<br />
-T     explicit mem_fun1_ref_t(S (T::*p)(A));<br />
-V     S operator()(T&amp; p, A x) const;<br />
-   };<br />
-<br />
-T   template&lt;class S, class T&gt; mem_fun_ref_t&lt;S,T&gt;<br />
-       mem_fun_ref(S (T::*f)());<br />
-<br />
-T   template&lt;class S, class T, class A&gt; mem_fun1_ref_t&lt;S,T,A&gt;<br />
-       mem_fun_ref(S (T::*f)(A));<br />
-<br />
-T  template &lt;class S, class T&gt; class const_mem_fun_t<br />
-        : public unary_function&lt;T*, S&gt; {<br />
-   public:<br />
-T   explicit const_mem_fun_t(S (T::*p)() const);<br />
-V   S operator()(const T* p) const;<br />
-   };<br />
-<br />
-T  template &lt;class S, class T, class A&gt; class const_mem_fun1_t<br />
-        : public binary_function&lt;T*, A, S&gt; {<br />
-   public:<br />
-T   explicit const mem_fun1_t(S (T::*p)(A) const);<br />
-V   S operator()(const T* p, A x) const;<br />
-   };<br />
-<br />
-V   template&lt;class S, class T&gt; const_mem_fun_t&lt;S,T&gt;<br />
-       mem_fun(S (T::*f)() const);<br />
-V   template&lt;class S, class T, class A&gt; const_mem_fun1_t&lt;S,T,A&gt;<br />
-       mem_fun(S (T::*f)(A) const);<br />
-<br />
-T   template &lt;class S, class T&gt; class const_mem_fun_ref_t<br />
-          : public unary_function&lt;T, S&gt; {<br />
-    public:<br />
-T     explicit const_mem_fun_ref_t(S (T::*p)() const);<br />
-V     S operator()(const T&amp; p) const;<br />
-   };<br />
-<br />
-T   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t<br />
-          : public binary_function&lt;T, A, S&gt; {<br />
-    public:<br />
-T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);<br />
-V     S operator()(const T&amp; p, A x) const;<br />
-   };<br />
-<br />
-T   template&lt;class S, class T&gt; const_mem_fun_ref_t&lt;S,T&gt;<br />
-       mem_fun_ref(S (T::*f)() const);<br />
-<br />
-T   template&lt;class S, class T, class A&gt; const_mem_fun1_ref_t&lt;S,T,A&gt;<br />
-        mem_fun_ref(S (T::*f)(A) const);<br />
-<br />
-   20.4  Memory                                              [lib.memory]<br />
-<br />
-   Header &lt;memory&gt; synopsis<br />
-<br />
-    // _lib.default.allocator_, the default allocator:<br />
-T   template &lt;class T&gt; class allocator;<br />
-T   template &lt;&gt; class allocator&lt;void&gt;;<br />
-T   template &lt;class T, class U&gt;<br />
-      bool operator==(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();<br />
-T   template &lt;class T, class U&gt;<br />
-      bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();<br />
-    // _lib.storage.iterator_, raw storage iterator:<br />
-T   template &lt;class OutputIterator, class T&gt; class raw_storage_iterator;<br />
-    // _lib.temporary.buffer_, temporary buffers:<br />
-T   template &lt;class T&gt;<br />
-      pair&lt;T*,ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);<br />
-T   template &lt;class T&gt;<br />
-      void return_temporary_buffer(T* p);<br />
-    // _lib.specialized.algorithms_, specialized algorithms:<br />
-T   template &lt;class InputIterator, class ForwardIterator&gt;<br />
-      ForwardIterator<br />
-        uninitialized_copy(InputIterator first, InputIterator last,<br />
-                           ForwardIterator result);<br />
-T   template &lt;class ForwardIterator, class T&gt;<br />
-      void uninitialized_fill(ForwardIterator first, ForwardIterator last,<br />
-                              const T&amp; x);<br />
-T   template &lt;class ForwardIterator, class Size, class T&gt;<br />
-      void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);<br />
-    // _lib.auto.ptr_, pointers:<br />
-X   template&lt;class X&gt; class auto_ptr;<br />
-   }<br />
-<br />
-   20.4.1  The default allocator                  [lib.default.allocator]<br />
-<br />
-T   template &lt;class T&gt; class allocator;<br />
-    // specialize for void:<br />
-T   template &lt;&gt; class allocator&lt;void&gt; {<br />
-    public:<br />
-T     typedef void*       pointer;<br />
-T     typedef const void* const_pointer;<br />
-      // reference-to-void members are impossible.<br />
-T     typedef void  value_type;<br />
-T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };<br />
-    };<br />
-<br />
-T   template &lt;class T&gt; class allocator {<br />
-     public:<br />
-T     typedef size_t    size_type;<br />
-T     typedef ptrdiff_t difference_type;<br />
-T     typedef T*        pointer;<br />
-T     typedef const T*  const_pointer;<br />
-T     typedef T&amp;        reference;<br />
-T     typedef const T&amp;  const_reference;<br />
-T     typedef T         value_type;<br />
-T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };<br />
-T     allocator() throw();<br />
-T     allocator(const allocator&amp;) throw();<br />
-T     template &lt;class U&gt; allocator(const allocator&lt;U&gt;&amp;) throw();<br />
-T    ~allocator() throw();<br />
-T     pointer address(reference x) const;<br />
-T     const_pointer address(const_reference x) const;<br />
-T     pointer allocate(<br />
-        size_type, allocator&lt;void&gt;::const_pointer hint = 0);<br />
-T     void deallocate(pointer p, size_type n);<br />
-T     size_type max_size() const throw();<br />
-T     void construct(pointer p, const T&amp; val);<br />
-T     void destroy(pointer p);<br />
-    };<br />
-<br />
-   20.4.1.2  allocator globals                    [lib.allocator.globals]<br />
-<br />
-T  template &lt;class T1, class T2&gt;<br />
-    bool operator==(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();<br />
-T  template &lt;class T1, class T2&gt;<br />
-    bool operator!=(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();<br />
-<br />
-   20.4.2  Raw storage iterator                    [lib.storage.iterator]<br />
-<br />
-T   template &lt;class OutputIterator, class T&gt;<br />
-    class raw_storage_iterator<br />
-      : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {<br />
-    public:<br />
-T     explicit raw_storage_iterator(OutputIterator x);<br />
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();<br />
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);<br />
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();<br />
-T     raw_storage_iterator&lt;OutputIterator,T&gt;  operator++(int);<br />
-    };<br />
-<br />
-   20.4.3  Temporary buffers                       [lib.temporary.buffer]<br />
-<br />
-T  template &lt;class T&gt;<br />
-    pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);<br />
-<br />
-T  template &lt;class T&gt; void return_temporary_buffer(T* p);<br />
-<br />
-   20.4.4  Specialized algorithms            [lib.specialized.algorithms]<br />
-<br />
-   20.4.4.1  uninitialized_copy                  [lib.uninitialized.copy]<br />
-<br />
-V  template &lt;class InputIterator, class ForwardIterator&gt;<br />
-    ForwardIterator<br />
-      uninitialized_copy(InputIterator first, InputIterator last,<br />
-                         ForwardIterator result);<br />
-<br />
-   20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]<br />
-<br />
-V  template &lt;class ForwardIterator, class T&gt;<br />
-    void uninitialized_fill(ForwardIterator first, ForwardIterator last,<br />
-                            const T&amp; x);<br />
-<br />
-   20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]<br />
-<br />
-V  template &lt;class ForwardIterator, class Size, class T&gt;<br />
-    void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);<br />
-<br />
-   20.4.5  Template class auto_ptr                         [lib.auto.ptr]<br />
-<br />
-X   template&lt;class X&gt; class auto_ptr {<br />
-      template &lt;class Y&gt; struct auto_ptr_ref {};<br />
-    public:<br />
-T     typedef X element_type;<br />
-      // _lib.auto.ptr.cons_ construct/copy/destroy:<br />
-T     explicit auto_ptr(X* p =0) throw();<br />
-T     auto_ptr(auto_ptr&amp;) throw();<br />
-T     template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp;) throw();<br />
-T     auto_ptr&amp; operator=(auto_ptr&amp;) throw();<br />
-T     template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;) throw();<br />
-T    ~auto_ptr() throw();<br />
-      // _lib.auto.ptr.members_ members:<br />
-T     X&amp; operator*() const throw();<br />
-T     X* operator-&gt;() const throw();<br />
-T     X* get() const throw();<br />
-T     X* release() throw();<br />
-T     void reset(X* p =0) throw();<br />
-<br />
-      // _lib.auto.ptr.conv_ conversions:<br />
-X     auto_ptr(auto_ptr_ref&lt;X&gt;) throw();<br />
-X     template&lt;class Y&gt; operator auto_ptr_ref&lt;Y&gt;() throw();<br />
-X     template&lt;class Y&gt; operator auto_ptr&lt;Y&gt;() throw();<br />
-    };<br />
-<br />
-   20.4.6  C Library                                       [lib.c.malloc]<br />
-<br />
-                    Table 7--Header &lt;cstdlib&gt; synopsis<br />
-<br />
-X                    Functions:   calloc   malloc<br />
-                                  free     realloc<br />
-<br />
-<br />
-                    Table 8--Header &lt;cstring&gt; synopsis<br />
-<br />
-X                    Macro:       NULL<br />
-X                    Type:        size_t<br />
-X                    Functions:   memchr    memcmp<br />
-X                    memcpy       memmove   memset<br />
-<br />
-                     Table 9--Header &lt;ctime&gt; synopsis<br />
-<br />
-X          Macros:   NULL<br />
-X          Types:    size_t   clock_t    time_t<br />
-X          Struct:   tm<br />
-           Functions:<br />
-X          asctime   clock    difftime   localtime   strftime<br />
-X          ctime     gmtime   mktime     time<br />
-<br />
-   21.1.1  Character traits requirements        [lib.char.traits.require]<br />
-<br />
-   2 The struct template<br />
-T  template&lt;class charT&gt; struct char_traits;<br />
-   shall be provided in the header &lt;string&gt; as a basis for  explicit spe-<br />
-   cializations.<br />
-<br />
-<br />
-   21.1.3.1  struct                [lib.char.traits.specializations.char]<br />
-       char_traits&lt;char&gt;<br />
-<br />
-T   template&lt;&gt;<br />
-    struct char_traits&lt;char&gt; {<br />
-T     typedef char        char_type;<br />
-T     typedef int         int_type;<br />
-T     typedef streamoff   off_type;<br />
-T     typedef streampos   pos_type;<br />
-T     typedef mbstate_t   state_type;<br />
-<br />
-T     static void assign(char_type&amp; c1, const char_type&amp; c2);<br />
-T     static bool eq(const char_type&amp; c1, const char_type&amp; c2);<br />
-T     static bool lt(const char_type&amp; c1, const char_type&amp; c2);<br />
-<br />
-T     static int compare(const char_type* s1, const char_type* s2, size_t n);<br />
-T     static size_t length(const char_type* s);<br />
-T     static const char_type* find(const char_type* s, size_t n,<br />
-                                   const char_type&amp; a);<br />
-T     static char_type* move(char_type* s1, const char_type* s2, size_t n);<br />
-T     static char_type* copy(char_type* s1, const char_type* s2, size_t n);<br />
-T     static char_type* assign(char_type* s, size_t n, char_type a);<br />
-<br />
-T     static int_type not_eof(const int_type&amp; c);<br />
-T     static char_type to_char_type(const int_type&amp; c);<br />
-T     static int_type to_int_type(const char_type&amp; c);<br />
-T     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);<br />
-T     static int_type eof();<br />
-    };<br />
-<br />
-   21.1.3.2  struct             [lib.char.traits.specializations.wchar.t]<br />
-       char_traits&lt;wchar_t&gt;<br />
-<br />
-V   template&lt;&gt;<br />
-    struct char_traits&lt;wchar_t&gt; {<br />
-V     typedef wchar_t      char_type;<br />
-V     typedef wint_t       int_type;<br />
-V     typedef streamoff   off_type;<br />
-V     typedef wstreampos   pos_type;<br />
-V     typedef mbstate_t    state_type;<br />
-<br />
-V     static void assign(char_type&amp; c1, const char_type&amp; c2);<br />
-V     static bool eq(const char_type&amp; c1, const char_type&amp; c2);<br />
-V     static bool lt(const char_type&amp; c1, const char_type&amp; c2);<br />
-<br />
-V     static int compare(const char_type* s1, const char_type* s2, size_t n);<br />
-V     static size_t length(const char_type* s);<br />
-V     static const char_type* find(const char_type* s, size_t n,<br />
-                                   const char_type&amp; a);<br />
-V     static char_type* move(char_type* s1, const char_type* s2, size_t n);<br />
-V     static char_type* copy(char_type* s1, const char_type* s2, size_t n);<br />
-V     static char_type* assign(char_type* s, size_t n, char_type a);<br />
-<br />
-V     static int_type not_eof(const int_type&amp; c);<br />
-V     static char_type to_char_type(const int_type&amp; c);<br />
-V     static int_type to_int_type(const char_type&amp; c);<br />
-V     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);<br />
-V     static int_type eof();<br />
-    };<br />
-<br />
-   21.2  String classes                              [lib.string.classes]<br />
-<br />
-    // _lib.char.traits_, character traits:<br />
-V   template&lt;class charT&gt;<br />
-      struct char_traits;<br />
-V   template &lt;&gt; struct char_traits&lt;char&gt;;<br />
-V   template &lt;&gt; struct char_traits&lt;wchar_t&gt;;<br />
-<br />
-    // _lib.basic.string_, basic_string:<br />
-V   template&lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-             class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_string;<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      basic_string&lt;charT,traits,Allocator&gt;<br />
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                  const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      basic_string&lt;charT,traits,Allocator&gt;<br />
-        operator+(const charT* lhs,<br />
-                  const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      basic_string&lt;charT,traits,Allocator&gt;<br />
-        operator+(charT lhs, const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      basic_string&lt;charT,traits,Allocator&gt;<br />
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                  const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      basic_string&lt;charT,traits,Allocator&gt;<br />
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, charT rhs);<br />
-<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator==(const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator!=(const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt; (const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt; (const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&lt;=(const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                      const charT* rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-      bool operator&gt;=(const charT* lhs,<br />
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-<br />
-    // _lib.string.special_:<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-       void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,<br />
-                 basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-     basic_istream&lt;charT,traits&gt;&amp;<br />
-      operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp; is,<br />
-                 basic_string&lt;charT,traits,Allocator&gt;&amp; str);<br />
-T   template&lt;class charT, class traits, class Allocator&gt;<br />
-     basic_ostream&lt;charT, traits&gt;&amp;<br />
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,<br />
-                 const basic_string&lt;charT,traits,Allocator&gt;&amp; str);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-     basic_istream&lt;charT,traits&gt;&amp;<br />
-       getline(basic_istream&lt;charT,traits&gt;&amp; is,<br />
-               basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-               charT delim);<br />
-V   template&lt;class charT, class traits, class Allocator&gt;<br />
-     basic_istream&lt;charT,traits&gt;&amp;<br />
-       getline(basic_istream&lt;charT,traits&gt;&amp; is,<br />
-               basic_string&lt;charT,traits,Allocator&gt;&amp; str);<br />
-V   typedef basic_string&lt;char&gt; string;<br />
-T   typedef basic_string&lt;wchar_t&gt; wstring;<br />
-   }<br />
-<br />
-   21.3  Template class basic_string                   [lib.basic.string]<br />
-<br />
-V  namespace std {<br />
-    template&lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-             class Allocator = allocator&lt;charT&gt; &gt;<br />
-    class basic_string {<br />
-    public:<br />
-      // types:<br />
-      typedef          traits                     traits_type;<br />
-      typedef typename traits::char_type          value_type;<br />
-      typedef          Allocator                  allocator_type;<br />
-      typedef typename Allocator::size_type       size_type;<br />
-      typedef typename Allocator::difference_type difference_type;<br />
-      typedef typename Allocator::reference       reference;<br />
-      typedef typename Allocator::const_reference const_reference;<br />
-      typedef typename Allocator::pointer         pointer;<br />
-      typedef typename Allocator::const_pointer   const_pointer;<br />
-      typedef implementation defined             iterator;<br />
-      typedef implementation defined             const_iterator;<br />
-      typedef std::reverse_iterator&lt;iterator&gt; reverse_iterator;<br />
-      typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-      static const size_type npos = -1;<br />
-<br />
-      // _lib.string.cons_ construct/copy/destroy:<br />
-V     explicit basic_string(const Allocator&amp; a = Allocator());<br />
-V     basic_string(const basic_string&amp; str, size_type pos = 0,<br />
-                   size_type n = npos, const Allocator&amp; a = Allocator());<br />
-V     basic_string(const charT* s,<br />
-                   size_type n, const Allocator&amp; a = Allocator());<br />
-V     basic_string(const charT* s, const Allocator&amp; a = Allocator());<br />
-V     basic_string(size_type n, charT c, const Allocator&amp; a = Allocator());<br />
-V     template&lt;class InputIterator&gt;<br />
-        basic_string(InputIterator begin, InputIterator end,<br />
-                     const Allocator&amp; a = Allocator());<br />
-V    ~basic_string();<br />
-V     basic_string&amp; operator=(const basic_string&amp; str);<br />
-V     basic_string&amp; operator=(const charT* s);<br />
-V     basic_string&amp; operator=(charT c);<br />
-      // _lib.string.iterators_ iterators:<br />
-V     iterator       begin();<br />
-V     const_iterator begin() const;<br />
-V     iterator       end();<br />
-V     const_iterator end() const;<br />
-<br />
-V     reverse_iterator       rbegin();<br />
-V     const_reverse_iterator rbegin() const;<br />
-V     reverse_iterator       rend();<br />
-V     const_reverse_iterator rend() const;<br />
-      // _lib.string.capacity_ capacity:<br />
-V     size_type size() const;<br />
-V     size_type length() const;<br />
-V     size_type max_size() const;<br />
-V     void resize(size_type n, charT c);<br />
-V     void resize(size_type n);<br />
-V     size_type capacity() const;<br />
-V     void reserve(size_type res_arg = 0);<br />
-V     void clear();<br />
-V     bool empty() const;<br />
-      // _lib.string.access_ element access:<br />
-V     const_reference operator[](size_type pos) const;<br />
-V     reference       operator[](size_type pos);<br />
-V     const_reference at(size_type n) const;<br />
-V     reference       at(size_type n);<br />
-      // _lib.string.modifiers_ modifiers:<br />
-V     basic_string&amp; operator+=(const basic_string&amp; str);<br />
-V     basic_string&amp; operator+=(const charT* s);<br />
-V     basic_string&amp; operator+=(charT c);<br />
-V     basic_string&amp; append(const basic_string&amp; str);<br />
-V     basic_string&amp; append(const basic_string&amp; str, size_type pos,<br />
-                           size_type n);<br />
-V     basic_string&amp; append(const charT* s, size_type n);<br />
-V     basic_string&amp; append(const charT* s);<br />
-V     basic_string&amp; append(size_type n, charT c);<br />
-V     template&lt;class InputIterator&gt;<br />
-        basic_string&amp; append(InputIterator first, InputIterator last);<br />
-V     void push_back(const charT);<br />
-<br />
-V     basic_string&amp; assign(const basic_string&amp;);<br />
-V     basic_string&amp; assign(const basic_string&amp; str, size_type pos,<br />
-                           size_type n);<br />
-V     basic_string&amp; assign(const charT* s, size_type n);<br />
-V     basic_string&amp; assign(const charT* s);<br />
-V     basic_string&amp; assign(size_type n, charT c);<br />
-V     template&lt;class InputIterator&gt;<br />
-        basic_string&amp; assign(InputIterator first, InputIterator last);<br />
-V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str);<br />
-V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str,<br />
-                           size_type pos2, size_type n);<br />
-V     basic_string&amp; insert(size_type pos, const charT* s, size_type n);<br />
-V     basic_string&amp; insert(size_type pos, const charT* s);<br />
-V     basic_string&amp; insert(size_type pos, size_type n, charT c);<br />
-V     iterator insert(iterator p, charT c);<br />
-V     void     insert(iterator p, size_type n, charT c);<br />
-V     template&lt;class InputIterator&gt;<br />
-        void insert(iterator p, InputIterator first, InputIterator last);<br />
-V     basic_string&amp; erase(size_type pos = 0, size_type n = npos);<br />
-V     iterator erase(iterator position);<br />
-V     iterator erase(iterator first, iterator last);<br />
-V     basic_string&amp; replace(size_type pos1, size_type n1,<br />
-                            const basic_string&amp; str);<br />
-V     basic_string&amp; replace(size_type pos1, size_type n1,<br />
-                            const basic_string&amp; str,<br />
-                            size_type pos2, size_type n2);<br />
-V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s,<br />
-                            size_type n2);<br />
-V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s);<br />
-V     basic_string&amp; replace(size_type pos, size_type n1, size_type n2,<br />
-                            charT c);<br />
-V     basic_string&amp; replace(iterator i1, iterator i2, const basic_string&amp; str);<br />
-V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s,<br />
-                            size_type n);<br />
-V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s);<br />
-V     basic_string&amp; replace(iterator i1, iterator i2,<br />
-                            size_type n, charT c);<br />
-V     template&lt;class InputIterator&gt;<br />
-        basic_string&amp; replace(iterator i1, iterator i2,<br />
-                              InputIterator j1, InputIterator j2);<br />
-V     size_type copy(charT* s, size_type n, size_type pos = 0) const;<br />
-V     void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;);<br />
-      // _lib.string.ops_ string operations:<br />
-V     const charT* c_str() const;         // explicit<br />
-V     const charT* data() const;<br />
-V     allocator_type get_allocator() const;<br />
-V     size_type find (const basic_string&amp; str, size_type pos = 0) const;<br />
-V     size_type find (const charT* s, size_type pos, size_type n) const;<br />
-V     size_type find (const charT* s, size_type pos = 0) const;<br />
-V     size_type find (charT c, size_type pos = 0) const;<br />
-V     size_type rfind(const basic_string&amp; str, size_type pos = npos) const;<br />
-V     size_type rfind(const charT* s, size_type pos, size_type n) const;<br />
-V     size_type rfind(const charT* s, size_type pos = npos) const;<br />
-V     size_type rfind(charT c, size_type pos = npos) const;<br />
-<br />
-V     size_type find_first_of(const basic_string&amp; str,<br />
-                              size_type pos = 0) const;<br />
-V     size_type find_first_of(const charT* s,<br />
-                              size_type pos, size_type n) const;<br />
-V     size_type find_first_of(const charT* s, size_type pos = 0) const;<br />
-V     size_type find_first_of(charT c, size_type pos = 0) const;<br />
-V     size_type find_last_of (const basic_string&amp; str,<br />
-                              size_type pos = npos) const;<br />
-V     size_type find_last_of (const charT* s,<br />
-                              size_type pos, size_type n) const;<br />
-V     size_type find_last_of (const charT* s, size_type pos = npos) const;<br />
-V     size_type find_last_of (charT c, size_type pos = npos) const;<br />
-V     size_type find_first_not_of(const basic_string&amp; str,<br />
-                                  size_type pos = 0) const;<br />
-V     size_type find_first_not_of(const charT* s, size_type pos,<br />
-                                  size_type n) const;<br />
-V     size_type find_first_not_of(const charT* s, size_type pos = 0) const;<br />
-V     size_type find_first_not_of(charT c, size_type pos = 0) const;<br />
-V     size_type find_last_not_of (const basic_string&amp; str,<br />
-                                  size_type pos = npos) const;<br />
-V     size_type find_last_not_of (const charT* s, size_type pos,<br />
-                                  size_type n) const;<br />
-V     size_type find_last_not_of (const charT* s,<br />
-                                  size_type pos = npos) const;<br />
-V     size_type find_last_not_of (charT c, size_type pos = npos) const;<br />
-V     basic_string substr(size_type pos = 0, size_type n = npos) const;<br />
-V     int compare(const basic_string&amp; str) const;<br />
-V     int compare(size_type pos1, size_type n1,<br />
-                  const basic_string&amp; str) const;<br />
-V     int compare(size_type pos1, size_type n1,<br />
-                  const basic_string&amp; str,<br />
-                  size_type pos2, size_type n2) const;<br />
-V     int compare(const charT* s) const;<br />
-V     int compare(size_type pos1, size_type n1,<br />
-                  const charT* s, size_type n2 = npos) const;<br />
-    };<br />
-   }<br />
-<br />
-   21.4  Null-terminated sequence utilities               [lib.c.strings]<br />
-<br />
-                    Table 10--Header &lt;cctype&gt; synopsis<br />
-<br />
-            isalnum   isdigit   isprint   isupper    tolower<br />
-X           isalpha   isgraph   ispunct   isxdigit   toupper<br />
-            iscntrl   islower   isspace<br />
-<br />
-                   Table 11--Header &lt;cwctype&gt; synopsis<br />
-<br />
-X  Macro:     WEOF &lt;cwctype&gt;<br />
-X  Types:     wctrans_t   wctype_t   wint_t &lt;cwctype&gt;<br />
-   Functions:<br />
-X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans<br />
-X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype<br />
-X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper<br />
-<br />
-                   Table 12--Header &lt;cstring&gt; synopsis<br />
-<br />
-X           Macro:    NULL &lt;cstring&gt;<br />
-X           Type:     size_t &lt;cstring&gt;<br />
-            Functions:<br />
-X           memchr    strcat    strcspn    strncpy   strtok<br />
-X           memcmp    strchr    strerror   strpbrk   strxfrm<br />
-X           memcpy    strcmp    strlen     strrchr<br />
-X           memmove   strcoll   strncat    strspn<br />
-X           memset    strcpy    strncmp    strstr<br />
-<br />
-                    Table 13--Header &lt;cwchar&gt; synopsis<br />
-   Macros:    NULL &lt;cwchar&gt;   WCHAR_MAX         WCHAR_MIN   WEOF &lt;cwchar&gt;<br />
-   Types:     mbstate_t       wint_t &lt;cwchar&gt;   size_t<br />
-   Functions:<br />
-X  btowc      getwchar        ungetwc           wcscpy      wcsrtombs   wmemchr<br />
-X  fgetwc     mbrlen          vfwprintf         wcscspn     wcsspn      wmemcmp<br />
-X  fgetws     mbrtowc         vswprintf         wcsftime    wcsstr      wmemcpy<br />
-X  fputwc     mbsinit         vwprintf          wcslen      wcstod      wmemmove<br />
-X  fputws     mbsrtowcs       wcrtomb           wcsncat     wcstok      wmemset<br />
-X  fwide      putwc           wcscat            wcsncmp     wcstol      wprintf<br />
-X  fwprintf   putwchar        wcschr            wcsncpy     wcstoul     wscanf<br />
-X  fwscanf    swprintf        wcscmp            wcspbrk     wcsxfrm<br />
-X  getwc      swscanf         wcscoll           wcsrchr     wctob<br />
-<br />
-                   Table 14--Header &lt;cstdlib&gt; synopsis<br />
-<br />
-               Macros:   MB_CUR_MAX<br />
-               Functions:<br />
-X              atol      mblen        strtod    wctomb<br />
-X              atof      mbstowcs     strtol    wcstombs<br />
-X              atoi      mbtowc       strtoul<br />
-<br />
-X  const char* strchr(const char* s, int c);<br />
-X       char* strchr(      char* s, int c);<br />
-<br />
-X  const char* strpbrk(const char* s1, const char* s2);<br />
-X       char* strpbrk(      char* s1, const char* s2);<br />
-<br />
-X  const char* strrchr(const char* s, int c);<br />
-X       char* strrchr(      char* s, int c);<br />
-<br />
-X  const char* strstr(const char* s1, const char* s2);<br />
-X       char* strstr(      char* s1, const char* s2);<br />
-<br />
-X  const void* memchr(const void* s, int c, size_t n);<br />
-X       void* memchr(      void* s, int c, size_t n);<br />
-<br />
-X  const wchar_t* wcschr(const wchar_t* s, wchar_t c);<br />
-X       wchar_t* wcschr(      wchar_t* s, wchar_t c);<br />
-<br />
-X  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);<br />
-X       wchar_t* wcspbrk(      wchar_t* s1, const wchar_t* s2);<br />
-<br />
-X  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);<br />
-X       wchar_t* wcsrchr(      wchar_t* s, wchar_t c);<br />
-<br />
-X  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);<br />
-X       wchar_t* wcsstr(      wchar_t* s1, const wchar_t* s2);<br />
-<br />
-X  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);<br />
-X       wchar_t* wmemchr(      wchar_t* s, wchar_t c, size_t n);<br />
-<br />
-   [for initial efforts on the above, see shadow/string.h]<br />
-<br />
-   22.1  Locales                                            [lib.locales]<br />
-<br />
-   Header &lt;locale&gt; synopsis<br />
-<br />
-    // _lib.locale_, locale:<br />
-T   class locale;<br />
-T   template &lt;class Facet&gt; const Facet&amp; use_facet(const locale&amp;);<br />
-T   template &lt;class Facet&gt; bool         has_facet(const locale&amp;) throw();<br />
-<br />
-    // _lib.locale.convenience_, convenience interfaces:<br />
-T   template &lt;class charT&gt; bool isspace (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isprint (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool iscntrl (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isupper (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool islower (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isalpha (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isdigit (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool ispunct (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isxdigit(charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isalnum (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; charT toupper(charT c, const locale&amp; loc);<br />
-T   template &lt;class charT&gt; charT tolower(charT c, const locale&amp; loc);<br />
-    // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:<br />
-    class ctype_base;<br />
-T   template &lt;class charT&gt; class ctype;<br />
-T   template &lt;&gt;            class ctype&lt;char&gt;;             // specialization<br />
-S   template &lt;class charT&gt; class ctype_byname;<br />
-S   template &lt;&gt;            class ctype_byname&lt;char&gt;;      // specialization<br />
-T   class codecvt_base;<br />
-X   template &lt;class internT, class externT, class stateT&gt; class codecvt;<br />
-S   template &lt;class internT, class externT, class stateT&gt; class codecvt_byname;<br />
-    // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:<br />
-X   template &lt;class charT, class InputIterator&gt;  class num_get;<br />
-X   template &lt;class charT, class OutputIterator&gt; class num_put;<br />
-T   template &lt;class charT&gt; class numpunct;<br />
-S   template &lt;class charT&gt; class numpunct_byname;<br />
-    // _lib.category.collate_, collation:<br />
-T   template &lt;class charT&gt; class collate;<br />
-S   template &lt;class charT&gt; class collate_byname;<br />
-    // _lib.category.time_, date and time:<br />
-T   class time_base;<br />
-S   template &lt;class charT, class InputIterator&gt;  class time_get;<br />
-S   template &lt;class charT, class InputIterator&gt;  class time_get_byname;<br />
-S   template &lt;class charT, class OutputIterator&gt; class time_put;<br />
-S   template &lt;class charT, class OutputIterator&gt; class time_put_byname;<br />
-    // _lib.category.monetary_, money:<br />
-T   class money_base;<br />
-S   template &lt;class charT, class InputIterator&gt;  class money_get;<br />
-S   template &lt;class charT, class OutputIterator&gt; class money_put;<br />
-S   template &lt;class charT, bool Intl&gt; class moneypunct;<br />
-S   template &lt;class charT, bool Intl&gt; class moneypunct_byname;<br />
-    // _lib.category.messages_, message retrieval:<br />
-T   class messages_base;<br />
-S   template &lt;class charT&gt; class messages;<br />
-S   template &lt;class charT&gt; class messages_byname;<br />
-<br />
-<br />
-   22.1.1  Class locale                                      [lib.locale]<br />
-<br />
-X   class locale {<br />
-    public:<br />
-      // types:<br />
-T     class facet;<br />
-T     class id;<br />
-T     typedef int category;<br />
-T     static const category   // values assigned here are for exposition only<br />
-T       none     = 0,<br />
-T       collate  = 0x010, ctype    = 0x020,<br />
-T       monetary = 0x040, numeric  = 0x080,<br />
-T       time     = 0x100, messages = 0x200,<br />
-T       all = collate | ctype | monetary | numeric | time  | messages;<br />
-      // construct/copy/destroy:<br />
-T     locale() throw()<br />
-T     locale(const locale&amp; other) throw()<br />
-X     explicit locale(const char* std_name);<br />
-X     locale(const locale&amp; other, const char* std_name, category);<br />
-T     template &lt;class Facet&gt; locale(const locale&amp; other, Facet* f);<br />
-T     locale(const locale&amp; other, const locale&amp; one, category);<br />
-T    ~locale() throw();           // non-virtual<br />
-T     const locale&amp; operator=(const locale&amp; other) throw();<br />
-T     template &lt;class Facet&gt; locale combine(const locale&amp; other) const;<br />
-      // locale operations:<br />
-X     basic_string&lt;char&gt;                  name() const;<br />
-T     bool operator==(const locale&amp; other) const;<br />
-T     bool operator!=(const locale&amp; other) const;<br />
-T     template &lt;class charT, class Traits, class Allocator&gt;<br />
-        bool operator()(const basic_string&lt;charT,Traits,Allocator&gt;&amp; s1,<br />
-                        const basic_string&lt;charT,Traits,Allocator&gt;&amp; s2) const;<br />
-      // global locale objects:<br />
-T     static       locale  global(const locale&amp;);<br />
-T     static const locale&amp; classic();<br />
-    };<br />
-<br />
-   22.1.1.1  locale types                              [lib.locale.types]<br />
-<br />
-   22.1.1.1.1  Type locale::category                [lib.locale.category]<br />
-<br />
-T  typedef int category;<br />
-<br />
-T   none, collate, ctype, monetary, numeric, time, and messages<br />
-<br />
-      [required locale members]<br />
-T     collate&lt;char&gt;, collate&lt;wchar_t&gt;<br />
-T     ctype&lt;char&gt;, ctype&lt;wchar_t&gt;<br />
-T     codecvt&lt;char,char,mbstate_t&gt;,<br />
-S     codecvt&lt;wchar_t,char,mbstate_t&gt;<br />
-T     moneypunct&lt;char&gt;, moneypunct&lt;wchar_t&gt;<br />
-T     moneypunct&lt;char,true&gt;, moneypunct&lt;wchar_t,true&gt;,<br />
-S     money_get&lt;char&gt;, money_get&lt;wchar_t<br />
-S     money_put&lt;char&gt;, money_put&lt;wchar_t&gt;<br />
-T     numpunct&lt;char&gt;, numpunct&lt;wchar_t&gt;,<br />
-X     num_get&lt;char&gt;, num_get&lt;wchar_t&gt;<br />
-X     num_put&lt;char&gt;, num_put&lt;wchar_t&gt;<br />
-S     time_get&lt;char&gt;, time_get&lt;wchar_t&gt;,<br />
-S     time_put&lt;char&gt;, time_put&lt;wchar_t&gt;<br />
-S     messages&lt;char&gt;, messages&lt;wchar_t&gt;<br />
-<br />
-      [required instantiations]<br />
-S    collate_byname&lt;char&gt;, collate_byname&lt;wchar_t&gt;<br />
-S    ctype_byname&lt;char&gt;, ctype_byname&lt;wchar_t&gt;<br />
-S    codecvt_byname&lt;char,char,mbstate_t&gt;,<br />
-S    codecvt_byname&lt;wchar_t,char,mbstate_t&gt;<br />
-S    moneypunct_byname&lt;char,International&gt;,<br />
-S    moneypunct_byname&lt;wchar_t,International&gt;,<br />
-S    money_get&lt;C,InputIterator&gt;,<br />
-S    money_put&lt;C,OutputIterator&gt;<br />
-S    numpunct_byname&lt;char&gt;, numpunct_byname&lt;wchar_t&gt;<br />
-X    num_get&lt;C,InputIterator&gt;, num_put&lt;C,OutputIterator&gt;<br />
-S    time_get&lt;char,InputIterator&gt;,<br />
-S    time_get_byname&lt;char,InputIterator&gt;,<br />
-S    time_get&lt;wchar_t,OutputIterator&gt;,<br />
-S    time_get_byname&lt;wchar_t,OutputIterator&gt;,<br />
-S    time_put&lt;char,OutputIterator&gt;,<br />
-S    time_put_byname&lt;char,OutputIterator&gt;,<br />
-S    time_put&lt;wchar_t,OutputIterator&gt;<br />
-S    time_put_byname&lt;wchar_t,OutputIterator&gt;<br />
-S    messages_byname&lt;char&gt;, messages_byname&lt;wchar_t&gt;<br />
-<br />
-<br />
-   22.1.1.1.2  Class locale::facet                     [lib.locale.facet]<br />
-<br />
-T   class locale::facet {<br />
-    protected:<br />
-T     explicit facet(size_t refs = 0);<br />
-T     virtual ~facet();<br />
-    private:<br />
-T     facet(const facet&amp;);                // not defined<br />
-T     void operator=(const facet&amp;);       // not defined<br />
-    };<br />
-   }<br />
-<br />
-<br />
-   22.1.1.1.3  Class locale::id                           [lib.locale.id]<br />
-<br />
-T   class locale::id {<br />
-    public:<br />
-T     id();<br />
-    private:<br />
-T     void operator=(const id&amp;);  // not defined<br />
-T     id(const id&amp;);              // not defined<br />
-    };<br />
-   }<br />
-<br />
-<br />
-   22.2.1  The ctype category                        [lib.category.ctype]<br />
-<br />
-T   class ctype_base {<br />
-    public:<br />
-T     enum mask {         // numeric values are for exposition only.<br />
-T       space=, print=, cntrl=, upper=, lower=,<br />
-T       alpha=, digit=, punct=, xdigit=,<br />
-T       alnum=, graph=<br />
-      };<br />
-    };<br />
-<br />
-<br />
-   22.2.1.1  Template class ctype                      [lib.locale.ctype]<br />
-<br />
-T   template &lt;class charT&gt;<br />
-    class ctype : public locale::facet, public ctype_base {<br />
-    public:<br />
-T     typedef charT char_type;<br />
-T     explicit ctype(size_t refs = 0);<br />
-T     bool         is(mask m, charT c) const;<br />
-T     const charT* is(const charT* low, const charT* high, mask* vec) const;<br />
-T     const charT* scan_is(mask m,<br />
-                           const charT* low, const charT* high) const;<br />
-T     const charT* scan_not(mask m,<br />
-                            const charT* low, const charT* high) const;<br />
-T     charT        toupper(charT c) const;<br />
-T     const charT* toupper(charT* low, const charT* high) const;<br />
-T     charT        tolower(charT c) const;<br />
-T     const charT* tolower(charT* low, const charT* high) const;<br />
-T     charT        widen(char c) const;<br />
-T     const char*  widen(const char* low, const char* high, charT* to) const;<br />
-T     char         narrow(charT c, char dfault) const;<br />
-T     const charT* narrow(const charT* low, const charT*, char dfault,<br />
-                          char* to) const;<br />
-T     static locale::id id;<br />
-<br />
-    protected:<br />
-T    ~ctype();                    // virtual<br />
-T     virtual bool         do_is(mask m, charT c) const;<br />
-T     virtual const charT* do_is(const charT* low, const charT* high,<br />
-                                 mask* vec) const;<br />
-T     virtual const charT* do_scan_is(mask m,<br />
-                              const charT* low, const charT* high) const;<br />
-T     virtual const charT* do_scan_not(mask m,<br />
-                              const charT* low, const charT* high) const;<br />
-T     virtual charT        do_toupper(charT) const;<br />
-T     virtual const charT* do_toupper(charT* low, const charT* high) const;<br />
-T     virtual charT        do_tolower(charT) const;<br />
-T     virtual const charT* do_tolower(charT* low, const charT* high) const;<br />
-T     virtual charT        do_widen(char) const;<br />
-T     virtual const char*  do_widen(const char* low, const char* high,<br />
-                                    charT* dest) const;<br />
-T     virtual char         do_narrow(charT, char dfault) const;<br />
-T     virtual const charT* do_narrow(const charT* low, const charT* high,<br />
-                                     char dfault, char* dest) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.1.2  Template class ctype_byname        [lib.locale.ctype.byname]<br />
-<br />
-X   template &lt;class charT&gt;<br />
-    class ctype_byname : public ctype&lt;charT&gt; {<br />
-    public:<br />
-T     typedef ctype&lt;charT&gt;::mask mask;<br />
-S     explicit ctype_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-S    ~ctype_byname();             // virtual<br />
-S     virtual bool         do_is(mask m, charT c) const;<br />
-S     virtual const charT* do_is(const charT* low, const charT* high,<br />
-                                 mask* vec) const;<br />
-S     virtual const char*  do_scan_is(mask m,<br />
-                               const charT* low, const charT* high) const;<br />
-S     virtual const char*  do_scan_not(mask m,<br />
-                               const charT* low, const charT* high) const;<br />
-S     virtual charT        do_toupper(charT) const;<br />
-S     virtual const charT* do_toupper(charT* low, const charT* high) const;<br />
-S     virtual charT        do_tolower(charT) const;<br />
-S     virtual const charT* do_tolower(charT* low, const charT* high) const;<br />
-S     virtual charT        do_widen(char) const;<br />
-S     virtual const char*  do_widen(const char* low, const char* high,<br />
-                                    charT* dest) const;<br />
-S     virtual char         do_narrow(charT, char dfault) const;<br />
-S     virtual const charT* do_narrow(const charT* low, const charT* high,<br />
-                                     char dfault, char* dest) const;<br />
-    };<br />
-<br />
-   22.2.1.3  ctype specializations              [lib.facet.ctype.special]<br />
-<br />
-T   template &lt;&gt; class ctype&lt;char&gt;<br />
-      : public locale::facet, public ctype_base {<br />
-    public:<br />
-T     typedef char char_type;<br />
-T     explicit ctype(const mask* tab = 0, bool del = false,<br />
-                     size_t refs = 0);<br />
-T     bool is(mask m, char c) const;<br />
-T     const char* is(const char* low, const char* high, mask* vec) const;<br />
-T     const char* scan_is (mask m,<br />
-                           const char* low, const char* high) const;<br />
-T     const char* scan_not(mask m,<br />
-                           const char* low, const char* high) const;<br />
-T     char        toupper(char c) const;<br />
-T     const char* toupper(char* low, const char* high) const;<br />
-T     char        tolower(char c) const;<br />
-T     const char* tolower(char* low, const char* high) const;<br />
-T     char  widen(char c) const;<br />
-T     const char* widen(const char* low, const char* high, char* to) const;<br />
-T     char  narrow(char c, char dfault) const;<br />
-T     const char* narrow(const char* low, const char* high, char dfault,<br />
-                         char* to) const;<br />
-T     static locale::id id;<br />
-T     static const size_t table_size = IMPLEMENTATION_DEFINED;<br />
-<br />
-    protected:<br />
-T     const mask* table() const throw();<br />
-T     static const mask* classic_table() throw();<br />
-T    ~ctype();                    // virtual<br />
-T     virtual char        do_toupper(char c) const;<br />
-T     virtual const char* do_toupper(char* low, const char* high) const;<br />
-T     virtual char        do_tolower(char c) const;<br />
-T     virtual const char* do_tolower(char* low, const char* high) const;<br />
-<br />
-T     virtual char        do_widen(char c) const;<br />
-T     virtual const char* do_widen(const char* low,<br />
-                                   const char* high,<br />
-                                   char* to) const;<br />
-T     virtual char        do_narrow(char c, char dfault) const;<br />
-T     virtual const char* do_narrow(const char* low,<br />
-                                    const char* high,<br />
-                                    char dfault, char* to) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.1.4  Class                      [lib.locale.ctype.byname.special]<br />
-       ctype_byname&lt;char&gt;<br />
-<br />
-X   template &lt;&gt; class ctype_byname&lt;char&gt; : public ctype&lt;char&gt; {<br />
-    public:<br />
-S     explicit ctype_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-S    ~ctype_byname();             // virtual<br />
-S     virtual char        do_toupper(char c) const;<br />
-S     virtual const char* do_toupper(char* low, const char* high) const;<br />
-S     virtual char        do_tolower(char c) const;<br />
-S     virtual const char* do_tolower(char* low, const char* high) const;<br />
-<br />
-S     virtual char        do_widen(char c) const;<br />
-S     virtual const char* do_widen(char* low,<br />
-                                   const char* high,<br />
-                                   char* to) const;<br />
-S     virtual char        do_widen(char c) const;<br />
-S     virtual const char* do_widen(char* low, const char* high) const;<br />
-<br />
-    };<br />
-<br />
-<br />
-<br />
-   22.2.1.5  Template class codecvt                  [lib.locale.codecvt]<br />
-<br />
-T  class codecvt_base {<br />
-   public:<br />
-T   enum result { ok, partial, error, noconv };<br />
-   };<br />
-<br />
-T  template &lt;class internT, class externT, class stateT&gt;<br />
-   class codecvt : public locale::facet, public codecvt_base {<br />
-   public:<br />
-T   typedef internT  intern_type;<br />
-T   typedef externT  extern_type;<br />
-T   typedef stateT state_type;<br />
-T   explicit codecvt(size_t refs = 0)<br />
-T   result out(stateT&amp; state,<br />
-     const internT* from, const internT* from_end, const internT*&amp; from_next,<br />
-           externT*   to,       externT* to_limit, externT*&amp; to_next) const;<br />
-T   result unshift(stateT&amp; state,<br />
-           externT*   to,        externT* to_limit, externT*&amp; to_next) const;<br />
-T   result in(stateT&amp; state,<br />
-     const externT* from, const externT* from_end, const externT*&amp; from_next,<br />
-           internT*   to,       internT* to_limit, internT*&amp; to_next) const;<br />
-T   int encoding() const throw();<br />
-T   bool always_noconv() const throw();<br />
-T   int length(const stateT&amp;, const externT* from, const externT* end,<br />
-               size_t max) const;<br />
-T   int max_length() const throw();<br />
-T   static locale::id id;<br />
-<br />
-   protected:<br />
-T   ~codecvt();                   // virtual<br />
-T   virtual result do_out(stateT&amp; state,<br />
-     const internT* from, const internT* from_end, const internT*&amp; from_next,<br />
-           externT* to,         externT* to_limit, externT*&amp; to_next) const;<br />
-T   virtual result do_in(stateT&amp; state,<br />
-T    const externT* from, const externT* from_end, const externT*&amp; from_next,<br />
-           internT* to,         internT* to_limit, internT*&amp; to_next) const;<br />
-T   virtual result do_unshift(stateT&amp; state,<br />
-           externT* to,         externT* to_limit, externT*&amp; to_next) const;<br />
-T   virtual int do_encoding() const throw();<br />
-T   virtual bool do_always_noconv() const throw();<br />
-T   virtual int do_length(const stateT&amp;, const externT* from,<br />
-                          const externT* end, size_t max) const;<br />
-T   virtual int do_max_length() const throw();<br />
-   };<br />
-   }<br />
-<br />
-<br />
-   22.2.1.6  Template class                   [lib.locale.codecvt.byname]<br />
-       codecvt_byname<br />
-<br />
-X  template &lt;class internT, class externT, class stateT&gt;<br />
-   class codecvt_byname : public codecvt&lt;internT, externT, stateT&gt; {<br />
-   public:<br />
-S   explicit codecvt_byname(const char*, size_t refs = 0);<br />
-   protected:<br />
-S  ~codecvt_byname();             // virtual<br />
-S   virtual result do_out(stateT&amp; state,<br />
-      const internT* from, const internT* from_end, const internT*&amp; from_next,<br />
-            externT* to,         externT* to_limit, externT*&amp; to_next) const;<br />
-S   virtual result do_in(stateT&amp; state,<br />
-      const externT* from, const externT* from_end, const externT*&amp; from_next,<br />
-            internT* to,         internT* to_limit, internT*&amp; to_next) const;<br />
-S   virtual result do_unshift(stateT&amp; state,<br />
-            externT* to,         externT* to_limit, externT*&amp; to_next) const;<br />
-S   virtual int do_encoding() const throw();<br />
-S   virtual bool do_always_noconv() const throw();<br />
-S   virtual int do_length(const stateT&amp;, const externT* from,<br />
-                          const externT* end, size_t max) const;<br />
-S   virtual result do_unshift(stateT&amp; state,<br />
-           externT* to, externT* to_limit, externT*&amp; to_next) const;<br />
-S   virtual int do_max_length() const throw();<br />
-    };<br />
-<br />
-<br />
-   22.2.2.1  Template class num_get                  [lib.locale.num.get]<br />
-<br />
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;<br />
-    class num_get : public locale::facet {<br />
-    public:<br />
-T     typedef charT            char_type;<br />
-T     typedef InputIterator    iter_type;<br />
-T     explicit num_get(size_t refs = 0);<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, bool&amp; v)           const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp; ,<br />
-                    ios_base::iostate&amp; err, long&amp; v)           const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, unsigned short&amp; v) const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, unsigned int&amp; v)   const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, unsigned long&amp; v)  const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, float&amp; v)          const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, double&amp; v)         const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, long double&amp; v)    const;<br />
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,<br />
-                    ios_base::iostate&amp; err, void*&amp; v)          const;<br />
-T     static locale::id id;<br />
-<br />
-    protected:<br />
-T    ~num_get();                  // virtual<br />
-T     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, bool&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, long&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, unsigned short&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, unsigned int&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, unsigned long&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, float&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, double&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, long double&amp; v) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,<br />
-          ios_base::iostate&amp; err, void*&amp; v) const;<br />
-    };<br />
-<br />
-<br />
-<br />
-   22.2.2.2  Template class num_put                   [lib.locale.nm.put]<br />
-<br />
-X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;<br />
-    class num_put : public locale::facet {<br />
-    public:<br />
-T     typedef charT            char_type;<br />
-T     typedef OutputIterator   iter_type;<br />
-T     explicit num_put(size_t refs = 0);<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, bool v) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, long v) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,<br />
-                    unsigned long v) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,<br />
-                    double v) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,<br />
-                    long double v) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,<br />
-                    const void* v) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~num_put();                  // virtual<br />
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               bool v) const;<br />
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               long v) const;<br />
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               unsigned long) const;<br />
-S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               double v) const;<br />
-S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               long double v) const;<br />
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,<br />
-                               const void* v) const;<br />
-    };<br />
-   }<br />
-<br />
-   22.2.3.1  Template class numpunct                [lib.locale.numpunct]<br />
-<br />
-T   template &lt;class charT&gt;<br />
-    class numpunct : public locale::facet {<br />
-    public:<br />
-T     typedef charT               char_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit numpunct(size_t refs = 0);<br />
-T     char_type    decimal_point()   const;<br />
-T     char_type    thousands_sep()   const;<br />
-T     string       grouping()        const;<br />
-T     string_type  truename()        const;<br />
-T     string_type  falsename()       const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~numpunct();                 // virtual<br />
-T     virtual char_type    do_decimal_point() const;<br />
-T     virtual char_type    do_thousands_sep() const;<br />
-T     virtual string       do_grouping()      const;<br />
-T     virtual string_type  do_truename()      const;      // for bool<br />
-T     virtual string_type  do_falsename()     const;      // for bool<br />
-    };<br />
-   }<br />
-<br />
-<br />
-<br />
-   22.2.3.2  Template class                  [lib.locale.numpunct.byname]<br />
-       numpunct_byname<br />
-<br />
-X   template &lt;class charT&gt;<br />
-    class numpunct_byname : public numpunct&lt;charT&gt; {<br />
-   // this class is specialized for char and wchar_t.<br />
-    public:<br />
-T     typedef charT                char_type;<br />
-T     typedef basic_string&lt;charT&gt;  string_type;<br />
-S     explicit numpunct_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-S    ~numpunct_byname();          // virtual<br />
-S     virtual char_type    do_decimal_point() const;<br />
-S     virtual char_type    do_thousands_sep() const;<br />
-S     virtual string       do_grouping()      const;<br />
-S     virtual string_type  do_truename()      const;      // for bool<br />
-S     virtual string_type  do_falsename()     const;      // for bool<br />
-    };<br />
-<br />
-<br />
-   22.2.4.1  Template class collate                  [lib.locale.collate]<br />
-<br />
-T   template &lt;class charT&gt;<br />
-    class collate : public locale::facet {<br />
-    public:<br />
-T     typedef charT               char_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit collate(size_t refs = 0);<br />
-T     int compare(const charT* low1, const charT* high1,<br />
-                  const charT* low2, const charT* high2) const;<br />
-T     string_type transform(const charT* low, const charT* high) const;<br />
-T     long hash(const charT* low, const charT* high) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~collate();                  // virtual<br />
-T     virtual int    do_compare(const charT* low1, const charT* high1,<br />
-                                const charT* low2, const charT* high2) const;<br />
-T     virtual string_type do_transform<br />
-                               (const charT* low, const charT* high) const;<br />
-T     virtual long   do_hash   (const charT* low, const charT* high) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.4.2  Template class                   [lib.locale.collate.byname]<br />
-       collate_byname<br />
-<br />
-X   template &lt;class charT&gt;<br />
-    class collate_byname : public collate&lt;charT&gt; {<br />
-    public:<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit collate_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-S    ~collate_byname();           // virtual<br />
-S     virtual int    do_compare(const charT* low1, const charT* high1,<br />
-                                const charT* low2, const charT* high2) const;<br />
-S     virtual string_type do_transform<br />
-                               (const charT* low, const charT* high) const;<br />
-S     virtual long   do_hash   (const charT* low, const charT* high) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.5.1  Template class time_get                [lib.locale.time.get]<br />
-<br />
-T   class time_base {<br />
-    public:<br />
-T     enum dateorder { no_order, dmy, mdy, ymd, ydm };<br />
-    };<br />
-<br />
-    [Note: semantics of time_get members are implementation-defined.<br />
-     To complete implementation requires documenting behavior.]<br />
-<br />
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;<br />
-    class time_get : public locale::facet, public time_base {<br />
-    public:<br />
-T     typedef charT            char_type;<br />
-T     typedef InputIterator    iter_type;<br />
-T     explicit time_get(size_t refs = 0);<br />
-<br />
-T     dateorder date_order()  const { return do_date_order(); }<br />
-T     iter_type get_time(iter_type s, iter_type end, ios_base&amp; f,<br />
-                         ios_base::iostate&amp; err, tm* t)  const;<br />
-T     iter_type get_date(iter_type s, iter_type end, ios_base&amp; f,<br />
-                         ios_base::iostate&amp; err, tm* t)  const;<br />
-T     iter_type get_weekday(iter_type s, iter_type end, ios_base&amp; f,<br />
-                            ios_base::iostate&amp; err, tm* t) const;<br />
-T     iter_type get_monthname(iter_type s, iter_type end, ios_base&amp; f,<br />
-                              ios_base::iostate&amp; err, tm* t) const;<br />
-T     iter_type get_year(iter_type s, iter_type end, ios_base&amp; f,<br />
-                         ios_base::iostate&amp; err, tm* t) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-     ~time_get();                 // virtual<br />
-X     virtual dateorder do_date_order()  const;<br />
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,<br />
-                                       ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_monthname(iter_type s, ios_base&amp;,<br />
-                                         ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-    };<br />
-<br />
-<br />
-<br />
-   22.2.5.2  Template class                  [lib.locale.time.get.byname]<br />
-       time_get_byname<br />
-<br />
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;<br />
-    class time_get_byname : public time_get&lt;charT, InputIterator&gt; {<br />
-    public:<br />
-T     typedef time_base::dateorder dateorder;<br />
-T     typedef InputIterator        iter_type<br />
-<br />
-S     explicit time_get_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-S    ~time_get_byname();          // virtual<br />
-S     virtual dateorder do_date_order()  const;<br />
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-T     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,<br />
-                                       ios_base::iostate&amp; err, tm* t) const;<br />
-T     virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&amp;,<br />
-                                         ios_base::iostate&amp; err, tm* t) const;<br />
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,<br />
-                                    ios_base::iostate&amp; err, tm* t) const;<br />
-    };<br />
-   }<br />
-<br />
-   22.2.5.3  Template class time_put                [lib.locale.time.put]<br />
-<br />
-X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;<br />
-    class time_put : public locale::facet {<br />
-    public:<br />
-T     typedef charT            char_type;<br />
-T     typedef OutputIterator   iter_type;<br />
-T     explicit time_put(size_t refs = 0);<br />
-      // the following is implemented in terms of other member functions.<br />
-S     iter_type put(iter_type s, ios_base&amp; f, char_type fill, const tm* tmb,<br />
-                    const charT* pattern, const charT* pat_end) const;<br />
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,<br />
-                    const tm* tmb, char format, char modifier = 0) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~time_put();                 // virtual<br />
-S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,<br />
-                               char format, char modifier) const;<br />
-    };<br />
-<br />
-<br />
-<br />
-   22.2.5.4  Template class                  [lib.locale.time.put.byname]<br />
-       time_put_byname<br />
-<br />
-T   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;<br />
-    class time_put_byname : public time_put&lt;charT, OutputIterator&gt;<br />
-    {<br />
-    public:<br />
-T     typedef charT          char_type;<br />
-T     typedef OutputIterator iter_type;<br />
-<br />
-T     explicit time_put_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-T    ~time_put_byname();          // virtual<br />
-S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,<br />
-                               char format, char modifier) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.6.1  Template class money_get              [lib.locale.money.get]<br />
-<br />
-X   template &lt;class charT,<br />
-              class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;<br />
-    class money_get : public locale::facet {<br />
-    public:<br />
-T     typedef charT               char_type;<br />
-T     typedef InputIterator       iter_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit money_get(size_t refs = 0);<br />
-T     iter_type get(iter_type s, iter_type end, bool intl,<br />
-                    ios_base&amp; f, ios_base::iostate&amp; err,<br />
-                    long double&amp; units) const;<br />
-T     iter_type get(iter_type s, iter_type end, bool intl,<br />
-                    ios_base&amp; f, ios_base::iostate&amp; err,<br />
-                    string_type&amp; digits) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~money_get();                // virtual<br />
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,<br />
-                       ios_base::iostate&amp; err, long double&amp; units) const;<br />
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,<br />
-                       ios_base::iostate&amp; err, string_type&amp; digits) const;<br />
-    };<br />
-<br />
-   22.2.6.2  Template class money_put              [lib.locale.money.put]<br />
-<br />
-X   template &lt;class charT,<br />
-              class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;<br />
-    class money_put : public locale::facet {<br />
-    public:<br />
-T     typedef charT               char_type;<br />
-T     typedef OutputIterator      iter_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit money_put(size_t refs = 0);<br />
-T     iter_type put(iter_type s, bool intl, ios_base&amp; f,<br />
-                    char_type fill, long double units) const;<br />
-T     iter_type put(iter_type s, bool intl, ios_base&amp; f,<br />
-                    char_type fill, const string_type&amp; digits) const;<br />
-T     static locale::id id;<br />
-<br />
-    protected:<br />
-T    ~money_put();                // virtual<br />
-S     virtual iter_type<br />
-        do_put(iter_type, bool, ios_base&amp;, char_type fill,<br />
-               long double units) const;<br />
-S     virtual iter_type<br />
-        do_put(iter_type, bool, ios_base&amp;, char_type fill,<br />
-               const string_type&amp; digits) const;<br />
-    };<br />
-<br />
-<br />
-   22.2.6.3  Template class moneypunct            [lib.locale.moneypunct]<br />
-<br />
-T   class money_base {<br />
-    public:<br />
-T     enum part { none, space, symbol, sign, value };<br />
-T     struct pattern { char field[4]; };<br />
-    };<br />
-<br />
-X   template &lt;class charT, bool International = false&gt;<br />
-    class moneypunct : public locale::facet, public money_base {<br />
-    public:<br />
-T     typedef charT char_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit moneypunct(size_t refs = 0);<br />
-T     charT        decimal_point() const;<br />
-T     charT        thousands_sep() const;<br />
-T     string       grouping()      const;<br />
-T     string_type  curr_symbol()   const;<br />
-T     string_type  positive_sign() const;<br />
-T     string_type  negative_sign() const;<br />
-T     int          frac_digits()   const;<br />
-T     pattern      pos_format()    const;<br />
-T     pattern      neg_format()    const;<br />
-T     static locale::id id;<br />
-T     static const bool intl = International;<br />
-    protected:<br />
-T    ~moneypunct();               // virtual<br />
-S     virtual charT        do_decimal_point() const;<br />
-S     virtual charT        do_thousands_sep() const;<br />
-S     virtual string       do_grouping()      const;<br />
-S     virtual string_type  do_curr_symbol()   const;<br />
-S     virtual string_type  do_positive_sign() const;<br />
-S     virtual string_type  do_negative_sign() const;<br />
-S     virtual int          do_frac_digits()   const;<br />
-T     virtual pattern      do_pos_format()    const;<br />
-T     virtual pattern      do_neg_format()    const;<br />
-    };<br />
-   }<br />
-<br />
-   22.2.6.4  Template class                [lib.locale.moneypunct.byname]<br />
-       moneypunct_byname<br />
-<br />
-X   template &lt;class charT, bool Intl = false&gt;<br />
-    class moneypunct_byname : public moneypunct&lt;charT, Intl&gt; {<br />
-    public:<br />
-T     typedef money_base::pattern pattern;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-<br />
-T     explicit moneypunct_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-T    ~moneypunct_byname();        // virtual<br />
-S     virtual charT        do_decimal_point() const;<br />
-S     virtual charT        do_thousands_sep() const;<br />
-S     virtual string       do_grouping()      const;<br />
-S     virtual string_type  do_curr_symbol()   const;<br />
-S     virtual string_type  do_positive_sign() const;<br />
-S     virtual string_type  do_negative_sign() const;<br />
-S     virtual int          do_frac_digits()   const;<br />
-S     virtual pattern      do_pos_format()    const;<br />
-S     virtual pattern      do_neg_format()    const;<br />
-    };<br />
-<br />
-   22.2.7.1  Template class messages                [lib.locale.messages]<br />
-<br />
-T   class messages_base {<br />
-    public:<br />
-T     typedef int catalog;<br />
-    };<br />
-<br />
-X   template &lt;class charT&gt;<br />
-    class messages : public locale::facet, public messages_base {<br />
-    public:<br />
-T     typedef charT char_type;<br />
-T     typedef basic_string&lt;charT&gt; string_type;<br />
-T     explicit messages(size_t refs = 0);<br />
-T     catalog open(const basic_string&lt;char&gt;&amp; fn, const locale&amp;) const;<br />
-T     string_type  get(catalog c, int set, int msgid,<br />
-                       const string_type&amp; dfault) const;<br />
-T     void    close(catalog c) const;<br />
-T     static locale::id id;<br />
-    protected:<br />
-T    ~messages();                 // virtual<br />
-S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;<br />
-S     virtual string_type  do_get(catalog, int set, int msgid,<br />
-                             const string_type&amp; dfault) const;<br />
-S     virtual void    do_close(catalog) const;<br />
-    };<br />
-<br />
-   22.2.7.2  Template class                  [lib.locale.messages.byname]<br />
-       messages_byname<br />
-<br />
-<br />
-X   template &lt;class charT&gt;<br />
-    class messages_byname : public messages&lt;charT&gt; {<br />
-    public:<br />
-T     typedef messages_base::catalog catalog;<br />
-T     typedef basic_string&lt;charT&gt;    string_type;<br />
-<br />
-T     explicit messages_byname(const char*, size_t refs = 0);<br />
-    protected:<br />
-T    ~messages_byname();          // virtual<br />
-S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;<br />
-S     virtual string_type  do_get(catalog, int set, int msgid,<br />
-                             const string_type&amp; dfault) const;<br />
-S     virtual void    do_close(catalog) const;<br />
-    };<br />
-<br />
-<br />
-   22.3  C Library Locales                                [lib.c.locales]<br />
-<br />
-<br />
-                   Table 13--Header &lt;clocale&gt; synopsis<br />
-            Macros:<br />
-X                        LC_ALL        LC_COLLATE   LC_CTYPE<br />
-X                        LC_MONETARY   LC_NUMERIC   LC_TIME<br />
-X                        NULL<br />
-X           Struct:      lconv<br />
-X           Functions:   localeconv    setlocale<br />
-<br />
-<br />
-   23.2  Sequences                                        [lib.sequences]<br />
-<br />
-   &lt;deque&gt;, &lt;list&gt;, &lt;queue&gt;, &lt;stack&gt;, and &lt;vector&gt;.<br />
-<br />
-   Header &lt;deque&gt; synopsis<br />
-<br />
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class deque;<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);<br />
-   }<br />
-<br />
-   Header &lt;list&gt; synopsis<br />
-<br />
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class list;<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);<br />
-   }<br />
-<br />
-   Header &lt;queue&gt; synopsis<br />
-<br />
-   namespace std {<br />
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class queue;<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator==(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator!=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container = vector&lt;T&gt;,<br />
-              class Compare = less&lt;typename Container::value_type&gt; &gt;<br />
-T   class priority_queue;<br />
-   }<br />
-<br />
-   Header &lt;stack&gt; synopsis<br />
-<br />
-   namespace std {<br />
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class stack;<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator==(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator!=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-   }<br />
-<br />
-   Header &lt;vector&gt; synopsis<br />
-<br />
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class vector;<br />
-<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);<br />
-<br />
-T   template &lt;class Allocator&gt; class vector&lt;bool,Allocator&gt;;<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);<br />
-   }<br />
-<br />
-   23.2.1  Template class deque                               [lib.deque]<br />
-<br />
-    template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;<br />
-T   class deque {<br />
-    public:<br />
-      // types:<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef T                                     value_type;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-      // _lib.deque.cons_ construct/copy/destroy:<br />
-T     explicit deque(const Allocator&amp; = Allocator());<br />
-T     explicit deque(size_type n, const T&amp; value = T(),<br />
-          const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        deque(InputIterator first, InputIterator last,<br />
-              const Allocator&amp; = Allocator());<br />
-T     deque(const deque&lt;T,Allocator&gt;&amp; x);<br />
-T    ~deque();<br />
-T     deque&lt;T,Allocator&gt;&amp; operator=(const deque&lt;T,Allocator&gt;&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void assign(InputIterator first, InputIterator last);<br />
-T     void assign(size_type n, const T&amp; t);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // _lib.deque.capacity_ capacity:<br />
-T     size_type size() const;<br />
-T     size_type max_size() const;<br />
-T     void      resize(size_type sz, T c = T());<br />
-T     bool      empty() const;<br />
-<br />
-      // element access:<br />
-T     reference       operator[](size_type n);<br />
-T     const_reference operator[](size_type n) const;<br />
-T     reference       at(size_type n);<br />
-T     const_reference at(size_type n) const;<br />
-T     reference       front();<br />
-T     const_reference front() const;<br />
-T     reference       back();<br />
-T     const_reference back() const;<br />
-      // _lib.deque.modifiers_ modifiers:<br />
-T     void push_front(const T&amp; x);<br />
-T     void push_back(const T&amp; x);<br />
-T     iterator insert(iterator position, const T&amp; x);<br />
-T     void     insert(iterator position, size_type n, const T&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void insert (iterator position,<br />
-                     InputIterator first, InputIterator last);<br />
-T     void pop_front();<br />
-T     void pop_back();<br />
-T     iterator erase(iterator position);<br />
-T     iterator erase(iterator first, iterator last);<br />
-T     void     swap(deque&lt;T,Allocator&gt;&amp;);<br />
-T     void     clear();<br />
-    };<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x,<br />
-                      const deque&lt;T,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);<br />
-<br />
-<br />
-   23.2.2  Template class list                                 [lib.list]<br />
-<br />
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;<br />
-    class list {<br />
-    public:<br />
-      // types:<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef T                                     value_type;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-<br />
-      // _lib.list.cons_ construct/copy/destroy:<br />
-T     explicit list(const Allocator&amp; = Allocator());<br />
-T     explicit list(size_type n, const T&amp; value = T(),<br />
-                    const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        list(InputIterator first, InputIterator last,<br />
-             const Allocator&amp; = Allocator());<br />
-T     list(const list&lt;T,Allocator&gt;&amp; x);<br />
-T    ~list();<br />
-T     list&lt;T,Allocator&gt;&amp; operator=(const list&lt;T,Allocator&gt;&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void assign(InputIterator first, InputIterator last);<br />
-T     void assign(size_type n, const T&amp; t);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // _lib.list.capacity_ capacity:<br />
-T     bool      empty() const;<br />
-T     size_type size() const;<br />
-T     size_type max_size() const;<br />
-T     void      resize(size_type sz, T c = T());<br />
-      // element access:<br />
-T     reference       front();<br />
-T     const_reference front() const;<br />
-T     reference       back();<br />
-T     const_reference back() const;<br />
-      // _lib.list.modifiers_ modifiers:<br />
-T     void push_front(const T&amp; x);<br />
-T     void pop_front();<br />
-T     void push_back(const T&amp; x);<br />
-T     void pop_back();<br />
-T     iterator insert(iterator position, const T&amp; x);<br />
-T     void     insert(iterator position, size_type n, const T&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void insert(iterator position, InputIterator first,<br />
-                    InputIterator last);<br />
-T     iterator erase(iterator position);<br />
-T     iterator erase(iterator position, iterator last);<br />
-T     void     swap(list&lt;T,Allocator&gt;&amp;);<br />
-T     void     clear();<br />
-      // _lib.list.ops_ list operations:<br />
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x);<br />
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator i);<br />
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator first,<br />
-                  iterator last);<br />
-T     void remove(const T&amp; value);<br />
-T     template &lt;class Predicate&gt; void remove_if(Predicate pred);<br />
-<br />
-T     void unique();<br />
-T     template &lt;class BinaryPredicate&gt;<br />
-        void unique(BinaryPredicate binary_pred);<br />
-T     void merge(list&lt;T,Allocator&gt;&amp; x);<br />
-T     template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);<br />
-        void sort();<br />
-T     template &lt;class Compare&gt; void sort(Compare comp);<br />
-        void reverse();<br />
-    };<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);<br />
-<br />
-<br />
-   23.2.3.1  Template class queue                             [lib.queue]<br />
-<br />
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt;<br />
-    class queue {<br />
-    public:<br />
-T     typedef typename Container::value_type            value_type;<br />
-T     typedef typename Container::size_type             size_type;<br />
-T     typedef          Container                        container_type;<br />
-    protected:<br />
-T     Container c;<br />
-    public:<br />
-T     explicit queue(const Container&amp; = Container());<br />
-<br />
-T     bool      empty() const             { return c.empty(); }<br />
-T     size_type size()  const             { return c.size(); }<br />
-T     value_type&amp;       front()           { return c.front(); }<br />
-T     const value_type&amp; front() const     { return c.front(); }<br />
-T     value_type&amp;       back()            { return c.back(); }<br />
-T     const value_type&amp; back() const      { return c.back(); }<br />
-T     void push(const value_type&amp; x)      { c.push_back(x); }<br />
-T     void pop()                          { c.pop_front(); }<br />
-    };<br />
-<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator==(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator!=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,<br />
-                      const queue&lt;T, Container&gt;&amp; y);<br />
-<br />
-   23.2.3.2  Template class priority_queue           [lib.priority.queue]<br />
-<br />
-T   template &lt;class T, class Container = vector&lt;T&gt;,<br />
-              class Compare = less&lt;typename Container::value_type&gt; &gt;<br />
-    class priority_queue {<br />
-    public:<br />
-T     typedef typename Container::value_type            value_type;<br />
-T     typedef typename Container::size_type             size_type;<br />
-T     typedef          Container                        container_type;<br />
-    protected:<br />
-T     Container c;<br />
-T     Compare comp;<br />
-    public:<br />
-T     explicit priority_queue(const Compare&amp; x = Compare(),<br />
-                              const Container&amp; = Container());<br />
-T     template &lt;class InputIterator&gt;<br />
-        priority_queue(InputIterator first, InputIterator last,<br />
-                       const Compare&amp; x = Compare(),<br />
-                       const Container&amp; = Container());<br />
-<br />
-T     bool      empty() const       { return c.empty(); }<br />
-T     size_type size()  const       { return c.size(); }<br />
-T     const value_type&amp; top() const { return c.front(); }<br />
-T     void push(const value_type&amp; x);<br />
-T     void pop();<br />
-    };<br />
-<br />
-   23.2.3.3  Template class stack                             [lib.stack]<br />
-<br />
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt;<br />
-    class stack {<br />
-    public:<br />
-T     typedef typename Container::value_type            value_type;<br />
-T     typedef typename Container::size_type             size_type;<br />
-T     typedef          Container                        container_type;<br />
-    protected:<br />
-T     Container c;<br />
-    public:<br />
-T     explicit stack(const Container&amp; = Container());<br />
-<br />
-T     bool      empty() const             { return c.empty(); }<br />
-T     size_type size()  const             { return c.size(); }<br />
-T     value_type&amp;       top()             { return c.back(); }<br />
-T     const value_type&amp; top() const       { return c.back(); }<br />
-T     void push(const value_type&amp; x)      { c.push_back(x); }<br />
-T     void pop()                          { c.pop_back(); }<br />
-    };<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator==(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator!=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-T   template &lt;class T, class Container&gt;<br />
-      bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,<br />
-                      const stack&lt;T, Container&gt;&amp; y);<br />
-<br />
-   23.2.4  Template class vector                             [lib.vector]<br />
-<br />
-    template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;<br />
-T   class vector {<br />
-    public:<br />
-      // types:<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef T                                     value_type;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-      // _lib.vector.cons_ construct/copy/destroy:<br />
-T     explicit vector(const Allocator&amp; = Allocator());<br />
-T     explicit vector(size_type n, const T&amp; value = T(),<br />
-          const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        vector(InputIterator first, InputIterator last,<br />
-          const Allocator&amp; = Allocator());<br />
-T     vector(const vector&lt;T,Allocator&gt;&amp; x);<br />
-T    ~vector();<br />
-T     vector&lt;T,Allocator&gt;&amp; operator=(const vector&lt;T,Allocator&gt;&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void assign(InputIterator first, InputIterator last);<br />
-T     void assign(size_type n, const T&amp; u);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // _lib.vector.capacity_ capacity:<br />
-T     size_type size() const;<br />
-T     size_type max_size() const;<br />
-T     void      resize(size_type sz, T c = T());<br />
-T     size_type capacity() const;<br />
-T     bool      empty() const;<br />
-T     void      reserve(size_type n);<br />
-<br />
-      // element access:<br />
-T     reference       operator[](size_type n);<br />
-T     const_reference operator[](size_type n) const;<br />
-T     const_reference at(size_type n) const;<br />
-T     reference       at(size_type n);<br />
-T     reference       front();<br />
-T     const_reference front() const;<br />
-T     reference       back();<br />
-T     const_reference back() const;<br />
-      // _lib.vector.modifiers_ modifiers:<br />
-T     void push_back(const T&amp; x);<br />
-T     void pop_back();<br />
-T     iterator insert(iterator position, const T&amp; x);<br />
-T     void     insert(iterator position, size_type n, const T&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-          void insert(iterator position,<br />
-                      InputIterator first, InputIterator last);<br />
-T     iterator erase(iterator position);<br />
-T     iterator erase(iterator first, iterator last);<br />
-T     void     swap(vector&lt;T,Allocator&gt;&amp;);<br />
-T     void     clear();<br />
-    };<br />
-<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator==(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,<br />
-                      const vector&lt;T,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class T, class Allocator&gt;<br />
-      void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);<br />
-<br />
-<br />
-   23.2.5  Class vector&lt;bool&gt;                           [lib.vector.bool]<br />
-<br />
-T   template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {<br />
-    public:<br />
-      // types:<br />
-T     typedef bool                                  const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef bool                                  value_type;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef implementation defined                pointer;<br />
-T     typedef implementation defined                const_pointer<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-      // bit reference:<br />
-T     class reference {<br />
-       friend class vector;<br />
-T      reference();<br />
-      public:<br />
-T      ~reference();<br />
-T       operator bool() const;<br />
-T       reference&amp; operator=(const bool x);<br />
-T       reference&amp; operator=(const reference&amp; x);<br />
-T       void flip();              // flips the bit<br />
-      };<br />
-<br />
-      // construct/copy/destroy:<br />
-T     explicit vector(const Allocator&amp; = Allocator());<br />
-T     explicit vector(size_type n, const bool&amp; value = bool(),<br />
-                      const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        vector(InputIterator first, InputIterator last,<br />
-          const Allocator&amp; = Allocator());<br />
-T     vector(const vector&lt;bool,Allocator&gt;&amp; x);<br />
-T    ~vector();<br />
-T     vector&lt;bool,Allocator&gt;&amp; operator=(const vector&lt;bool,Allocator&gt;&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void assign(InputIterator first, InputIterator last);<br />
-T     void assign(size_type n, const T&amp; t);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // capacity:<br />
-T     size_type size() const;<br />
-T     size_type max_size() const;<br />
-T     void      resize(size_type sz, bool c = false);<br />
-T     size_type capacity() const;<br />
-T     bool      empty() const;<br />
-T     void      reserve(size_type n);<br />
-      // element access:<br />
-T     reference       operator[](size_type n);<br />
-T     const_reference operator[](size_type n) const;<br />
-T     const_reference at(size_type n) const;<br />
-T     reference       at(size_type n);<br />
-T     reference       front();<br />
-T     const_reference front() const;<br />
-T     reference       back();<br />
-T     const_reference back() const;<br />
-      // modifiers:<br />
-T     void push_back(const bool&amp; x);<br />
-T     void pop_back();<br />
-T     iterator insert(iterator position, const bool&amp; x);<br />
-T     void     insert (iterator position, size_type n, const bool&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-          void insert(iterator position,<br />
-                      InputIterator first, InputIterator last);<br />
-T     iterator erase(iterator position);<br />
-T     iterator erase(iterator first, iterator last);<br />
-T     void swap(vector&lt;bool,Allocator&gt;&amp;);<br />
-T     static void swap(reference x, reference y);<br />
-T     void flip();                // flips all bits<br />
-T     void clear();<br />
-    };<br />
-<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-T   template &lt;class Allocator&gt;<br />
-      bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,<br />
-                      const vector&lt;bool,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class Allocator&gt;<br />
-      void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);<br />
-<br />
-   23.3  Associative containers                         [lib.associative]<br />
-<br />
- &lt;map&gt; and &lt;set&gt;:<br />
-<br />
-   Header &lt;map&gt; synopsis<br />
-<br />
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;<br />
-T     class map;<br />
-<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;<br />
-      class multimap;<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-   }<br />
-<br />
-   Header &lt;set&gt; synopsis<br />
-<br />
-    template &lt;class Key, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;Key&gt; &gt;<br />
-T     class set;<br />
-<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;Key&gt; &gt;<br />
-      class multiset;<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-   }<br />
-<br />
-   23.3.1  Template class map                                   [lib.map]<br />
-<br />
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;<br />
-T     class map {<br />
-    public:<br />
-      // types:<br />
-T     typedef Key                                   key_type;<br />
-T     typedef T                                     mapped_type;<br />
-T     typedef pair&lt;const Key, T&gt;                    value_type;<br />
-T     typedef Compare                               key_compare;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-T     class value_compare<br />
-        : public binary_function&lt;value_type,value_type,bool&gt; {<br />
-      friend class map;<br />
-      protected:<br />
-T       Compare comp;<br />
-T       value_compare(Compare c) : comp(c) {}<br />
-      public:<br />
-T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {<br />
-          return comp(x.first, y.first);<br />
-        }<br />
-      };<br />
-<br />
-      // _lib.map.cons_ construct/copy/destroy:<br />
-T     explicit map(const Compare&amp; comp = Compare(),<br />
-                   const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        map(InputIterator first, InputIterator last,<br />
-            const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());<br />
-T     map(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);<br />
-T    ~map();<br />
-T     map&lt;Key,T,Compare,Allocator&gt;&amp;<br />
-        operator=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // capacity:<br />
-T     bool      empty() const;<br />
-T     size_type size() const;<br />
-T     size_type max_size() const;<br />
-      // _lib.map.access_ element access:<br />
-T     T&amp; operator[](const key_type&amp; x);<br />
-      // modifiers:<br />
-T     pair&lt;iterator, bool&gt; insert(const value_type&amp; x);<br />
-T     iterator             insert(iterator position, const value_type&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void insert(InputIterator first, InputIterator last);<br />
-T     void      erase(iterator position);<br />
-T     size_type erase(const key_type&amp; x);<br />
-T     void      erase(iterator first, iterator last);<br />
-T     void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;);<br />
-T     void clear();<br />
-      // observers:<br />
-T     key_compare   key_comp() const;<br />
-T     value_compare value_comp() const;<br />
-      // _lib.map.ops_ map operations:<br />
-T     iterator       find(const key_type&amp; x);<br />
-T     const_iterator find(const key_type&amp; x) const;<br />
-T     size_type      count(const key_type&amp; x) const;<br />
-T     iterator       lower_bound(const key_type&amp; x);<br />
-T     const_iterator lower_bound(const key_type&amp; x) const;<br />
-T     iterator       upper_bound(const key_type&amp; x);<br />
-T     const_iterator upper_bound(const key_type&amp; x) const;<br />
-T     pair&lt;iterator,iterator&gt;<br />
-          equal_range(const key_type&amp; x);<br />
-T     pair&lt;const_iterator,const_iterator&gt;<br />
-          equal_range(const key_type&amp; x) const;<br />
-    };<br />
-<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                map&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-<br />
-   23.3.2  Template class multimap                         [lib.multimap]<br />
-<br />
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;<br />
-T   class multimap {<br />
-    public:<br />
-      // types:<br />
-T     typedef Key                                   key_type;<br />
-T     typedef T                                     mapped_type;<br />
-T     typedef pair&lt;const Key,T&gt;                     value_type;<br />
-T     typedef Compare                               key_compare;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-T     class value_compare<br />
-        : public binary_function&lt;value_type,value_type,bool&gt; {<br />
-      friend class multimap;<br />
-      protected:<br />
-T       Compare comp;<br />
-T       value_compare(Compare c) : comp(c) {}<br />
-      public:<br />
-T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {<br />
-          return comp(x.first, y.first);<br />
-        }<br />
-      };<br />
-      // construct/copy/destroy:<br />
-T     explicit multimap(const Compare&amp; comp = Compare(),<br />
-                        const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        multimap(InputIterator first, InputIterator last,<br />
-                 const Compare&amp; comp = Compare(),<br />
-                 const Allocator&amp; = Allocator());<br />
-T     multimap(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);<br />
-T    ~multimap();<br />
-T     multimap&lt;Key,T,Compare,Allocator&gt;&amp;<br />
-        operator=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);<br />
-T     allocator_type get_allocator() const;<br />
-<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // capacity:<br />
-T     bool           empty() const;<br />
-T     size_type      size() const;<br />
-T     size_type      max_size() const;<br />
-      // modifiers:<br />
-T     iterator insert(const value_type&amp; x);<br />
-T     iterator insert(iterator position, const value_type&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void insert(InputIterator first, InputIterator last);<br />
-T     void      erase(iterator position);<br />
-T     size_type erase(const key_type&amp; x);<br />
-T     void      erase(iterator first, iterator last);<br />
-T     void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;);<br />
-T     void clear();<br />
-      // observers:<br />
-T     key_compare    key_comp() const;<br />
-T     value_compare  value_comp() const;<br />
-      // map operations:<br />
-T     iterator       find(const key_type&amp; x);<br />
-T     const_iterator find(const key_type&amp; x) const;<br />
-T     size_type      count(const key_type&amp; x) const;<br />
-T     iterator       lower_bound(const key_type&amp; x);<br />
-T     const_iterator lower_bound(const key_type&amp; x) const;<br />
-T     iterator       upper_bound(const key_type&amp; x);<br />
-T     const_iterator upper_bound(const key_type&amp; x) const;<br />
-T     pair&lt;iterator,iterator&gt;             equal_range(const key_type&amp; x);<br />
-T     pair&lt;const_iterator,const_iterator&gt; equal_range(const key_type&amp; x) const;<br />
-    };<br />
-<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;<br />
-      void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,<br />
-                multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);<br />
-<br />
-<br />
-   23.3.3  Template class set                                   [lib.set]<br />
-<br />
-    template &lt;class Key, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;Key&gt; &gt;<br />
-T   class set {<br />
-    public:<br />
-      // types:<br />
-T     typedef Key                                   key_type;<br />
-T     typedef Key                                   value_type;<br />
-T     typedef Compare                               key_compare;<br />
-T     typedef Compare                               value_compare;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type;<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-      // _lib.set.cons_ construct/copy/destroy:<br />
-T     explicit set(const Compare&amp; comp = Compare(),<br />
-                   const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        set(InputIterator first, InputIterator last,<br />
-            const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());<br />
-T     set(const set&lt;Key,Compare,Allocator&gt;&amp; x);<br />
-T    ~set();<br />
-T     set&lt;Key,Compare,Allocator&gt;&amp;<br />
-        operator=(const set&lt;Key,Compare,Allocator&gt;&amp; x);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // capacity:<br />
-T     bool          empty() const;<br />
-T     size_type     size() const;<br />
-T     size_type     max_size() const;<br />
-      // modifiers:<br />
-T     pair&lt;iterator,bool&gt; insert(const value_type&amp; x);<br />
-T     iterator            insert(iterator position, const value_type&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-T         void insert(InputIterator first, InputIterator last);<br />
-T     void      erase(iterator position);<br />
-T     size_type erase(const key_type&amp; x);<br />
-T     void      erase(iterator first, iterator last);<br />
-T     void swap(set&lt;Key,Compare,Allocator&gt;&amp;);<br />
-T     void clear();<br />
-<br />
-      // observers:<br />
-T     key_compare   key_comp() const;<br />
-T     value_compare value_comp() const;<br />
-      // set operations:<br />
-T     iterator  find(const key_type&amp; x) const;<br />
-T     size_type count(const key_type&amp; x) const;<br />
-T     iterator  lower_bound(const key_type&amp; x) const;<br />
-T     iterator  upper_bound(const key_type&amp; x) const;<br />
-T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;<br />
-    };<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                set&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-<br />
-   23.3.4  Template class multiset                         [lib.multiset]<br />
-<br />
-    template &lt;class Key, class Compare = less&lt;Key&gt;,<br />
-              class Allocator = allocator&lt;Key&gt; &gt;<br />
-T   class multiset {<br />
-    public:<br />
-      // types:<br />
-T     typedef Key                                   key_type;<br />
-T     typedef Key                                   value_type;<br />
-T     typedef Compare                               key_compare;<br />
-T     typedef Compare                               value_compare;<br />
-T     typedef Allocator                             allocator_type;<br />
-T     typedef typename Allocator::reference         reference;<br />
-T     typedef typename Allocator::const_reference   const_reference;<br />
-T     typedef implementation defined                iterator;<br />
-T     typedef implementation defined                const_iterator;<br />
-T     typedef implementation defined                size_type;<br />
-T     typedef implementation defined                difference_type<br />
-T     typedef typename Allocator::pointer           pointer;<br />
-T     typedef typename Allocator::const_pointer     const_pointer;<br />
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;<br />
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;<br />
-<br />
-      // construct/copy/destroy:<br />
-T     explicit multiset(const Compare&amp; comp = Compare(),<br />
-                        const Allocator&amp; = Allocator());<br />
-T     template &lt;class InputIterator&gt;<br />
-        multiset(InputIterator first, InputIterator last,<br />
-                 const Compare&amp; comp = Compare(),<br />
-                 const Allocator&amp; = Allocator());<br />
-T     multiset(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);<br />
-T    ~multiset();<br />
-T     multiset&lt;Key,Compare,Allocator&gt;&amp;<br />
-          operator=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);<br />
-T     allocator_type get_allocator() const;<br />
-      // iterators:<br />
-T     iterator               begin();<br />
-T     const_iterator         begin() const;<br />
-T     iterator               end();<br />
-T     const_iterator         end() const;<br />
-T     reverse_iterator       rbegin();<br />
-T     const_reverse_iterator rbegin() const;<br />
-T     reverse_iterator       rend();<br />
-T     const_reverse_iterator rend() const;<br />
-      // capacity:<br />
-T     bool          empty() const;<br />
-T     size_type     size() const;<br />
-T     size_type     max_size() const;<br />
-      // modifiers:<br />
-T     iterator insert(const value_type&amp; x);<br />
-T     iterator insert(iterator position, const value_type&amp; x);<br />
-T     template &lt;class InputIterator&gt;<br />
-        void insert(InputIterator first, InputIterator last);<br />
-T     void      erase(iterator position);<br />
-T     size_type erase(const key_type&amp; x);<br />
-T     void      erase(iterator first, iterator last);<br />
-T     void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;);<br />
-T     void clear();<br />
-      // observers:<br />
-T     key_compare   key_comp() const;<br />
-T     value_compare value_comp() const;<br />
-      // set operations:<br />
-T     iterator  find(const key_type&amp; x) const;<br />
-T     size_type count(const key_type&amp; x) const;<br />
-T     iterator  lower_bound(const key_type&amp; x) const;<br />
-T     iterator  upper_bound(const key_type&amp; x) const;<br />
-T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;<br />
-    };<br />
-<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-    // specialized algorithms:<br />
-T   template &lt;class Key, class Compare, class Allocator&gt;<br />
-      void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,<br />
-                multiset&lt;Key,Compare,Allocator&gt;&amp; y);<br />
-<br />
-   23.3.5  Template class bitset                    [lib.template.bitset]<br />
-<br />
-   Header &lt;bitset&gt; synopsis<br />
-<br />
-T   template &lt;size_t N&gt; class bitset;<br />
-    // _lib.bitset.operators_ bitset operations:<br />
-T   template &lt;size_t N&gt;<br />
-      bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);<br />
-T   template &lt;size_t N&gt;<br />
-      bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);<br />
-T   template &lt;size_t N&gt;<br />
-      bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);<br />
-T   template &lt;class charT, class traits, size_t N&gt;<br />
-      basic_istream&lt;charT, traits&gt;&amp;<br />
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);<br />
-T   template &lt;class charT, class traits, size_t N&gt;<br />
-      basic_ostream&lt;charT, traits&gt;&amp;<br />
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);<br />
-<br />
-T   template&lt;size_t N&gt; class bitset {<br />
-    public:<br />
-      // bit reference:<br />
-T     class reference {<br />
-        friend class bitset;<br />
-T       reference();<br />
-      public:<br />
-T      ~reference();<br />
-T       reference&amp; operator=(bool x);             // for b[i] = x;<br />
-T       reference&amp; operator=(const reference&amp;);   // for b[i] = b[j];<br />
-T       bool operator~() const;                   // flips the bit<br />
-T       operator bool() const;                    // for x = b[i];<br />
-T       reference&amp; flip();                        // for b[i].flip();<br />
-      };<br />
-<br />
-      // _lib.bitset.cons_ constructors:<br />
-T     bitset();<br />
-T     bitset(unsigned long val);<br />
-T     template&lt;class charT, class traits, class Allocator&gt;<br />
-        explicit bitset(<br />
-          const basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-          typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos = 0,<br />
-          typename basic_string&lt;charT,traits,Allocator&gt;::size_type n =<br />
-            basic_string&lt;charT,traits,Allocator&gt;::npos);<br />
-      // _lib.bitset.members_ bitset operations:<br />
-T     bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs);<br />
-T     bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs);<br />
-T     bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs);<br />
-T     bitset&lt;N&gt;&amp; operator&lt;&lt;=(size_t pos);<br />
-T     bitset&lt;N&gt;&amp; operator&gt;&gt;=(size_t pos);<br />
-T     bitset&lt;N&gt;&amp; set();<br />
-T     bitset&lt;N&gt;&amp; set(size_t pos, int val = true);<br />
-T     bitset&lt;N&gt;&amp; reset();<br />
-T     bitset&lt;N&gt;&amp; reset(size_t pos);<br />
-T     bitset&lt;N&gt;  operator~() const;<br />
-T     bitset&lt;N&gt;&amp; flip();<br />
-T     bitset&lt;N&gt;&amp; flip(size_t pos);<br />
-      // element access:<br />
-T     reference operator[](size_t pos);         // for b[i];<br />
-T     unsigned long  to_ulong() const;<br />
-T     template &lt;class charT, class traits, class Allocator&gt;<br />
-        basic_string&lt;charT, traits, Allocator&gt; to_string() const;<br />
-T     size_t count() const;<br />
-T     size_t size()  const;<br />
-T     bool operator==(const bitset&lt;N&gt;&amp; rhs) const;<br />
-T     bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;<br />
-T     bool test(size_t pos) const;<br />
-T     bool any() const;<br />
-T     bool none() const;<br />
-T     bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const;<br />
-T     bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const;<br />
-    };<br />
-<br />
-<br />
-<br />
-<br />
-   24.2  Header &lt;iterator&gt; synopsis               [lib.iterator.synopsis]<br />
-<br />
-    // _lib.iterator.primitives_, primitives:<br />
-T   template&lt;class Iterator&gt; struct iterator_traits;<br />
-T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;<br />
-<br />
-X   template&lt;class Category, class T, class Distance = ptrdiff_t,<br />
-             class Pointer = T*, class Reference = T&amp;&gt; struct iterator;<br />
-T   struct input_iterator_tag {};<br />
-T   struct output_iterator_tag {};<br />
-T   struct forward_iterator_tag: public input_iterator_tag {};<br />
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};<br />
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};<br />
-    // _lib.iterator.operations_, iterator operations:<br />
-T   template &lt;class InputIterator, class Distance&gt;<br />
-      void advance(InputIterator&amp; i, Distance n);<br />
-T   template &lt;class InputIterator&gt;<br />
-      typename iterator_traits&lt;InputIterator&gt;::difference_type<br />
-      distance(InputIterator first, InputIterator last);<br />
-    // _lib.predef.iterators_, predefined iterators:<br />
-X   template &lt;class Iterator&gt; class reverse_iterator;<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator==(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&lt;(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator!=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&gt;(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&gt;=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&lt;=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      reverse_iterator&lt;Iterator&gt;<br />
-        operator+(<br />
-          typename reverse_iterator&lt;Iterator&gt;::difference_type n,<br />
-          const reverse_iterator&lt;Iterator&gt;&amp; x);<br />
-<br />
-X   template &lt;class Container&gt; class back_insert_iterator;<br />
-T   template &lt;class Container&gt;<br />
-      back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);<br />
-X   template &lt;class Container&gt; class front_insert_iterator;<br />
-T   template &lt;class Container&gt;<br />
-      front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);<br />
-X   template &lt;class Container&gt; class insert_iterator;<br />
-T   template &lt;class Container, class Iterator&gt;<br />
-      insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);<br />
-    // _lib.stream.iterators_, stream iterators:<br />
-X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,<br />
-              class Distance = ptrdiff_t&gt;<br />
-      class istream_iterator;<br />
-    template &lt;class T, class charT, class traits, class Distance&gt;<br />
-X     bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,<br />
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);<br />
-    template &lt;class T, class charT, class traits, class Distance&gt;<br />
-X     bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,<br />
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);<br />
-X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;<br />
-        class ostream_iterator;<br />
-X   template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class istreambuf_iterator;<br />
-X   template &lt;class charT, class traits&gt;<br />
-      bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,<br />
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);<br />
-X   template &lt;class charT, class traits&gt;<br />
-      bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,<br />
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);<br />
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class ostreambuf_iterator;<br />
-<br />
-   24.3  Iterator primitives                    [lib.iterator.primitives]<br />
-<br />
-T   template&lt;class Iterator&gt; struct iterator_traits {<br />
-T     typedef typename Iterator::difference_type difference_type;<br />
-T     typedef typename Iterator::value_type value_type;<br />
-T     typedef typename Iterator::pointer pointer;<br />
-T     typedef typename Iterator::reference reference;<br />
-T     typedef typename Iterator::iterator_category iterator_category;<br />
-    };<br />
-<br />
-T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt; {<br />
-T     typedef ptrdiff_t difference_type;<br />
-T     typedef T value_type;<br />
-T     typedef T* pointer;<br />
-T     typedef T&amp; reference;<br />
-T     typedef random_access_iterator_tag iterator_category;<br />
-    };<br />
-<br />
-T   template&lt;class T&gt; struct iterator_traits&lt;const T*&gt; {<br />
-T     typedef ptrdiff_t difference_type;<br />
-T     typedef T value_type;<br />
-T     typedef const T* pointer;<br />
-T     typedef const T&amp; reference;<br />
-T     typedef random_access_iterator_tag iterator_category;<br />
-    };<br />
-<br />
-   24.3.2  Basic iterator                            [lib.iterator.basic]<br />
-<br />
-    template&lt;class Category, class T, class Distance = ptrdiff_t,<br />
-             class Pointer = T*, class Reference = T&amp;&gt;<br />
-X     struct iterator {<br />
-T         typedef T         value_type;<br />
-T         typedef Distance  difference_type;<br />
-T         typedef Pointer   pointer;<br />
-T         typedef Reference reference;<br />
-T         typedef Category  iterator_category;<br />
-    };<br />
-<br />
-   24.3.3  Standard iterator tags                 [lib.std.iterator.tags]<br />
-<br />
-T   struct input_iterator_tag {};<br />
-T   struct output_iterator_tag {};<br />
-T   struct forward_iterator_tag: public input_iterator_tag {};<br />
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};<br />
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};<br />
-<br />
-<br />
-   24.4.1  Reverse iterators                      [lib.reverse.iterators]<br />
-<br />
-    template &lt;class Iterator&gt;<br />
-X   class reverse_iterator : public<br />
-          iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,<br />
-                   typename iterator_traits&lt;Iterator&gt;::value_type,<br />
-                   typename iterator_traits&lt;Iterator&gt;::difference_type,<br />
-                   typename iterator_traits&lt;Iterator&gt;::pointer,<br />
-                   typename iterator_traits&lt;Iterator&gt;::reference&gt; {<br />
-    protected:<br />
-T     Iterator current;<br />
-    public:<br />
-T     typedef Iterator<br />
-          iterator_type;<br />
-T     typedef typename iterator_traits&lt;Iterator&gt;::difference_type<br />
-          difference_type;<br />
-T     typedef typename iterator_traits&lt;Iterator&gt;::reference<br />
-          reference;<br />
-T     typedef typename iterator_traits&lt;Iterator&gt;::pointer<br />
-          pointer;<br />
-<br />
-T     reverse_iterator();<br />
-T     explicit reverse_iterator(Iterator x);<br />
-T     template &lt;class U&gt; reverse_iterator(const reverse_iterator&lt;U&gt;&amp; u);<br />
-T     Iterator base() const;      // explicit<br />
-T     reference operator*() const;<br />
-T     pointer   operator-&gt;() const;<br />
-T     reverse_iterator&amp; operator++();<br />
-T     reverse_iterator  operator++(int);<br />
-T     reverse_iterator&amp; operator--();<br />
-T     reverse_iterator  operator--(int);<br />
-<br />
-T     reverse_iterator  operator+ (difference_type n) const;<br />
-T     reverse_iterator&amp; operator+=(difference_type n);<br />
-T     reverse_iterator  operator- (difference_type n) const;<br />
-T     reverse_iterator&amp; operator-=(difference_type n);<br />
-T     reference operator[](difference_type n) const;<br />
-    };<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator==(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&lt;(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator!=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&gt;(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&gt;=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      bool operator&lt;=(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; y);<br />
-T   template &lt;class Iterator&gt;<br />
-      reverse_iterator&lt;Iterator&gt; operator+(<br />
-        typename reverse_iterator&lt;Iterator&gt;::difference_type n,<br />
-        const reverse_iterator&lt;Iterator&gt;&amp; x);<br />
-<br />
-<br />
-   24.4.2.1  Template class                    [lib.back.insert.iterator]<br />
-       back_insert_iterator<br />
-<br />
-    template &lt;class Container&gt;<br />
-X   class back_insert_iterator :<br />
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {<br />
-    protected:<br />
-T     Container* container;<br />
-    public:<br />
-T     typedef Container container_type;<br />
-T     explicit back_insert_iterator(Container&amp; x);<br />
-T     back_insert_iterator&lt;Container&gt;&amp;<br />
-        operator=(typename Container::const_reference value);<br />
-<br />
-T     back_insert_iterator&lt;Container&gt;&amp; operator*();<br />
-T     back_insert_iterator&lt;Container&gt;&amp; operator++();<br />
-T     back_insert_iterator&lt;Container&gt;  operator++(int);<br />
-    };<br />
-T   template &lt;class Container&gt;<br />
-      back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);<br />
-<br />
-<br />
-<br />
-   24.4.2.3  Template class                   [lib.front.insert.iterator]<br />
-       front_insert_iterator<br />
-<br />
-    template &lt;class Container&gt;<br />
-X   class front_insert_iterator :<br />
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {<br />
-    protected:<br />
-T     Container* container;<br />
-    public:<br />
-T     typedef Container container_type;<br />
-T     explicit front_insert_iterator(Container&amp; x);<br />
-T     front_insert_iterator&lt;Container&gt;&amp;<br />
-        operator=(typename Container::const_reference value);<br />
-T     front_insert_iterator&lt;Container&gt;&amp; operator*();<br />
-T     front_insert_iterator&lt;Container&gt;&amp; operator++();<br />
-T     front_insert_iterator&lt;Container&gt;  operator++(int);<br />
-    };<br />
-T   template &lt;class Container&gt;<br />
-      front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);<br />
-<br />
-<br />
-   24.4.2.5  Template class insert_iterator         [lib.insert.iterator]<br />
-<br />
-    template &lt;class Container&gt;<br />
-X   class insert_iterator :<br />
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {<br />
-    protected:<br />
-T     Container* container;<br />
-T     typename Container::iterator iter;<br />
-    public:<br />
-T     typedef Container container_type;<br />
-T     insert_iterator(Container&amp; x, typename Container::iterator i);<br />
-T     insert_iterator&lt;Container&gt;&amp;<br />
-        operator=(typename Container::const_reference value);<br />
-T     insert_iterator&lt;Container&gt;&amp; operator*();<br />
-T     insert_iterator&lt;Container&gt;&amp; operator++();<br />
-T     insert_iterator&lt;Container&gt;&amp; operator++(int);<br />
-    };<br />
-T   template &lt;class Container, class Iterator&gt;<br />
-      insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);<br />
-<br />
-   24.5.1  Template class istream_iterator         [lib.istream.iterator]<br />
-<br />
-    template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,<br />
-        class Distance = ptrdiff_t&gt;<br />
-X   class istream_iterator:<br />
-      public iterator&lt;input_iterator_tag, T, Distance, const T*, const T&amp;&gt; {<br />
-    public:<br />
-T     typedef charT char_type<br />
-T     typedef traits traits_type;<br />
-T     typedef basic_istream&lt;charT,traits&gt; istream_type;<br />
-T     istream_iterator();<br />
-T     istream_iterator(istream_type&amp; s);<br />
-T     istream_iterator(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x);<br />
-T    ~istream_iterator();<br />
-<br />
-T     const T&amp; operator*() const;<br />
-T     const T* operator-&gt;() const;<br />
-T     istream_iterator&lt;T,charT,traits,Distance&gt;&amp; operator++();<br />
-T     istream_iterator&lt;T,charT,traits,Distance&gt;  operator++(int);<br />
-    };<br />
-<br />
-T   template &lt;class T, class charT, class traits, class Distance&gt;<br />
-      bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,<br />
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);<br />
-T   template &lt;class T, class charT, class traits, class Distance&gt;<br />
-      bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,<br />
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);<br />
-<br />
-<br />
-   24.5.2  Template class ostream_iterator         [lib.ostream.iterator]<br />
-<br />
-    template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class ostream_iterator:<br />
-      public iterator&lt;output_iterator_tag, void, void, void, void&gt; {<br />
-    public:<br />
-T     typedef charT char_type;<br />
-T     typedef traits traits_type;<br />
-T     typedef basic_ostream&lt;charT,traits&gt; ostream_type;<br />
-T     ostream_iterator(ostream_type&amp; s);<br />
-T     ostream_iterator(ostream_type&amp; s, const charT* delimiter);<br />
-T     ostream_iterator(const ostream_iterator&lt;T,charT,traits&gt;&amp; x);<br />
-T    ~ostream_iterator();<br />
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(const T&amp; value);<br />
-<br />
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator*();<br />
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++();<br />
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++(int);<br />
-    };<br />
-<br />
-<br />
-   24.5.3  Template class                       [lib.istreambuf.iterator]<br />
-       istreambuf_iterator<br />
-<br />
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class istreambuf_iterator<br />
-       : public iterator&lt;input_iterator_tag, charT,<br />
-                         typename traits::off_type, charT*, charT&amp;&gt; {<br />
-    public:<br />
-T     typedef charT                         char_type;<br />
-T     typedef traits                        traits_type;<br />
-T     typedef typename traits::int_type     int_type;<br />
-T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;<br />
-T     typedef basic_istream&lt;charT,traits&gt;   istream_type;<br />
-T     class proxy;                        // exposition only<br />
-T     istreambuf_iterator() throw();<br />
-T     istreambuf_iterator(istream_type&amp; s) throw();<br />
-T     istreambuf_iterator(streambuf_type* s) throw();<br />
-T     istreambuf_iterator(const proxy&amp; p) throw();<br />
-T     charT operator*() const;<br />
-T     istreambuf_iterator&lt;charT,traits&gt;&amp; operator++();<br />
-T     proxy operator++(int);<br />
-X     bool equal(istreambuf_iterator&amp; b);<br />
-    };<br />
-<br />
-T   template &lt;class charT, class traits&gt;<br />
-      bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,<br />
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);<br />
-<br />
-T   template &lt;class charT, class traits&gt;<br />
-      bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,<br />
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);<br />
-<br />
-   24.5.3.1  Template class              [lib.istreambuf.iterator::proxy]<br />
-       istreambuf_iterator::proxy<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-T     class istreambuf_iterator&lt;charT, traits&gt;::proxy<br />
-    {<br />
-T     charT keep_;<br />
-T     basic_streambuf&lt;charT,traits&gt;* sbuf_;<br />
-T     proxy(charT c,<br />
-            basic_streambuf&lt;charT,traits&gt;* sbuf);<br />
-        : keep_(c), sbuf_(sbuf) {}<br />
-    public:<br />
-T     charT operator*() { return keep_; }<br />
-    };<br />
-<br />
-<br />
-<br />
-   24.5.4  Template class                       [lib.ostreambuf.iterator]<br />
-       ostreambuf_iterator<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-T   class ostreambuf_iterator:<br />
-      public iterator&lt;output_iterator_tag, void, void, void, void&gt; {<br />
-    public:<br />
-T     typedef charT                         char_type;<br />
-T     typedef traits                        traits_type;<br />
-T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;<br />
-T     typedef basic_ostream&lt;charT,traits&gt;   ostream_type;<br />
-    public:<br />
-T     ostreambuf_iterator(ostream_type&amp; s) throw();<br />
-T     ostreambuf_iterator(streambuf_type* s) throw();<br />
-T     ostreambuf_iterator&amp; operator=(charT c);<br />
-T     ostreambuf_iterator&amp; operator*();<br />
-T     ostreambuf_iterator&amp; operator++();<br />
-T     ostreambuf_iterator&amp; operator++(int);<br />
-T     bool failed() const throw();<br />
-    };<br />
-<br />
-<br />
-   Header &lt;algorithm&gt; synopsis<br />
-<br />
-<br />
-    // _lib.alg.nonmodifying_, non-modifying sequence operations:<br />
-T   template&lt;class InputIterator, class Function&gt;<br />
-      Function for_each(InputIterator first, InputIterator last, Function f);<br />
-T   template&lt;class InputIterator, class T&gt;<br />
-      InputIterator find(InputIterator first, InputIterator last,<br />
-                         const T&amp; value);<br />
-T   template&lt;class InputIterator, class Predicate&gt;<br />
-      InputIterator find_if(InputIterator first, InputIterator last,<br />
-                            Predicate pred);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;<br />
-      ForwardIterator1<br />
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                 ForwardIterator2 first2, ForwardIterator2 last2);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2,<br />
-             class BinaryPredicate&gt;<br />
-      ForwardIterator1<br />
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                 ForwardIterator2 first2, ForwardIterator2 last2,<br />
-                 BinaryPredicate pred);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;<br />
-      ForwardIterator1<br />
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                      ForwardIterator2 first2, ForwardIterator2 last2);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2,<br />
-             class BinaryPredicate&gt;<br />
-      ForwardIterator1<br />
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                 ForwardIterator2 first2, ForwardIterator2 last2,<br />
-                 BinaryPredicate pred);<br />
-T   template&lt;class ForwardIterator&gt;<br />
-      ForwardIterator adjacent_find(ForwardIterator first,<br />
-                                    ForwardIterator last);<br />
-T   template&lt;class ForwardIterator, class BinaryPredicate&gt;<br />
-      ForwardIterator adjacent_find(ForwardIterator first,<br />
-          ForwardIterator last, BinaryPredicate pred);<br />
-T   template&lt;class InputIterator, class T&gt;<br />
-      typename iterator_traits&lt;InputIterator&gt;::difference_type<br />
-        count(InputIterator first, InputIterator last, const T&amp; value);<br />
-T   template&lt;class InputIterator, class Predicate&gt;<br />
-      typename iterator_traits&lt;InputIterator&gt;::difference_type<br />
-        count_if(InputIterator first, InputIterator last, Predicate pred);<br />
-T   template&lt;class InputIterator1, class InputIterator2&gt;<br />
-      pair&lt;InputIterator1, InputIterator2&gt;<br />
-        mismatch(InputIterator1 first1, InputIterator1 last1,<br />
-                 InputIterator2 first2);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;<br />
-      pair&lt;InputIterator1, InputIterator2&gt;<br />
-        mismatch(InputIterator1 first1, InputIterator1 last1,<br />
-                 InputIterator2 first2, BinaryPredicate pred);<br />
-<br />
-T   template&lt;class InputIterator1, class InputIterator2&gt;<br />
-      bool equal(InputIterator1 first1, InputIterator1 last1,<br />
-                 InputIterator2 first2);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;<br />
-      bool equal(InputIterator1 first1, InputIterator1 last1,<br />
-                 InputIterator2 first2, BinaryPredicate pred);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;<br />
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                              ForwardIterator2 first2, ForwardIterator2 last2);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2,<br />
-             class BinaryPredicate&gt;<br />
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,<br />
-                              ForwardIterator2 first2, ForwardIterator2 last2,<br />
-                              BinaryPredicate pred);<br />
-T   template&lt;class ForwardIterator, class Size, class T&gt;<br />
-      ForwardIterator  search_n(ForwardIterator first, ForwardIterator last,<br />
-                              Size count, const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class Size, class T, class BinaryPredicate&gt;<br />
-      ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,<br />
-                              Size count, const T&amp; value,<br />
-                              BinaryPredicate pred);<br />
-    // _lib.alg.modifying.operations_, modifying sequence operations:<br />
-    // _lib.alg.copy_, copy:<br />
-T   template&lt;class InputIterator, class OutputIterator&gt;<br />
-      OutputIterator copy(InputIterator first, InputIterator last,<br />
-                          OutputIterator result);<br />
-T   template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;<br />
-      BidirectionalIterator2<br />
-        copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,<br />
-                      BidirectionalIterator2 result);<br />
-    // _lib.alg.swap_, swap:<br />
-T   template&lt;class T&gt; void swap(T&amp; a, T&amp; b);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;<br />
-      ForwardIterator2 swap_ranges(ForwardIterator1 first1,<br />
-          ForwardIterator1 last1, ForwardIterator2 first2);<br />
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;<br />
-      void iter_swap(ForwardIterator1 a, ForwardIterator2 b);<br />
-T   template&lt;class InputIterator, class OutputIterator, class UnaryOperation&gt;<br />
-      OutputIterator transform(InputIterator first, InputIterator last,<br />
-                               OutputIterator result, UnaryOperation op);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-             class BinaryOperation&gt;<br />
-      OutputIterator transform(InputIterator1 first1, InputIterator1 last1,<br />
-                               InputIterator2 first2, OutputIterator result,<br />
-                               BinaryOperation binary_op);<br />
-<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      void replace(ForwardIterator first, ForwardIterator last,<br />
-                   const T&amp; old_value, const T&amp; new_value);<br />
-T   template&lt;class ForwardIterator, class Predicate, class T&gt;<br />
-      void replace_if(ForwardIterator first, ForwardIterator last,<br />
-                      Predicate pred, const T&amp; new_value);<br />
-T   template&lt;class InputIterator, class OutputIterator, class T&gt;<br />
-      OutputIterator replace_copy(InputIterator first, InputIterator last,<br />
-                                  OutputIterator result,<br />
-                                  const T&amp; old_value, const T&amp; new_value);<br />
-T   template&lt;class Iterator, class OutputIterator, class Predicate, class T&gt;<br />
-      OutputIterator replace_copy_if(Iterator first, Iterator last,<br />
-                                     OutputIterator result,<br />
-                                     Predicate pred, const T&amp; new_value);<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      void fill(ForwardIterator first, ForwardIterator last, const T&amp; value);<br />
-T   template&lt;class OutputIterator, class Size, class T&gt;<br />
-      void fill_n(OutputIterator first, Size n, const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class Generator&gt;<br />
-      void generate(ForwardIterator first, ForwardIterator last, Generator gen);<br />
-T   template&lt;class OutputIterator, class Size, class Generator&gt;<br />
-      void generate_n(OutputIterator first, Size n, Generator gen);<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      ForwardIterator remove(ForwardIterator first, ForwardIterator last,<br />
-                             const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class Predicate&gt;<br />
-      ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,<br />
-                                Predicate pred);<br />
-T   template&lt;class InputIterator, class OutputIterator, class T&gt;<br />
-      OutputIterator remove_copy(InputIterator first, InputIterator last,<br />
-                                 OutputIterator result, const T&amp; value);<br />
-T   template&lt;class InputIterator, class OutputIterator, class Predicate&gt;<br />
-      OutputIterator remove_copy_if(InputIterator first, InputIterator last,<br />
-                                    OutputIterator result, Predicate pred);<br />
-T   template&lt;class ForwardIterator&gt;<br />
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last);<br />
-T   template&lt;class ForwardIterator, class BinaryPredicate&gt;<br />
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last,<br />
-                             BinaryPredicate pred);<br />
-T   template&lt;class InputIterator, class OutputIterator&gt;<br />
-      OutputIterator unique_copy(InputIterator first, InputIterator last,<br />
-                                 OutputIterator result);<br />
-T   template&lt;class InputIterator, class OutputIterator, class BinaryPredicate&gt;<br />
-      OutputIterator unique_copy(InputIterator first, InputIterator last,<br />
-                                 OutputIterator result, BinaryPredicate pred);<br />
-T   template&lt;class BidirectionalIterator&gt;<br />
-      void reverse(BidirectionalIterator first, BidirectionalIterator last);<br />
-T   template&lt;class BidirectionalIterator, class OutputIterator&gt;<br />
-      OutputIterator reverse_copy(BidirectionalIterator first,<br />
-                                  BidirectionalIterator last,<br />
-                                  OutputIterator result);<br />
-<br />
-T   template&lt;class ForwardIterator&gt;<br />
-      void rotate(ForwardIterator first, ForwardIterator middle,<br />
-                  ForwardIterator last);<br />
-T   template&lt;class ForwardIterator, class OutputIterator&gt;<br />
-      OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,<br />
-                                 ForwardIterator last, OutputIterator result);<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void random_shuffle(RandomAccessIterator first,<br />
-                          RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;<br />
-      void random_shuffle(RandomAccessIterator first,<br />
-                          RandomAccessIterator last,<br />
-                          RandomNumberGenerator&amp; rand);<br />
-    // _lib.alg.partitions_, partitions:<br />
-T   template&lt;class BidirectionalIterator, class Predicate&gt;<br />
-      BidirectionalIterator partition(BidirectionalIterator first,<br />
-                                      BidirectionalIterator last,<br />
-                                      Predicate pred);<br />
-T   template&lt;class BidirectionalIterator, class Predicate&gt;<br />
-      BidirectionalIterator stable_partition(BidirectionalIterator first,<br />
-                                             BidirectionalIterator last,<br />
-                                             Predicate pred);<br />
-    // _lib.alg.sorting_, sorting and related operations:<br />
-    // _lib.alg.sort_, sorting:<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void sort(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void sort(RandomAccessIterator first, RandomAccessIterator last,<br />
-                Compare comp);<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last,<br />
-                       Compare comp);<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void partial_sort(RandomAccessIterator first,<br />
-                        RandomAccessIterator middle,<br />
-                        RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void partial_sort(RandomAccessIterator first,<br />
-                        RandomAccessIterator middle,<br />
-                        RandomAccessIterator last, Compare comp);<br />
-T   template&lt;class InputIterator, class RandomAccessIterator&gt;<br />
-      RandomAccessIterator<br />
-        partial_sort_copy(InputIterator first, InputIterator last,<br />
-                          RandomAccessIterator result_first,<br />
-                          RandomAccessIterator result_last);<br />
-T   template&lt;class InputIterator, class RandomAccessIterator, class Compare&gt;<br />
-      RandomAccessIterator<br />
-        partial_sort_copy(InputIterator first, InputIterator last,<br />
-                          RandomAccessIterator result_first,<br />
-                          RandomAccessIterator result_last,<br />
-                          Compare comp);<br />
-<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,<br />
-                       RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,<br />
-                       RandomAccessIterator last, Compare comp);<br />
-    // _lib.alg.binary.search_, binary search:<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,<br />
-                                  const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class T, class Compare&gt;<br />
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,<br />
-                                  const T&amp; value, Compare comp);<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,<br />
-                                  const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class T, class Compare&gt;<br />
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,<br />
-                                  const T&amp; value, Compare comp);<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      pair&lt;ForwardIterator, ForwardIterator&gt;<br />
-        equal_range(ForwardIterator first, ForwardIterator last,<br />
-                    const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class T, class Compare&gt;<br />
-      pair&lt;ForwardIterator, ForwardIterator&gt;<br />
-        equal_range(ForwardIterator first, ForwardIterator last,<br />
-                    const T&amp; value, Compare comp);<br />
-T   template&lt;class ForwardIterator, class T&gt;<br />
-      bool binary_search(ForwardIterator first, ForwardIterator last,<br />
-                         const T&amp; value);<br />
-T   template&lt;class ForwardIterator, class T, class Compare&gt;<br />
-      bool binary_search(ForwardIterator first, ForwardIterator last,<br />
-                         const T&amp; value, Compare comp);<br />
-    // _lib.alg.merge_, merge:<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;<br />
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,<br />
-                           InputIterator2 first2, InputIterator2 last2,<br />
-                           OutputIterator result);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-             class Compare&gt;<br />
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,<br />
-                           InputIterator2 first2, InputIterator2 last2,<br />
-                           OutputIterator result, Compare comp);<br />
-T   template&lt;class BidirectionalIterator&gt;<br />
-      void inplace_merge(BidirectionalIterator first,<br />
-                         BidirectionalIterator middle,<br />
-                         BidirectionalIterator last);<br />
-T   template&lt;class BidirectionalIterator, class Compare&gt;<br />
-      void inplace_merge(BidirectionalIterator first,<br />
-                         BidirectionalIterator middle,<br />
-                         BidirectionalIterator last, Compare comp);<br />
-<br />
-    // _lib.alg.set.operations_, set operations:<br />
-T   template&lt;class InputIterator1, class InputIterator2&gt;<br />
-      bool includes(InputIterator1 first1, InputIterator1 last1,<br />
-                    InputIterator2 first2, InputIterator2 last2);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;<br />
-      bool includes(InputIterator1 first1, InputIterator1 last1,<br />
-                    InputIterator2 first2, InputIterator2 last2, Compare comp);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;<br />
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,<br />
-                               InputIterator2 first2, InputIterator2 last2,<br />
-                               OutputIterator result);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-             class Compare&gt;<br />
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,<br />
-                               InputIterator2 first2, InputIterator2 last2,<br />
-                               OutputIterator result, Compare comp);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;<br />
-      OutputIterator set_intersection<br />
-          (InputIterator1 first1, InputIterator1 last1,<br />
-           InputIterator2 first2, InputIterator2 last2,<br />
-           OutputIterator result);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-             class Compare&gt;<br />
-      OutputIterator set_intersection<br />
-          (InputIterator1 first1, InputIterator1 last1,<br />
-           InputIterator2 first2, InputIterator2 last2,<br />
-           OutputIterator result, Compare comp);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;<br />
-      OutputIterator set_difference<br />
-          (InputIterator1 first1, InputIterator1 last1,<br />
-           InputIterator2 first2, InputIterator2 last2,<br />
-           OutputIterator result);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-             class Compare&gt;<br />
-      OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,<br />
-                                    InputIterator2 first2, InputIterator2 last2,<br />
-                                    OutputIterator result, Compare comp);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;<br />
-      OutputIterator<br />
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,<br />
-                                 InputIterator2 first2, InputIterator2 last2,<br />
-                                 OutputIterator result);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,<br />
-              class Compare&gt;<br />
-      OutputIterator<br />
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,<br />
-                                 InputIterator2 first2, InputIterator2 last2,<br />
-                                 OutputIterator result, Compare comp);<br />
-    // _lib.alg.heap.operations_, heap operations:<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last,<br />
-                     Compare comp);<br />
-<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last,<br />
-                    Compare comp);<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last,<br />
-                     Compare comp);<br />
-T   template&lt;class RandomAccessIterator&gt;<br />
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last);<br />
-T   template&lt;class RandomAccessIterator, class Compare&gt;<br />
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last,<br />
-                     Compare comp);<br />
-    // _lib.alg.min.max_, minimum and maximum:<br />
-T   template&lt;class T&gt; const T&amp; min(const T&amp; a, const T&amp; b);<br />
-T   template&lt;class T, class Compare&gt;<br />
-      const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);<br />
-T   template&lt;class T&gt; const T&amp; max(const T&amp; a, const T&amp; b);<br />
-T   template&lt;class T, class Compare&gt;<br />
-      const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);<br />
-T   template&lt;class ForwardIterator&gt;<br />
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last);<br />
-T   template&lt;class ForwardIterator, class Compare&gt;<br />
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last,<br />
-                                Compare comp);<br />
-T   template&lt;class ForwardIterator&gt;<br />
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last);<br />
-T   template&lt;class ForwardIterator, class Compare&gt;<br />
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last,<br />
-                                Compare comp);<br />
-T   template&lt;class InputIterator1, class InputIterator2&gt;<br />
-      bool lexicographical_compare<br />
-          (InputIterator1 first1, InputIterator1 last1,<br />
-           InputIterator2 first2, InputIterator2 last2);<br />
-T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;<br />
-      bool lexicographical_compare<br />
-          (InputIterator1 first1, InputIterator1 last1,<br />
-           InputIterator2 first2, InputIterator2 last2,<br />
-           Compare comp);<br />
-<br />
-    // _lib.alg.permutation.generators_, permutations<br />
-T   template&lt;class BidirectionalIterator&gt;<br />
-      bool next_permutation(BidirectionalIterator first,<br />
-                            BidirectionalIterator last);<br />
-T   template&lt;class BidirectionalIterator, class Compare&gt;<br />
-      bool next_permutation(BidirectionalIterator first,<br />
-                            BidirectionalIterator last, Compare comp);<br />
-T   template&lt;class BidirectionalIterator&gt;<br />
-      bool prev_permutation(BidirectionalIterator first,<br />
-                            BidirectionalIterator last);<br />
-T   template&lt;class BidirectionalIterator, class Compare&gt;<br />
-      bool prev_permutation(BidirectionalIterator first,<br />
-                            BidirectionalIterator last, Compare comp);<br />
-<br />
-<br />
-   25.4  C library algorithms                         [lib.alg.c.library]<br />
-<br />
-   1 Header &lt;cstdlib&gt; (partial, Table 2):<br />
-<br />
-                    Table 2--Header &lt;cstdlib&gt; synopsis<br />
-<br />
-                      Functions:   bsearch   qsort<br />
-<br />
-<br />
-X  extern "C" void *bsearch(const void *key, const void *base,<br />
-                          size_t nmemb, size_t size,<br />
-                          int (*compar)(const void *, const void *));<br />
-X  extern "C++" void *bsearch(const void *key, const void *base,<br />
-                          size_t nmemb, size_t size,<br />
-                          int (*compar)(const void *, const void *));<br />
-<br />
-X  extern "C" void qsort(void* base, size_t nmemb, size_t size,<br />
-                  int (*compar)(const void*, const void*));<br />
-X  extern "C++" void qsort(void* base, size_t nmemb, size_t size,<br />
-                  int (*compar)(const void*, const void*));<br />
-<br />
-<br />
-<br />
-   26.2  Complex numbers                            [lib.complex.numbers]<br />
-<br />
-<br />
-   26.2.1  Header &lt;complex&gt; synopsis               [lib.complex.synopsis]<br />
-<br />
-T   template&lt;class T&gt; class complex;<br />
-T   template&lt;&gt; class complex&lt;float&gt;;<br />
-T   template&lt;&gt; class complex&lt;double&gt;;<br />
-T   template&lt;&gt; class complex&lt;long double&gt;;<br />
-    // _lib.complex.ops_ operators:<br />
-T   template&lt;class T&gt;<br />
-      complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator==<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T, class charT, class traits&gt;<br />
-      basic_istream&lt;charT, traits&gt;&amp;<br />
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T, class charT, class traits&gt;<br />
-      basic_ostream&lt;charT, traits&gt;&amp;<br />
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-    // _lib.complex.value.ops_ values:<br />
-T   template&lt;class T&gt; T real(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; T imag(const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; T abs(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; T arg(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; T norm(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp;, const T&amp;);<br />
-    // _lib.complex.transcendentals_ transcendentals:<br />
-T   template&lt;class T&gt; complex&lt;T&gt; cos  (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; cosh (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; exp  (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; log  (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; log10(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, int);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; sin  (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; sinh (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; sqrt (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; tan  (const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; tanh (const complex&lt;T&gt;&amp;);<br />
-   }<br />
-<br />
-   26.2.2  Template class complex                           [lib.complex]<br />
-<br />
-    template&lt;class T&gt;<br />
-T   class complex {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-T     complex(const T&amp; re = T(), const T&amp; im = T());<br />
-T     complex(const complex&amp;);<br />
-T     template&lt;class X&gt; complex(const complex&lt;X&gt;&amp;);<br />
-<br />
-T     T real() const;<br />
-T     T imag() const;<br />
-<br />
-T     complex&lt;T&gt;&amp; operator= (const T&amp;);<br />
-T     complex&lt;T&gt;&amp; operator+=(const T&amp;);<br />
-T     complex&lt;T&gt;&amp; operator-=(const T&amp;);<br />
-T     complex&lt;T&gt;&amp; operator*=(const T&amp;);<br />
-T     complex&lt;T&gt;&amp; operator/=(const T&amp;);<br />
-<br />
-T     complex&amp; operator=(const complex&amp;);<br />
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator= (const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);<br />
-    };<br />
-<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/<br />
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T, class charT, class traits&gt;<br />
-      basic_istream&lt;charT, traits&gt;&amp;<br />
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T, class charT, class traits&gt;<br />
-      basic_ostream&lt;charT, traits&gt;&amp;<br />
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);<br />
-<br />
-<br />
-   26.2.3  complex specializations                  [lib.complex.special]<br />
-<br />
-T   template&lt;&gt; class complex&lt;float&gt; {<br />
-    public:<br />
-T     typedef float value_type;<br />
-<br />
-T     complex(float re = 0.0f, float im = 0.0f);<br />
-T     explicit complex(const complex&lt;double&gt;&amp;);<br />
-T     explicit complex(const complex&lt;long double&gt;&amp;);<br />
-T     float real() const;<br />
-T     float imag() const;<br />
-<br />
-T     complex&lt;float&gt;&amp; operator= (float);<br />
-T     complex&lt;float&gt;&amp; operator+=(float);<br />
-T     complex&lt;float&gt;&amp; operator-=(float);<br />
-T     complex&lt;float&gt;&amp; operator*=(float);<br />
-T     complex&lt;float&gt;&amp; operator/=(float);<br />
-<br />
-T     complex&lt;float&gt;&amp; operator=(const complex&lt;float&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator= (const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);<br />
-    };<br />
-T   template&lt;&gt; class complex&lt;double&gt; {<br />
-    public:<br />
-T     typedef double value_type;<br />
-<br />
-T     complex(double re = 0.0, double im = 0.0);<br />
-T     complex(const complex&lt;float&gt;&amp;);<br />
-T     explicit complex(const complex&lt;long double&gt;&amp;);<br />
-T     double real() const;<br />
-T     double imag() const;<br />
-<br />
-T     complex&lt;double&gt;&amp; operator= (double);<br />
-T     complex&lt;double&gt;&amp; operator+=(double);<br />
-T     complex&lt;double&gt;&amp; operator-=(double);<br />
-T     complex&lt;double&gt;&amp; operator*=(double);<br />
-T     complex&lt;double&gt;&amp; operator/=(double);<br />
-<br />
-T     complex&lt;double&gt;&amp; operator=(const complex&lt;double&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);<br />
-    };<br />
-<br />
-T   template&lt;&gt; class complex&lt;long double&gt; {<br />
-    public:<br />
-T     typedef long double value_type;<br />
-<br />
-T     complex(long double re = 0.0L, long double im = 0.0L);<br />
-T     complex(const complex&lt;float&gt;&amp;);<br />
-T     complex(const complex&lt;double&gt;&amp;);<br />
-T     long double real() const;<br />
-T     long double imag() const;<br />
-<br />
-T     complex&lt;long double&gt;&amp; operator=(const complex&lt;long double&gt;&amp;);<br />
-T     complex&lt;long double&gt;&amp; operator= (long double);<br />
-T     complex&lt;long double&gt;&amp; operator+=(long double);<br />
-T     complex&lt;long double&gt;&amp; operator-=(long double);<br />
-T     complex&lt;long double&gt;&amp; operator*=(long double);<br />
-T     complex&lt;long double&gt;&amp; operator/=(long double);<br />
-<br />
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);<br />
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);<br />
-    };<br />
-<br />
-   26.3  Numeric arrays                                    [lib.numarray]<br />
-<br />
-   26.3.1  Header &lt;valarray&gt; synopsis             [lib.valarray.synopsis]<br />
-<br />
-T   template&lt;class T&gt; class valarray;         // An array of type T<br />
-T   class slice;<br />
-T   template&lt;class T&gt; class slice_array;<br />
-T   class gslice;<br />
-T   template&lt;class T&gt; class gslice_array;<br />
-T   template&lt;class T&gt; class mask_array;       // a masked array<br />
-T   template&lt;class T&gt; class indirect_array;   // an indirected array<br />
-<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator*<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator%<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator-<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp;<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator|<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt;<br />
-      valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; abs  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; acos (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; asin (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; atan (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2<br />
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; cos  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; cosh (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; exp  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; log  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; log10(const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const T&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const T&amp;, const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; sin  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; sinh (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; sqrt (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; tan  (const valarray&lt;T&gt;&amp;);<br />
-T   template&lt;class T&gt; valarray&lt;T&gt; tanh (const valarray&lt;T&gt;&amp;);<br />
-   }<br />
-<br />
-<br />
-   26.3.2  Template class valarray                [lib.template.valarray]<br />
-<br />
-T   template&lt;class T&gt; class valarray {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-      // _lib.valarray.cons_ construct/destroy:<br />
-T     valarray();<br />
-T     explicit valarray(size_t);<br />
-T     valarray(const T&amp;, size_t);<br />
-T     valarray(const T*, size_t);<br />
-T     valarray(const valarray&amp;);<br />
-T     valarray(const slice_array&lt;T&gt;&amp;);<br />
-T     valarray(const gslice_array&lt;T&gt;&amp;);<br />
-T     valarray(const mask_array&lt;T&gt;&amp;);<br />
-T     valarray(const indirect_array&lt;T&gt;&amp;);<br />
-T    ~valarray();<br />
-<br />
-      // _lib.valarray.assign_ assignment:<br />
-T     valarray&lt;T&gt;&amp; operator=(const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator=(const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator=(const slice_array&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator=(const gslice_array&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator=(const mask_array&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator=(const indirect_array&lt;T&gt;&amp;);<br />
-      // _lib.valarray.access_ element access:<br />
-T     T                 operator[](size_t) const;<br />
-T     T&amp;                operator[](size_t);<br />
-      // _lib.valarray.sub_ subset operations:<br />
-T     valarray&lt;T&gt;       operator[](slice) const;<br />
-T     slice_array&lt;T&gt;    operator[](slice);<br />
-T     valarray&lt;T&gt;       operator[](const gslice&amp;) const;<br />
-T     gslice_array&lt;T&gt;   operator[](const gslice&amp;);<br />
-T     valarray&lt;T&gt;       operator[](const valarray&lt;bool&gt;&amp;) const;<br />
-T     mask_array&lt;T&gt;     operator[](const valarray&lt;bool&gt;&amp;);<br />
-T     valarray&lt;T&gt;       operator[](const valarray&lt;size_t&gt;&amp;) const;<br />
-T     indirect_array&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp;);<br />
-      // _lib.valarray.unary_ unary operators:<br />
-T     valarray&lt;T&gt; operator+() const;<br />
-T     valarray&lt;T&gt; operator-() const;<br />
-T     valarray&lt;T&gt; operator~() const;<br />
-T     valarray&lt;T&gt; operator!() const;<br />
-      // _lib.valarray.cassign_ computed assignment:<br />
-T     valarray&lt;T&gt;&amp; operator*= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator/= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator%= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator+= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator-= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator^= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&amp;= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator|= (const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const T&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator*= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator/= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator%= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator+= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator-= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator^= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator|= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&amp;= (const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const valarray&lt;T&gt;&amp;);<br />
-T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const valarray&lt;T&gt;&amp;);<br />
-      // _lib.valarray.members_ member functions:<br />
-T     size_t size() const;<br />
-T     T    sum() const;<br />
-T     T    min() const;<br />
-T     T    max() const;<br />
-<br />
-T     valarray&lt;T&gt; shift (int) const;<br />
-T     valarray&lt;T&gt; cshift(int) const;<br />
-T     valarray&lt;T&gt; apply(T func(T)) const;<br />
-T     valarray&lt;T&gt; apply(T func(const T&amp;)) const;<br />
-T     void resize(size_t sz, T c = T());<br />
-    };<br />
-   }<br />
-<br />
-<br />
-<br />
-   26.3.4  Class slice                                  [lib.class.slice]<br />
-<br />
-T   class slice {<br />
-    public:<br />
-T     slice();<br />
-T     slice(size_t, size_t, size_t);<br />
-<br />
-T     size_t start() const;<br />
-T     size_t size() const;<br />
-T     size_t stride() const;<br />
-    };<br />
-   }<br />
-<br />
-<br />
-<br />
-   26.3.5  Template class slice_array          [lib.template.slice.array]<br />
-<br />
-T   template &lt;class T&gt; class slice_array {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator=(const T&amp;);<br />
-T    ~slice_array();<br />
-    private:<br />
-T     slice_array();<br />
-T     slice_array(const slice_array&amp;);<br />
-T     slice_array&amp; operator=(const slice_array&amp;);<br />
-    };<br />
-   }<br />
-<br />
-<br />
-<br />
-   26.3.6  The gslice class                            [lib.class.gslice]<br />
-<br />
-T   class gslice {<br />
-    public:<br />
-T     gslice();<br />
-T     gslice(size_t s, const valarray&lt;size_t&gt;&amp; l, const valarray&lt;size_t&gt;&amp; d);<br />
-<br />
-T     size_t           start() const;<br />
-T     valarray&lt;size_t&gt; size() const;<br />
-T     valarray&lt;size_t&gt; stride() const;<br />
-    };<br />
-<br />
-<br />
-   26.3.7  Template class gslice_array        [lib.template.gslice.array]<br />
-<br />
-T   template &lt;class T&gt; class gslice_array {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator=(const T&amp;);<br />
-T    ~gslice_array();<br />
-    private:<br />
-T     gslice_array();<br />
-T     gslice_array(const gslice_array&amp;);<br />
-T     gslice_array&amp; operator=(const gslice_array&amp;);<br />
-    };<br />
-<br />
-<br />
-   26.3.8  Template class mask_array            [lib.template.mask.array]<br />
-<br />
-T   template &lt;class T&gt; class mask_array {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator=(const T&amp;);<br />
-T    ~mask_array();<br />
-    private:<br />
-T     mask_array();<br />
-T     mask_array(const mask_array&amp;);<br />
-T     mask_array&amp; operator=(const mask_array&amp;);<br />
-      //  remainder implementation defined<br />
-    };<br />
-<br />
-<br />
-   26.3.9  Template class                   [lib.template.indirect.array]<br />
-       indirect_array<br />
-<br />
-T   template &lt;class T&gt; class indirect_array {<br />
-    public:<br />
-T     typedef T value_type;<br />
-<br />
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;<br />
-T     void operator=(const T&amp;);<br />
-T    ~indirect_array();<br />
-    private:<br />
-T     indirect_array();<br />
-T     indirect_array(const indirect_array&amp;);<br />
-T     indirect_array&amp; operator=(const indirect_array&amp;);<br />
-      //  remainder implementation defined<br />
-    };<br />
-<br />
-   26.4  Generalized numeric operations                 [lib.numeric.ops]<br />
-<br />
-   Header &lt;numeric&gt; synopsis<br />
-<br />
-T   template &lt;class InputIterator, class T&gt;<br />
-      T accumulate(InputIterator first, InputIterator last, T init);<br />
-<br />
-T   template &lt;class InputIterator, class T, class BinaryOperation&gt;<br />
-      T accumulate(InputIterator first, InputIterator last, T init,<br />
-                   BinaryOperation binary_op);<br />
-<br />
-T   template &lt;class InputIterator1, class InputIterator2, class T&gt;<br />
-      T inner_product(InputIterator1 first1, InputIterator1 last1,<br />
-                      InputIterator2 first2, T init);<br />
-<br />
-T   template &lt;class InputIterator1, class InputIterator2, class T,<br />
-              class BinaryOperation1, class BinaryOperation2&gt;<br />
-      T inner_product(InputIterator1 first1, InputIterator1 last1,<br />
-                      InputIterator2 first2, T init,<br />
-                      BinaryOperation1 binary_op1,<br />
-                      BinaryOperation2 binary_op2);<br />
-<br />
-T   template &lt;class InputIterator, class OutputIterator&gt;<br />
-      OutputIterator partial_sum(InputIterator first,<br />
-                                 InputIterator last,<br />
-                                 OutputIterator result);<br />
-<br />
-T   template &lt;class InputIterator, class OutputIterator,<br />
-              class BinaryOperation&gt;<br />
-      OutputIterator partial_sum(InputIterator first,<br />
-                                 InputIterator last,<br />
-                                 OutputIterator result,<br />
-                                 BinaryOperation binary_op);<br />
-<br />
-T   template &lt;class InputIterator, class OutputIterator&gt;<br />
-      OutputIterator adjacent_difference(InputIterator first,<br />
-                                         InputIterator last,<br />
-                                         OutputIterator result);<br />
-<br />
-T   template &lt;class InputIterator, class OutputIterator,<br />
-              class BinaryOperation&gt;<br />
-      OutputIterator adjacent_difference(InputIterator first,<br />
-                                         InputIterator last,<br />
-                                         OutputIterator result,<br />
-                                         BinaryOperation binary_op);<br />
-<br />
-<br />
-   26.5  C Library                                           [lib.c.math]<br />
-<br />
-                     Table 2--Header &lt;cmath&gt; synopsis<br />
-X               Macro:   HUGE_VAL<br />
-                Functions:<br />
-X               acos     cos        fmod    modf   tan<br />
-X               asin     cosh       frexp   pow    tanh<br />
-X               atan     exp        ldexp   sin<br />
-X               atan2    fabs       log     sinh<br />
-X               ceil     floor      log10   sqrt<br />
-<br />
-                    Table 3--Header &lt;cstdlib&gt; synopsis<br />
-X                     Macros:   RAND_MAX<br />
-X                     Types:    div_t      ldiv_t<br />
-                      Functions:<br />
-X                     abs       labs       srand<br />
-X                     div       ldiv       rand<br />
-<br />
-X  long   abs(long);               // labs()<br />
-X  ldiv_t div(long, long);         // ldiv()<br />
-<br />
-X  float abs  (float);<br />
-X  float acos (float);<br />
-X  float asin (float);<br />
-X  float atan (float);<br />
-X  float atan2(float, float);<br />
-X  float ceil (float);<br />
-X  float cos  (float);<br />
-X  float cosh (float);<br />
-X  float exp  (float);<br />
-X  float fabs (float);<br />
-X  float floor(float);<br />
-X  float fmod (float, float);<br />
-X  float frexp(float, int*);<br />
-X  float ldexp(float, int);<br />
-X  float log  (float);<br />
-X  float log10(float);<br />
-X  float modf (float, float*);<br />
-X  float pow  (float, float);<br />
-X  float pow  (float, int);<br />
-X  float sin  (float);<br />
-X  float sinh (float);<br />
-X  float sqrt (float);<br />
-X  float tan  (float);<br />
-X  float tanh (float);<br />
-<br />
-X  double abs(double);            // fabs()<br />
-X  double pow(double, int);<br />
-<br />
-X  long double abs  (long double);<br />
-X  long double acos (long double);<br />
-X  long double asin (long double);<br />
-X  long double atan (long double);<br />
-X  long double atan2(long double, long double);<br />
-X  long double ceil (long double);<br />
-X  long double cos  (long double);<br />
-X  long double cosh (long double);<br />
-X  long double exp  (long double);<br />
-X  long double fabs (long double);<br />
-X  long double floor(long double);<br />
-X  long double fmod (long double, long double);<br />
-X  long double frexp(long double, int*);<br />
-X  long double ldexp(long double, int);<br />
-X  long double log  (long double);<br />
-X  long double log10(long double);<br />
-X  long double modf (long double, long double*);<br />
-X  long double pow  (long double, long double);<br />
-X  long double pow  (long double, int);<br />
-X  long double sin  (long double);<br />
-X  long double sinh (long double);<br />
-X  long double sqrt (long double);<br />
-X  long double tan  (long double);<br />
-X  long double tanh (long double);<br />
-<br />
-   Header &lt;iosfwd&gt; synopsis<br />
-<br />
-X   template&lt;class charT&gt; class char_traits;<br />
-X   template&lt;&gt; class char_traits&lt;char&gt;;<br />
-X   template&lt;&gt; class char_traits&lt;wchar_t&gt;;<br />
-X   template&lt;class T&gt; class allocator;<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ios;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_streambuf;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_istream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ostream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_iostream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_stringbuf;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_istringstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_ostringstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_stringstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_filebuf;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ifstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ofstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_fstream;<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class istreambuf_iterator;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class ostreambuf_iterator;<br />
-X   typedef basic_ios&lt;char&gt;       ios;<br />
-X   typedef basic_ios&lt;wchar_t&gt;    wios;<br />
-X   typedef basic_streambuf&lt;char&gt; streambuf;<br />
-X   typedef basic_istream&lt;char&gt;   istream;<br />
-X   typedef basic_ostream&lt;char&gt;   ostream;<br />
-X   typedef basic_iostream&lt;char&gt;  iostream;<br />
-X   typedef basic_stringbuf&lt;char&gt;     stringbuf;<br />
-X   typedef basic_istringstream&lt;char&gt; istringstream;<br />
-X   typedef basic_ostringstream&lt;char&gt; ostringstream;<br />
-X   typedef basic_stringstream&lt;char&gt;  stringstream;<br />
-X   typedef basic_filebuf&lt;char&gt;  filebuf;<br />
-X   typedef basic_ifstream&lt;char&gt; ifstream;<br />
-X   typedef basic_ofstream&lt;char&gt; ofstream;<br />
-X   typedef basic_fstream&lt;char&gt;  fstream;<br />
-X   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;<br />
-X   typedef basic_istream&lt;wchar_t&gt;   wistream;<br />
-X   typedef basic_ostream&lt;wchar_t&gt;   wostream;<br />
-X   typedef basic_iostream&lt;wchar_t&gt;  wiostream;<br />
-X   typedef basic_stringbuf&lt;wchar_t&gt;     wstringbuf;<br />
-X   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;<br />
-X   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;<br />
-X   typedef basic_stringstream&lt;wchar_t&gt;  wstringstream;<br />
-<br />
-X   typedef basic_filebuf&lt;wchar_t&gt;  wfilebuf;<br />
-X   typedef basic_ifstream&lt;wchar_t&gt; wifstream;<br />
-X   typedef basic_ofstream&lt;wchar_t&gt; wofstream;<br />
-X   typedef basic_fstream&lt;wchar_t&gt;  wfstream;<br />
-X   template &lt;class state&gt; class fpos;<br />
-X   typedef fpos&lt;char_traits&lt;char&gt;::state_type&gt;    streampos;<br />
-X   typedef fpos&lt;char_traits&lt;wchar_t&gt;::state_type&gt; wstreampos;<br />
-<br />
-   27.3  Standard iostream objects                 [lib.iostream.objects]<br />
-<br />
-   Header &lt;iostream&gt; synopsis<br />
-<br />
-T  [must also include &lt;istream&gt; and &lt;ostream&gt;]<br />
-T   extern istream cin;<br />
-T   extern ostream cout;<br />
-T   extern ostream cerr;<br />
-T   extern ostream clog;<br />
-<br />
-T   extern wistream wcin;<br />
-T   extern wostream wcout;<br />
-T   extern wostream wcerr;<br />
-T   extern wostream wclog;<br />
-<br />
-   27.4  Iostreams base classes                      [lib.iostreams.base]<br />
-<br />
-   Header &lt;ios&gt; synopsis<br />
-<br />
-   #include &lt;iosfwd&gt;<br />
-<br />
-T   typedef OFF_T  streamoff;<br />
-T   typedef SZ_T streamsize;<br />
-T   template &lt;class stateT&gt; class fpos;<br />
-<br />
-    class ios_base;<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ios;<br />
-   // _lib.std.ios.manip_, manipulators:<br />
-T   ios_base&amp; boolalpha  (ios_base&amp; str);<br />
-T   ios_base&amp; noboolalpha(ios_base&amp; str);<br />
-T   ios_base&amp; showbase   (ios_base&amp; str);<br />
-T   ios_base&amp; noshowbase (ios_base&amp; str);<br />
-T   ios_base&amp; showpoint  (ios_base&amp; str);<br />
-T   ios_base&amp; noshowpoint(ios_base&amp; str);<br />
-T   ios_base&amp; showpos    (ios_base&amp; str);<br />
-T   ios_base&amp; noshowpos  (ios_base&amp; str);<br />
-T   ios_base&amp; skipws     (ios_base&amp; str);<br />
-T   ios_base&amp; noskipws   (ios_base&amp; str);<br />
-T   ios_base&amp; nouppercase(ios_base&amp; str);<br />
-T   ios_base&amp; uppercase  (ios_base&amp; str);<br />
-M   ios_base&amp; unitbuf    (ios_base&amp; str);<br />
-M   ios_base&amp; nounitbuf  (ios_base&amp; str);<br />
-   // _lib.adjustfield.manip_ adjustfield:<br />
-T   ios_base&amp; internal   (ios_base&amp; str);<br />
-T   ios_base&amp; left       (ios_base&amp; str);<br />
-T   ios_base&amp; right      (ios_base&amp; str);<br />
-   // _lib.basefield.manip_ basefield:<br />
-T   ios_base&amp; dec        (ios_base&amp; str);<br />
-T   ios_base&amp; hex        (ios_base&amp; str);<br />
-T   ios_base&amp; oct        (ios_base&amp; str);<br />
-<br />
-   // _lib.floatfield.manip_ floatfield:<br />
-T   ios_base&amp; fixed      (ios_base&amp; str);<br />
-T   ios_base&amp; scientific (ios_base&amp; str);<br />
-<br />
-<br />
-   27.4.2  Class ios_base                                  [lib.ios.base]<br />
-<br />
-T   class ios_base {<br />
-    public:<br />
-      class failure;<br />
-T     typedef T1 fmtflags;<br />
-T     static const fmtflags boolalpha;<br />
-T     static const fmtflags dec;<br />
-T     static const fmtflags fixed;<br />
-T     static const fmtflags hex;<br />
-T     static const fmtflags internal;<br />
-T     static const fmtflags left;<br />
-T     static const fmtflags oct;<br />
-T     static const fmtflags right;<br />
-T     static const fmtflags scientific;<br />
-T     static const fmtflags showbase;<br />
-T     static const fmtflags showpoint;<br />
-T     static const fmtflags showpos;<br />
-T     static const fmtflags skipws;<br />
-X     static const fmtflags unitbuf;<br />
-T     static const fmtflags uppercase;<br />
-T     static const fmtflags adjustfield;<br />
-T     static const fmtflags basefield;<br />
-T     static const fmtflags floatfield;<br />
-<br />
-      typedef T2 iostate;<br />
-T     static const iostate badbit;<br />
-T     static const iostate eofbit;<br />
-T     static const iostate failbit;<br />
-T     static const iostate goodbit;<br />
-T     typedef T3 openmode;<br />
-T     static const openmode app;<br />
-T     static const openmode ate;<br />
-T     static const openmode binary;<br />
-T     static const openmode in;<br />
-T     static const openmode out;<br />
-T     static const openmode trunc;<br />
-T     typedef T4 seekdir;<br />
-T     static const seekdir beg;<br />
-T     static const seekdir cur;<br />
-T     static const seekdir end;<br />
-T     class Init;<br />
-      // _lib.fmtflags.state_ fmtflags state:<br />
-T     fmtflags flags() const;<br />
-T     fmtflags flags(fmtflags fmtfl);<br />
-T     fmtflags setf(fmtflags fmtfl);<br />
-T     fmtflags setf(fmtflags fmtfl, fmtflags mask);<br />
-T     void unsetf(fmtflags mask);<br />
-T     streamsize precision() const;<br />
-T     streamsize precision(streamsize prec);<br />
-T     streamsize width() const;<br />
-T     streamsize width(streamsize wide);<br />
-      // _lib.ios.base.locales_ locales:<br />
-T     locale imbue(const locale&amp; loc);<br />
-T     locale getloc() const;<br />
-      // _lib.ios.base.storage_ storage:<br />
-T     static int xalloc();<br />
-T     long&amp;  iword(int index);<br />
-T     void*&amp; pword(int index);<br />
-      // destructor<br />
-T     virtual ~ios_base();<br />
-      // _lib.ios.base.callback_ callbacks;<br />
-T     enum event { erase_event, imbue_event, copyfmt_event };<br />
-T     typedef void (*event_callback)(event, ios_base&amp;, int index);<br />
-T     void register_callback(event_call_back fn, int index);<br />
-T     static bool sync_with_stdio(bool sync = true);<br />
-    protected:<br />
-T     ios_base();<br />
-    };<br />
-<br />
-   27.4.2.1.1  Class ios_base::failure                 [lib.ios::failure]<br />
-<br />
-T   class ios_base::failure : public exception {<br />
-    public:<br />
-T     explicit failure(const string&amp; msg);<br />
-T     virtual ~failure();<br />
-T     virtual const char* what() const throw();<br />
-    };<br />
-<br />
-<br />
-   27.4.2.1.6  Class ios_base::Init                       [lib.ios::Init]<br />
-<br />
-T   class ios_base::Init {<br />
-    public:<br />
-T     Init();<br />
-T    ~Init();<br />
-    };<br />
-<br />
-<br />
-   27.4.3  Template class fpos                                 [lib.fpos]<br />
-<br />
-X   template &lt;class stateT&gt; class fpos {<br />
-    public:<br />
-      // _lib.fpos.members_ Members<br />
-T     stateT state() const;<br />
-T     void state(stateT);<br />
-    private;<br />
-T     stateT st; // exposition only<br />
-    };<br />
-<br />
-<br />
-   27.4.5  Template class basic_ios                             [lib.ios]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_ios : public ios_base {<br />
-    public:<br />
-<br />
-      // Types:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-T     operator void*() const<br />
-T     bool operator!() const<br />
-T     iostate rdstate() const;<br />
-T     void clear(iostate state = goodbit);<br />
-T     void setstate(iostate state);<br />
-T     bool good() const;<br />
-T     bool eof()  const;<br />
-T     bool fail() const;<br />
-T     bool bad()  const;<br />
-T     iostate exceptions() const;<br />
-T     void exceptions(iostate except);<br />
-      // _lib.basic.ios.cons_ Constructor/destructor:<br />
-T     explicit basic_ios(basic_streambuf&lt;charT,traits&gt;* sb);<br />
-T     virtual ~basic_ios();<br />
-      // _lib.basic.ios.members_ Members:<br />
-T     basic_ostream&lt;charT,traits&gt;* tie() const;<br />
-T     basic_ostream&lt;charT,traits&gt;* tie(basic_ostream&lt;charT,traits&gt;* tiestr);<br />
-T     basic_streambuf&lt;charT,traits&gt;* rdbuf() const;<br />
-T     basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);<br />
-X     basic_ios&amp; copyfmt(const basic_ios&amp; rhs);<br />
-T     char_type fill() const;<br />
-T     char_type fill(char_type ch);<br />
-      // _lib.ios.base.locales_ locales:<br />
-T     locale imbue(const locale&amp; loc);<br />
-X     char     narrow(char_type c, char dfault) const;<br />
-X     char_type widen(char c) const;<br />
-    protected:<br />
-      basic_ios();<br />
-T     void init(basic_streambuf&lt;charT,traits&gt;* sb);<br />
-   private:<br />
-T     basic_ios(const basic_ios&amp; );       // not defined<br />
-T     basic_ios&amp; operator=(const basic_ios&amp;);     // not defined<br />
-    };<br />
-<br />
-<br />
-   27.5  Stream buffers                              [lib.stream.buffers]<br />
-<br />
-   Header &lt;streambuf&gt; synopsis<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_streambuf;<br />
-T   typedef basic_streambuf&lt;char&gt;     streambuf;<br />
-T   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;<br />
-<br />
-   27.5.2  Template class                                 [lib.streambuf]<br />
-       basic_streambuf&lt;charT,traits&gt;<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_streambuf {<br />
-    public:<br />
-<br />
-      // Types:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-T     virtual ~basic_streambuf();<br />
-      // _lib.streambuf.locales_ locales:<br />
-T     locale   pubimbue(const locale &amp;loc);<br />
-T     locale   getloc() const;<br />
-      // _lib.streambuf.buffer_ buffer and positioning:<br />
-T     basic_streambuf&lt;char_type,traits&gt;*<br />
-               pubsetbuf(char_type* s, streamsize n);<br />
-T     pos_type pubseekoff(off_type off, ios_base::seekdir way,<br />
-                          ios_base::openmode which =<br />
-                              ios_base::in | ios_base::out);<br />
-T     pos_type pubseekpos(pos_type sp,<br />
-                          ios_base::openmode which =<br />
-                              ios_base::in | ios_base::out);<br />
-T     int      pubsync();<br />
-<br />
-      // Get and put areas:<br />
-      // _lib.streambuf.pub.get_ Get area:<br />
-T     streamsize in_avail();<br />
-T     int_type snextc();<br />
-T     int_type sbumpc();<br />
-T     int_type sgetc();<br />
-T     streamsize sgetn(char_type* s, streamsize n);<br />
-      // _lib.streambuf.pub.pback_ Putback:<br />
-X     int_type sputbackc(char_type c);<br />
-X     int_type sungetc();<br />
-      // _lib.streambuf.pub.put_ Put area:<br />
-T     int_type   sputc(char_type c);<br />
-X     streamsize sputn(const char_type* s, streamsize n);<br />
-    protected:<br />
-T     basic_streambuf();<br />
-      // _lib.streambuf.get.area_ Get area:<br />
-T     char_type* eback() const;<br />
-T     char_type* gptr()  const;<br />
-T     char_type* egptr() const;<br />
-T     void       gbump(int n);<br />
-T     void       setg(char_type* gbeg, char_type* gnext, char_type* gend);<br />
-      // _lib.streambuf.put.area_ Put area:<br />
-T     char_type* pbase() const;<br />
-T     char_type* pptr() const;<br />
-T     char_type* epptr() const;<br />
-T     void       pbump(int n);<br />
-T     void       setp(char_type* pbeg, char_type* pend);<br />
-      // _lib.streambuf.virtuals_ virtual functions:<br />
-      // _lib.streambuf.virt.locales_ Locales:<br />
-T     virtual void imbue(const locale &amp;loc);<br />
-      // _lib.streambuf.virt.buffer_ Buffer management and positioning:<br />
-T     virtual basic_streambuf&lt;char_type,traits&gt;*<br />
-                       setbuf(char_type* s, streamsize n);<br />
-T     virtual pos_type seekoff(off_type off, ios_base::seekdir way,<br />
-                ios_base::openmode which = ios_base::in | ios_base::out);<br />
-T     virtual pos_type seekpos(pos_type sp,<br />
-                ios_base::openmode which = ios_base::in | ios_base::out);<br />
-T     virtual int      sync();<br />
-      // _lib.streambuf.virt.get_ Get area:<br />
-T     virtual int        showmanyc();<br />
-T     virtual streamsize xsgetn(char_type* s, streamsize n);<br />
-T     virtual int_type   underflow();<br />
-T     virtual int_type   uflow();<br />
-      // _lib.streambuf.virt.pback_ Putback:<br />
-T     virtual int_type   pbackfail(int_type c = traits::eof());<br />
-      // _lib.streambuf.virt.put_ Put area:<br />
-X     virtual streamsize xsputn(const char_type* s, streamsize n);<br />
-T     virtual int_type   overflow (int_type c = traits::eof());<br />
-    };<br />
-<br />
-   27.6  Formatting and manipulators                [lib.iostream.format]<br />
-<br />
-   Header &lt;istream&gt; synopsis<br />
-<br />
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_istream;<br />
-T   typedef basic_istream&lt;char&gt;     istream;<br />
-T   typedef basic_istream&lt;wchar_t&gt; wistream;<br />
-<br />
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_iostream;<br />
-T   typedef basic_iostream&lt;char&gt;    iostream;<br />
-T   typedef basic_iostream&lt;wchar_t&gt; wiostream;<br />
-<br />
-X   template &lt;class charT, class traits&gt;<br />
-      basic_istream&lt;charT,traits&gt;&amp; ws(basic_istream&lt;charT,traits&gt;&amp; is);<br />
-<br />
-   Header &lt;ostream&gt; synopsis<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ostream;<br />
-T   typedef basic_ostream&lt;char&gt;     ostream;<br />
-T   typedef basic_ostream&lt;wchar_t&gt; wostream;<br />
-<br />
-T   template &lt;class charT, class traits&gt;<br />
-      basic_ostream&lt;charT,traits&gt;&amp; endl(basic_ostream&lt;charT,traits&gt;&amp; os);<br />
-T   template &lt;class charT, class traits&gt;<br />
-      basic_ostream&lt;charT,traits&gt;&amp; ends(basic_ostream&lt;charT,traits&gt;&amp; os);<br />
-T   template &lt;class charT, class traits&gt;<br />
-      basic_ostream&lt;charT,traits&gt;&amp; flush(basic_ostream&lt;charT,traits&gt;&amp; os);<br />
-<br />
-   Header &lt;iomanip&gt; synopsis<br />
-<br />
-      // Types T1, T2, ... are unspecified implementation types<br />
-T     T1 resetiosflags(ios_base::fmtflags mask);<br />
-T     T2 setiosflags  (ios_base::fmtflags mask);<br />
-T     T3 setbase(int base);<br />
-T     template&lt;charT&gt; T4 setfill(charT c);<br />
-T     T5 setprecision(int n);<br />
-T     T6 setw(int n);<br />
-<br />
-<br />
-   27.6.1.1  Template class basic_istream                   [lib.istream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-T   class basic_istream : virtual public basic_ios&lt;charT,traits&gt; {<br />
-    public:<br />
-    // Types (inherited from basic_ios (_lib.ios_)):<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.istream.cons_ Constructor/destructor:<br />
-T     explicit basic_istream(basic_streambuf&lt;charT,traits&gt;* sb);<br />
-T     virtual ~basic_istream();<br />
-      // _lib.istream::sentry_ Prefix/suffix:<br />
-T     class sentry;<br />
-<br />
-      // _lib.istream.formatted_ Formatted input:<br />
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;<br />
-          (basic_istream&lt;charT,traits&gt;&amp; (*pf)(basic_istream&lt;charT,traits&gt;&amp;))<br />
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;<br />
-          (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;))<br />
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;<br />
-          (ios_base&amp; (*pf)(ios_base&amp;))<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(bool&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(short&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned short&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(int&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned int&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned long&amp; n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(float&amp; f);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(double&amp; f);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long double&amp; f);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(void*&amp; p);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;<br />
-          (basic_streambuf&lt;char_type,traits&gt;* sb);<br />
-      // _lib.istream.unformatted_ Unformatted input:<br />
-T     streamsize gcount() const;<br />
-S     int_type get();<br />
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type&amp; c);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n,<br />
-                        char_type delim);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb,<br />
-                        char_type delim);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n,<br />
-                        char_type delim);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; ignore<br />
-          (streamsize n = 1, int_type delim = traits::eof());<br />
-S     int_type                     peek();<br />
-S     basic_istream&lt;charT,traits&gt;&amp; read    (char_type* s, streamsize n);<br />
-S     streamsize                   readsome(char_type* s, streamsize n);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; putback(char_type c);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; unget();<br />
-S     int sync();<br />
-<br />
-S     pos_type tellg();<br />
-S     basic_istream&lt;charT,traits&gt;&amp; seekg(pos_type);<br />
-S     basic_istream&lt;charT,traits&gt;&amp; seekg(off_type, ios_base::seekdir);<br />
-    };<br />
-<br />
-    // _lib.istream::extractors_ character extraction templates:<br />
-S   template&lt;class charT, class traits&gt;<br />
-      basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,<br />
-                                              charT&amp;);<br />
-S   template&lt;class traits&gt;<br />
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,<br />
-                                             unsigned char&amp;);<br />
-S   template&lt;class traits&gt;<br />
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,<br />
-                                             signed char&amp;);<br />
-<br />
-S   template&lt;class charT, class traits&gt;<br />
-      basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,<br />
-                                              charT*);<br />
-S   template&lt;class traits&gt;<br />
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,<br />
-                                             unsigned char*);<br />
-S   template&lt;class traits&gt;<br />
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,<br />
-                                             signed char*);<br />
-<br />
-   27.6.1.1.2  Class basic_istream::sentry          [lib.istream::sentry]<br />
-<br />
-<br />
-    template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;<br />
-S   class basic_istream&lt;charT,traits&gt;::sentry {<br />
-      typedef traits traits_type;<br />
-S     bool ok_; // exposition only<br />
-     public:<br />
-S     explicit sentry(basic_istream&lt;charT,traits&gt;&amp; is, bool noskipws = false);<br />
-S     ~sentry();<br />
-S     operator bool() const { return ok_; }<br />
-     private:<br />
-T     sentry(const sentry&amp;); //   not defined<br />
-T     sentry&amp; operator=(const sentry&amp;); //   not defined<br />
-    };<br />
-<br />
-<br />
-   27.6.1.5  Template class basic_iostream            [lib.iostreamclass]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-T   class basic_iostream :<br />
-      public basic_istream&lt;charT,traits&gt;,<br />
-      public basic_ostream&lt;charT,traits&gt; {<br />
-    public:<br />
-      // constructor/destructor<br />
-T     explicit basic_iostream(basic_streambuf&lt;charT,traits&gt;* sb);<br />
-T     virtual ~basic_iostream();<br />
-    };<br />
-<br />
-<br />
-   27.6.2.1  Template class basic_ostream                   [lib.ostream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {<br />
-    public:<br />
-    // Types (inherited from basic_ios (_lib.ios_)):<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.ostream.cons_ Constructor/destructor:<br />
-T     explicit basic_ostream(basic_streambuf&lt;char_type,traits&gt;* sb);<br />
-T     virtual ~basic_ostream();<br />
-      // _lib.ostream::sentry_ Prefix/suffix:<br />
-T     class sentry;<br />
-      // _lib.ostream.formatted_ Formatted output:<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;<br />
-          (basic_ostream&lt;charT,traits&gt;&amp; (*pf)(basic_ostream&lt;charT,traits&gt;&amp;));<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;<br />
-          (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;));<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;<br />
-          (ios_base&amp; (*pf)(ios_base&amp;));<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(bool n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(short n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned short n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(int n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned int n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long n);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned long n);<br />
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(float f);<br />
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(double f);<br />
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long double f);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(const void* p);<br />
-X     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;<br />
-          (basic_streambuf&lt;char_type,traits&gt;* sb);<br />
-      // _lib.ostream.unformatted_ Unformatted output:<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; put(char_type c);<br />
-T     basic_ostream&lt;charT,traits&gt;&amp; write(const char_type* s, streamsize n);<br />
-X     basic_ostream&lt;charT,traits&gt;&amp; flush();<br />
-<br />
-      // _lib.ostream.seeks_ seeks:<br />
-S     pos_type tellp();<br />
-S     basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type);<br />
-S     basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type, ios_base::seekdir);<br />
-    };<br />
-    // _lib.ostream.inserters.character_ character inserters<br />
-X   template&lt;class charT, class traits&gt;<br />
-    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,<br />
-                                            charT);<br />
-X   template&lt;class charT, class traits&gt;<br />
-    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,<br />
-                                            char);<br />
-    // specialization<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             char);<br />
-    // signed and unsigned<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             signed char);<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             unsigned char)<br />
-X   template&lt;class charT, class traits&gt;<br />
-      basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,<br />
-                                              const charT*);<br />
-X   template&lt;class charT, class traits&gt;<br />
-      basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,<br />
-                                              const char*);<br />
-    // partial specializationss<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             const char*);<br />
-    //  signed and unsigned<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             const signed char*);<br />
-X   template&lt;class traits&gt;<br />
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,<br />
-                                             const unsigned char*);<br />
-<br />
-<br />
-   27.6.2.3  Class basic_ostream::sentry            [lib.ostream::sentry]<br />
-<br />
-    template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_ostream&lt;charT,traits&gt;::sentry {<br />
-      bool ok_; // exposition only<br />
-     public:<br />
-X     explicit sentry(basic_ostream&lt;charT,traits&gt;&amp; os);<br />
-X     ~sentry();<br />
-X     operator bool() const { return ok_; }<br />
-     private<br />
-X     sentry(const sentry&amp;); //   not defined<br />
-X     sentry&amp; operator=(const sentry&amp;); //   not defined<br />
-    };<br />
-<br />
-   27.7  String-based streams                        [lib.string.streams]<br />
-<br />
-   Header &lt;sstream&gt; synopsis<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-                      class Allocator = allocator&lt;charT&gt; &gt;<br />
-      class basic_stringbuf;<br />
-<br />
-T   typedef basic_stringbuf&lt;char&gt;     stringbuf;<br />
-T   typedef basic_stringbuf&lt;wchar_t&gt; wstringbuf;<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-                      class Allocator = allocator&lt;charT&gt; &gt;<br />
-X     class basic_istringstream;<br />
-<br />
-T   typedef basic_istringstream&lt;char&gt;     istringstream;<br />
-T   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-                      class Allocator = allocator&lt;charT&gt; &gt;<br />
-X     class basic_ostringstream;<br />
-T   typedef basic_ostringstream&lt;char&gt;     ostringstream;<br />
-T   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-                      class Allocator = allocator&lt;charT&gt; &gt;<br />
-X     class basic_stringstream;<br />
-T   typedef basic_stringstream&lt;char&gt;     stringstream;<br />
-T   typedef basic_stringstream&lt;wchar_t&gt; wstringstream;<br />
-<br />
-   27.7.1  Template class basic_stringbuf                 [lib.stringbuf]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-X   class basic_stringbuf : public basic_streambuf&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.stringbuf.cons_ Constructors:<br />
-S     explicit basic_stringbuf(ios_base::openmode which<br />
-                                = ios_base::in | ios_base::out);<br />
-S     explicit basic_stringbuf<br />
-          (const basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-           ios_base::openmode which = ios_base::in | ios_base::out);<br />
-      // _lib.stringbuf.members_ Get and set:<br />
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;<br />
-S     void               str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);<br />
-<br />
-    protected:<br />
-      // _lib.stringbuf.virtuals_ Overridden virtual functions:<br />
-S     virtual int_type   underflow();<br />
-S     virtual int_type   pbackfail(int_type c = traits::eof());<br />
-S     virtual int_type   overflow (int_type c = traits::eof());<br />
-S     virtual  basic_streambuf&lt;charT,traits&gt;* setbuf(charT*, streamsize);<br />
-<br />
-S     virtual pos_type   seekoff(off_type off, ios_base::seekdir way,<br />
-                                 ios_base::openmode which<br />
-                                  = ios_base::in | ios_base::out);<br />
-S     virtual pos_type   seekpos(pos_type sp,<br />
-                                 ios_base::openmode which<br />
-                                  = ios_base::in | ios_base::out);<br />
-    };<br />
-<br />
-<br />
-   27.7.2  Template class basic_istringstream         [lib.istringstream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-X   class basic_istringstream : public basic_istream&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.istringstream.cons_ Constructors:<br />
-S     explicit basic_istringstream(ios_base::openmode which = ios_base::in);<br />
-S     explicit basic_istringstream(<br />
-                         const basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-                         ios_base::openmode which = ios_base::in);<br />
-<br />
-      // _lib.istringstream.members_ Members:<br />
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;<br />
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;<br />
-S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);<br />
-   private:<br />
-   //  basic_stringbuf&lt;charT,traits,Allocator&gt; sb;   exposition only<br />
-    };<br />
-<br />
-   27.7.3  Class basic_ostringstream                  [lib.ostringstream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-X   class basic_ostringstream : public basic_ostream&lt;charT,traits&gt; {<br />
-    public:<br />
-<br />
-      // Types:<br />
-T     typedef charT            char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-      // _lib.ostringstream.cons_ Constructors/destructor:<br />
-S     explicit basic_ostringstream(ios_base::openmode which = ios_base::out);<br />
-S     explicit basic_ostringstream(<br />
-                           const basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-                           ios_base::openmode which = ios_base::out);<br />
-      // _lib.ostringstream.members_ Members:<br />
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;<br />
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;<br />
-S     void    str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);<br />
-    };<br />
-<br />
-<br />
-   27.7.4  Template class basic_stringstream           [lib.stringstream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,<br />
-              class Allocator = allocator&lt;charT&gt; &gt;<br />
-X   class basic_stringstream<br />
-      : public basic_iostream&lt;charT,traits&gt; {<br />
-    public:<br />
-      // Types<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-      // constructors/destructors<br />
-S     explicit basic_stringstream(<br />
-          ios_base::openmode which = ios_base::out|ios_base::in);<br />
-S     explicit basic_stringstream(<br />
-          const basic_string&lt;charT,traits,Allocator&gt;&amp; str,<br />
-          ios_base::openmode which = ios_base::out|ios_base::in);<br />
-      // Members:<br />
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;<br />
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;<br />
-S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);<br />
-    };<br />
-<br />
-<br />
-<br />
-   27.8.1  File streams                                    [lib.fstreams]<br />
-<br />
-<br />
-   Header &lt;fstream&gt; synopsis<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_filebuf;<br />
-T   typedef basic_filebuf&lt;char&gt;    filebuf;<br />
-T   typedef basic_filebuf&lt;wchar_t&gt; wfilebuf;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ifstream;<br />
-T   typedef basic_ifstream&lt;char&gt;    ifstream;<br />
-T   typedef basic_ifstream&lt;wchar_t&gt; wifstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_ofstream;<br />
-T   typedef basic_ofstream&lt;char&gt;    ofstream;<br />
-T   typedef basic_ofstream&lt;wchar_t&gt; wofstream;<br />
-<br />
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-      class basic_fstream;<br />
-T   typedef basic_fstream&lt;char&gt;     fstream;<br />
-T   typedef basic_fstream&lt;wchar_t&gt; wfstream;<br />
-<br />
-   27.8.1.1  Template class basic_filebuf                   [lib.filebuf]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.filebuf.cons_ Constructors/destructor:<br />
-X     basic_filebuf();<br />
-X     virtual ~basic_filebuf();<br />
-       // _lib.filebuf.members_ Members:<br />
-T     bool is_open() const;<br />
-X     basic_filebuf&lt;charT,traits&gt;* open<br />
-          (const char* s, ios_base::openmode mode);<br />
-X     basic_filebuf&lt;charT,traits&gt;* close();<br />
-    protected:<br />
-      // _lib.filebuf.virtuals_ Overridden virtual functions:<br />
-X     virtual streamsize showmanyc();<br />
-X     virtual int_type underflow();<br />
-X     virtual int_type uflow();<br />
-X     virtual int_type pbackfail(int_type c = traits::eof());<br />
-X     virtual int_type overflow (int_type c = traits::eof());<br />
-S     virtual basic_streambuf&lt;charT,traits&gt;*<br />
-                       setbuf(char_type* s, streamsize n);<br />
-S     virtual pos_type seekoff(off_type off, ios_base::seekdir way,<br />
-                               ios_base::openmode which<br />
-                                 = ios_base::in | ios_base::out);<br />
-S     virtual pos_type seekpos(pos_type sp, ios_base::openmode which<br />
-                                 = ios_base::in | ios_base::out);<br />
-S     virtual int      sync();<br />
-S     virtual void     imbue(const locale&amp; loc);<br />
-    };<br />
-<br />
-<br />
-<br />
-   27.8.1.5  Template class basic_ifstream                 [lib.ifstream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_ifstream : public basic_istream&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.ifstream.cons_ Constructors:<br />
-S     basic_ifstream();<br />
-S     explicit basic_ifstream(const char* s,<br />
-                              ios_base::openmode mode = ios_base::in);<br />
-      // _lib.ifstream.members_ Members:<br />
-S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;<br />
-S     bool is_open();<br />
-S     void open(const char* s, ios_base::openmode mode = ios_base::in);<br />
-S     void close();<br />
-    };<br />
-<br />
-<br />
-   27.8.1.8  Template class basic_ofstream                 [lib.ofstream]<br />
-<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-X   class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // _lib.ofstream.cons_ Constructors:<br />
-X     basic_ofstream();<br />
-X     explicit basic_ofstream(const char* s,<br />
-                              ios_base::openmode mode<br />
-                                = ios_base::out);<br />
-      // _lib.ofstream.members_ Members:<br />
-X     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;<br />
-T     bool is_open();<br />
-X     void open(const char* s, ios_base::openmode mode = ios_base::out);<br />
-X     void close();<br />
-    };<br />
-<br />
-<br />
-   27.8.1.11  Template class basic_fstream                  [lib.fstream]<br />
-<br />
-    template &lt;class charT, class traits=char_traits&lt;charT&gt; &gt;<br />
-X   class basic_fstream<br />
-      : public basic_iostream&lt;charT,traits&gt; {<br />
-    public:<br />
-T     typedef charT                     char_type;<br />
-T     typedef typename traits::int_type int_type;<br />
-T     typedef typename traits::pos_type pos_type;<br />
-T     typedef typename traits::off_type off_type;<br />
-T     typedef traits                    traits_type;<br />
-      // constructors/destructor<br />
-S     basic_fstream();<br />
-S     explicit basic_fstream(<br />
-          const char* s,<br />
-          ios_base::openmode mode = ios_base::in|ios_base::out);<br />
-<br />
-      // Members:<br />
-S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;<br />
-S     bool is_open();<br />
-S     void open(<br />
-          const char* s,<br />
-          ios_base::openmode mode = ios_base::in|ios_base::out);<br />
-S     void close();<br />
-    };<br />
-<br />
-<br />
-<br />
-   27.8.2  C Library files                                  [lib.c.files]<br />
-<br />
-<br />
-                    Table 13--Header &lt;cstdio&gt; synopsis<br />
-    Macros:<br />
-X   BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX<br />
-X   EOF            NULL &lt;cstdio&gt;   stderr     _IOFBF<br />
-X   FILENAME_MAX   SEEK_CUR        stdin      _IOLBF<br />
-X   FOPEN_MAX      SEEK_END        stdout     _IONBF<br />
-<br />
-X   Types:         FILE            fpos_t     size_t &lt;cstdio&gt;<br />
-    Functions:<br />
-X   clearerr       fgets           fscanf     gets     rewind<br />
-X   fclose         fopen           fseek      perror   scanf     tmpnam<br />
-X   feof           fprintf         fsetpos    printf   setbuf    ungetc<br />
-X   ferror         fputc           ftell      putc     setvbuf   vprintf<br />
-X   fflush         fputs           fwrite     puts     sprintf   vfprintf<br />
-X   fgetc          fread           getc       remove   sscanf    vsprintf<br />
-X   fgetpos        freopen         getchar    putchar  rename    tmpfile<br />
-<br />
-<br />
-<br />
-<br />
-   1.5  Standard C library headers                       [depr.c.headers]<br />
-<br />
-X     &lt;assert.h&gt;   &lt;iso646.h&gt;   &lt;setjmp.h&gt;   &lt;stdio.h&gt;    &lt;wchar.h&gt;<br />
-      &lt;ctype.h&gt;    &lt;limits.h&gt;   &lt;signal.h&gt;   &lt;stdlib.h&gt;   &lt;wctype.h&gt;<br />
-      &lt;errno.h&gt;    &lt;locale.h&gt;   &lt;stdarg.h&gt;   &lt;string.h&gt;<br />
-      &lt;float.h&gt;    &lt;math.h&gt;     &lt;stddef.h&gt;   &lt;time.h&gt;<br />
-<br />
-   1.6  Old iostreams members                          [depr.ios.members]<br />
-<br />
-   [Note: these should be #ifdef'd to permit diagnostics if used.]<br />
-   namespace std {<br />
-    class ios_base {<br />
-    public:<br />
-T     typedef T1  io_state;<br />
-T     typedef T2 open_mode;<br />
-T     typedef T3  seek_dir;<br />
-T     typedef OFF_T  streamoff;<br />
-T     typedef OFF_T  streampos;<br />
-      // remainder unchanged<br />
-    };<br />
-   }<br />
-<br />
-   [Note: these should be #ifdef'd to permit diagnostics if used.]<br />
-   namespace std {<br />
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-    class basic_streambuf {<br />
-    public:<br />
-T     void stossc();<br />
-      // remainder unchanged<br />
-    };<br />
-   }<br />
-<br />
-   8 An implementation may provide  the  following  member  functions  that<br />
-   overload signatures specified in clause _lib.iostreams_:<br />
-<br />
-   [Note: the following overloads should be #ifdef'd to permit<br />
-    diagnostics to be emitted, by default, if used.]<br />
-<br />
-    template&lt;class charT, class Traits&gt; class basic_ios {<br />
-    public:<br />
-M     void clear(io_state state);<br />
-M     void setstate(io_state state);<br />
-      // remainder unchanged<br />
-    };<br />
-    class ios_base {<br />
-    public:<br />
-M     void exceptions(io_state);<br />
-      // remainder unchanged<br />
-    };<br />
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-    class basic_streambuf {<br />
-    public:<br />
-M     pos_type pubseekoff(off_type off, ios_base::seek_dir way,<br />
-                ios_base::open_mode which = ios_base::in | ios_base::out);<br />
-M     pos_type pubseekpos(pos_type sp,<br />
-                ios_base::open_mode which = ios_base::in | ios_base::out);<br />
-      // remainder unchanged<br />
-    };<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-    class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {<br />
-    public:<br />
-M     basic_filebuf&lt;charT,traits&gt;* open<br />
-          (const char* s, ios_base::open_mode mode);<br />
-      // remainder unchanged<br />
-    };<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-    class basic_ifstream : public basic_istream&lt;charT,traits&gt; {<br />
-    public:<br />
-M     void open(const char* s, ios_base::open_mode mode = in);<br />
-      // remainder unchanged<br />
-    };<br />
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;<br />
-    class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {<br />
-    public:<br />
-M     void open(const char* s, ios_base::open_mode mode = out | trunc);<br />
-      // remainder unchanged<br />
-    };<br />
-   }<br />
-<br />
-<br />
-<br />
-   1.7.1  Class strstreambuf                          [depr.strstreambuf]<br />
-<br />
-   [Note: It should be possible to adopt these components with only<br />
-    minor changes from the 2.8 version of the library.]<br />
-<br />
-M   class strstreambuf : public basic_streambuf&lt;char&gt; {<br />
-    public:<br />
-M     explicit strstreambuf(streamsize alsize_arg = 0);<br />
-M     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));<br />
-M     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);<br />
-M     strstreambuf(const char* gnext_arg, streamsize n);<br />
-M     strstreambuf(signed char* gnext_arg, streamsize n,<br />
-                   signed char* pbeg_arg = 0);<br />
-M     strstreambuf(const signed char* gnext_arg, streamsize n);<br />
-M     strstreambuf(unsigned char* gnext_arg, streamsize n,<br />
-                   unsigned char* pbeg_arg = 0);<br />
-M     strstreambuf(const unsigned char* gnext_arg, streamsize n);<br />
-M     virtual ~strstreambuf();<br />
-M     void  freeze(bool freezefl = true);<br />
-M     char* str();<br />
-M     int   pcount();<br />
-    protected:<br />
-M     virtual int_type overflow (int_type c = EOF);<br />
-M     virtual int_type pbackfail(int_type c = EOF);<br />
-M     virtual int_type underflow();<br />
-M     virtual pos_type seekoff(off_type off, ios_base::seekdir way,<br />
-                               ios_base::openmode which<br />
-                                = ios_base::in | ios_base::out);<br />
-M     virtual pos_type seekpos(pos_type sp, ios_base::openmode which<br />
-                                = ios_base::in | ios_base::out);<br />
-M     virtual streambuf&lt;char&gt;* setbuf(char* s, streamsize n);<br />
-   }<br />
-<br />
-   1.7.4  Class strstream                                [depr.strstream]<br />
-<br />
-M   class strstream<br />
-      : public basic_iostream&lt;char&gt; {<br />
-    public:<br />
-      // Types<br />
-M     typedef char                                char_type;<br />
-M     typedef typename char_traits&lt;char&gt;::int_type int_type<br />
-M     typedef typename char_traits&lt;char&gt;::pos_type pos_type;<br />
-M     typedef typename char_traits&lt;char&gt;::off_type off_type;<br />
-      // consturctors/destructor<br />
-M     strstream();<br />
-M     strstream(char* s, int n,<br />
-                ios_base::openmode mode = ios_base::in|ios_base::out);<br />
-M     virtual ~strstream();<br />
-      // Members:<br />
-M     strstreambuf* rdbuf() const;<br />
-M     void freeze(bool freezefl = true);<br />
-M     int pcount() const;<br />
-M     char* str();<br />
-    };<br />
-</p></div></div><div class="sect3" lang="en" xml:lang="en"><div class="titlepage"><div><div><h4 class="title"><a id="standard.1998.specific"></a>Implementation Specific Behavior</h4></div></div></div><p>
-     The ISO standard defines the following phrase:
-   </p><div class="blockquote"><blockquote class="blockquote"><div class="variablelist"><dl><dt><span class="term">
-        <code class="code">[1.3.5] implementation-defined behavior</code>
-       </span></dt><dd><p>
-        Behavior, for a well-formed program construct and correct data, that
-         depends on the implementation <span class="emphasis"><em>and that each implementation
-         shall document</em></span>.
-        </p></dd></dl></div></blockquote></div><p>
-     We do so here, for the C++ library only.  Behavior of the
-     compiler, linker, runtime loader, and other elements of "the
-     implementation" are documented elsewhere.&nb