From: Benjamin Kosnik Date: Thu, 16 Apr 2009 02:04:15 +0000 (+0000) Subject: html: Regenerate, remove un-needed. X-Git-Tag: releases/gcc-4.5.0~6571 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=9434ad538492ba9fb8b40f58b903f6241882d506;p=thirdparty%2Fgcc.git html: Regenerate, remove un-needed. 2009-04-15 Benjamin Kosnik * doc/html: Regenerate, remove un-needed. From-SVN: r146145 --- diff --git a/libstdc++-v3/doc/html/manual/bk01apas02.html b/libstdc++-v3/doc/html/manual/bk01apas02.html deleted file mode 100644 index 26f6eb724794..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apas02.html +++ /dev/null @@ -1,91 +0,0 @@ - - -Directory Layout and Source Conventions
Directory Layout and Source Conventions
Prev Appendix A. Contributing Next

Directory Layout and Source Conventions

- The unpacked source directory of libstdc++ contains the files - needed to create the GNU C++ Library. -


-It has subdirectories:
-
-  doc
-    Files in HTML and text format that document usage, quirks of the
-    implementation, and contributor checklists.
-
-  include
-    All header files for the C++ library are within this directory,
-    modulo specific runtime-related files that are in the libsupc++
-    directory.
-
-    include/std
-      Files meant to be found by #include <name> directives in
-      standard-conforming user programs.  
-
-    include/c
-      Headers intended to directly include standard C headers. 
-      [NB: this can be enabled via --enable-cheaders=c]
-
-    include/c_global 
-      Headers intended to include standard C headers in
-      the global namespace, and put select names into the std::
-      namespace.  [NB: this is the default, and is the same as
-      --enable-cheaders=c_global]
-
-    include/c_std 
-      Headers intended to include standard C headers
-      already in namespace std, and put select names into the std::
-      namespace.  [NB: this is the same as --enable-cheaders=c_std]
-
-    include/bits
-      Files included by standard headers and by other files in
-      the bits directory. 
-
-    include/backward
-      Headers provided for backward compatibility, such as <iostream.h>.
-      They are not used in this library.
-
-    include/ext
-      Headers that define extensions to the standard library.  No
-      standard header refers to any of them.
-
-  scripts
-    Scripts that are used during the configure, build, make, or test
-    process.
-
-  src
-    Files that are used in constructing the library, but are not
-    installed.
-
-  testsuites/[backward, demangle, ext, performance, thread, 17_* to 27_*]
-    Test programs are here, and may be used to begin to exercise the 
-    library.  Support for "make check" and "make check-install" is
-    complete, and runs through all the subdirectories here when this
-    command is issued from the build directory.  Please note that
-    "make check" requires DejaGNU 1.4 or later to be installed.  Please
-    note that "make check-script" calls the script mkcheck, which
-    requires bash, and which may need the paths to bash adjusted to
-    work properly, as /bin/bash is assumed.
-
-Other subdirectories contain variant versions of certain files
-that are meant to be copied or linked by the configure script.
-Currently these are:
-
-  config/abi
-  config/cpu
-  config/io
-  config/locale
-  config/os
-
-In addition, a subdirectory holds the convenience library libsupc++.
-
-  libsupc++
-    Contains the runtime library for C++, including exception
-    handling and memory allocation and deallocation, RTTI, terminate
-    handlers, etc.
-
-Note that glibc also has a bits/ subdirectory.  We will either
-need to be careful not to collide with names in its bits/
-directory; or rename bits to (e.g.) cppbits/.
-
-In files throughout the system, lines marked with an "XXX" indicate
-a bug or incompletely-implemented feature.  Lines marked "XXX MT"
-indicate a place that may require attention for multi-thread safety.
-  

Prev Up Next
Appendix A. Contributing Home Coding Style
diff --git a/libstdc++-v3/doc/html/manual/bk01apas03.html b/libstdc++-v3/doc/html/manual/bk01apas03.html deleted file mode 100644 index 947c9648912d..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apas03.html +++ /dev/null @@ -1,585 +0,0 @@ - - -Coding Style
Coding Style
Prev Appendix A. Contributing Next

Coding Style

-

Bad Identifiers

- Identifiers that conflict and should be avoided. -


-      This is the list of names “reserved to the
-      implementation” that have been claimed by certain
-      compilers and system headers of interest, and should not be used
-      in the library. It will grow, of course.  We generally are
-      interested in names that are not all-caps, except for those like
-      "_T"
-
-      For Solaris:
-      _B
-      _C
-      _L
-      _N
-      _P
-      _S
-      _U
-      _X
-      _E1
-      ..
-      _E24
-
-      Irix adds:
-      _A
-      _G
-
-      MS adds:
-      _T
-
-      BSD adds:
-      __used
-      __unused
-      __inline
-      _Complex
-      __istype
-      __maskrune
-      __tolower
-      __toupper
-      __wchar_t
-      __wint_t
-      _res
-      _res_ext
-      __tg_*
-
-      SPU adds:
-      __ea
-
-      For GCC:
-
-      [Note that this list is out of date. It applies to the old
-      name-mangling; in G++ 3.0 and higher a different name-mangling is
-      used. In addition, many of the bugs relating to G++ interpreting
-      these names as operators have been fixed.]
-
-      The full set of __* identifiers (combined from gcc/cp/lex.c and
-      gcc/cplus-dem.c) that are either old or new, but are definitely 
-      recognized by the demangler, is:
-
-      __aa
-      __aad
-      __ad
-      __addr
-      __adv
-      __aer
-      __als
-      __alshift
-      __amd
-      __ami
-      __aml
-      __amu
-      __aor
-      __apl
-      __array
-      __ars
-      __arshift
-      __as
-      __bit_and
-      __bit_ior
-      __bit_not
-      __bit_xor
-      __call
-      __cl
-      __cm
-      __cn
-      __co
-      __component
-      __compound
-      __cond
-      __convert
-      __delete
-      __dl
-      __dv
-      __eq
-      __er
-      __ge
-      __gt
-      __indirect
-      __le
-      __ls
-      __lt
-      __max
-      __md
-      __method_call
-      __mi
-      __min
-      __minus
-      __ml
-      __mm
-      __mn
-      __mult
-      __mx
-      __ne
-      __negate
-      __new
-      __nop
-      __nt
-      __nw
-      __oo
-      __op
-      __or
-      __pl
-      __plus
-      __postdecrement
-      __postincrement
-      __pp
-      __pt
-      __rf
-      __rm
-      __rs
-      __sz
-      __trunc_div
-      __trunc_mod
-      __truth_andif
-      __truth_not
-      __truth_orif
-      __vc
-      __vd
-      __vn
-
-      SGI badnames:
-      __builtin_alloca
-      __builtin_fsqrt
-      __builtin_sqrt
-      __builtin_fabs
-      __builtin_dabs
-      __builtin_cast_f2i
-      __builtin_cast_i2f
-      __builtin_cast_d2ll
-      __builtin_cast_ll2d
-      __builtin_copy_dhi2i
-      __builtin_copy_i2dhi
-      __builtin_copy_dlo2i
-      __builtin_copy_i2dlo
-      __add_and_fetch
-      __sub_and_fetch
-      __or_and_fetch
-      __xor_and_fetch
-      __and_and_fetch
-      __nand_and_fetch
-      __mpy_and_fetch
-      __min_and_fetch
-      __max_and_fetch
-      __fetch_and_add
-      __fetch_and_sub
-      __fetch_and_or
-      __fetch_and_xor
-      __fetch_and_and
-      __fetch_and_nand
-      __fetch_and_mpy
-      __fetch_and_min
-      __fetch_and_max
-      __lock_test_and_set
-      __lock_release
-      __lock_acquire
-      __compare_and_swap
-      __synchronize
-      __high_multiply
-      __unix
-      __sgi
-      __linux__
-      __i386__
-      __i486__
-      __cplusplus
-      __embedded_cplusplus
-      // long double conversion members mangled as __opr
-      // http://gcc.gnu.org/ml/libstdc++/1999-q4/msg00060.html
-      _opr
-    

By Example


-      This library is written to appropriate C++ coding standards. As such,
-      it is intended to precede the recommendations of the GNU Coding
-      Standard, which can be referenced in full here:
-
-      http://www.gnu.org/prep/standards/standards.html#Formatting
-
-      The rest of this is also interesting reading, but skip the "Design
-      Advice" part.
-
-      The GCC coding conventions are here, and are also useful:
-      http://gcc.gnu.org/codingconventions.html
-
-      In addition, because it doesn't seem to be stated explicitly anywhere
-      else, there is an 80 column source limit.
-
-      ChangeLog entries for member functions should use the
-      classname::member function name syntax as follows:
-
-      1999-04-15  Dennis Ritchie  <dr@att.com>
-
-      * src/basic_file.cc (__basic_file::open): Fix thinko in
-      _G_HAVE_IO_FILE_OPEN bits.
-
-      Notable areas of divergence from what may be previous local practice
-      (particularly for GNU C) include:
-
-      01. Pointers and references
-      char* p = "flop";
-      char& c = *p;
-      -NOT-
-      char *p = "flop";  // wrong
-      char &c = *p;      // wrong
-      
-      Reason: In C++, definitions are mixed with executable code. Here,       
-      p is being initialized, not *p. This is near-universal
-      practice among C++ programmers; it is normal for C hackers
-      to switch spontaneously as they gain experience.
-
-      02. Operator names and parentheses
-      operator==(type)
-      -NOT-
-      operator == (type)  // wrong
-      
-      Reason: The == is part of the function name. Separating
-      it makes the declaration look like an expression. 
-
-      03. Function names and parentheses
-      void mangle()
-      -NOT-
-      void mangle ()  // wrong
-
-      Reason: no space before parentheses (except after a control-flow
-      keyword) is near-universal practice for C++. It identifies the
-      parentheses as the function-call operator or declarator, as 
-      opposed to an expression or other overloaded use of parentheses.
-
-      04. Template function indentation
-      template<typename T>
-      void 
-      template_function(args)
-      { }
-      -NOT-
-      template<class T>
-      void template_function(args) {};
-      
-      Reason: In class definitions, without indentation whitespace is
-      needed both above and below the declaration to distinguish
-      it visually from other members. (Also, re: "typename"
-      rather than "class".)  T often could be int, which is 
-      not a class. ("class", here, is an anachronism.)
-
-      05. Template class indentation
-      template<typename _CharT, typename _Traits>
-      class basic_ios : public ios_base
-      {
-      public:
-      // Types:
-      };
-      -NOT-
-      template<class _CharT, class _Traits>
-      class basic_ios : public ios_base
-      {
-      public:
-      // Types:
-      };
-      -NOT-
-      template<class _CharT, class _Traits>
-      class basic_ios : public ios_base
-      {
-      public:
-      // Types:
-      };
-
-      06. Enumerators
-      enum
-      {
-      space = _ISspace,
-      print = _ISprint,
-      cntrl = _IScntrl
-      };
-      -NOT-
-      enum { space = _ISspace, print = _ISprint, cntrl = _IScntrl };
-
-      07. Member initialization lists
-      All one line, separate from class name.
-
-      gribble::gribble() 
-      : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
-      { }
-      -NOT-
-      gribble::gribble() : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
-      { }
-
-      08. Try/Catch blocks
-      try 
-      {
-      //
-      }   
-      catch (...)
-      {
-      //
-      }   
-      -NOT-
-      try {
-      // 
-      } catch(...) { 
-      //
-      }
-
-      09. Member functions declarations and definitions
-      Keywords such as extern, static, export, explicit, inline, etc
-      go on the line above the function name. Thus
-
-      virtual int   
-      foo()
-      -NOT-
-      virtual int foo()
-
-      Reason: GNU coding conventions dictate return types for functions
-      are on a separate line than the function name and parameter list
-      for definitions. For C++, where we have member functions that can
-      be either inline definitions or declarations, keeping to this
-      standard allows all member function names for a given class to be
-      aligned to the same margin, increasing readability.
-
-
-      10. Invocation of member functions with "this->"
-      For non-uglified names, use this->name to call the function.
-
-      this->sync()
-      -NOT-
-      sync()
-
-      Reason: Koenig lookup.
-
-      11. Namespaces
-      namespace std
-      {
-      blah blah blah;
-      } // namespace std
-
-      -NOT-
-
-      namespace std {
-      blah blah blah;
-      } // namespace std
-
-      12. Spacing under protected and private in class declarations:
-      space above, none below
-      i.e.
-
-      public:
-      int foo;
-
-      -NOT-
-      public:
-      
-      int foo;
-
-      13. Spacing WRT return statements.
-      no extra spacing before returns, no parenthesis
-      i.e.
-
-      }
-      return __ret;
-
-      -NOT-
-      }
-
-      return __ret;
-
-      -NOT-
-
-      }
-      return (__ret);
-
-
-      14. Location of global variables.
-      All global variables of class type, whether in the "user visible"
-      space (e.g., cin) or the implementation namespace, must be defined
-      as a character array with the appropriate alignment and then later
-      re-initialized to the correct value.
-
-      This is due to startup issues on certain platforms, such as AIX.
-      For more explanation and examples, see src/globals.cc. All such
-      variables should be contained in that file, for simplicity.
-
-      15. Exception abstractions
-      Use the exception abstractions found in functexcept.h, which allow
-      C++ programmers to use this library with -fno-exceptions. (Even if
-      that is rarely advisable, it's a necessary evil for backwards
-      compatibility.)
-
-      16. Exception error messages
-      All start with the name of the function where the exception is
-      thrown, and then (optional) descriptive text is added. Example:
-
-      __throw_logic_error(__N("basic_string::_S_construct NULL not valid"));
-
-      Reason: The verbose terminate handler prints out exception::what(),
-      as well as the typeinfo for the thrown exception. As this is the
-      default terminate handler, by putting location info into the
-      exception string, a very useful error message is printed out for
-      uncaught exceptions. So useful, in fact, that non-programmers can
-      give useful error messages, and programmers can intelligently
-      speculate what went wrong without even using a debugger.
-
-      17. The doxygen style guide to comments is a separate document,
-      see index.
-
-      The library currently has a mixture of GNU-C and modern C++ coding
-      styles. The GNU C usages will be combed out gradually.
-
-      Name patterns:
-
-      For nonstandard names appearing in Standard headers, we are constrained 
-      to use names that begin with underscores. This is called "uglification".
-      The convention is:
-
-      Local and argument names:  __[a-z].*
-
-      Examples:  __count  __ix  __s1  
-
-      Type names and template formal-argument names: _[A-Z][^_].*
-
-      Examples:  _Helper  _CharT  _N 
-
-      Member data and function names: _M_.*
-
-      Examples:  _M_num_elements  _M_initialize ()
-
-      Static data members, constants, and enumerations: _S_.*
-
-      Examples: _S_max_elements  _S_default_value
-
-      Don't use names in the same scope that differ only in the prefix, 
-      e.g. _S_top and _M_top. See BADNAMES for a list of forbidden names.
-      (The most tempting of these seem to be and "_T" and "__sz".)
-
-      Names must never have "__" internally; it would confuse name
-      unmanglers on some targets. Also, never use "__[0-9]", same reason.
-
-      --------------------------
-
-      [BY EXAMPLE]
-      
-      #ifndef  _HEADER_
-      #define  _HEADER_ 1
-
-      namespace std
-      {
-      class gribble
-      {
-      public:
-      gribble() throw();
-
-      gribble(const gribble&);
-
-      explicit 
-      gribble(int __howmany);
-
-      gribble& 
-      operator=(const gribble&);
-
-      virtual 
-      ~gribble() throw ();
-
-      // Start with a capital letter, end with a period.
-      inline void  
-      public_member(const char* __arg) const;
-
-      // In-class function definitions should be restricted to one-liners.
-      int 
-      one_line() { return 0 }
-
-      int 
-      two_lines(const char* arg) 
-      { return strchr(arg, 'a'); }
-
-      inline int 
-      three_lines();  // inline, but defined below.
-
-      // Note indentation.
-      template<typename _Formal_argument>
-      void 
-      public_template() const throw();
-
-      template<typename _Iterator>
-      void 
-      other_template();
-
-      private:
-      class _Helper;
-
-      int _M_private_data;
-      int _M_more_stuff;
-      _Helper* _M_helper;
-      int _M_private_function();
-
-      enum _Enum 
-      { 
-      _S_one, 
-      _S_two 
-      };
-
-      static void 
-      _S_initialize_library();
-      };
-
-      // More-or-less-standard language features described by lack, not presence.
-      # ifndef _G_NO_LONGLONG
-      extern long long _G_global_with_a_good_long_name;  // avoid globals!
-      # endif
-
-      // Avoid in-class inline definitions, define separately;
-      // likewise for member class definitions:
-      inline int
-      gribble::public_member() const
-      { int __local = 0; return __local; }
-
-      class gribble::_Helper
-      {
-      int _M_stuff;
-
-      friend class gribble;
-      };
-      }
-
-      // Names beginning with "__": only for arguments and
-      //   local variables; never use "__" in a type name, or
-      //   within any name; never use "__[0-9]".
-
-      #endif /* _HEADER_ */
-
-
-      namespace std 
-      {
-      template<typename T>  // notice: "typename", not "class", no space
-      long_return_value_type<with_many, args>  
-      function_name(char* pointer,               // "char *pointer" is wrong.
-      char* argument, 
-      const Reference& ref)
-      {
-      // int a_local;  /* wrong; see below. */
-      if (test) 
-      { 
-      nested code 
-      }
-      
-      int a_local = 0;  // declare variable at first use.
-
-      //  char a, b, *p;   /* wrong */
-      char a = 'a';
-      char b = a + 1;
-      char* c = "abc";  // each variable goes on its own line, always.
-
-      // except maybe here...
-      for (unsigned i = 0, mask = 1; mask; ++i, mask <<= 1) {
-      // ...
-      }
-      }
-      
-      gribble::gribble()
-      : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
-      { }
-
-      inline int 
-      gribble::three_lines()
-      {
-      // doesn't fit in one line.
-      }
-      } // namespace std
-    

Prev Up Next
Directory Layout and Source Conventions Home Documentation Style
diff --git a/libstdc++-v3/doc/html/manual/bk01apas04.html b/libstdc++-v3/doc/html/manual/bk01apas04.html deleted file mode 100644 index 09a6f978d54d..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apas04.html +++ /dev/null @@ -1,227 +0,0 @@ - - -Documentation Style
Documentation Style
Prev Appendix A. Contributing Next

Documentation Style

Doxygen

Prerequisites

- Prerequisite tools are Bash 2.x, - Doxygen, and - the GNU - coreutils. (GNU versions of find, xargs, and possibly - sed and grep are used, just because the GNU versions make - things very easy.) -

- To generate the pretty pictures and hierarchy - graphs, the - Graphviz - package will need to be installed. -

Generating the Doxygen Files

- The following Makefile rules run Doxygen to generate HTML - docs, XML docs, and the man pages. -

- 

make doc-html-doxygen

-

- 

make doc-xml-doxygen

-

- 

make doc-man-doxygen

-

- Careful observers will see that the Makefile rules simply call - a script from the source tree, run_doxygen, 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 --help.) -

- If you wish to tweak the Doxygen settings, do so by editing - doc/doxygen/user.cfg.in. Notes to fellow - library hackers are written in triple-# comments. -

Markup

- In general, libstdc++ files should be formatted according to - the rules found in the - Coding Standard. Before - any doxygen-specific formatting tweaks are made, please try to - make sure that the initial formatting is sound. -

- Adding Doxygen markup to a file (informally called - “doxygenating”) is very simple. The Doxygen manual can be - found - here. - We try to use a very-recent version of Doxygen. -

- For classes, use - deque/vector/list - and std::pair as examples. For - functions, see their member functions, and the free functions - in stl_algobase.h. Member functions of - other container-like types should read similarly to these - member functions. -

- These points accompany the first list in section 3.1 of the - Doxygen manual: -

  1. Use the Javadoc style...

  2. - ...not the Qt style. The intermediate *'s are preferred. -

  3. - Use the triple-slash style only for one-line comments (the - “brief” mode). Very recent versions of Doxygen permit - full-mode comments in triple-slash blocks, but the - formatting still comes out wonky. -

  4. - This is disgusting. Don't do this. -

- 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 <pre> blocks and @code/@endcode sections, spacing can - have “interesting” effects. -

- Use either kind of grouping, as - appropriate. doxygroups.cc exists for this - purpose. See stl_iterator.h for a good example - of the “other” kind of grouping. -

- 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.) -

Docbook

Prerequisites

- Editing the DocBook sources requires an XML editor. Many - exist: some notable options - include emacs, Kate, - or Conglomerate. -

- Some editors support special “XML Validation” - modes that can validate the file as it is - produced. Recommended is the nXML Mode - for emacs. -

- Besides an editor, additional DocBook files and XML tools are - also required. -

- Access to the DocBook stylesheets and DTD is required. The - stylesheets are usually packaged by vendor, in something - like docbook-style-xsl. To exactly match - generated output, please use a version of the stylesheets - equivalent - to docbook-style-xsl-1.74.0-5. The - installation directory for this package corresponds to - the XSL_STYLE_DIR - in doc/Makefile.am and defaults - to /usr/share/sgml/docbook/xsl-stylesheets. -

- For processing XML, an XML processor and some style - sheets are necessary. Defaults are xsltproc - provided by libxslt. -

- For validating the XML document, you'll need - something like xmllint and access to the - DocBook DTD. These are provided - by a vendor package like lixml2. -

- For PDF output, something that transforms valid XML to PDF is - required. Possible solutions include xmlto, - Apache - FOP, or prince. Other options are - listed on the DocBook web pages. Please - consult the list when - preparing printed manuals for current best practice and suggestions. -

- Make sure that the XML documentation and markup is valid for - any change. This can be done easily, with the validation rules - in the Makefile, which is equivalent to doing: - 

-	  
-xmllint --noout --valid xml/index.xml
-	  
-

Generating the DocBook Files

- 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. -

- 

make doc-html

-

- 

make doc-pdf

-

- 

make doc-xml-single

-

- 

make doc-xml-validate

-

File Organization and Basics


-      Which files are important
-
-      All Docbook files are in the directory
-      libstdc++-v3/doc/xml
-
-      Inside this directory, the files of importance:
-      spine.xml   - index to documentation set
-      manual/spine.xml  - index to manual
-      manual/*.xml   - individual chapters and sections of the manual
-      faq.xml   - index to FAQ
-      api.xml   - index to source level / API 
-
-      All *.txml files are template xml files, i.e., otherwise empty files with
-      the correct structure, suitable for filling in with new information.
-
-      Canonical Writing Style
-
-      class template
-      function template
-      member function template
-      (via C++ Templates, Vandevoorde)
-
-      class in namespace std: allocator, not std::allocator
-
-      header file: iostream, not <iostream>
-
-
-      General structure
-
-      <set>
-      <book>
-      </book>
-
-      <book>
-      <chapter>
-      </chapter>
-      </book>
-
-      <book>
-      <part>
-      <chapter>
-      <section>
-      </section>
-
-      <sect1>
-      </sect1>
-
-      <sect1>
-      <sect2>
-      </sect2>
-      </sect1>
-      </chapter>
-
-      <chapter>
-      </chapter>
-      </part>  
-      </book>
-
-      </set>
-    

Markup By Example

-Complete details on Docbook markup can be found in the DocBook Element -Reference, online. An -incomplete reference for HTML to Docbook conversion is detailed in the -table below. -

Table A.1. HTML to Docbook XML markup comparison

HTMLXML
<p><para>
<pre><computeroutput>, <programlisting>, - <literallayout>
<ul><itemizedlist>
<ol><orderedlist>
<il><listitem>
<dl><variablelist>
<dt><term>
<dd><listitem>
<a href=""><ulink url="">
<code><literal>, <programlisting>
<strong><emphasis>
<em><emphasis>
"<quote>

- And examples of detailed markup for which there are no real HTML - equivalents are listed in the table below. -

Table A.2. Docbook XML Element Use

ElementUse
<structname><structname>char_traits</structname>
<classname><classname>string</classname>
<function> -

<function>clear()</function>

-

<function>fs.clear()</function>

-
<type><type>long long</type>
<varname><varname>fs</varname>
<literal> -

<literal>-Weffc++</literal>

-

<literal>rel_ops</literal>

-
<constant> -

<constant>_GNU_SOURCE</constant>

-

<constant>3.0</constant>

-
<command><command>g++</command>
<errortext><errortext>In instantiation of</errortext>
<filename> -

<filename class="headerfile">ctype.h</filename>

-

<filename class="directory">/home/gcc/build</filename>

-

Prev Up Next
Coding Style Home Design Notes
diff --git a/libstdc++-v3/doc/html/manual/bk01apas05.html b/libstdc++-v3/doc/html/manual/bk01apas05.html deleted file mode 100644 index 635b39cde7c8..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apas05.html +++ /dev/null @@ -1,857 +0,0 @@ - - -Design Notes
Design Notes
Prev Appendix A. Contributing Next

Design Notes

-


-
-    The Library
-    -----------
-
-    This paper is covers two major areas:
-
-    - Features and policies not mentioned in the standard that
-    the quality of the library implementation depends on, including
-    extensions and "implementation-defined" features;
-
-    - Plans for required but unimplemented library features and
-    optimizations to them.
-
-    Overhead
-    --------
-
-    The standard defines a large library, much larger than the standard
-    C library. A naive implementation would suffer substantial overhead
-    in compile time, executable size, and speed, rendering it unusable
-    in many (particularly embedded) applications. The alternative demands
-    care in construction, and some compiler support, but there is no
-    need for library subsets.
-
-    What are the sources of this overhead?  There are four main causes:
-
-    - The library is specified almost entirely as templates, which
-    with current compilers must be included in-line, resulting in
-    very slow builds as tens or hundreds of thousands of lines
-    of function definitions are read for each user source file.
-    Indeed, the entire SGI STL, as well as the dos Reis valarray,
-    are provided purely as header files, largely for simplicity in
-    porting. Iostream/locale is (or will be) as large again.
-
-    - The library is very flexible, specifying a multitude of hooks
-    where users can insert their own code in place of defaults.
-    When these hooks are not used, any time and code expended to
-    support that flexibility is wasted.
-
-    - Templates are often described as causing to "code bloat". In
-    practice, this refers (when it refers to anything real) to several
-    independent processes. First, when a class template is manually
-    instantiated in its entirely, current compilers place the definitions
-    for all members in a single object file, so that a program linking
-    to one member gets definitions of all. Second, template functions
-    which do not actually depend on the template argument are, under
-    current compilers, generated anew for each instantiation, rather
-    than being shared with other instantiations. Third, some of the
-    flexibility mentioned above comes from virtual functions (both in
-    regular classes and template classes) which current linkers add
-    to the executable file even when they manifestly cannot be called.
-
-    - The library is specified to use a language feature, exceptions,
-    which in the current gcc compiler ABI imposes a run time and
-    code space cost to handle the possibility of exceptions even when
-    they are not used. Under the new ABI (accessed with -fnew-abi),
-    there is a space overhead and a small reduction in code efficiency
-    resulting from lost optimization opportunities associated with
-    non-local branches associated with exceptions.
-
-    What can be done to eliminate this overhead?  A variety of coding
-    techniques, and compiler, linker and library improvements and
-    extensions may be used, as covered below. Most are not difficult,
-    and some are already implemented in varying degrees.
-
-    Overhead: Compilation Time
-    --------------------------
-
-    Providing "ready-instantiated" template code in object code archives
-    allows us to avoid generating and optimizing template instantiations
-    in each compilation unit which uses them. However, the number of such
-    instantiations that are useful to provide is limited, and anyway this
-    is not enough, by itself, to minimize compilation time. In particular,
-    it does not reduce time spent parsing conforming headers.
-
-    Quicker header parsing will depend on library extensions and compiler
-    improvements.  One approach is some variation on the techniques
-    previously marketed as "pre-compiled headers", now standardized as
-    support for the "export" keyword. "Exported" template definitions
-    can be placed (once) in a "repository" -- really just a library, but
-    of template definitions rather than object code -- to be drawn upon
-    at link time when an instantiation is needed, rather than placed in
-    header files to be parsed along with every compilation unit.
-
-    Until "export" is implemented we can put some of the lengthy template
-    definitions in #if guards or alternative headers so that users can skip
-    over the full definitions when they need only the ready-instantiated
-    specializations.
-
-    To be precise, this means that certain headers which define
-    templates which users normally use only for certain arguments
-    can be instrumented to avoid exposing the template definitions
-    to the compiler unless a macro is defined. For example, in
-    <string>, we might have:
-
-    template <class _CharT, ... > class basic_string {
-    ... // member declarations
-    };
-    ... // operator declarations
-
-    #ifdef _STRICT_ISO_
-    # if _G_NO_TEMPLATE_EXPORT
-    #   include <bits/std_locale.h>  // headers needed by definitions
-    #   ...
-    #   include <bits/string.tcc>  // member and global template definitions.
-    # endif
-    #endif
-
-    Users who compile without specifying a strict-ISO-conforming flag
-    would not see many of the template definitions they now see, and rely
-    instead on ready-instantiated specializations in the library. This
-    technique would be useful for the following substantial components:
-    string, locale/iostreams, valarray. It would *not* be useful or
-    usable with the following: containers, algorithms, iterators,
-    allocator. Since these constitute a large (though decreasing)
-    fraction of the library, the benefit the technique offers is
-    limited.
-
-    The language specifies the semantics of the "export" keyword, but
-    the gcc compiler does not yet support it. When it does, problems
-    with large template inclusions can largely disappear, given some
-    minor library reorganization, along with the need for the apparatus
-    described above.
-
-    Overhead: Flexibility Cost
-    --------------------------
-
-    The library offers many places where users can specify operations
-    to be performed by the library in place of defaults. Sometimes
-    this seems to require that the library use a more-roundabout, and
-    possibly slower, way to accomplish the default requirements than
-    would be used otherwise.
-
-    The primary protection against this overhead is thorough compiler
-    optimization, to crush out layers of inline function interfaces.
-    Kuck & Associates has demonstrated the practicality of this kind
-    of optimization.
-
-    The second line of defense against this overhead is explicit
-    specialization. By defining helper function templates, and writing
-    specialized code for the default case, overhead can be eliminated
-    for that case without sacrificing flexibility. This takes full
-    advantage of any ability of the optimizer to crush out degenerate
-    code.
-
-    The library specifies many virtual functions which current linkers
-    load even when they cannot be called. Some minor improvements to the
-    compiler and to ld would eliminate any such overhead by simply
-    omitting virtual functions that the complete program does not call.
-    A prototype of this work has already been done. For targets where
-    GNU ld is not used, a "pre-linker" could do the same job.
-
-    The main areas in the standard interface where user flexibility
-    can result in overhead are:
-
-    - Allocators:  Containers are specified to use user-definable
-    allocator types and objects, making tuning for the container
-    characteristics tricky.
-
-    - Locales: the standard specifies locale objects used to implement
-    iostream operations, involving many virtual functions which use
-    streambuf iterators.
-
-    - Algorithms and containers: these may be instantiated on any type,
-    frequently duplicating code for identical operations.
-
-    - Iostreams and strings: users are permitted to use these on their
-    own types, and specify the operations the stream must use on these
-    types.
-
-    Note that these sources of overhead are _avoidable_. The techniques
-    to avoid them are covered below.
-
-    Code Bloat
-    ----------
-
-    In the SGI STL, and in some other headers, many of the templates
-    are defined "inline" -- either explicitly or by their placement
-    in class definitions -- which should not be inline. This is a
-    source of code bloat. Matt had remarked that he was relying on
-    the compiler to recognize what was too big to benefit from inlining,
-    and generate it out-of-line automatically. However, this also can
-    result in code bloat except where the linker can eliminate the extra
-    copies.
-
-    Fixing these cases will require an audit of all inline functions
-    defined in the library to determine which merit inlining, and moving
-    the rest out of line. This is an issue mainly in chapters 23, 25, and
-    27. Of course it can be done incrementally, and we should generally
-    accept patches that move large functions out of line and into ".tcc"
-    files, which can later be pulled into a repository. Compiler/linker
-    improvements to recognize very large inline functions and move them
-    out-of-line, but shared among compilation units, could make this
-    work unnecessary.
-
-    Pre-instantiating template specializations currently produces large
-    amounts of dead code which bloats statically linked programs. The
-    current state of the static library, libstdc++.a, is intolerable on
-    this account, and will fuel further confused speculation about a need
-    for a library "subset". A compiler improvement that treats each
-    instantiated function as a separate object file, for linking purposes,
-    would be one solution to this problem. An alternative would be to
-    split up the manual instantiation files into dozens upon dozens of
-    little files, each compiled separately, but an abortive attempt at
-    this was done for <string> and, though it is far from complete, it
-    is already a nuisance. A better interim solution (just until we have
-    "export") is badly needed.
-
-    When building a shared library, the current compiler/linker cannot
-    automatically generate the instantiations needed. This creates a
-    miserable situation; it means any time something is changed in the
-    library, before a shared library can be built someone must manually
-    copy the declarations of all templates that are needed by other parts
-    of the library to an "instantiation" file, and add it to the build
-    system to be compiled and linked to the library. This process is
-    readily automated, and should be automated as soon as possible.
-    Users building their own shared libraries experience identical
-    frustrations.
-
-    Sharing common aspects of template definitions among instantiations
-    can radically reduce code bloat. The compiler could help a great
-    deal here by recognizing when a function depends on nothing about
-    a template parameter, or only on its size, and giving the resulting
-    function a link-name "equate" that allows it to be shared with other
-    instantiations. Implementation code could take advantage of the
-    capability by factoring out code that does not depend on the template
-    argument into separate functions to be merged by the compiler.
-
-    Until such a compiler optimization is implemented, much can be done
-    manually (if tediously) in this direction. One such optimization is
-    to derive class templates from non-template classes, and move as much
-    implementation as possible into the base class. Another is to partial-
-    specialize certain common instantiations, such as vector<T*>, to share
-    code for instantiations on all types T. While these techniques work,
-    they are far from the complete solution that a compiler improvement
-    would afford.
-
-    Overhead: Expensive Language Features
-    -------------------------------------
-
-    The main "expensive" language feature used in the standard library
-    is exception support, which requires compiling in cleanup code with
-    static table data to locate it, and linking in library code to use
-    the table. For small embedded programs the amount of such library
-    code and table data is assumed by some to be excessive. Under the
-    "new" ABI this perception is generally exaggerated, although in some
-    cases it may actually be excessive.
-
-    To implement a library which does not use exceptions directly is
-    not difficult given minor compiler support (to "turn off" exceptions
-    and ignore exception constructs), and results in no great library
-    maintenance difficulties. To be precise, given "-fno-exceptions",
-    the compiler should treat "try" blocks as ordinary blocks, and
-    "catch" blocks as dead code to ignore or eliminate. Compiler
-    support is not strictly necessary, except in the case of "function
-    try blocks"; otherwise the following macros almost suffice:
-
-    #define throw(X)
-    #define try      if (true)
-    #define catch(X) else if (false)
-
-    However, there may be a need to use function try blocks in the
-    library implementation, and use of macros in this way can make
-    correct diagnostics impossible. Furthermore, use of this scheme
-    would require the library to call a function to re-throw exceptions
-    from a try block. Implementing the above semantics in the compiler
-    is preferable.
-
-    Given the support above (however implemented) it only remains to
-    replace code that "throws" with a call to a well-documented "handler"
-    function in a separate compilation unit which may be replaced by
-    the user. The main source of exceptions that would be difficult
-    for users to avoid is memory allocation failures, but users can
-    define their own memory allocation primitives that never throw.
-    Otherwise, the complete list of such handlers, and which library
-    functions may call them, would be needed for users to be able to
-    implement the necessary substitutes. (Fortunately, they have the
-    source code.)
-
-    Opportunities
-    -------------
-
-    The template capabilities of C++ offer enormous opportunities for
-    optimizing common library operations, well beyond what would be
-    considered "eliminating overhead". In particular, many operations
-    done in Glibc with macros that depend on proprietary language
-    extensions can be implemented in pristine Standard C++. For example,
-    the chapter 25 algorithms, and even C library functions such as strchr,
-    can be specialized for the case of static arrays of known (small) size.
-
-    Detailed optimization opportunities are identified below where
-    the component where they would appear is discussed. Of course new
-    opportunities will be identified during implementation.
-
-    Unimplemented Required Library Features
-    ---------------------------------------
-
-    The standard specifies hundreds of components, grouped broadly by
-    chapter. These are listed in excruciating detail in the CHECKLIST
-    file.
-
-    17 general
-    18 support
-    19 diagnostics
-    20 utilities
-    21 string
-    22 locale
-    23 containers
-    24 iterators
-    25 algorithms
-    26 numerics
-    27 iostreams
-    Annex D  backward compatibility
-
-    Anyone participating in implementation of the library should obtain
-    a copy of the standard, ISO 14882.  People in the U.S. can obtain an
-    electronic copy for US$18 from ANSI's web site. Those from other
-    countries should visit http://www.iso.ch/ to find out the location
-    of their country's representation in ISO, in order to know who can
-    sell them a copy.
-
-    The emphasis in the following sections is on unimplemented features
-    and optimization opportunities.
-
-    Chapter 17  General
-    -------------------
-
-    Chapter 17 concerns overall library requirements.
-
-    The standard doesn't mention threads. A multi-thread (MT) extension
-    primarily affects operators new and delete (18), allocator (20),
-    string (21), locale (22), and iostreams (27). The common underlying
-    support needed for this is discussed under chapter 20.
-
-    The standard requirements on names from the C headers create a
-    lot of work, mostly done. Names in the C headers must be visible
-    in the std:: and sometimes the global namespace; the names in the
-    two scopes must refer to the same object. More stringent is that
-    Koenig lookup implies that any types specified as defined in std::
-    really are defined in std::. Names optionally implemented as
-    macros in C cannot be macros in C++. (An overview may be read at
-    <http://www.cantrip.org/cheaders.html>). The scripts "inclosure"
-    and "mkcshadow", and the directories shadow/ and cshadow/, are the
-    beginning of an effort to conform in this area.
-
-    A correct conforming definition of C header names based on underlying
-    C library headers, and practical linking of conforming namespaced
-    customer code with third-party C libraries depends ultimately on
-    an ABI change, allowing namespaced C type names to be mangled into
-    type names as if they were global, somewhat as C function names in a
-    namespace, or C++ global variable names, are left unmangled. Perhaps
-    another "extern" mode, such as 'extern "C-global"' would be an
-    appropriate place for such type definitions. Such a type would
-    affect mangling as follows:
-
-    namespace A {
-    struct X {};
-    extern "C-global" {  // or maybe just 'extern "C"'
-    struct Y {};
-    };
-    }
-    void f(A::X*);  // mangles to f__FPQ21A1X
-    void f(A::Y*);  // mangles to f__FP1Y
-
-    (It may be that this is really the appropriate semantics for regular
-    'extern "C"', and 'extern "C-global"', as an extension, would not be
-    necessary.) This would allow functions declared in non-standard C headers
-    (and thus fixable by neither us nor users) to link properly with functions
-    declared using C types defined in properly-namespaced headers. The
-    problem this solves is that C headers (which C++ programmers do persist
-    in using) frequently forward-declare C struct tags without including
-    the header where the type is defined, as in
-
-    struct tm;
-    void munge(tm*);
-
-    Without some compiler accommodation, munge cannot be called by correct
-    C++ code using a pointer to a correctly-scoped tm* value.
-
-    The current C headers use the preprocessor extension "#include_next",
-    which the compiler complains about when run "-pedantic".
-    (Incidentally, it appears that "-fpedantic" is currently ignored,
-    probably a bug.)  The solution in the C compiler is to use
-    "-isystem" rather than "-I", but unfortunately in g++ this seems
-    also to wrap the whole header in an 'extern "C"' block, so it's
-    unusable for C++ headers. The correct solution appears to be to
-    allow the various special include-directory options, if not given
-    an argument, to affect subsequent include-directory options additively,
-    so that if one said
-
-    -pedantic -iprefix $(prefix) \
-    -idirafter -ino-pedantic -ino-extern-c -iwithprefix -I g++-v3 \
-    -iwithprefix -I g++-v3/ext
-
-    the compiler would search $(prefix)/g++-v3 and not report
-    pedantic warnings for files found there, but treat files in
-    $(prefix)/g++-v3/ext pedantically. (The undocumented semantics
-    of "-isystem" in g++ stink. Can they be rescinded?  If not it
-    must be replaced with something more rationally behaved.)
-
-    All the C headers need the treatment above; in the standard these
-    headers are mentioned in various chapters. Below, I have only
-    mentioned those that present interesting implementation issues.
-
-    The components identified as "mostly complete", below, have not been
-    audited for conformance. In many cases where the library passes
-    conformance tests we have non-conforming extensions that must be
-    wrapped in #if guards for "pedantic" use, and in some cases renamed
-    in a conforming way for continued use in the implementation regardless
-    of conformance flags.
-
-    The STL portion of the library still depends on a header
-    stl/bits/stl_config.h full of #ifdef clauses. This apparatus
-    should be replaced with autoconf/automake machinery.
-
-    The SGI STL defines a type_traits<> template, specialized for
-    many types in their code including the built-in numeric and
-    pointer types and some library types, to direct optimizations of
-    standard functions. The SGI compiler has been extended to generate
-    specializations of this template automatically for user types,
-    so that use of STL templates on user types can take advantage of
-    these optimizations. Specializations for other, non-STL, types
-    would make more optimizations possible, but extending the gcc
-    compiler in the same way would be much better. Probably the next
-    round of standardization will ratify this, but probably with
-    changes, so it probably should be renamed to place it in the
-    implementation namespace.
-
-    The SGI STL also defines a large number of extensions visible in
-    standard headers. (Other extensions that appear in separate headers
-    have been sequestered in subdirectories ext/ and backward/.)  All
-    these extensions should be moved to other headers where possible,
-    and in any case wrapped in a namespace (not std!), and (where kept
-    in a standard header) girded about with macro guards. Some cannot be
-    moved out of standard headers because they are used to implement
-    standard features.  The canonical method for accommodating these
-    is to use a protected name, aliased in macro guards to a user-space
-    name. Unfortunately C++ offers no satisfactory template typedef
-    mechanism, so very ad-hoc and unsatisfactory aliasing must be used
-    instead.
-
-    Implementation of a template typedef mechanism should have the highest
-    priority among possible extensions, on the same level as implementation
-    of the template "export" feature.
-
-    Chapter 18  Language support
-    ----------------------------
-
-    Headers: <limits> <new> <typeinfo> <exception>
-    C headers: <cstddef> <climits> <cfloat>  <cstdarg> <csetjmp>
-    <ctime>   <csignal> <cstdlib> (also 21, 25, 26)
-
-    This defines the built-in exceptions, rtti, numeric_limits<>,
-    operator new and delete. Much of this is provided by the
-    compiler in its static runtime library.
-
-    Work to do includes defining numeric_limits<> specializations in
-    separate files for all target architectures. Values for integer types
-    except for bool and wchar_t are readily obtained from the C header
-    <limits.h>, but values for the remaining numeric types (bool, wchar_t,
-    float, double, long double) must be entered manually. This is
-    largely dog work except for those members whose values are not
-    easily deduced from available documentation. Also, this involves
-    some work in target configuration to identify the correct choice of
-    file to build against and to install.
-
-    The definitions of the various operators new and delete must be
-    made thread-safe, which depends on a portable exclusion mechanism,
-    discussed under chapter 20.  Of course there is always plenty of
-    room for improvements to the speed of operators new and delete.
-
-    <cstdarg>, in Glibc, defines some macros that gcc does not allow to
-    be wrapped into an inline function. Probably this header will demand
-    attention whenever a new target is chosen. The functions atexit(),
-    exit(), and abort() in cstdlib have different semantics in C++, so
-    must be re-implemented for C++.
-
-    Chapter 19  Diagnostics
-    -----------------------
-
-    Headers: <stdexcept>
-    C headers: <cassert> <cerrno>
-
-    This defines the standard exception objects, which are "mostly complete".
-    Cygnus has a version, and now SGI provides a slightly different one.
-    It makes little difference which we use.
-
-    The C global name "errno", which C allows to be a variable or a macro,
-    is required in C++ to be a macro. For MT it must typically result in
-    a function call.
-
-    Chapter 20  Utilities
-    ---------------------
-    Headers: <utility> <functional> <memory>
-    C header: <ctime> (also in 18)
-
-    SGI STL provides "mostly complete" versions of all the components
-    defined in this chapter. However, the auto_ptr<> implementation
-    is known to be wrong. Furthermore, the standard definition of it
-    is known to be unimplementable as written. A minor change to the
-    standard would fix it, and auto_ptr<> should be adjusted to match.
-
-    Multi-threading affects the allocator implementation, and there must
-    be configuration/installation choices for different users' MT
-    requirements. Anyway, users will want to tune allocator options
-    to support different target conditions, MT or no.
-
-    The primitives used for MT implementation should be exposed, as an
-    extension, for users' own work. We need cross-CPU "mutex" support,
-    multi-processor shared-memory atomic integer operations, and single-
-    processor uninterruptible integer operations, and all three configurable
-    to be stubbed out for non-MT use, or to use an appropriately-loaded
-    dynamic library for the actual runtime environment, or statically
-    compiled in for cases where the target architecture is known.
-
-    Chapter 21  String
-    ------------------
-    Headers: <string>
-    C headers: <cctype> <cwctype> <cstring> <cwchar> (also in 27)
-    <cstdlib> (also in 18, 25, 26)
-
-    We have "mostly-complete" char_traits<> implementations. Many of the
-    char_traits<char> operations might be optimized further using existing
-    proprietary language extensions.
-
-    We have a "mostly-complete" basic_string<> implementation. The work
-    to manually instantiate char and wchar_t specializations in object
-    files to improve link-time behavior is extremely unsatisfactory,
-    literally tripling library-build time with no commensurate improvement
-    in static program link sizes. It must be redone. (Similar work is
-    needed for some components in chapters 22 and 27.)
-
-    Other work needed for strings is MT-safety, as discussed under the
-    chapter 20 heading.
-
-    The standard C type mbstate_t from <cwchar> and used in char_traits<>
-    must be different in C++ than in C, because in C++ the default constructor
-    value mbstate_t() must be the "base" or "ground" sequence state.
-    (According to the likely resolution of a recently raised Core issue,
-    this may become unnecessary. However, there are other reasons to
-    use a state type not as limited as whatever the C library provides.)
-    If we might want to provide conversions from (e.g.) internally-
-    represented EUC-wide to externally-represented Unicode, or vice-
-    versa, the mbstate_t we choose will need to be more accommodating
-    than what might be provided by an underlying C library.
-
-    There remain some basic_string template-member functions which do
-    not overload properly with their non-template brethren. The infamous
-    hack akin to what was done in vector<> is needed, to conform to
-    23.1.1 para 10. The CHECKLIST items for basic_string marked 'X',
-    or incomplete, are so marked for this reason.
-
-    Replacing the string iterators, which currently are simple character
-    pointers, with class objects would greatly increase the safety of the
-    client interface, and also permit a "debug" mode in which range,
-    ownership, and validity are rigorously checked. The current use of
-    raw pointers as string iterators is evil. vector<> iterators need the
-    same treatment. Note that the current implementation freely mixes
-    pointers and iterators, and that must be fixed before safer iterators
-    can be introduced.
-
-    Some of the functions in <cstring> are different from the C version.
-    generally overloaded on const and non-const argument pointers. For
-    example, in <cstring> strchr is overloaded. The functions isupper
-    etc. in <cctype> typically implemented as macros in C are functions
-    in C++, because they are overloaded with others of the same name
-    defined in <locale>.
-
-    Many of the functions required in <cwctype> and <cwchar> cannot be
-    implemented using underlying C facilities on intended targets because
-    such facilities only partly exist.
-
-    Chapter 22  Locale
-    ------------------
-    Headers: <locale>
-    C headers: <clocale>
-
-    We have a "mostly complete" class locale, with the exception of
-    code for constructing, and handling the names of, named locales.
-    The ways that locales are named (particularly when categories
-    (e.g. LC_TIME, LC_COLLATE) are different) varies among all target
-    environments. This code must be written in various versions and
-    chosen by configuration parameters.
-
-    Members of many of the facets defined in <locale> are stubs. Generally,
-    there are two sets of facets: the base class facets (which are supposed
-    to implement the "C" locale) and the "byname" facets, which are supposed
-    to read files to determine their behavior. The base ctype<>, collate<>,
-    and numpunct<> facets are "mostly complete", except that the table of
-    bitmask values used for "is" operations, and corresponding mask values,
-    are still defined in libio and just included/linked. (We will need to
-    implement these tables independently, soon, but should take advantage
-    of libio where possible.)  The num_put<>::put members for integer types
-    are "mostly complete".
-
-    A complete list of what has and has not been implemented may be
-    found in CHECKLIST. However, note that the current definition of
-    codecvt<wchar_t,char,mbstate_t> is wrong. It should simply write
-    out the raw bytes representing the wide characters, rather than
-    trying to convert each to a corresponding single "char" value.
-
-    Some of the facets are more important than others. Specifically,
-    the members of ctype<>, numpunct<>, num_put<>, and num_get<> facets
-    are used by other library facilities defined in <string>, <istream>,
-    and <ostream>, and the codecvt<> facet is used by basic_filebuf<>
-    in <fstream>, so a conforming iostream implementation depends on
-    these.
-
-    The "long long" type eventually must be supported, but code mentioning
-    it should be wrapped in #if guards to allow pedantic-mode compiling.
-
-    Performance of num_put<> and num_get<> depend critically on
-    caching computed values in ios_base objects, and on extensions
-    to the interface with streambufs.
-
-    Specifically: retrieving a copy of the locale object, extracting
-    the needed facets, and gathering data from them, for each call to
-    (e.g.) operator<< would be prohibitively slow.  To cache format
-    data for use by num_put<> and num_get<> we have a _Format_cache<>
-    object stored in the ios_base::pword() array. This is constructed
-    and initialized lazily, and is organized purely for utility. It
-    is discarded when a new locale with different facets is imbued.
-
-    Using only the public interfaces of the iterator arguments to the
-    facet functions would limit performance by forbidding "vector-style"
-    character operations. The streambuf iterator optimizations are
-    described under chapter 24, but facets can also bypass the streambuf
-    iterators via explicit specializations and operate directly on the
-    streambufs, and use extended interfaces to get direct access to the
-    streambuf internal buffer arrays. These extensions are mentioned
-    under chapter 27. These optimizations are particularly important
-    for input parsing.
-
-    Unused virtual members of locale facets can be omitted, as mentioned
-    above, by a smart linker.
-
-    Chapter 23  Containers
-    ----------------------
-    Headers: <deque> <list> <queue> <stack> <vector> <map> <set> <bitset>
-
-    All the components in chapter 23 are implemented in the SGI STL.
-    They are "mostly complete"; they include a large number of
-    nonconforming extensions which must be wrapped. Some of these
-    are used internally and must be renamed or duplicated.
-
-    The SGI components are optimized for large-memory environments. For
-    embedded targets, different criteria might be more appropriate. Users
-    will want to be able to tune this behavior. We should provide
-    ways for users to compile the library with different memory usage
-    characteristics.
-
-    A lot more work is needed on factoring out common code from different
-    specializations to reduce code size here and in chapter 25. The
-    easiest fix for this would be a compiler/ABI improvement that allows
-    the compiler to recognize when a specialization depends only on the
-    size (or other gross quality) of a template argument, and allow the
-    linker to share the code with similar specializations. In its
-    absence, many of the algorithms and containers can be partial-
-    specialized, at least for the case of pointers, but this only solves
-    a small part of the problem. Use of a type_traits-style template
-    allows a few more optimization opportunities, more if the compiler
-    can generate the specializations automatically.
-
-    As an optimization, containers can specialize on the default allocator
-    and bypass it, or take advantage of details of its implementation
-    after it has been improved upon.
-
-    Replacing the vector iterators, which currently are simple element
-    pointers, with class objects would greatly increase the safety of the
-    client interface, and also permit a "debug" mode in which range,
-    ownership, and validity are rigorously checked. The current use of
-    pointers for iterators is evil.
-
-    As mentioned for chapter 24, the deque iterator is a good example of
-    an opportunity to implement a "staged" iterator that would benefit
-    from specializations of some algorithms.
-
-    Chapter 24  Iterators
-    ---------------------
-    Headers: <iterator>
-
-    Standard iterators are "mostly complete", with the exception of
-    the stream iterators, which are not yet templatized on the
-    stream type. Also, the base class template iterator<> appears
-    to be wrong, so everything derived from it must also be wrong,
-    currently.
-
-    The streambuf iterators (currently located in stl/bits/std_iterator.h,
-    but should be under bits/) can be rewritten to take advantage of
-    friendship with the streambuf implementation.
-
-    Matt Austern has identified opportunities where certain iterator
-    types, particularly including streambuf iterators and deque
-    iterators, have a "two-stage" quality, such that an intermediate
-    limit can be checked much more quickly than the true limit on
-    range operations. If identified with a member of iterator_traits,
-    algorithms may be specialized for this case. Of course the
-    iterators that have this quality can be identified by specializing
-    a traits class.
-
-    Many of the algorithms must be specialized for the streambuf
-    iterators, to take advantage of block-mode operations, in order
-    to allow iostream/locale operations' performance not to suffer.
-    It may be that they could be treated as staged iterators and
-    take advantage of those optimizations.
-
-    Chapter 25  Algorithms
-    ----------------------
-    Headers: <algorithm>
-    C headers: <cstdlib> (also in 18, 21, 26))
-
-    The algorithms are "mostly complete". As mentioned above, they
-    are optimized for speed at the expense of code and data size.
-
-    Specializations of many of the algorithms for non-STL types would
-    give performance improvements, but we must use great care not to
-    interfere with fragile template overloading semantics for the
-    standard interfaces. Conventionally the standard function template
-    interface is an inline which delegates to a non-standard function
-    which is then overloaded (this is already done in many places in
-    the library). Particularly appealing opportunities for the sake of
-    iostream performance are for copy and find applied to streambuf
-    iterators or (as noted elsewhere) for staged iterators, of which
-    the streambuf iterators are a good example.
-
-    The bsearch and qsort functions cannot be overloaded properly as
-    required by the standard because gcc does not yet allow overloading
-    on the extern-"C"-ness of a function pointer.
-
-    Chapter 26  Numerics
-    --------------------
-    Headers: <complex> <valarray> <numeric>
-    C headers: <cmath>, <cstdlib> (also 18, 21, 25)
-
-    Numeric components: Gabriel dos Reis's valarray, Drepper's complex,
-    and the few algorithms from the STL are "mostly done".  Of course
-    optimization opportunities abound for the numerically literate. It
-    is not clear whether the valarray implementation really conforms
-    fully, in the assumptions it makes about aliasing (and lack thereof)
-    in its arguments.
-
-    The C div() and ldiv() functions are interesting, because they are the
-    only case where a C library function returns a class object by value.
-    Since the C++ type div_t must be different from the underlying C type
-    (which is in the wrong namespace) the underlying functions div() and
-    ldiv() cannot be re-used efficiently. Fortunately they are trivial to
-    re-implement.
-
-    Chapter 27  Iostreams
-    ---------------------
-    Headers: <iosfwd> <streambuf> <ios> <ostream> <istream> <iostream>
-    <iomanip> <sstream> <fstream>
-    C headers: <cstdio> <cwchar> (also in 21)
-
-    Iostream is currently in a very incomplete state. <iosfwd>, <iomanip>,
-    ios_base, and basic_ios<> are "mostly complete". basic_streambuf<> and
-    basic_ostream<> are well along, but basic_istream<> has had little work
-    done. The standard stream objects, <sstream> and <fstream> have been
-    started; basic_filebuf<> "write" functions have been implemented just
-    enough to do "hello, world".
-
-    Most of the istream and ostream operators << and >> (with the exception
-    of the op<<(integer) ones) have not been changed to use locale primitives,
-    sentry objects, or char_traits members.
-
-    All these templates should be manually instantiated for char and
-    wchar_t in a way that links only used members into user programs.
-
-    Streambuf is fertile ground for optimization extensions. An extended
-    interface giving iterator access to its internal buffer would be very
-    useful for other library components.
-
-    Iostream operations (primarily operators << and >>) can take advantage
-    of the case where user code has not specified a locale, and bypass locale
-    operations entirely. The current implementation of op<</num_put<>::put,
-    for the integer types, demonstrates how they can cache encoding details
-    from the locale on each operation. There is lots more room for
-    optimization in this area.
-
-    The definition of the relationship between the standard streams
-    cout et al. and stdout et al. requires something like a "stdiobuf".
-    The SGI solution of using double-indirection to actually use a
-    stdio FILE object for buffering is unsatisfactory, because it
-    interferes with peephole loop optimizations.
-
-    The <sstream> header work has begun. stringbuf can benefit from
-    friendship with basic_string<> and basic_string<>::_Rep to use
-    those objects directly as buffers, and avoid allocating and making
-    copies.
-
-    The basic_filebuf<> template is a complex beast. It is specified to
-    use the locale facet codecvt<> to translate characters between native
-    files and the locale character encoding. In general this involves
-    two buffers, one of "char" representing the file and another of
-    "char_type", for the stream, with codecvt<> translating. The process
-    is complicated by the variable-length nature of the translation, and
-    the need to seek to corresponding places in the two representations.
-    For the case of basic_filebuf<char>, when no translation is needed,
-    a single buffer suffices. A specialized filebuf can be used to reduce
-    code space overhead when no locale has been imbued. Matt Austern's
-    work at SGI will be useful, perhaps directly as a source of code, or
-    at least as an example to draw on.
-
-    Filebuf, almost uniquely (cf. operator new), depends heavily on
-    underlying environmental facilities. In current releases iostream
-    depends fairly heavily on libio constant definitions, but it should
-    be made independent.  It also depends on operating system primitives
-    for file operations. There is immense room for optimizations using
-    (e.g.) mmap for reading. The shadow/ directory wraps, besides the
-    standard C headers, the libio.h and unistd.h headers, for use mainly
-    by filebuf. These wrappings have not been completed, though there
-    is scaffolding in place.
-
-    The encapsulation of certain C header <cstdio> names presents an
-    interesting problem. It is possible to define an inline std::fprintf()
-    implemented in terms of the 'extern "C"' vfprintf(), but there is no
-    standard vfscanf() to use to implement std::fscanf(). It appears that
-    vfscanf but be re-implemented in C++ for targets where no vfscanf
-    extension has been defined. This is interesting in that it seems
-    to be the only significant case in the C library where this kind of
-    rewriting is necessary. (Of course Glibc provides the vfscanf()
-    extension.)  (The functions related to exit() must be rewritten
-    for other reasons.)
-
-
-    Annex D
-    -------
-    Headers: <strstream>
-
-    Annex D defines many non-library features, and many minor
-    modifications to various headers, and a complete header.
-    It is "mostly done", except that the libstdc++-2 <strstream>
-    header has not been adopted into the library, or checked to
-    verify that it matches the draft in those details that were
-    clarified by the committee. Certainly it must at least be
-    moved into the std namespace.
-
-    We still need to wrap all the deprecated features in #if guards
-    so that pedantic compile modes can detect their use.
-
-    Nonstandard Extensions
-    ----------------------
-    Headers: <iostream.h> <strstream.h> <hash> <rbtree>
-    <pthread_alloc> <stdiobuf> (etc.)
-
-    User code has come to depend on a variety of nonstandard components
-    that we must not omit. Much of this code can be adopted from
-    libstdc++-v2 or from the SGI STL. This particularly includes
-    <iostream.h>, <strstream.h>, and various SGI extensions such
-    as <hash_map.h>. Many of these are already placed in the
-    subdirectories ext/ and backward/. (Note that it is better to
-    include them via "<backward/hash_map.h>" or "<ext/hash_map>" than
-    to search the subdirectory itself via a "-I" directive.
-  

Prev Up Next
Documentation Style Home Appendix B. Porting and Maintenance
diff --git a/libstdc++-v3/doc/html/manual/bk01apd.html b/libstdc++-v3/doc/html/manual/bk01apd.html deleted file mode 100644 index 72f1d7e8d4b6..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apd.html +++ /dev/null @@ -1,41 +0,0 @@ - - -Appendix D. GNU General Public License
Appendix D. GNU General Public License
Prev The GNU C++ Library Next

Appendix D. GNU General Public License

Version 2, June 1991

Copyright © 1989, 1991 Free Software Foundation, Inc.

-

Free Software Foundation, Inc. 
-   51 Franklin Street, Fifth Floor, 
-   Boston, MA 02110-1301
-   USA
-

-

Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

Version 2, June 1991

Table of Contents

Preamble
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
Section 0
Section 1
Section 2
Section 3
Section 4
Section 5
Section 6
Section 7
Section 8
Section 9
Section 10
NO WARRANTY Section 11
Section 12
How to Apply These Terms to Your New Programs

Preamble

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.

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.

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.

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.

We protect your rights with two steps: -

  1. copyright the software, and

  2. offer you this license which gives you legal permission to copy, - distribute and/or modify the software.

-

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.

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.

The precise terms and conditions for copying, distribution and modification - follow.

Prev Up Next
Appendix C. Free Software Needs Free Documentation Home TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
diff --git a/libstdc++-v3/doc/html/manual/bk01apds02.html b/libstdc++-v3/doc/html/manual/bk01apds02.html deleted file mode 100644 index 2a0af92067c2..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apds02.html +++ /dev/null @@ -1,129 +0,0 @@ - - -TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
Prev Appendix D. GNU General Public License Next

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

Section 0

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 “Program”, below, refers to any such - program or work, and a - “work based on the Program” 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 - “modification”.) Each licensee is addressed as “you”.

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.

Section 1

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.

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.

Section 2

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 - Section 1 above, provided - that you also meet all of these conditions: -

  1. You must cause the modified files to carry prominent notices stating that - you changed the files and the date of any change.

  2. 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.

  3. 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.)

-

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.

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.

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.

Section 3

You may copy and distribute the Program (or a work based on it, under - Section 2 in object code or executable form under the terms of - Sections 1 and - 2 above provided that you also do one of the following: -

  1. 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,

  2. 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,

  3. 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.)

-

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.

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.

Section 4

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.

Section 5

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.

Section 6

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.

Section 7

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.

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.

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.

This section is intended to make thoroughly clear what is believed to be a consequence of the - rest of this License.

Section 8

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.

Section 9

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.

Each version is given a distinguishing version number. If the Program specifies a version number of - this License which applies to it and “any later version”, 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.

Section 10

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.

NO WARRANTY Section 11

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 “AS IS” 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.

Section 12

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.

END OF TERMS AND CONDITIONS

Prev Up Next
Appendix D. GNU General Public License Home How to Apply These Terms to Your New Programs
diff --git a/libstdc++-v3/doc/html/manual/bk01apds03.html b/libstdc++-v3/doc/html/manual/bk01apds03.html deleted file mode 100644 index d95dfd7a6869..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01apds03.html +++ /dev/null @@ -1,32 +0,0 @@ - - -How to Apply These Terms to Your New Programs
How to Apply These Terms to Your New Programs
Prev Appendix D. GNU General Public License Next

How to Apply These Terms to Your New Programs

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.

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 “copyright” line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.> - Copyright (C) <year> <name of author>

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.

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.

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

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this - when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type “show w”. - This is free software, and you are welcome to redistribute it - under certain conditions; type “show c” for details.

The hypothetical commands “show w” and “show c” should - show the appropriate parts of the General Public License. Of course, the commands you - use may be called something other than “show w” and “show c”; - they could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your - school, if any, to sign a “copyright disclaimer” for the program, if - necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program - “Gnomovision” (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989 - Ty Coon, President of Vice

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.

Prev Up Next
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION Home Appendix E. GNU Free Documentation License
diff --git a/libstdc++-v3/doc/html/manual/bk01ape.html b/libstdc++-v3/doc/html/manual/bk01ape.html deleted file mode 100644 index 6b3403b9bb8a..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01ape.html +++ /dev/null @@ -1,393 +0,0 @@ - - -Appendix E. GNU Free Documentation License
Appendix E. GNU Free Documentation License
Prev The GNU C++ Library Next

Appendix E. GNU Free Documentation License

- Copyright (C) 2000, 2001, 2002 Free Software Foundation, - Inc. 51 Franklin St, Fifth Floor, - Boston, MA 02110-1301 USA. Everyone is permitted to copy and - distribute verbatim copies of this license document, but changing it is - not allowed. -

- 0. PREAMBLE -

- 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. -

- 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. -

- 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.

- 1. APPLICABILITY AND DEFINITIONS -

- 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. -

- 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. -

- 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. -

- 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. -

- 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. -

- 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". -

- 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. -

- 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. -

- 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. -

- 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. -

- 2. VERBATIM COPYING -

- 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. -

- You may also lend copies, under the same conditions stated above, and you - may publicly display copies. -

- 3. COPYING IN QUANTITY -

- 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. -

- 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. -

- 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. -

- 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. -

- 4. MODIFICATIONS -

- 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: -

  1. - 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. -
  2. - 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. -
  3. - State on the Title page the name of the publisher of the Modified - Version, as the publisher. -
  4. - Preserve all the copyright notices of the Document. -
  5. - Add an appropriate copyright notice for your modifications adjacent to - the other copyright notices. -
  6. - 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. -
  7. - Preserve in that license notice the full lists of Invariant Sections - and required Cover Texts given in the Document's license notice. -
  8. - Include an unaltered copy of this License. -
  9. - 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. -
  10. - 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. -
  11. - 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. -
  12. - 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. -
  13. - Delete any section Entitled "Endorsements". Such a section may not be - included in the Modified Version. -
  14. - Do not retitle any existing section to be Entitled "Endorsements" or - to conflict in title with any Invariant Section. -
  15. - Preserve any Warranty Disclaimers. -

- 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. -

- 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. -

- 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. -

- 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. -

- 5. COMBINING DOCUMENTS -

- 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. -

- 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. -

- 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". -

- 6. COLLECTIONS OF DOCUMENTS -

- 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. -

- 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. -

- 7. AGGREGATION WITH INDEPENDENT WORKS -

- 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. -

- 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. -

- 8. TRANSLATION -

- 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. -

- 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. -

- 9. TERMINATION -

- 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. -

- 10. FUTURE REVISIONS OF THIS LICENSE -

- 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 http://www.gnu.org/copyleft/. -

- 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. -

- ADDENDUM: How to use this License for your documents -

- 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: -

- Copyright (C) YEAR YOUR NAME. -

- 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". -

- If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, - replace the "with...Texts." line with this: -

- with the Invariant Sections being LIST THEIR TITLES, with the - Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. -

- If you have Invariant Sections without Cover Texts, or some other - combination of the three, merge those two alternatives to suit the - situation. -

- 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. -

Prev Up Next
How to Apply These Terms to Your New Programs Home 
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch01.html b/libstdc++-v3/doc/html/manual/bk01pt01ch01.html deleted file mode 100644 index 60abfa4a7937..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch01.html +++ /dev/null @@ -1,6131 +0,0 @@ - - -Chapter 1. Status
Chapter 1. Status
Prev Part I. Introduction Next

Chapter 1. Status

Table of Contents

Implementation Status
C++ 1998
C++ TR1
C++ 200x
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs

Implementation Status

C++ 1998

Checklist


-   Completion Checklist for the Standard C++ Library
-   Updated: 2003-04-25
-
-   Status Code Legend:
-    M - Missing
-    S - Present as stub.
-    X - Partially implemented, or buggy.
-    T - Implemented, pending test/inspection.
-    V - Verified to pass all available test suites.
-    Q - Qualified by inspection for non-testable correctness.
-    P - Portability verified.
-    C - Certified.
-
-   Lexical notes:
-   Only status codes appear in column 0.  Notes relating to conformance
-   issues appear [in brackets].
-
-   Note that this checklist does not (yet) include all emendations
-   recommended by the ISO Library Working Group:
-   http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html
-
-   Detailed explanation of status codes:
-
-    M - Missing:  The name is not visible to programs that include
-        the specified header, either at compile or link stage.
-
-    S - Present as stub:  A program can use the name, but no implementation
-        is provided.  Programs that use the name link correctly, but
-        cannot usefully be run.
-
-    X - Partially implemented, or buggy:  Some implementation has been
-        provided, but it is known or believed not to conform fully.
-        It may have an incorrect base class, wrong namespace, wrong
-        storage class, or simply not fully implement requirements.
-        However, it may be sufficiently usable to help test other
-        components.
-
-    T - Implemented, pending test/inspection:  Implementation believed
-        to be complete, and informal testing suggests it is ready for
-        formal verification.
-
-    V - Verified, passes all test suites:  Verified to satisfy all
-        generically testable conformance requirements.
-
-    Q - Qualified by inspection for non-testable correctness:
-        Inspected, "implementation-defined" documentation accepted,
-        local usability criteria satisfied, formally inspected for
-        other untestable conformance.  (Untestable requirements
-        include exception-safety, thread-safety, worst-case
-        complexity, memory cleanliness, usefulness.)
-
-    P - Portability verified:  Qualified on all primary target platforms.
-
-    C - Certified:  Formally certified to have passed all tests,
-        inspections, qualifications; approved under "signing authority"
-        to be used to satisfy contractual guarantees.
-
-   ----------------------------------------------------------------------
-       <algorithm>    <iomanip>    <list>      <ostream>     <streambuf>
-       <bitset>       <ios>        <locale>    <queue>       <string>
-       <complex>      <iosfwd>     <map>       <set>         <typeinfo>
-X      <deque>        <iostream>   <memory>    <sstream>     <utility>
-       <exception>    <istream>    <new>       <stack>       <valarray>
-       <fstream>      <iterator>   <numeric>   <stdexcept>   <vector>
-       <functional>   <limits>
-
-   [C header names must be in std:: to qualify.  Related to shadow/ dir.]
-           <cassert> <ciso646> <csetjmp> <cstdio>  <ctime>
-           <cctype>  <climits> <csignal> <cstdlib> <cwchar>
-X          <cerrno>  <clocale> <cstdarg> <cstring> <cwctype>
-           <cfloat>  <cmath>   <cstddef>
-
-    Macro:
-X   errno,  declared  or  defined in <cerrno>.
-
-    Macro fn:
-X   setjmp(jmp_buf), declared or defined in <csetjmp>
-X   va_end(va_list), declared or defined in <cstdarg>
-
-    Types:
-X   clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t,
-X   ptrdiff_t, sig_atomic_t, size_t,  time_t,  tm,  va_list,
-X   wctrans_t, wctype_t, and wint_t.
-
-   1 Which  of  the functions in the C++ Standard Library are not reentrant
-    subroutines is implementation-defined.
-
-   18.1  Types                                        [lib.support.types]
-X      <cstddef>
-X      NULL
-X      offsetof
-X      ptrdiff_t
-X      size_t
-
-   18.2  Implementation properties                   [lib.support.limits]
-
-    <limits>, <climits>, and <cfloat>
-
-   18.2.1  Numeric limits                                    [lib.limits]
-
-X   template<class T> class numeric_limits;
-
-T   enum float_round_style;
-T   enum float_denorm_style;
-
-T   template<> class numeric_limits<bool>;
-
-T   template<> class numeric_limits<char>;
-T   template<> class numeric_limits<signed char>;
-T   template<> class numeric_limits<unsigned char>;
-T   template<> class numeric_limits<wchar_t>;
-
-T   template<> class numeric_limits<short>;
-T   template<> class numeric_limits<int>;
-T   template<> class numeric_limits<long>;
-T   template<> class numeric_limits<unsigned short>;
-T   template<> class numeric_limits<unsigned int>;
-T   template<> class numeric_limits<unsigned long>;
-
-X   template<> class numeric_limits<float>;
-X   template<> class numeric_limits<double>;
-X   template<> class numeric_limits<long double>;
-
-   18.2.1.1  Template class numeric_limits           [lib.numeric.limits]
-T   template<class T> class numeric_limits {
-    public:
-T     static const bool is_specialized = false;
-T     static T min() throw();
-T     static T max() throw();
-T     static const int  digits = 0;
-T     static const int  digits10 = 0;
-T     static const bool is_signed = false;
-T     static const bool is_integer = false;
-T     static const bool is_exact = false;
-T     static const int  radix = 0;
-T     static T epsilon() throw();
-T     static T round_error() throw();
-
-T     static const int  min_exponent = 0;
-T     static const int  min_exponent10 = 0;
-T     static const int  max_exponent = 0;
-T     static const int  max_exponent10 = 0;
-
-T     static const bool has_infinity = false;
-T     static const bool has_quiet_NaN = false;
-T     static const bool has_signaling_NaN = false;
-T     static const float_denorm_style has_denorm = denorm_absent;
-T     static const bool has_denorm_loss = false;
-T     static T infinity() throw();
-T     static T quiet_NaN() throw();
-T     static T signaling_NaN() throw();
-T     static T denorm_min() throw();
-
-T     static const bool is_iec559 = false;
-T     static const bool is_bounded = false;
-T     static const bool is_modulo = false;
-
-T     static const bool traps = false;
-T     static const bool tinyness_before = false;
-T     static const float_round_style round_style = round_toward_zero;
-    };
-
-   18.2.1.3  Type float_round_style                     [lib.round.style]
-
-T   enum float_round_style {
-T     round_indeterminate       = -1,
-T     round_toward_zero         =  0,
-T     round_to_nearest          =  1,
-T     round_toward_infinity     =  2,
-T     round_toward_neg_infinity =  3
-    };
-
-   18.2.1.4  Type float_denorm_style                   [lib.denorm.style]
-
-T   enum float_denorm_style {
-T     denorm_indeterminate = -1;
-T     denorm_absent = 0;
-T     denorm present = 1;
-    };
-
-   18.2.1.5  numeric_limits specializations         [lib.numeric.special]
-   
-   [Note: see Note at 18.2.1.  ]
-
-   18.2.2  C Library                                       [lib.c.limits]
-
-   1 Header <climits> (Table 3):
-      CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX
-X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
-      CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX
-
-   3 Header <cfloat> (Table 4):
-
-    DBL_DIG          DBL_MIN_EXP      FLT_MIN_10_EXP   LDBL_MAX_10_EXP
-    DBL_EPSILON      FLT_DIG          FLT_MIN_EXP      LDBL_MAX_EXP
-    DBL_MANT_DIG     FLT_EPSILON      FLT_RADIX        LDBL_MIN
-X   DBL_MAX          FLT_MANT_DIG     FLT_ROUNDS       LDBL_MIN_10_EXP
-    DBL_MAX_10_EXP   FLT_MAX          LDBL_DIG         LDBL_MIN_EXP
-    DBL_MAX_EXP      FLT_MAX_10_EXP   LDBL_EPSILON
-    DBL_MIN          FLT_MAX_EXP      LDBL_MANT_DIG
-    DBL_MIN_10_EXP   FLT_MIN          LDBL_MAX
-
-
-        1 Header <cstdlib> (partial), Table 5:
-X             EXIT_FAILURE     EXIT_SUCCESS
-              abort   atexit   exit
-
-S    abort(void)
-S    extern "C" int atexit(void (*f)(void))
-S    extern "C++" int atexit(void (*f)(void))
-S    exit(int status)
-
-   18.4  Dynamic memory management                  [lib.support.dynamic]
-
-   Header <new> synopsis
-
-T    class bad_alloc;
-T    struct nothrow_t {};
-T    extern const nothrow_t nothrow;
-T    typedef void (*new_handler)();
-T    new_handler set_new_handler(new_handler new_p) throw();
-
-T    void* operator new(std::size_t size) throw(std::bad_alloc);
-T    void* operator new(std::size_t size, const std::nothrow_t&) throw();
-T    void  operator delete(void* ptr) throw();
-T    void  operator delete(void* ptr, const std::nothrow_t&) throw();
-T    void* operator new[](std::size_t size) throw(std::bad_alloc);
-T    void* operator new[](std::size_t size, const std::nothrow_t&) throw();
-T    void  operator delete[](void* ptr) throw();
-T    void  operator delete[](void* ptr, const std::nothrow_t&) throw();
-T    void* operator new  (std::size_t size, void* ptr) throw();
-T    void* operator new[](std::size_t size, void* ptr) throw();
-T    void  operator delete  (void* ptr, void*) throw();
-T    void  operator delete[](void* ptr, void*) throw();
-
-   18.4.2.1  Class bad_alloc                              [lib.bad.alloc]
-
-T   class bad_alloc : public exception {
-    public:
-T     bad_alloc() throw();
-T     bad_alloc(const bad_alloc&) throw();
-T     bad_alloc& operator=(const bad_alloc&) throw();
-T     virtual ~bad_alloc() throw();
-T     virtual const char* what() const throw();
-
-
-
-T  new_handler set_new_handler(new_handler new_p) throw();
-
-
-     Header <typeinfo> synopsis
-
-T    class type_info;
-T    class bad_cast;
-T    class bad_typeid;
-
-   18.5.1 - Class type_info [lib.type.info]
-
-T    class type_info {
-    public:
-T      virtual ~type_info();
-T      bool operator==(const type_info& rhs) const;
-T      bool operator!=(const type_info& rhs) const;
-T      bool before(const type_info& rhs) const;
-T      const char* name() const;
-    private:
-T      type_info(const type_info& rhs);
-T      type_info& operator=(const type_info& rhs);
-    };
-
-   18.5.2 - Class bad_cast [lib.bad.cast]
-
-T  bad_cast() throw();
-T  virtual const char* bad_cast::what() const throw();
-
-   18.5.3  Class bad_typeid                              [lib.bad.typeid]
-
-T    class bad_typeid : public exception {
-    public:
-T      bad_typeid() throw();
-T      bad_typeid(const bad_typeid&) throw();
-T      bad_typeid& operator=(const bad_typeid&) throw();
-T      virtual ~bad_typeid() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.6  Exception handling                       [lib.support.exception]
-
-T      Header <exception> synopsis
-
-T    class exception;
-T    class bad_exception;
-
-T    typedef void (*unexpected_handler)();
-T    unexpected_handler set_unexpected(unexpected_handler f) throw();
-T    void unexpected();
-T    typedef void (*terminate_handler)();
-T    terminate_handler set_terminate(terminate_handler f) throw();
-T    void terminate();
-T    bool uncaught_exception();
-
-   18.6.1  Class exception                                [lib.exception]
-
-T    class exception {
-     public:
-T      exception() throw();
-T      exception(const exception&) throw();
-T      exception& operator=(const exception&) throw();
-T      virtual ~exception() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.6.2.1  Class bad_exception                      [lib.bad.exception]
-T    class bad_exception : public exception {
-    public:
-T      bad_exception() throw();
-T      bad_exception(const bad_exception&) throw();
-T      bad_exception& operator=(const bad_exception&) throw();
-T      virtual ~bad_exception() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.7  Other runtime support                      [lib.support.runtime]
-
-   1 Headers <cstdarg> (variable arguments),  <csetjmp>  (nonlocal  jumps),
-    <ctime>  (system  clock clock(), time()), <csignal> (signal handling),
-    and <cstdlib> (runtime environment getenv(), system()).
-
-                    Table 6--Header <cstdarg> synopsis
-                 Macros:   va_arg    va_end   va_start
-X                Type:     va_list
-
-                    Table 7--Header <csetjmp> synopsis
-
-                          Macro:      setjmp |
-X                         Type:       jmp_buf
-                          Function:   longjmp
-
-                     Table 8--Header <ctime> synopsis
-
-                      Macros:      CLOCKS_PER_SEC
-X                     Types:       clock_t
-                      Functions:   clock
-
-                    Table 9--Header <csignal> synopsis
-
-X        Macros:      SIGABRT        SIGILL   SIGSEGV   SIG_DFL
-         SIG_IGN      SIGFPE         SIGINT   SIGTERM   SIG_ERR
-         Type:        sig_atomic_t
-         Functions:   raise          signal
-
-                   Table 10--Header <cstdlib> synopsis
-
-X                     Functions:   getenv   system
-
-   19.1  Exception classes                           [lib.std.exceptions]
-
-   Header <stdexcept> synopsis
-
-T     class logic_error;
-T     class domain_error;
-T     class invalid_argument;
-T     class length_error;
-T     class out_of_range;
-T     class runtime_error;
-T     class range_error;
-T     class overflow_error;
-T     class underflow_error;
-
-   19.1.1  Class logic_error                            [lib.logic.error]
-T   class logic_error : public exception {
-    public:
-T     explicit logic_error(const string& what_arg);
-    };
-
-   19.1.2  Class domain_error                          [lib.domain.error]
-
-T   class domain_error : public logic_error {
-    public:
-T     explicit domain_error(const string& what_arg);
-    };
-
-   19.1.3  Class invalid_argument                  [lib.invalid.argument]
-
-T   class invalid_argument : public logic_error {
-    public:
-T     explicit invalid_argument(const string& what_arg);
-    };
-
-   19.1.4  Class length_error                          [lib.length.error]
-
-T   class length_error : public logic_error {
-    public:
-T     explicit length_error(const string& what_arg);
-    };
-
-   19.1.5  Class out_of_range                          [lib.out.of.range]
-
-T   class out_of_range : public logic_error {
-    public:
-T     explicit out_of_range(const string& what_arg);
-    };
-
-
-   19.1.6  Class runtime_error                        [lib.runtime.error]
-
-T   class runtime_error : public exception {
-    public:
-T     explicit runtime_error(const string& what_arg);
-    };
-
-
-   19.1.7  Class range_error                            [lib.range.error]
-
-T   class range_error : public runtime_error {
-    public:
-T     explicit range_error(const string& what_arg);
-    };
-
-   19.1.8  Class overflow_error                      [lib.overflow.error]
-
-T   class overflow_error : public runtime_error {
-    public:
-T     explicit overflow_error(const string& what_arg);
-    };
-
-
-   19.1.9  Class underflow_error                    [lib.underflow.error]
-
-T   class underflow_error : public runtime_error {
-    public:
-T     explicit underflow_error(const string& what_arg);
-    };
-
-
-   19.2  Assertions                                      [lib.assertions]
-
-                    Table 2--Header <cassert> synopsis
-
-X                         Macro:   assert
-
-   19.3  Error numbers                                        [lib.errno]
-
-                    Table 3--Header <cerrno> synopsis
-
-X                    |Macros:   EDOM   ERANGE   errno |
-
-
-   20.2  Utility components                                 [lib.utility]
-
-   Header <utility> synopsis
-
-    // _lib.operators_, operators:
-T    namespace rel_ops {
-T      template<class T> bool operator!=(const T&, const T&);
-T      template<class T> bool operator> (const T&, const T&);
-T      template<class T> bool operator<=(const T&, const T&);
-T      template<class T> bool operator>=(const T&, const T&);
-    }
-    // _lib.pairs_, pairs:
-T   template <class T1, class T2> struct pair;
-T   template <class T1, class T2>
-      bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2>
-      bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2>
-      bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2>
-      bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2>
-      bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2>
-      bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
-T   template <class T1, class T2> pair<T1,T2> make_pair(const T1&, const T2&);
-
-
-   20.2.2  Pairs                                              [lib.pairs]
-
-T  template <class T1, class T2>
-   struct pair {
-T    typedef T1 first_type;
-T    typedef T2 second_type;
-
-T    T1 first;
-T    T2 second;
-T    pair();
-T    pair(const T1& x, const T2& y);
-T    template<class U, class V> pair(const pair<U, V> &p);
-   };
-
-   20.3  Function objects                          [lib.function.objects]
-
-   Header <functional> synopsis
-
-    // _lib.base_, base:
-V   template <class Arg, class Result> struct unary_function;
-V   template <class Arg1, class Arg2, class Result> struct binary_function;
-
-    // _lib.arithmetic.operations_, arithmetic operations:
-V   template <class T> struct plus;
-V   template <class T> struct minus;
-V   template <class T> struct multiplies;
-V   template <class T> struct divides;
-V   template <class T> struct modulus;
-V   template <class T> struct negate;
-    // _lib.comparisons_, comparisons:
-V   template <class T> struct equal_to;
-V   template <class T> struct not_equal_to;
-V   template <class T> struct greater;
-V   template <class T> struct less;
-V   template <class T> struct greater_equal;
-V   template <class T> struct less_equal;
-    // _lib.logical.operations_, logical operations:
-V   template <class T> struct logical_and;
-V   template <class T> struct logical_or;
-V   template <class T> struct logical_not;
-    // _lib.negators_, negators:
-    template <class Predicate> struct unary_negate;
-V   template <class Predicate>
-      unary_negate<Predicate>  not1(const Predicate&);
-V   template <class Predicate> struct binary_negate;
-V   template <class Predicate>
-      binary_negate<Predicate> not2(const Predicate&);
-    // _lib.binders_, binders:
-V   template <class Operation>  class binder1st;
-V   template <class Operation, class T>
-      binder1st<Operation> bind1st(const Operation&, const T&);
-V   template <class Operation> class binder2nd;
-V   template <class Operation, class T>
-      binder2nd<Operation> bind2nd(const Operation&, const T&);
-    // _lib.function.pointer.adaptors_, adaptors:
-V   template <class Arg, class Result> class pointer_to_unary_function;
-V   template <class Arg, class Result>
-      pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
-V   template <class Arg1, class Arg2, class Result>
-      class pointer_to_binary_function;
-V   template <class Arg1, class Arg2, class Result>
-      pointer_to_binary_function<Arg1,Arg2,Result>
-        ptr_fun(Result (*)(Arg1,Arg2));
-
-    // _lib.member.pointer.adaptors_, adaptors:
-V   template<class S, class T> class mem_fun_t;
-V   template<class S, class T, class A> class mem_fun1_t;
-V   template<class S, class T>
-        mem_fun_t<S,T> mem_fun(S (T::*f)());
-V   template<class S, class T, class A>
-        mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
-V   template<class S, class T> class mem_fun_ref_t;
-V   template<class S, class T, class A> class mem_fun1_ref_t;
-V   template<class S, class T>
-        mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
-V   template<class S, class T, class A>
-        mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
-
-V   template <class S, class T> class const_mem_fun_t;
-V   template <class S, class T, class A> class const_mem_fun1_t;
-V   template <class S, class T>
-      const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
-V   template <class S, class T, class A>
-      const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
-V   template <class S, class T> class const_mem_fun_ref_t;
-V   template <class S, class T, class A> class const_mem_fun1_ref_t;
-V   template <class S, class T>
-      const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
-V   template <class S, class T, class A>
-      const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
-   }
-
-   20.3.1  Base                                                [lib.base]
-
-V   template <class Arg, class Result>
-    struct unary_function {
-V     typedef Arg    argument_type;
-V     typedef Result result_type;
-    };
-V   template <class Arg1, class Arg2, class Result>
-    struct binary_function {
-V     typedef Arg1   first_argument_type;
-V     typedef Arg2   second_argument_type;
-V     typedef Result result_type;
-    };
-
-   20.3.2  Arithmetic operations              [lib.arithmetic.operations]
-
-T  template <class T> struct plus : binary_function<T,T,T> {
-V   T operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct minus : binary_function<T,T,T> {
-V   T operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct multiplies : binary_function<T,T,T> {
-V   T operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct divides : binary_function<T,T,T> {
-V   T operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct modulus : binary_function<T,T,T> {
-V   T operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct negate : unary_function<T,T> {
-V   T operator()(const T& x) const;
-   };
-
-   20.3.3  Comparisons                                  [lib.comparisons]
-
-T  template <class T> struct equal_to : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct not_equal_to : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct greater : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct less : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct greater_equal : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct less_equal : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-   20.3.4  Logical operations                    [lib.logical.operations]
-
-T  template <class T> struct logical_and : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct logical_or : binary_function<T,T,bool> {
-V   bool operator()(const T& x, const T& y) const;
-   };
-
-T  template <class T> struct logical_not : unary_function<T,bool> {
-V   bool operator()(const T& x) const;
-   };
-
-   20.3.5  Negators                                        [lib.negators]
-
-T  template <class Predicate>
-    class unary_negate
-      : public unary_function<typename Predicate::argument_type,bool> {
-   public:
-T   explicit unary_negate(const Predicate& pred);
-V   bool operator()(const typename Predicate::argument_type& x) const;
-   };
-
-T  template <class Predicate>
-    class binary_negate
-      : public binary_function<typename Predicate::first_argument_type,
-          typename Predicate::second_argument_type, bool> {
-    public:
-T     explicit binary_negate(const Predicate& pred);
-V     bool operator()(const typename Predicate::first_argument_type&  x,
-          const typename Predicate::second_argument_type& y) const;
-    };
-
-
-   20.3.6  Binders                                          [lib.binders]
-
-   20.3.6.1  Template class binder1st                    [lib.binder.1st]
-T   template <class Operation>
-    class binder1st
-      : public unary_function<typename Operation::second_argument_type,
-                              typename Operation::result_type> {
-    protected:
-T     Operation                      op;
-T     typename Operation::first_argument_type value;
-    public:
-V     binder1st(const Operation& x,
-                const typename Operation::first_argument_type& y);
-V     typename Operation::result_type
-        operator()(const typename Operation::second_argument_type& x) const;
-    };
-
-   20.3.6.2  bind1st                                       [lib.bind.1st]
-
-V  template <class Operation, class T>
-    binder1st<Operation> bind1st(const Operation& op, const T& x);
-
-   20.3.6.3  Template class binder2nd                    [lib.binder.2nd]
-T   template <class Operation>
-    class binder2nd
-      : public unary_function<typename Operation::first_argument_type,
-                              typename Operation::result_type> {
-    protected:
-T     Operation                       op;
-T     typename Operation::second_argument_type value;
-    public:
-V     binder2nd(const Operation& x,
-                const typename Operation::second_argument_type& y);
-V     typename Operation::result_type
-        operator()(const typename Operation::first_argument_type& x) const;
-    };
-
-   20.3.6.4  bind2nd                                       [lib.bind.2nd]
-
-T  template <class Operation, class T>
-    binder2nd<Operation> bind2nd(const Operation& op, const T& x);
-
-
-   20.3.7  Adaptors for pointers to       [lib.function.pointer.adaptors]
-       functions
-
-   1 To  allow  pointers to (unary and binary) functions to work with func-
-   tion adaptors the library provides:
-
-T   template <class Arg, class Result>
-    class pointer_to_unary_function : public unary_function<Arg, Result> {
-    public:
-T     explicit pointer_to_unary_function(Result (*f)(Arg));
-V     Result operator()(Arg x) const;
-    };
-
-T  template <class Arg, class Result>
-    pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg));
-
-T       template <class Arg1, class Arg2, class Result>
-        class pointer_to_binary_function :
-          public binary_function<Arg1,Arg2,Result> {
-        public:
-T         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
-V         Result operator()(Arg1 x, Arg2 y) const;
-        };
-
-
-   20.3.8  Adaptors for pointers to         [lib.member.pointer.adaptors]
-       members
-
-T  template <class S, class T> class mem_fun_t
-          : public unary_function<T*, S> {
-   public:
-T   explicit mem_fun_t(S (T::*p)());
-V   S operator()(T* p) const;
-   };
-
-T   template <class S, class T, class A> class mem_fun1_t
-          : public binary_function<T*, A, S> {
-    public:
-T     explicit mem_fun1_t(S (T::*p)(A));
-V     S operator()(T* p, A x) const;
-   };
-
-V   template<class S, class T> mem_fun_t<S,T>
-       mem_fun(S (T::*f)());
-V   template<class S, class T, class A> mem_fun1_t<S,T,A>
-       mem_fun(S (T::*f)(A));
-
-T   template <class S, class T> class mem_fun_ref_t
-          : public unary_function<T, S> {
-    public:
-T     explicit mem_fun_ref_t(S (T::*p)());
-V     S operator()(T& p) const;
-   };
-
-T   template <class S, class T, class A> class mem_fun1_ref_t
-          : public binary_function<T, A, S> {
-    public:
-T     explicit mem_fun1_ref_t(S (T::*p)(A));
-V     S operator()(T& p, A x) const;
-   };
-
-T   template<class S, class T> mem_fun_ref_t<S,T>
-       mem_fun_ref(S (T::*f)());
-
-T   template<class S, class T, class A> mem_fun1_ref_t<S,T,A>
-       mem_fun_ref(S (T::*f)(A));
-
-T  template <class S, class T> class const_mem_fun_t
-        : public unary_function<T*, S> {
-   public:
-T   explicit const_mem_fun_t(S (T::*p)() const);
-V   S operator()(const T* p) const;
-   };
-
-T  template <class S, class T, class A> class const_mem_fun1_t
-        : public binary_function<T*, A, S> {
-   public:
-T   explicit const mem_fun1_t(S (T::*p)(A) const);
-V   S operator()(const T* p, A x) const;
-   };
-
-V   template<class S, class T> const_mem_fun_t<S,T>
-       mem_fun(S (T::*f)() const);
-V   template<class S, class T, class A> const_mem_fun1_t<S,T,A>
-       mem_fun(S (T::*f)(A) const);
-
-T   template <class S, class T> class const_mem_fun_ref_t
-          : public unary_function<T, S> {
-    public:
-T     explicit const_mem_fun_ref_t(S (T::*p)() const);
-V     S operator()(const T& p) const;
-   };
-
-T   template <class S, class T, class A> class const_mem_fun1_ref_t
-          : public binary_function<T, A, S> {
-    public:
-T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
-V     S operator()(const T& p, A x) const;
-   };
-
-T   template<class S, class T> const_mem_fun_ref_t<S,T>
-       mem_fun_ref(S (T::*f)() const);
-
-T   template<class S, class T, class A> const_mem_fun1_ref_t<S,T,A>
-        mem_fun_ref(S (T::*f)(A) const);
-
-   20.4  Memory                                              [lib.memory]
-
-   Header <memory> synopsis
-
-    // _lib.default.allocator_, the default allocator:
-T   template <class T> class allocator;
-T   template <> class allocator<void>;
-T   template <class T, class U>
-      bool operator==(const allocator<T>&, const allocator<U>&) throw();
-T   template <class T, class U>
-      bool operator!=(const allocator<T>&, const allocator<U>&) throw();
-    // _lib.storage.iterator_, raw storage iterator:
-T   template <class OutputIterator, class T> class raw_storage_iterator;
-    // _lib.temporary.buffer_, temporary buffers:
-T   template <class T>
-      pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n);
-T   template <class T>
-      void return_temporary_buffer(T* p);
-    // _lib.specialized.algorithms_, specialized algorithms:
-T   template <class InputIterator, class ForwardIterator>
-      ForwardIterator
-        uninitialized_copy(InputIterator first, InputIterator last,
-                           ForwardIterator result);
-T   template <class ForwardIterator, class T>
-      void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                              const T& x);
-T   template <class ForwardIterator, class Size, class T>
-      void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
-    // _lib.auto.ptr_, pointers:
-X   template<class X> class auto_ptr;
-   }
-
-   20.4.1  The default allocator                  [lib.default.allocator]
-
-T   template <class T> class allocator;
-    // specialize for void:
-T   template <> class allocator<void> {
-    public:
-T     typedef void*       pointer;
-T     typedef const void* const_pointer;
-      // reference-to-void members are impossible.
-T     typedef void  value_type;
-T     template <class U> struct rebind { typedef allocator<U> other; };
-    };
-
-T   template <class T> class allocator {
-     public:
-T     typedef size_t    size_type;
-T     typedef ptrdiff_t difference_type;
-T     typedef T*        pointer;
-T     typedef const T*  const_pointer;
-T     typedef T&        reference;
-T     typedef const T&  const_reference;
-T     typedef T         value_type;
-T     template <class U> struct rebind { typedef allocator<U> other; };
-T     allocator() throw();
-T     allocator(const allocator&) throw();
-T     template <class U> allocator(const allocator<U>&) throw();
-T    ~allocator() throw();
-T     pointer address(reference x) const;
-T     const_pointer address(const_reference x) const;
-T     pointer allocate(
-        size_type, allocator<void>::const_pointer hint = 0);
-T     void deallocate(pointer p, size_type n);
-T     size_type max_size() const throw();
-T     void construct(pointer p, const T& val);
-T     void destroy(pointer p);
-    };
-
-   20.4.1.2  allocator globals                    [lib.allocator.globals]
-
-T  template <class T1, class T2>
-    bool operator==(const allocator<T1>&, const allocator<T2>&) throw();
-T  template <class T1, class T2>
-    bool operator!=(const allocator<T1>&, const allocator<T2>&) throw();
-
-   20.4.2  Raw storage iterator                    [lib.storage.iterator]
-
-T   template <class OutputIterator, class T>
-    class raw_storage_iterator
-      : public iterator<output_iterator_tag,void,void,void,void> {
-    public:
-T     explicit raw_storage_iterator(OutputIterator x);
-T     raw_storage_iterator<OutputIterator,T>& operator*();
-T     raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
-T     raw_storage_iterator<OutputIterator,T>& operator++();
-T     raw_storage_iterator<OutputIterator,T>  operator++(int);
-    };
-
-   20.4.3  Temporary buffers                       [lib.temporary.buffer]
-
-T  template <class T>
-    pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n);
-
-T  template <class T> void return_temporary_buffer(T* p);
-
-   20.4.4  Specialized algorithms            [lib.specialized.algorithms]
-
-   20.4.4.1  uninitialized_copy                  [lib.uninitialized.copy]
-
-V  template <class InputIterator, class ForwardIterator>
-    ForwardIterator
-      uninitialized_copy(InputIterator first, InputIterator last,
-                         ForwardIterator result);
-
-   20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]
-
-V  template <class ForwardIterator, class T>
-    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                            const T& x);
-
-   20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]
-
-V  template <class ForwardIterator, class Size, class T>
-    void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
-
-   20.4.5  Template class auto_ptr                         [lib.auto.ptr]
-
-X   template<class X> class auto_ptr {
-      template <class Y> struct auto_ptr_ref {};
-    public:
-T     typedef X element_type;
-      // _lib.auto.ptr.cons_ construct/copy/destroy:
-T     explicit auto_ptr(X* p =0) throw();
-T     auto_ptr(auto_ptr&) throw();
-T     template<class Y> auto_ptr(auto_ptr<Y>&) throw();
-T     auto_ptr& operator=(auto_ptr&) throw();
-T     template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
-T    ~auto_ptr() throw();
-      // _lib.auto.ptr.members_ members:
-T     X& operator*() const throw();
-T     X* operator->() const throw();
-T     X* get() const throw();
-T     X* release() throw();
-T     void reset(X* p =0) throw();
-
-      // _lib.auto.ptr.conv_ conversions:
-X     auto_ptr(auto_ptr_ref<X>) throw();
-X     template<class Y> operator auto_ptr_ref<Y>() throw();
-X     template<class Y> operator auto_ptr<Y>() throw();
-    };
-
-   20.4.6  C Library                                       [lib.c.malloc]
-
-                    Table 7--Header <cstdlib> synopsis
-
-X                    Functions:   calloc   malloc
-                                  free     realloc
-
-
-                    Table 8--Header <cstring> synopsis
-
-X                    Macro:       NULL
-X                    Type:        size_t
-X                    Functions:   memchr    memcmp
-X                    memcpy       memmove   memset
-
-                     Table 9--Header <ctime> synopsis
-
-X          Macros:   NULL
-X          Types:    size_t   clock_t    time_t
-X          Struct:   tm
-           Functions:
-X          asctime   clock    difftime   localtime   strftime
-X          ctime     gmtime   mktime     time
-
-   21.1.1  Character traits requirements        [lib.char.traits.require]
-
-   2 The struct template
-T  template<class charT> struct char_traits;
-   shall be provided in the header <string> as a basis for  explicit spe-
-   cializations.
-
-
-   21.1.3.1  struct                [lib.char.traits.specializations.char]
-       char_traits<char>
-
-T   template<>
-    struct char_traits<char> {
-T     typedef char        char_type;
-T     typedef int         int_type;
-T     typedef streamoff   off_type;
-T     typedef streampos   pos_type;
-T     typedef mbstate_t   state_type;
-
-T     static void assign(char_type& c1, const char_type& c2);
-T     static bool eq(const char_type& c1, const char_type& c2);
-T     static bool lt(const char_type& c1, const char_type& c2);
-
-T     static int compare(const char_type* s1, const char_type* s2, size_t n);
-T     static size_t length(const char_type* s);
-T     static const char_type* find(const char_type* s, size_t n,
-                                   const char_type& a);
-T     static char_type* move(char_type* s1, const char_type* s2, size_t n);
-T     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
-T     static char_type* assign(char_type* s, size_t n, char_type a);
-
-T     static int_type not_eof(const int_type& c);
-T     static char_type to_char_type(const int_type& c);
-T     static int_type to_int_type(const char_type& c);
-T     static bool eq_int_type(const int_type& c1, const int_type& c2);
-T     static int_type eof();
-    };
-
-   21.1.3.2  struct             [lib.char.traits.specializations.wchar.t]
-       char_traits<wchar_t>
-
-V   template<>
-    struct char_traits<wchar_t> {
-V     typedef wchar_t      char_type;
-V     typedef wint_t       int_type;
-V     typedef streamoff   off_type;
-V     typedef wstreampos   pos_type;
-V     typedef mbstate_t    state_type;
-
-V     static void assign(char_type& c1, const char_type& c2);
-V     static bool eq(const char_type& c1, const char_type& c2);
-V     static bool lt(const char_type& c1, const char_type& c2);
-
-V     static int compare(const char_type* s1, const char_type* s2, size_t n);
-V     static size_t length(const char_type* s);
-V     static const char_type* find(const char_type* s, size_t n,
-                                   const char_type& a);
-V     static char_type* move(char_type* s1, const char_type* s2, size_t n);
-V     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
-V     static char_type* assign(char_type* s, size_t n, char_type a);
-
-V     static int_type not_eof(const int_type& c);
-V     static char_type to_char_type(const int_type& c);
-V     static int_type to_int_type(const char_type& c);
-V     static bool eq_int_type(const int_type& c1, const int_type& c2);
-V     static int_type eof();
-    };
-
-   21.2  String classes                              [lib.string.classes]
-
-    // _lib.char.traits_, character traits:
-V   template<class charT>
-      struct char_traits;
-V   template <> struct char_traits<char>;
-V   template <> struct char_traits<wchar_t>;
-
-    // _lib.basic.string_, basic_string:
-V   template<class charT, class traits = char_traits<charT>,
-             class Allocator = allocator<charT> >
-      class basic_string;
-V   template<class charT, class traits, class Allocator>
-      basic_string<charT,traits,Allocator>
-        operator+(const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      basic_string<charT,traits,Allocator>
-        operator+(const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      basic_string<charT,traits,Allocator>
-        operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      basic_string<charT,traits,Allocator>
-        operator+(const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      basic_string<charT,traits,Allocator>
-        operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);
-
-V   template<class charT, class traits, class Allocator>
-      bool operator==(const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator==(const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator==(const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator!=(const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator< (const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator< (const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator< (const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator> (const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator> (const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator> (const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator<=(const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
-                      const charT* rhs);
-V   template<class charT, class traits, class Allocator>
-      bool operator>=(const charT* lhs,
-                      const basic_string<charT,traits,Allocator>& rhs);
-
-    // _lib.string.special_:
-V   template<class charT, class traits, class Allocator>
-       void swap(basic_string<charT,traits,Allocator>& lhs,
-                 basic_string<charT,traits,Allocator>& rhs);
-V   template<class charT, class traits, class Allocator>
-     basic_istream<charT,traits>&
-      operator>>(basic_istream<charT,traits>& is,
-                 basic_string<charT,traits,Allocator>& str);
-T   template<class charT, class traits, class Allocator>
-     basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>& os,
-                 const basic_string<charT,traits,Allocator>& str);
-V   template<class charT, class traits, class Allocator>
-     basic_istream<charT,traits>&
-       getline(basic_istream<charT,traits>& is,
-               basic_string<charT,traits,Allocator>& str,
-               charT delim);
-V   template<class charT, class traits, class Allocator>
-     basic_istream<charT,traits>&
-       getline(basic_istream<charT,traits>& is,
-               basic_string<charT,traits,Allocator>& str);
-V   typedef basic_string<char> string;
-T   typedef basic_string<wchar_t> wstring;
-   }
-
-   21.3  Template class basic_string                   [lib.basic.string]
-
-V  namespace std {
-    template<class charT, class traits = char_traits<charT>,
-             class Allocator = allocator<charT> >
-    class basic_string {
-    public:
-      // types:
-      typedef          traits                     traits_type;
-      typedef typename traits::char_type          value_type;
-      typedef          Allocator                  allocator_type;
-      typedef typename Allocator::size_type       size_type;
-      typedef typename Allocator::difference_type difference_type;
-      typedef typename Allocator::reference       reference;
-      typedef typename Allocator::const_reference const_reference;
-      typedef typename Allocator::pointer         pointer;
-      typedef typename Allocator::const_pointer   const_pointer;
-      typedef implementation defined             iterator;
-      typedef implementation defined             const_iterator;
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      static const size_type npos = -1;
-
-      // _lib.string.cons_ construct/copy/destroy:
-V     explicit basic_string(const Allocator& a = Allocator());
-V     basic_string(const basic_string& str, size_type pos = 0,
-                   size_type n = npos, const Allocator& a = Allocator());
-V     basic_string(const charT* s,
-                   size_type n, const Allocator& a = Allocator());
-V     basic_string(const charT* s, const Allocator& a = Allocator());
-V     basic_string(size_type n, charT c, const Allocator& a = Allocator());
-V     template<class InputIterator>
-        basic_string(InputIterator begin, InputIterator end,
-                     const Allocator& a = Allocator());
-V    ~basic_string();
-V     basic_string& operator=(const basic_string& str);
-V     basic_string& operator=(const charT* s);
-V     basic_string& operator=(charT c);
-      // _lib.string.iterators_ iterators:
-V     iterator       begin();
-V     const_iterator begin() const;
-V     iterator       end();
-V     const_iterator end() const;
-
-V     reverse_iterator       rbegin();
-V     const_reverse_iterator rbegin() const;
-V     reverse_iterator       rend();
-V     const_reverse_iterator rend() const;
-      // _lib.string.capacity_ capacity:
-V     size_type size() const;
-V     size_type length() const;
-V     size_type max_size() const;
-V     void resize(size_type n, charT c);
-V     void resize(size_type n);
-V     size_type capacity() const;
-V     void reserve(size_type res_arg = 0);
-V     void clear();
-V     bool empty() const;
-      // _lib.string.access_ element access:
-V     const_reference operator[](size_type pos) const;
-V     reference       operator[](size_type pos);
-V     const_reference at(size_type n) const;
-V     reference       at(size_type n);
-      // _lib.string.modifiers_ modifiers:
-V     basic_string& operator+=(const basic_string& str);
-V     basic_string& operator+=(const charT* s);
-V     basic_string& operator+=(charT c);
-V     basic_string& append(const basic_string& str);
-V     basic_string& append(const basic_string& str, size_type pos,
-                           size_type n);
-V     basic_string& append(const charT* s, size_type n);
-V     basic_string& append(const charT* s);
-V     basic_string& append(size_type n, charT c);
-V     template<class InputIterator>
-        basic_string& append(InputIterator first, InputIterator last);
-V     void push_back(const charT);
-
-V     basic_string& assign(const basic_string&);
-V     basic_string& assign(const basic_string& str, size_type pos,
-                           size_type n);
-V     basic_string& assign(const charT* s, size_type n);
-V     basic_string& assign(const charT* s);
-V     basic_string& assign(size_type n, charT c);
-V     template<class InputIterator>
-        basic_string& assign(InputIterator first, InputIterator last);
-V     basic_string& insert(size_type pos1, const basic_string& str);
-V     basic_string& insert(size_type pos1, const basic_string& str,
-                           size_type pos2, size_type n);
-V     basic_string& insert(size_type pos, const charT* s, size_type n);
-V     basic_string& insert(size_type pos, const charT* s);
-V     basic_string& insert(size_type pos, size_type n, charT c);
-V     iterator insert(iterator p, charT c);
-V     void     insert(iterator p, size_type n, charT c);
-V     template<class InputIterator>
-        void insert(iterator p, InputIterator first, InputIterator last);
-V     basic_string& erase(size_type pos = 0, size_type n = npos);
-V     iterator erase(iterator position);
-V     iterator erase(iterator first, iterator last);
-V     basic_string& replace(size_type pos1, size_type n1,
-                            const basic_string& str);
-V     basic_string& replace(size_type pos1, size_type n1,
-                            const basic_string& str,
-                            size_type pos2, size_type n2);
-V     basic_string& replace(size_type pos, size_type n1, const charT* s,
-                            size_type n2);
-V     basic_string& replace(size_type pos, size_type n1, const charT* s);
-V     basic_string& replace(size_type pos, size_type n1, size_type n2,
-                            charT c);
-V     basic_string& replace(iterator i1, iterator i2, const basic_string& str);
-V     basic_string& replace(iterator i1, iterator i2, const charT* s,
-                            size_type n);
-V     basic_string& replace(iterator i1, iterator i2, const charT* s);
-V     basic_string& replace(iterator i1, iterator i2,
-                            size_type n, charT c);
-V     template<class InputIterator>
-        basic_string& replace(iterator i1, iterator i2,
-                              InputIterator j1, InputIterator j2);
-V     size_type copy(charT* s, size_type n, size_type pos = 0) const;
-V     void swap(basic_string<charT,traits,Allocator>&);
-      // _lib.string.ops_ string operations:
-V     const charT* c_str() const;         // explicit
-V     const charT* data() const;
-V     allocator_type get_allocator() const;
-V     size_type find (const basic_string& str, size_type pos = 0) const;
-V     size_type find (const charT* s, size_type pos, size_type n) const;
-V     size_type find (const charT* s, size_type pos = 0) const;
-V     size_type find (charT c, size_type pos = 0) const;
-V     size_type rfind(const basic_string& str, size_type pos = npos) const;
-V     size_type rfind(const charT* s, size_type pos, size_type n) const;
-V     size_type rfind(const charT* s, size_type pos = npos) const;
-V     size_type rfind(charT c, size_type pos = npos) const;
-
-V     size_type find_first_of(const basic_string& str,
-                              size_type pos = 0) const;
-V     size_type find_first_of(const charT* s,
-                              size_type pos, size_type n) const;
-V     size_type find_first_of(const charT* s, size_type pos = 0) const;
-V     size_type find_first_of(charT c, size_type pos = 0) const;
-V     size_type find_last_of (const basic_string& str,
-                              size_type pos = npos) const;
-V     size_type find_last_of (const charT* s,
-                              size_type pos, size_type n) const;
-V     size_type find_last_of (const charT* s, size_type pos = npos) const;
-V     size_type find_last_of (charT c, size_type pos = npos) const;
-V     size_type find_first_not_of(const basic_string& str,
-                                  size_type pos = 0) const;
-V     size_type find_first_not_of(const charT* s, size_type pos,
-                                  size_type n) const;
-V     size_type find_first_not_of(const charT* s, size_type pos = 0) const;
-V     size_type find_first_not_of(charT c, size_type pos = 0) const;
-V     size_type find_last_not_of (const basic_string& str,
-                                  size_type pos = npos) const;
-V     size_type find_last_not_of (const charT* s, size_type pos,
-                                  size_type n) const;
-V     size_type find_last_not_of (const charT* s,
-                                  size_type pos = npos) const;
-V     size_type find_last_not_of (charT c, size_type pos = npos) const;
-V     basic_string substr(size_type pos = 0, size_type n = npos) const;
-V     int compare(const basic_string& str) const;
-V     int compare(size_type pos1, size_type n1,
-                  const basic_string& str) const;
-V     int compare(size_type pos1, size_type n1,
-                  const basic_string& str,
-                  size_type pos2, size_type n2) const;
-V     int compare(const charT* s) const;
-V     int compare(size_type pos1, size_type n1,
-                  const charT* s, size_type n2 = npos) const;
-    };
-   }
-
-   21.4  Null-terminated sequence utilities               [lib.c.strings]
-
-                    Table 10--Header <cctype> synopsis
-
-            isalnum   isdigit   isprint   isupper    tolower
-X           isalpha   isgraph   ispunct   isxdigit   toupper
-            iscntrl   islower   isspace
-
-                   Table 11--Header <cwctype> synopsis
-
-X  Macro:     WEOF <cwctype>
-X  Types:     wctrans_t   wctype_t   wint_t <cwctype>
-   Functions:
-X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans
-X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype
-X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper
-
-                   Table 12--Header <cstring> synopsis
-
-X           Macro:    NULL <cstring>
-X           Type:     size_t <cstring>
-            Functions:
-X           memchr    strcat    strcspn    strncpy   strtok
-X           memcmp    strchr    strerror   strpbrk   strxfrm
-X           memcpy    strcmp    strlen     strrchr
-X           memmove   strcoll   strncat    strspn
-X           memset    strcpy    strncmp    strstr
-
-                    Table 13--Header <cwchar> synopsis
-   Macros:    NULL <cwchar>   WCHAR_MAX         WCHAR_MIN   WEOF <cwchar>
-   Types:     mbstate_t       wint_t <cwchar>   size_t
-   Functions:
-X  btowc      getwchar        ungetwc           wcscpy      wcsrtombs   wmemchr
-X  fgetwc     mbrlen          vfwprintf         wcscspn     wcsspn      wmemcmp
-X  fgetws     mbrtowc         vswprintf         wcsftime    wcsstr      wmemcpy
-X  fputwc     mbsinit         vwprintf          wcslen      wcstod      wmemmove
-X  fputws     mbsrtowcs       wcrtomb           wcsncat     wcstok      wmemset
-X  fwide      putwc           wcscat            wcsncmp     wcstol      wprintf
-X  fwprintf   putwchar        wcschr            wcsncpy     wcstoul     wscanf
-X  fwscanf    swprintf        wcscmp            wcspbrk     wcsxfrm
-X  getwc      swscanf         wcscoll           wcsrchr     wctob
-
-                   Table 14--Header <cstdlib> synopsis
-
-               Macros:   MB_CUR_MAX
-               Functions:
-X              atol      mblen        strtod    wctomb
-X              atof      mbstowcs     strtol    wcstombs
-X              atoi      mbtowc       strtoul
-
-X  const char* strchr(const char* s, int c);
-X       char* strchr(      char* s, int c);
-
-X  const char* strpbrk(const char* s1, const char* s2);
-X       char* strpbrk(      char* s1, const char* s2);
-
-X  const char* strrchr(const char* s, int c);
-X       char* strrchr(      char* s, int c);
-
-X  const char* strstr(const char* s1, const char* s2);
-X       char* strstr(      char* s1, const char* s2);
-
-X  const void* memchr(const void* s, int c, size_t n);
-X       void* memchr(      void* s, int c, size_t n);
-
-X  const wchar_t* wcschr(const wchar_t* s, wchar_t c);
-X       wchar_t* wcschr(      wchar_t* s, wchar_t c);
-
-X  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);
-X       wchar_t* wcspbrk(      wchar_t* s1, const wchar_t* s2);
-
-X  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);
-X       wchar_t* wcsrchr(      wchar_t* s, wchar_t c);
-
-X  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
-X       wchar_t* wcsstr(      wchar_t* s1, const wchar_t* s2);
-
-X  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
-X       wchar_t* wmemchr(      wchar_t* s, wchar_t c, size_t n);
-
-   [for initial efforts on the above, see shadow/string.h]
-
-   22.1  Locales                                            [lib.locales]
-
-   Header <locale> synopsis
-
-    // _lib.locale_, locale:
-T   class locale;
-T   template <class Facet> const Facet& use_facet(const locale&);
-T   template <class Facet> bool         has_facet(const locale&) throw();
-
-    // _lib.locale.convenience_, convenience interfaces:
-T   template <class charT> bool isspace (charT c, const locale& loc);
-T   template <class charT> bool isprint (charT c, const locale& loc);
-T   template <class charT> bool iscntrl (charT c, const locale& loc);
-T   template <class charT> bool isupper (charT c, const locale& loc);
-T   template <class charT> bool islower (charT c, const locale& loc);
-T   template <class charT> bool isalpha (charT c, const locale& loc);
-T   template <class charT> bool isdigit (charT c, const locale& loc);
-T   template <class charT> bool ispunct (charT c, const locale& loc);
-T   template <class charT> bool isxdigit(charT c, const locale& loc);
-T   template <class charT> bool isalnum (charT c, const locale& loc);
-T   template <class charT> bool isgraph (charT c, const locale& loc);
-T   template <class charT> charT toupper(charT c, const locale& loc);
-T   template <class charT> charT tolower(charT c, const locale& loc);
-    // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
-    class ctype_base;
-T   template <class charT> class ctype;
-T   template <>            class ctype<char>;             // specialization
-S   template <class charT> class ctype_byname;
-S   template <>            class ctype_byname<char>;      // specialization
-T   class codecvt_base;
-X   template <class internT, class externT, class stateT> class codecvt;
-S   template <class internT, class externT, class stateT> class codecvt_byname;
-    // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
-X   template <class charT, class InputIterator>  class num_get;
-X   template <class charT, class OutputIterator> class num_put;
-T   template <class charT> class numpunct;
-S   template <class charT> class numpunct_byname;
-    // _lib.category.collate_, collation:
-T   template <class charT> class collate;
-S   template <class charT> class collate_byname;
-    // _lib.category.time_, date and time:
-T   class time_base;
-S   template <class charT, class InputIterator>  class time_get;
-S   template <class charT, class InputIterator>  class time_get_byname;
-S   template <class charT, class OutputIterator> class time_put;
-S   template <class charT, class OutputIterator> class time_put_byname;
-    // _lib.category.monetary_, money:
-T   class money_base;
-S   template <class charT, class InputIterator>  class money_get;
-S   template <class charT, class OutputIterator> class money_put;
-S   template <class charT, bool Intl> class moneypunct;
-S   template <class charT, bool Intl> class moneypunct_byname;
-    // _lib.category.messages_, message retrieval:
-T   class messages_base;
-S   template <class charT> class messages;
-S   template <class charT> class messages_byname;
-
-
-   22.1.1  Class locale                                      [lib.locale]
-
-X   class locale {
-    public:
-      // types:
-T     class facet;
-T     class id;
-T     typedef int category;
-T     static const category   // values assigned here are for exposition only
-T       none     = 0,
-T       collate  = 0x010, ctype    = 0x020,
-T       monetary = 0x040, numeric  = 0x080,
-T       time     = 0x100, messages = 0x200,
-T       all = collate | ctype | monetary | numeric | time  | messages;
-      // construct/copy/destroy:
-T     locale() throw()
-T     locale(const locale& other) throw()
-X     explicit locale(const char* std_name);
-X     locale(const locale& other, const char* std_name, category);
-T     template <class Facet> locale(const locale& other, Facet* f);
-T     locale(const locale& other, const locale& one, category);
-T    ~locale() throw();           // non-virtual
-T     const locale& operator=(const locale& other) throw();
-T     template <class Facet> locale combine(const locale& other) const;
-      // locale operations:
-X     basic_string<char>                  name() const;
-T     bool operator==(const locale& other) const;
-T     bool operator!=(const locale& other) const;
-T     template <class charT, class Traits, class Allocator>
-        bool operator()(const basic_string<charT,Traits,Allocator>& s1,
-                        const basic_string<charT,Traits,Allocator>& s2) const;
-      // global locale objects:
-T     static       locale  global(const locale&);
-T     static const locale& classic();
-    };
-
-   22.1.1.1  locale types                              [lib.locale.types]
-
-   22.1.1.1.1  Type locale::category                [lib.locale.category]
-
-T  typedef int category;
-
-T   none, collate, ctype, monetary, numeric, time, and messages
-
-      [required locale members]
-T     collate<char>, collate<wchar_t>
-T     ctype<char>, ctype<wchar_t>
-T     codecvt<char,char,mbstate_t>,
-S     codecvt<wchar_t,char,mbstate_t>
-T     moneypunct<char>, moneypunct<wchar_t>
-T     moneypunct<char,true>, moneypunct<wchar_t,true>,
-S     money_get<char>, money_get<wchar_t
-S     money_put<char>, money_put<wchar_t>
-T     numpunct<char>, numpunct<wchar_t>,
-X     num_get<char>, num_get<wchar_t>
-X     num_put<char>, num_put<wchar_t>
-S     time_get<char>, time_get<wchar_t>,
-S     time_put<char>, time_put<wchar_t>
-S     messages<char>, messages<wchar_t>
-
-      [required instantiations]
-S    collate_byname<char>, collate_byname<wchar_t>
-S    ctype_byname<char>, ctype_byname<wchar_t>
-S    codecvt_byname<char,char,mbstate_t>,
-S    codecvt_byname<wchar_t,char,mbstate_t>
-S    moneypunct_byname<char,International>,
-S    moneypunct_byname<wchar_t,International>,
-S    money_get<C,InputIterator>,
-S    money_put<C,OutputIterator>
-S    numpunct_byname<char>, numpunct_byname<wchar_t>
-X    num_get<C,InputIterator>, num_put<C,OutputIterator>
-S    time_get<char,InputIterator>,
-S    time_get_byname<char,InputIterator>,
-S    time_get<wchar_t,OutputIterator>,
-S    time_get_byname<wchar_t,OutputIterator>,
-S    time_put<char,OutputIterator>,
-S    time_put_byname<char,OutputIterator>,
-S    time_put<wchar_t,OutputIterator>
-S    time_put_byname<wchar_t,OutputIterator>
-S    messages_byname<char>, messages_byname<wchar_t>
-
-
-   22.1.1.1.2  Class locale::facet                     [lib.locale.facet]
-
-T   class locale::facet {
-    protected:
-T     explicit facet(size_t refs = 0);
-T     virtual ~facet();
-    private:
-T     facet(const facet&);                // not defined
-T     void operator=(const facet&);       // not defined
-    };
-   }
-
-
-   22.1.1.1.3  Class locale::id                           [lib.locale.id]
-
-T   class locale::id {
-    public:
-T     id();
-    private:
-T     void operator=(const id&);  // not defined
-T     id(const id&);              // not defined
-    };
-   }
-
-
-   22.2.1  The ctype category                        [lib.category.ctype]
-
-T   class ctype_base {
-    public:
-T     enum mask {         // numeric values are for exposition only.
-T       space=, print=, cntrl=, upper=, lower=,
-T       alpha=, digit=, punct=, xdigit=,
-T       alnum=, graph=
-      };
-    };
-
-
-   22.2.1.1  Template class ctype                      [lib.locale.ctype]
-
-T   template <class charT>
-    class ctype : public locale::facet, public ctype_base {
-    public:
-T     typedef charT char_type;
-T     explicit ctype(size_t refs = 0);
-T     bool         is(mask m, charT c) const;
-T     const charT* is(const charT* low, const charT* high, mask* vec) const;
-T     const charT* scan_is(mask m,
-                           const charT* low, const charT* high) const;
-T     const charT* scan_not(mask m,
-                            const charT* low, const charT* high) const;
-T     charT        toupper(charT c) const;
-T     const charT* toupper(charT* low, const charT* high) const;
-T     charT        tolower(charT c) const;
-T     const charT* tolower(charT* low, const charT* high) const;
-T     charT        widen(char c) const;
-T     const char*  widen(const char* low, const char* high, charT* to) const;
-T     char         narrow(charT c, char dfault) const;
-T     const charT* narrow(const charT* low, const charT*, char dfault,
-                          char* to) const;
-T     static locale::id id;
-
-    protected:
-T    ~ctype();                    // virtual
-T     virtual bool         do_is(mask m, charT c) const;
-T     virtual const charT* do_is(const charT* low, const charT* high,
-                                 mask* vec) const;
-T     virtual const charT* do_scan_is(mask m,
-                              const charT* low, const charT* high) const;
-T     virtual const charT* do_scan_not(mask m,
-                              const charT* low, const charT* high) const;
-T     virtual charT        do_toupper(charT) const;
-T     virtual const charT* do_toupper(charT* low, const charT* high) const;
-T     virtual charT        do_tolower(charT) const;
-T     virtual const charT* do_tolower(charT* low, const charT* high) const;
-T     virtual charT        do_widen(char) const;
-T     virtual const char*  do_widen(const char* low, const char* high,
-                                    charT* dest) const;
-T     virtual char         do_narrow(charT, char dfault) const;
-T     virtual const charT* do_narrow(const charT* low, const charT* high,
-                                     char dfault, char* dest) const;
-    };
-
-
-   22.2.1.2  Template class ctype_byname        [lib.locale.ctype.byname]
-
-X   template <class charT>
-    class ctype_byname : public ctype<charT> {
-    public:
-T     typedef ctype<charT>::mask mask;
-S     explicit ctype_byname(const char*, size_t refs = 0);
-    protected:
-S    ~ctype_byname();             // virtual
-S     virtual bool         do_is(mask m, charT c) const;
-S     virtual const charT* do_is(const charT* low, const charT* high,
-                                 mask* vec) const;
-S     virtual const char*  do_scan_is(mask m,
-                               const charT* low, const charT* high) const;
-S     virtual const char*  do_scan_not(mask m,
-                               const charT* low, const charT* high) const;
-S     virtual charT        do_toupper(charT) const;
-S     virtual const charT* do_toupper(charT* low, const charT* high) const;
-S     virtual charT        do_tolower(charT) const;
-S     virtual const charT* do_tolower(charT* low, const charT* high) const;
-S     virtual charT        do_widen(char) const;
-S     virtual const char*  do_widen(const char* low, const char* high,
-                                    charT* dest) const;
-S     virtual char         do_narrow(charT, char dfault) const;
-S     virtual const charT* do_narrow(const charT* low, const charT* high,
-                                     char dfault, char* dest) const;
-    };
-
-   22.2.1.3  ctype specializations              [lib.facet.ctype.special]
-
-T   template <> class ctype<char>
-      : public locale::facet, public ctype_base {
-    public:
-T     typedef char char_type;
-T     explicit ctype(const mask* tab = 0, bool del = false,
-                     size_t refs = 0);
-T     bool is(mask m, char c) const;
-T     const char* is(const char* low, const char* high, mask* vec) const;
-T     const char* scan_is (mask m,
-                           const char* low, const char* high) const;
-T     const char* scan_not(mask m,
-                           const char* low, const char* high) const;
-T     char        toupper(char c) const;
-T     const char* toupper(char* low, const char* high) const;
-T     char        tolower(char c) const;
-T     const char* tolower(char* low, const char* high) const;
-T     char  widen(char c) const;
-T     const char* widen(const char* low, const char* high, char* to) const;
-T     char  narrow(char c, char dfault) const;
-T     const char* narrow(const char* low, const char* high, char dfault,
-                         char* to) const;
-T     static locale::id id;
-T     static const size_t table_size = IMPLEMENTATION_DEFINED;
-
-    protected:
-T     const mask* table() const throw();
-T     static const mask* classic_table() throw();
-T    ~ctype();                    // virtual
-T     virtual char        do_toupper(char c) const;
-T     virtual const char* do_toupper(char* low, const char* high) const;
-T     virtual char        do_tolower(char c) const;
-T     virtual const char* do_tolower(char* low, const char* high) const;
-
-T     virtual char        do_widen(char c) const;
-T     virtual const char* do_widen(const char* low,
-                                   const char* high,
-                                   char* to) const;
-T     virtual char        do_narrow(char c, char dfault) const;
-T     virtual const char* do_narrow(const char* low,
-                                    const char* high,
-                                    char dfault, char* to) const;
-    };
-
-
-   22.2.1.4  Class                      [lib.locale.ctype.byname.special]
-       ctype_byname<char>
-
-X   template <> class ctype_byname<char> : public ctype<char> {
-    public:
-S     explicit ctype_byname(const char*, size_t refs = 0);
-    protected:
-S    ~ctype_byname();             // virtual
-S     virtual char        do_toupper(char c) const;
-S     virtual const char* do_toupper(char* low, const char* high) const;
-S     virtual char        do_tolower(char c) const;
-S     virtual const char* do_tolower(char* low, const char* high) const;
-
-S     virtual char        do_widen(char c) const;
-S     virtual const char* do_widen(char* low,
-                                   const char* high,
-                                   char* to) const;
-S     virtual char        do_widen(char c) const;
-S     virtual const char* do_widen(char* low, const char* high) const;
-
-    };
-
-
-
-   22.2.1.5  Template class codecvt                  [lib.locale.codecvt]
-
-T  class codecvt_base {
-   public:
-T   enum result { ok, partial, error, noconv };
-   };
-
-T  template <class internT, class externT, class stateT>
-   class codecvt : public locale::facet, public codecvt_base {
-   public:
-T   typedef internT  intern_type;
-T   typedef externT  extern_type;
-T   typedef stateT state_type;
-T   explicit codecvt(size_t refs = 0)
-T   result out(stateT& state,
-     const internT* from, const internT* from_end, const internT*& from_next,
-           externT*   to,       externT* to_limit, externT*& to_next) const;
-T   result unshift(stateT& state,
-           externT*   to,        externT* to_limit, externT*& to_next) const;
-T   result in(stateT& state,
-     const externT* from, const externT* from_end, const externT*& from_next,
-           internT*   to,       internT* to_limit, internT*& to_next) const;
-T   int encoding() const throw();
-T   bool always_noconv() const throw();
-T   int length(const stateT&, const externT* from, const externT* end,
-               size_t max) const;
-T   int max_length() const throw();
-T   static locale::id id;
-
-   protected:
-T   ~codecvt();                   // virtual
-T   virtual result do_out(stateT& state,
-     const internT* from, const internT* from_end, const internT*& from_next,
-           externT* to,         externT* to_limit, externT*& to_next) const;
-T   virtual result do_in(stateT& state,
-T    const externT* from, const externT* from_end, const externT*& from_next,
-           internT* to,         internT* to_limit, internT*& to_next) const;
-T   virtual result do_unshift(stateT& state,
-           externT* to,         externT* to_limit, externT*& to_next) const;
-T   virtual int do_encoding() const throw();
-T   virtual bool do_always_noconv() const throw();
-T   virtual int do_length(const stateT&, const externT* from,
-                          const externT* end, size_t max) const;
-T   virtual int do_max_length() const throw();
-   };
-   }
-
-
-   22.2.1.6  Template class                   [lib.locale.codecvt.byname]
-       codecvt_byname
-
-X  template <class internT, class externT, class stateT>
-   class codecvt_byname : public codecvt<internT, externT, stateT> {
-   public:
-S   explicit codecvt_byname(const char*, size_t refs = 0);
-   protected:
-S  ~codecvt_byname();             // virtual
-S   virtual result do_out(stateT& state,
-      const internT* from, const internT* from_end, const internT*& from_next,
-            externT* to,         externT* to_limit, externT*& to_next) const;
-S   virtual result do_in(stateT& state,
-      const externT* from, const externT* from_end, const externT*& from_next,
-            internT* to,         internT* to_limit, internT*& to_next) const;
-S   virtual result do_unshift(stateT& state,
-            externT* to,         externT* to_limit, externT*& to_next) const;
-S   virtual int do_encoding() const throw();
-S   virtual bool do_always_noconv() const throw();
-S   virtual int do_length(const stateT&, const externT* from,
-                          const externT* end, size_t max) const;
-S   virtual result do_unshift(stateT& state,
-           externT* to, externT* to_limit, externT*& to_next) const;
-S   virtual int do_max_length() const throw();
-    };
-
-
-   22.2.2.1  Template class num_get                  [lib.locale.num.get]
-
-X   template <class charT, class InputIterator = istreambuf_iterator<charT> >
-    class num_get : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef InputIterator    iter_type;
-T     explicit num_get(size_t refs = 0);
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, bool& v)           const;
-T     iter_type get(iter_type in, iter_type end, ios_base& ,
-                    ios_base::iostate& err, long& v)           const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, unsigned short& v) const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, unsigned int& v)   const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, unsigned long& v)  const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, float& v)          const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, double& v)         const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, long double& v)    const;
-T     iter_type get(iter_type in, iter_type end, ios_base&,
-                    ios_base::iostate& err, void*& v)          const;
-T     static locale::id id;
-
-    protected:
-T    ~num_get();                  // virtual
-T     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, bool& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, long& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, unsigned short& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, unsigned int& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, unsigned long& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, float& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, double& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, long double& v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
-          ios_base::iostate& err, void*& v) const;
-    };
-
-
-
-   22.2.2.2  Template class num_put                   [lib.locale.nm.put]
-
-X   template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
-    class num_put : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef OutputIterator   iter_type;
-T     explicit num_put(size_t refs = 0);
-T     iter_type put(iter_type s, ios_base& f, char_type fill, bool v) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill, long v) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill,
-                    unsigned long v) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill,
-                    double v) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill,
-                    long double v) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill,
-                    const void* v) const;
-T     static locale::id id;
-    protected:
-T    ~num_put();                  // virtual
-T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               bool v) const;
-T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               long v) const;
-T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               unsigned long) const;
-S     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               double v) const;
-S     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               long double v) const;
-T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                               const void* v) const;
-    };
-   }
-
-   22.2.3.1  Template class numpunct                [lib.locale.numpunct]
-
-T   template <class charT>
-    class numpunct : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef basic_string<charT> string_type;
-T     explicit numpunct(size_t refs = 0);
-T     char_type    decimal_point()   const;
-T     char_type    thousands_sep()   const;
-T     string       grouping()        const;
-T     string_type  truename()        const;
-T     string_type  falsename()       const;
-T     static locale::id id;
-    protected:
-T    ~numpunct();                 // virtual
-T     virtual char_type    do_decimal_point() const;
-T     virtual char_type    do_thousands_sep() const;
-T     virtual string       do_grouping()      const;
-T     virtual string_type  do_truename()      const;      // for bool
-T     virtual string_type  do_falsename()     const;      // for bool
-    };
-   }
-
-
-
-   22.2.3.2  Template class                  [lib.locale.numpunct.byname]
-       numpunct_byname
-
-X   template <class charT>
-    class numpunct_byname : public numpunct<charT> {
-   // this class is specialized for char and wchar_t.
-    public:
-T     typedef charT                char_type;
-T     typedef basic_string<charT>  string_type;
-S     explicit numpunct_byname(const char*, size_t refs = 0);
-    protected:
-S    ~numpunct_byname();          // virtual
-S     virtual char_type    do_decimal_point() const;
-S     virtual char_type    do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_truename()      const;      // for bool
-S     virtual string_type  do_falsename()     const;      // for bool
-    };
-
-
-   22.2.4.1  Template class collate                  [lib.locale.collate]
-
-T   template <class charT>
-    class collate : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef basic_string<charT> string_type;
-T     explicit collate(size_t refs = 0);
-T     int compare(const charT* low1, const charT* high1,
-                  const charT* low2, const charT* high2) const;
-T     string_type transform(const charT* low, const charT* high) const;
-T     long hash(const charT* low, const charT* high) const;
-T     static locale::id id;
-    protected:
-T    ~collate();                  // virtual
-T     virtual int    do_compare(const charT* low1, const charT* high1,
-                                const charT* low2, const charT* high2) const;
-T     virtual string_type do_transform
-                               (const charT* low, const charT* high) const;
-T     virtual long   do_hash   (const charT* low, const charT* high) const;
-    };
-
-
-   22.2.4.2  Template class                   [lib.locale.collate.byname]
-       collate_byname
-
-X   template <class charT>
-    class collate_byname : public collate<charT> {
-    public:
-T     typedef basic_string<charT> string_type;
-T     explicit collate_byname(const char*, size_t refs = 0);
-    protected:
-S    ~collate_byname();           // virtual
-S     virtual int    do_compare(const charT* low1, const charT* high1,
-                                const charT* low2, const charT* high2) const;
-S     virtual string_type do_transform
-                               (const charT* low, const charT* high) const;
-S     virtual long   do_hash   (const charT* low, const charT* high) const;
-    };
-
-
-   22.2.5.1  Template class time_get                [lib.locale.time.get]
-
-T   class time_base {
-    public:
-T     enum dateorder { no_order, dmy, mdy, ymd, ydm };
-    };
-
-    [Note: semantics of time_get members are implementation-defined.
-     To complete implementation requires documenting behavior.]
-
-X   template <class charT, class InputIterator = istreambuf_iterator<charT> >
-    class time_get : public locale::facet, public time_base {
-    public:
-T     typedef charT            char_type;
-T     typedef InputIterator    iter_type;
-T     explicit time_get(size_t refs = 0);
-
-T     dateorder date_order()  const { return do_date_order(); }
-T     iter_type get_time(iter_type s, iter_type end, ios_base& f,
-                         ios_base::iostate& err, tm* t)  const;
-T     iter_type get_date(iter_type s, iter_type end, ios_base& f,
-                         ios_base::iostate& err, tm* t)  const;
-T     iter_type get_weekday(iter_type s, iter_type end, ios_base& f,
-                            ios_base::iostate& err, tm* t) const;
-T     iter_type get_monthname(iter_type s, iter_type end, ios_base& f,
-                              ios_base::iostate& err, tm* t) const;
-T     iter_type get_year(iter_type s, iter_type end, ios_base& f,
-                         ios_base::iostate& err, tm* t) const;
-T     static locale::id id;
-    protected:
-     ~time_get();                 // virtual
-X     virtual dateorder do_date_order()  const;
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&,
-                                       ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_monthname(iter_type s, ios_base&,
-                                         ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-    };
-
-
-
-   22.2.5.2  Template class                  [lib.locale.time.get.byname]
-       time_get_byname
-
-X   template <class charT, class InputIterator = istreambuf_iterator<charT> >
-    class time_get_byname : public time_get<charT, InputIterator> {
-    public:
-T     typedef time_base::dateorder dateorder;
-T     typedef InputIterator        iter_type
-
-S     explicit time_get_byname(const char*, size_t refs = 0);
-    protected:
-S    ~time_get_byname();          // virtual
-S     virtual dateorder do_date_order()  const;
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-T     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&,
-                                       ios_base::iostate& err, tm* t) const;
-T     virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&,
-                                         ios_base::iostate& err, tm* t) const;
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&,
-                                    ios_base::iostate& err, tm* t) const;
-    };
-   }
-
-   22.2.5.3  Template class time_put                [lib.locale.time.put]
-
-X   template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
-    class time_put : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef OutputIterator   iter_type;
-T     explicit time_put(size_t refs = 0);
-      // the following is implemented in terms of other member functions.
-S     iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb,
-                    const charT* pattern, const charT* pat_end) const;
-T     iter_type put(iter_type s, ios_base& f, char_type fill,
-                    const tm* tmb, char format, char modifier = 0) const;
-T     static locale::id id;
-    protected:
-T    ~time_put();                 // virtual
-S     virtual iter_type do_put(iter_type s, ios_base&, char_type, const tm* t,
-                               char format, char modifier) const;
-    };
-
-
-
-   22.2.5.4  Template class                  [lib.locale.time.put.byname]
-       time_put_byname
-
-T   template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
-    class time_put_byname : public time_put<charT, OutputIterator>
-    {
-    public:
-T     typedef charT          char_type;
-T     typedef OutputIterator iter_type;
-
-T     explicit time_put_byname(const char*, size_t refs = 0);
-    protected:
-T    ~time_put_byname();          // virtual
-S     virtual iter_type do_put(iter_type s, ios_base&, char_type, const tm* t,
-                               char format, char modifier) const;
-    };
-
-
-   22.2.6.1  Template class money_get              [lib.locale.money.get]
-
-X   template <class charT,
-              class InputIterator = istreambuf_iterator<charT> >
-    class money_get : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef InputIterator       iter_type;
-T     typedef basic_string<charT> string_type;
-T     explicit money_get(size_t refs = 0);
-T     iter_type get(iter_type s, iter_type end, bool intl,
-                    ios_base& f, ios_base::iostate& err,
-                    long double& units) const;
-T     iter_type get(iter_type s, iter_type end, bool intl,
-                    ios_base& f, ios_base::iostate& err,
-                    string_type& digits) const;
-T     static locale::id id;
-    protected:
-T    ~money_get();                // virtual
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&,
-                       ios_base::iostate& err, long double& units) const;
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&,
-                       ios_base::iostate& err, string_type& digits) const;
-    };
-
-   22.2.6.2  Template class money_put              [lib.locale.money.put]
-
-X   template <class charT,
-              class OutputIterator = ostreambuf_iterator<charT> >
-    class money_put : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef OutputIterator      iter_type;
-T     typedef basic_string<charT> string_type;
-T     explicit money_put(size_t refs = 0);
-T     iter_type put(iter_type s, bool intl, ios_base& f,
-                    char_type fill, long double units) const;
-T     iter_type put(iter_type s, bool intl, ios_base& f,
-                    char_type fill, const string_type& digits) const;
-T     static locale::id id;
-
-    protected:
-T    ~money_put();                // virtual
-S     virtual iter_type
-        do_put(iter_type, bool, ios_base&, char_type fill,
-               long double units) const;
-S     virtual iter_type
-        do_put(iter_type, bool, ios_base&, char_type fill,
-               const string_type& digits) const;
-    };
-
-
-   22.2.6.3  Template class moneypunct            [lib.locale.moneypunct]
-
-T   class money_base {
-    public:
-T     enum part { none, space, symbol, sign, value };
-T     struct pattern { char field[4]; };
-    };
-
-X   template <class charT, bool International = false>
-    class moneypunct : public locale::facet, public money_base {
-    public:
-T     typedef charT char_type;
-T     typedef basic_string<charT> string_type;
-T     explicit moneypunct(size_t refs = 0);
-T     charT        decimal_point() const;
-T     charT        thousands_sep() const;
-T     string       grouping()      const;
-T     string_type  curr_symbol()   const;
-T     string_type  positive_sign() const;
-T     string_type  negative_sign() const;
-T     int          frac_digits()   const;
-T     pattern      pos_format()    const;
-T     pattern      neg_format()    const;
-T     static locale::id id;
-T     static const bool intl = International;
-    protected:
-T    ~moneypunct();               // virtual
-S     virtual charT        do_decimal_point() const;
-S     virtual charT        do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_curr_symbol()   const;
-S     virtual string_type  do_positive_sign() const;
-S     virtual string_type  do_negative_sign() const;
-S     virtual int          do_frac_digits()   const;
-T     virtual pattern      do_pos_format()    const;
-T     virtual pattern      do_neg_format()    const;
-    };
-   }
-
-   22.2.6.4  Template class                [lib.locale.moneypunct.byname]
-       moneypunct_byname
-
-X   template <class charT, bool Intl = false>
-    class moneypunct_byname : public moneypunct<charT, Intl> {
-    public:
-T     typedef money_base::pattern pattern;
-T     typedef basic_string<charT> string_type;
-
-T     explicit moneypunct_byname(const char*, size_t refs = 0);
-    protected:
-T    ~moneypunct_byname();        // virtual
-S     virtual charT        do_decimal_point() const;
-S     virtual charT        do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_curr_symbol()   const;
-S     virtual string_type  do_positive_sign() const;
-S     virtual string_type  do_negative_sign() const;
-S     virtual int          do_frac_digits()   const;
-S     virtual pattern      do_pos_format()    const;
-S     virtual pattern      do_neg_format()    const;
-    };
-
-   22.2.7.1  Template class messages                [lib.locale.messages]
-
-T   class messages_base {
-    public:
-T     typedef int catalog;
-    };
-
-X   template <class charT>
-    class messages : public locale::facet, public messages_base {
-    public:
-T     typedef charT char_type;
-T     typedef basic_string<charT> string_type;
-T     explicit messages(size_t refs = 0);
-T     catalog open(const basic_string<char>& fn, const locale&) const;
-T     string_type  get(catalog c, int set, int msgid,
-                       const string_type& dfault) const;
-T     void    close(catalog c) const;
-T     static locale::id id;
-    protected:
-T    ~messages();                 // virtual
-S     virtual catalog do_open(const basic_string<char>&, const locale&) const;
-S     virtual string_type  do_get(catalog, int set, int msgid,
-                             const string_type& dfault) const;
-S     virtual void    do_close(catalog) const;
-    };
-
-   22.2.7.2  Template class                  [lib.locale.messages.byname]
-       messages_byname
-
-
-X   template <class charT>
-    class messages_byname : public messages<charT> {
-    public:
-T     typedef messages_base::catalog catalog;
-T     typedef basic_string<charT>    string_type;
-
-T     explicit messages_byname(const char*, size_t refs = 0);
-    protected:
-T    ~messages_byname();          // virtual
-S     virtual catalog do_open(const basic_string<char>&, const locale&) const;
-S     virtual string_type  do_get(catalog, int set, int msgid,
-                             const string_type& dfault) const;
-S     virtual void    do_close(catalog) const;
-    };
-
-
-   22.3  C Library Locales                                [lib.c.locales]
-
-
-                   Table 13--Header <clocale> synopsis
-            Macros:
-X                        LC_ALL        LC_COLLATE   LC_CTYPE
-X                        LC_MONETARY   LC_NUMERIC   LC_TIME
-X                        NULL
-X           Struct:      lconv
-X           Functions:   localeconv    setlocale
-
-
-   23.2  Sequences                                        [lib.sequences]
-
-   <deque>, <list>, <queue>, <stack>, and <vector>.
-
-   Header <deque> synopsis
-
-T   template <class T, class Allocator = allocator<T> > class deque;
-T   template <class T, class Allocator>
-      bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-   }
-
-   Header <list> synopsis
-
-T   template <class T, class Allocator = allocator<T> > class list;
-T   template <class T, class Allocator>
-      bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-   }
-
-   Header <queue> synopsis
-
-   namespace std {
-T   template <class T, class Container = deque<T> > class queue;
-T   template <class T, class Container>
-      bool operator==(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator< (const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator!=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator> (const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator>=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator<=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container = vector<T>,
-              class Compare = less<typename Container::value_type> >
-T   class priority_queue;
-   }
-
-   Header <stack> synopsis
-
-   namespace std {
-T   template <class T, class Container = deque<T> > class stack;
-T   template <class T, class Container>
-      bool operator==(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator< (const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator!=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator> (const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator>=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator<=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-   }
-
-   Header <vector> synopsis
-
-T   template <class T, class Allocator = allocator<T> > class vector;
-
-T   template <class T, class Allocator>
-      bool operator==(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-
-T   template <class Allocator> class vector<bool,Allocator>;
-T   template <class Allocator>
-      bool operator==(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator< (const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator!=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator> (const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator>=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator<=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y);
-   }
-
-   23.2.1  Template class deque                               [lib.deque]
-
-    template <class T, class Allocator = allocator<T> >
-T   class deque {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      // _lib.deque.cons_ construct/copy/destroy:
-T     explicit deque(const Allocator& = Allocator());
-T     explicit deque(size_type n, const T& value = T(),
-          const Allocator& = Allocator());
-T     template <class InputIterator>
-        deque(InputIterator first, InputIterator last,
-              const Allocator& = Allocator());
-T     deque(const deque<T,Allocator>& x);
-T    ~deque();
-T     deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
-T     template <class InputIterator>
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T& t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.deque.capacity_ capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-T     bool      empty() const;
-
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     reference       at(size_type n);
-T     const_reference at(size_type n) const;
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.deque.modifiers_ modifiers:
-T     void push_front(const T& x);
-T     void push_back(const T& x);
-T     iterator insert(iterator position, const T& x);
-T     void     insert(iterator position, size_type n, const T& x);
-T     template <class InputIterator>
-        void insert (iterator position,
-                     InputIterator first, InputIterator last);
-T     void pop_front();
-T     void pop_back();
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void     swap(deque<T,Allocator>&);
-T     void     clear();
-    };
-T   template <class T, class Allocator>
-      bool operator==(const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const deque<T,Allocator>& x,
-                      const deque<T,Allocator>& y);
-    // specialized algorithms:
-T   template <class T, class Allocator>
-      void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-
-
-   23.2.2  Template class list                                 [lib.list]
-
-T   template <class T, class Allocator = allocator<T> >
-    class list {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-      // _lib.list.cons_ construct/copy/destroy:
-T     explicit list(const Allocator& = Allocator());
-T     explicit list(size_type n, const T& value = T(),
-                    const Allocator& = Allocator());
-T     template <class InputIterator>
-        list(InputIterator first, InputIterator last,
-             const Allocator& = Allocator());
-T     list(const list<T,Allocator>& x);
-T    ~list();
-T     list<T,Allocator>& operator=(const list<T,Allocator>& x);
-T     template <class InputIterator>
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T& t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.list.capacity_ capacity:
-T     bool      empty() const;
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-      // element access:
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.list.modifiers_ modifiers:
-T     void push_front(const T& x);
-T     void pop_front();
-T     void push_back(const T& x);
-T     void pop_back();
-T     iterator insert(iterator position, const T& x);
-T     void     insert(iterator position, size_type n, const T& x);
-T     template <class InputIterator>
-        void insert(iterator position, InputIterator first,
-                    InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator position, iterator last);
-T     void     swap(list<T,Allocator>&);
-T     void     clear();
-      // _lib.list.ops_ list operations:
-T     void splice(iterator position, list<T,Allocator>& x);
-T     void splice(iterator position, list<T,Allocator>& x, iterator i);
-T     void splice(iterator position, list<T,Allocator>& x, iterator first,
-                  iterator last);
-T     void remove(const T& value);
-T     template <class Predicate> void remove_if(Predicate pred);
-
-T     void unique();
-T     template <class BinaryPredicate>
-        void unique(BinaryPredicate binary_pred);
-T     void merge(list<T,Allocator>& x);
-T     template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
-        void sort();
-T     template <class Compare> void sort(Compare comp);
-        void reverse();
-    };
-T   template <class T, class Allocator>
-      bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-    // specialized algorithms:
-T   template <class T, class Allocator>
-      void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-
-
-   23.2.3.1  Template class queue                             [lib.queue]
-
-T   template <class T, class Container = deque<T> >
-    class queue {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-    public:
-T     explicit queue(const Container& = Container());
-
-T     bool      empty() const             { return c.empty(); }
-T     size_type size()  const             { return c.size(); }
-T     value_type&       front()           { return c.front(); }
-T     const value_type& front() const     { return c.front(); }
-T     value_type&       back()            { return c.back(); }
-T     const value_type& back() const      { return c.back(); }
-T     void push(const value_type& x)      { c.push_back(x); }
-T     void pop()                          { c.pop_front(); }
-    };
-
-T   template <class T, class Container>
-      bool operator==(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator< (const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator!=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator> (const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator>=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-T   template <class T, class Container>
-      bool operator<=(const queue<T, Container>& x,
-                      const queue<T, Container>& y);
-
-   23.2.3.2  Template class priority_queue           [lib.priority.queue]
-
-T   template <class T, class Container = vector<T>,
-              class Compare = less<typename Container::value_type> >
-    class priority_queue {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-T     Compare comp;
-    public:
-T     explicit priority_queue(const Compare& x = Compare(),
-                              const Container& = Container());
-T     template <class InputIterator>
-        priority_queue(InputIterator first, InputIterator last,
-                       const Compare& x = Compare(),
-                       const Container& = Container());
-
-T     bool      empty() const       { return c.empty(); }
-T     size_type size()  const       { return c.size(); }
-T     const value_type& top() const { return c.front(); }
-T     void push(const value_type& x);
-T     void pop();
-    };
-
-   23.2.3.3  Template class stack                             [lib.stack]
-
-T   template <class T, class Container = deque<T> >
-    class stack {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-    public:
-T     explicit stack(const Container& = Container());
-
-T     bool      empty() const             { return c.empty(); }
-T     size_type size()  const             { return c.size(); }
-T     value_type&       top()             { return c.back(); }
-T     const value_type& top() const       { return c.back(); }
-T     void push(const value_type& x)      { c.push_back(x); }
-T     void pop()                          { c.pop_back(); }
-    };
-T   template <class T, class Container>
-      bool operator==(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator< (const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator!=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator> (const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator>=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-T   template <class T, class Container>
-      bool operator<=(const stack<T, Container>& x,
-                      const stack<T, Container>& y);
-
-   23.2.4  Template class vector                             [lib.vector]
-
-    template <class T, class Allocator = allocator<T> >
-T   class vector {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      // _lib.vector.cons_ construct/copy/destroy:
-T     explicit vector(const Allocator& = Allocator());
-T     explicit vector(size_type n, const T& value = T(),
-          const Allocator& = Allocator());
-T     template <class InputIterator>
-        vector(InputIterator first, InputIterator last,
-          const Allocator& = Allocator());
-T     vector(const vector<T,Allocator>& x);
-T    ~vector();
-T     vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
-T     template <class InputIterator>
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T& u);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.vector.capacity_ capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-T     size_type capacity() const;
-T     bool      empty() const;
-T     void      reserve(size_type n);
-
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     const_reference at(size_type n) const;
-T     reference       at(size_type n);
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.vector.modifiers_ modifiers:
-T     void push_back(const T& x);
-T     void pop_back();
-T     iterator insert(iterator position, const T& x);
-T     void     insert(iterator position, size_type n, const T& x);
-T     template <class InputIterator>
-          void insert(iterator position,
-                      InputIterator first, InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void     swap(vector<T,Allocator>&);
-T     void     clear();
-    };
-
-T   template <class T, class Allocator>
-      bool operator==(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator< (const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator!=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator> (const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator>=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-T   template <class T, class Allocator>
-      bool operator<=(const vector<T,Allocator>& x,
-                      const vector<T,Allocator>& y);
-    // specialized algorithms:
-T   template <class T, class Allocator>
-      void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-
-
-   23.2.5  Class vector<bool>                           [lib.vector.bool]
-
-T   template <class Allocator> class vector<bool, Allocator> {
-    public:
-      // types:
-T     typedef bool                                  const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef bool                                  value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef implementation defined                pointer;
-T     typedef implementation defined                const_pointer
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      // bit reference:
-T     class reference {
-       friend class vector;
-T      reference();
-      public:
-T      ~reference();
-T       operator bool() const;
-T       reference& operator=(const bool x);
-T       reference& operator=(const reference& x);
-T       void flip();              // flips the bit
-      };
-
-      // construct/copy/destroy:
-T     explicit vector(const Allocator& = Allocator());
-T     explicit vector(size_type n, const bool& value = bool(),
-                      const Allocator& = Allocator());
-T     template <class InputIterator>
-        vector(InputIterator first, InputIterator last,
-          const Allocator& = Allocator());
-T     vector(const vector<bool,Allocator>& x);
-T    ~vector();
-T     vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
-T     template <class InputIterator>
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T& t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, bool c = false);
-T     size_type capacity() const;
-T     bool      empty() const;
-T     void      reserve(size_type n);
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     const_reference at(size_type n) const;
-T     reference       at(size_type n);
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // modifiers:
-T     void push_back(const bool& x);
-T     void pop_back();
-T     iterator insert(iterator position, const bool& x);
-T     void     insert (iterator position, size_type n, const bool& x);
-T     template <class InputIterator>
-          void insert(iterator position,
-                      InputIterator first, InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void swap(vector<bool,Allocator>&);
-T     static void swap(reference x, reference y);
-T     void flip();                // flips all bits
-T     void clear();
-    };
-
-T   template <class Allocator>
-      bool operator==(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator< (const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator!=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator> (const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator>=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-T   template <class Allocator>
-      bool operator<=(const vector<bool,Allocator>& x,
-                      const vector<bool,Allocator>& y);
-    // specialized algorithms:
-T   template <class Allocator>
-      void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y);
-
-   23.3  Associative containers                         [lib.associative]
-
- <map> and <set>:
-
-   Header <map> synopsis
-
-    template <class Key, class T, class Compare = less<Key>,
-              class Allocator = allocator<pair<const Key, T> > >
-T     class map;
-
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator==(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator< (const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator!=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator> (const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator>=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator<=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      void swap(map<Key,T,Compare,Allocator>& x,
-                map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare = less<Key>,
-              class Allocator = allocator<pair<const Key, T> > >
-      class multimap;
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator==(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator< (const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator> (const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      void swap(multimap<Key,T,Compare,Allocator>& x,
-                multimap<Key,T,Compare,Allocator>& y);
-   }
-
-   Header <set> synopsis
-
-    template <class Key, class Compare = less<Key>,
-              class Allocator = allocator<Key> >
-T     class set;
-
-T   template <class Key, class Compare, class Allocator>
-      bool operator==(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator< (const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator!=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator> (const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator>=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator<=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      void swap(set<Key,Compare,Allocator>& x,
-                set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare = less<Key>,
-              class Allocator = allocator<Key> >
-      class multiset;
-T   template <class Key, class Compare, class Allocator>
-      bool operator==(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator< (const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator!=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator> (const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator>=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator<=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      void swap(multiset<Key,Compare,Allocator>& x,
-                multiset<Key,Compare,Allocator>& y);
-   }
-
-   23.3.1  Template class map                                   [lib.map]
-
-    template <class Key, class T, class Compare = less<Key>,
-              class Allocator = allocator<pair<const Key, T> > >
-T     class map {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef T                                     mapped_type;
-T     typedef pair<const Key, T>                    value_type;
-T     typedef Compare                               key_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-T     class value_compare
-        : public binary_function<value_type,value_type,bool> {
-      friend class map;
-      protected:
-T       Compare comp;
-T       value_compare(Compare c) : comp(c) {}
-      public:
-T       bool operator()(const value_type& x, const value_type& y) const {
-          return comp(x.first, y.first);
-        }
-      };
-
-      // _lib.map.cons_ construct/copy/destroy:
-T     explicit map(const Compare& comp = Compare(),
-                   const Allocator& = Allocator());
-T     template <class InputIterator>
-        map(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(), const Allocator& = Allocator());
-T     map(const map<Key,T,Compare,Allocator>& x);
-T    ~map();
-T     map<Key,T,Compare,Allocator>&
-        operator=(const map<Key,T,Compare,Allocator>& x);
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool      empty() const;
-T     size_type size() const;
-T     size_type max_size() const;
-      // _lib.map.access_ element access:
-T     T& operator[](const key_type& x);
-      // modifiers:
-T     pair<iterator, bool> insert(const value_type& x);
-T     iterator             insert(iterator position, const value_type& x);
-T     template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type& x);
-T     void      erase(iterator first, iterator last);
-T     void swap(map<Key,T,Compare,Allocator>&);
-T     void clear();
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // _lib.map.ops_ map operations:
-T     iterator       find(const key_type& x);
-T     const_iterator find(const key_type& x) const;
-T     size_type      count(const key_type& x) const;
-T     iterator       lower_bound(const key_type& x);
-T     const_iterator lower_bound(const key_type& x) const;
-T     iterator       upper_bound(const key_type& x);
-T     const_iterator upper_bound(const key_type& x) const;
-T     pair<iterator,iterator>
-          equal_range(const key_type& x);
-T     pair<const_iterator,const_iterator>
-          equal_range(const key_type& x) const;
-    };
-
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator==(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator< (const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator!=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator> (const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator>=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator<=(const map<Key,T,Compare,Allocator>& x,
-                      const map<Key,T,Compare,Allocator>& y);
-    // specialized algorithms:
-T   template <class Key, class T, class Compare, class Allocator>
-      void swap(map<Key,T,Compare,Allocator>& x,
-                map<Key,T,Compare,Allocator>& y);
-
-   23.3.2  Template class multimap                         [lib.multimap]
-
-    template <class Key, class T, class Compare = less<Key>,
-              class Allocator = allocator<pair<const Key, T> > >
-T   class multimap {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef T                                     mapped_type;
-T     typedef pair<const Key,T>                     value_type;
-T     typedef Compare                               key_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-T     class value_compare
-        : public binary_function<value_type,value_type,bool> {
-      friend class multimap;
-      protected:
-T       Compare comp;
-T       value_compare(Compare c) : comp(c) {}
-      public:
-T       bool operator()(const value_type& x, const value_type& y) const {
-          return comp(x.first, y.first);
-        }
-      };
-      // construct/copy/destroy:
-T     explicit multimap(const Compare& comp = Compare(),
-                        const Allocator& = Allocator());
-T     template <class InputIterator>
-        multimap(InputIterator first, InputIterator last,
-                 const Compare& comp = Compare(),
-                 const Allocator& = Allocator());
-T     multimap(const multimap<Key,T,Compare,Allocator>& x);
-T    ~multimap();
-T     multimap<Key,T,Compare,Allocator>&
-        operator=(const multimap<Key,T,Compare,Allocator>& x);
-T     allocator_type get_allocator() const;
-
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool           empty() const;
-T     size_type      size() const;
-T     size_type      max_size() const;
-      // modifiers:
-T     iterator insert(const value_type& x);
-T     iterator insert(iterator position, const value_type& x);
-T     template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type& x);
-T     void      erase(iterator first, iterator last);
-T     void swap(multimap<Key,T,Compare,Allocator>&);
-T     void clear();
-      // observers:
-T     key_compare    key_comp() const;
-T     value_compare  value_comp() const;
-      // map operations:
-T     iterator       find(const key_type& x);
-T     const_iterator find(const key_type& x) const;
-T     size_type      count(const key_type& x) const;
-T     iterator       lower_bound(const key_type& x);
-T     const_iterator lower_bound(const key_type& x) const;
-T     iterator       upper_bound(const key_type& x);
-T     const_iterator upper_bound(const key_type& x) const;
-T     pair<iterator,iterator>             equal_range(const key_type& x);
-T     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
-    };
-
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator==(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator< (const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator> (const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-T   template <class Key, class T, class Compare, class Allocator>
-      bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
-                      const multimap<Key,T,Compare,Allocator>& y);
-    // specialized algorithms:
-T   template <class Key, class T, class Compare, class Allocator>
-      void swap(multimap<Key,T,Compare,Allocator>& x,
-                multimap<Key,T,Compare,Allocator>& y);
-
-
-   23.3.3  Template class set                                   [lib.set]
-
-    template <class Key, class Compare = less<Key>,
-              class Allocator = allocator<Key> >
-T   class set {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef Key                                   value_type;
-T     typedef Compare                               key_compare;
-T     typedef Compare                               value_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      // _lib.set.cons_ construct/copy/destroy:
-T     explicit set(const Compare& comp = Compare(),
-                   const Allocator& = Allocator());
-T     template <class InputIterator>
-        set(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(), const Allocator& = Allocator());
-T     set(const set<Key,Compare,Allocator>& x);
-T    ~set();
-T     set<Key,Compare,Allocator>&
-        operator=(const set<Key,Compare,Allocator>& x);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool          empty() const;
-T     size_type     size() const;
-T     size_type     max_size() const;
-      // modifiers:
-T     pair<iterator,bool> insert(const value_type& x);
-T     iterator            insert(iterator position, const value_type& x);
-T     template <class InputIterator>
-T         void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type& x);
-T     void      erase(iterator first, iterator last);
-T     void swap(set<Key,Compare,Allocator>&);
-T     void clear();
-
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // set operations:
-T     iterator  find(const key_type& x) const;
-T     size_type count(const key_type& x) const;
-T     iterator  lower_bound(const key_type& x) const;
-T     iterator  upper_bound(const key_type& x) const;
-T     pair<iterator,iterator> equal_range(const key_type& x) const;
-    };
-T   template <class Key, class Compare, class Allocator>
-      bool operator==(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator< (const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator!=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator> (const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator>=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator<=(const set<Key,Compare,Allocator>& x,
-                      const set<Key,Compare,Allocator>& y);
-    // specialized algorithms:
-T   template <class Key, class Compare, class Allocator>
-      void swap(set<Key,Compare,Allocator>& x,
-                set<Key,Compare,Allocator>& y);
-
-   23.3.4  Template class multiset                         [lib.multiset]
-
-    template <class Key, class Compare = less<Key>,
-              class Allocator = allocator<Key> >
-T   class multiset {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef Key                                   value_type;
-T     typedef Compare                               key_compare;
-T     typedef Compare                               value_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator<iterator>       reverse_iterator;
-T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-      // construct/copy/destroy:
-T     explicit multiset(const Compare& comp = Compare(),
-                        const Allocator& = Allocator());
-T     template <class InputIterator>
-        multiset(InputIterator first, InputIterator last,
-                 const Compare& comp = Compare(),
-                 const Allocator& = Allocator());
-T     multiset(const multiset<Key,Compare,Allocator>& x);
-T    ~multiset();
-T     multiset<Key,Compare,Allocator>&
-          operator=(const multiset<Key,Compare,Allocator>& x);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool          empty() const;
-T     size_type     size() const;
-T     size_type     max_size() const;
-      // modifiers:
-T     iterator insert(const value_type& x);
-T     iterator insert(iterator position, const value_type& x);
-T     template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type& x);
-T     void      erase(iterator first, iterator last);
-T     void swap(multiset<Key,Compare,Allocator>&);
-T     void clear();
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // set operations:
-T     iterator  find(const key_type& x) const;
-T     size_type count(const key_type& x) const;
-T     iterator  lower_bound(const key_type& x) const;
-T     iterator  upper_bound(const key_type& x) const;
-T     pair<iterator,iterator> equal_range(const key_type& x) const;
-    };
-
-T   template <class Key, class Compare, class Allocator>
-      bool operator==(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator< (const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator!=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator> (const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator>=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-T   template <class Key, class Compare, class Allocator>
-      bool operator<=(const multiset<Key,Compare,Allocator>& x,
-                      const multiset<Key,Compare,Allocator>& y);
-    // specialized algorithms:
-T   template <class Key, class Compare, class Allocator>
-      void swap(multiset<Key,Compare,Allocator>& x,
-                multiset<Key,Compare,Allocator>& y);
-
-   23.3.5  Template class bitset                    [lib.template.bitset]
-
-   Header <bitset> synopsis
-
-T   template <size_t N> class bitset;
-    // _lib.bitset.operators_ bitset operations:
-T   template <size_t N>
-      bitset<N> operator&(const bitset<N>&, const bitset<N>&);
-T   template <size_t N>
-      bitset<N> operator|(const bitset<N>&, const bitset<N>&);
-T   template <size_t N>
-      bitset<N> operator^(const bitset<N>&, const bitset<N>&);
-T   template <class charT, class traits, size_t N>
-      basic_istream<charT, traits>&
-      operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
-T   template <class charT, class traits, size_t N>
-      basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
-
-T   template<size_t N> class bitset {
-    public:
-      // bit reference:
-T     class reference {
-        friend class bitset;
-T       reference();
-      public:
-T      ~reference();
-T       reference& operator=(bool x);             // for b[i] = x;
-T       reference& operator=(const reference&);   // for b[i] = b[j];
-T       bool operator~() const;                   // flips the bit
-T       operator bool() const;                    // for x = b[i];
-T       reference& flip();                        // for b[i].flip();
-      };
-
-      // _lib.bitset.cons_ constructors:
-T     bitset();
-T     bitset(unsigned long val);
-T     template<class charT, class traits, class Allocator>
-        explicit bitset(
-          const basic_string<charT,traits,Allocator>& str,
-          typename basic_string<charT,traits,Allocator>::size_type pos = 0,
-          typename basic_string<charT,traits,Allocator>::size_type n =
-            basic_string<charT,traits,Allocator>::npos);
-      // _lib.bitset.members_ bitset operations:
-T     bitset<N>& operator&=(const bitset<N>& rhs);
-T     bitset<N>& operator|=(const bitset<N>& rhs);
-T     bitset<N>& operator^=(const bitset<N>& rhs);
-T     bitset<N>& operator<<=(size_t pos);
-T     bitset<N>& operator>>=(size_t pos);
-T     bitset<N>& set();
-T     bitset<N>& set(size_t pos, int val = true);
-T     bitset<N>& reset();
-T     bitset<N>& reset(size_t pos);
-T     bitset<N>  operator~() const;
-T     bitset<N>& flip();
-T     bitset<N>& flip(size_t pos);
-      // element access:
-T     reference operator[](size_t pos);         // for b[i];
-T     unsigned long  to_ulong() const;
-T     template <class charT, class traits, class Allocator>
-        basic_string<charT, traits, Allocator> to_string() const;
-T     size_t count() const;
-T     size_t size()  const;
-T     bool operator==(const bitset<N>& rhs) const;
-T     bool operator!=(const bitset<N>& rhs) const;
-T     bool test(size_t pos) const;
-T     bool any() const;
-T     bool none() const;
-T     bitset<N> operator<<(size_t pos) const;
-T     bitset<N> operator>>(size_t pos) const;
-    };
-
-
-
-
-   24.2  Header <iterator> synopsis               [lib.iterator.synopsis]
-
-    // _lib.iterator.primitives_, primitives:
-T   template<class Iterator> struct iterator_traits;
-T   template<class T> struct iterator_traits<T*>;
-
-X   template<class Category, class T, class Distance = ptrdiff_t,
-             class Pointer = T*, class Reference = T&> struct iterator;
-T   struct input_iterator_tag {};
-T   struct output_iterator_tag {};
-T   struct forward_iterator_tag: public input_iterator_tag {};
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
-    // _lib.iterator.operations_, iterator operations:
-T   template <class InputIterator, class Distance>
-      void advance(InputIterator& i, Distance n);
-T   template <class InputIterator>
-      typename iterator_traits<InputIterator>::difference_type
-      distance(InputIterator first, InputIterator last);
-    // _lib.predef.iterators_, predefined iterators:
-X   template <class Iterator> class reverse_iterator;
-T   template <class Iterator>
-      bool operator==(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator<(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator!=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator>(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator>=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator<=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      typename reverse_iterator<Iterator>::difference_type operator-(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      reverse_iterator<Iterator>
-        operator+(
-          typename reverse_iterator<Iterator>::difference_type n,
-          const reverse_iterator<Iterator>& x);
-
-X   template <class Container> class back_insert_iterator;
-T   template <class Container>
-      back_insert_iterator<Container> back_inserter(Container& x);
-X   template <class Container> class front_insert_iterator;
-T   template <class Container>
-      front_insert_iterator<Container> front_inserter(Container& x);
-X   template <class Container> class insert_iterator;
-T   template <class Container, class Iterator>
-      insert_iterator<Container> inserter(Container& x, Iterator i);
-    // _lib.stream.iterators_, stream iterators:
-X   template <class T, class charT = char, class traits = char_traits<charT>,
-              class Distance = ptrdiff_t>
-      class istream_iterator;
-    template <class T, class charT, class traits, class Distance>
-X     bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
-                      const istream_iterator<T,charT,traits,Distance>& y);
-    template <class T, class charT, class traits, class Distance>
-X     bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
-                      const istream_iterator<T,charT,traits,Distance>& y);
-X   template <class T, class charT = char, class traits = char_traits<charT> >
-        class ostream_iterator;
-X   template<class charT, class traits = char_traits<charT> >
-      class istreambuf_iterator;
-X   template <class charT, class traits>
-      bool operator==(const istreambuf_iterator<charT,traits>& a,
-                      const istreambuf_iterator<charT,traits>& b);
-X   template <class charT, class traits>
-      bool operator!=(const istreambuf_iterator<charT,traits>& a,
-                      const istreambuf_iterator<charT,traits>& b);
-T   template <class charT, class traits = char_traits<charT> >
-      class ostreambuf_iterator;
-
-   24.3  Iterator primitives                    [lib.iterator.primitives]
-
-T   template<class Iterator> struct iterator_traits {
-T     typedef typename Iterator::difference_type difference_type;
-T     typedef typename Iterator::value_type value_type;
-T     typedef typename Iterator::pointer pointer;
-T     typedef typename Iterator::reference reference;
-T     typedef typename Iterator::iterator_category iterator_category;
-    };
-
-T   template<class T> struct iterator_traits<T*> {
-T     typedef ptrdiff_t difference_type;
-T     typedef T value_type;
-T     typedef T* pointer;
-T     typedef T& reference;
-T     typedef random_access_iterator_tag iterator_category;
-    };
-
-T   template<class T> struct iterator_traits<const T*> {
-T     typedef ptrdiff_t difference_type;
-T     typedef T value_type;
-T     typedef const T* pointer;
-T     typedef const T& reference;
-T     typedef random_access_iterator_tag iterator_category;
-    };
-
-   24.3.2  Basic iterator                            [lib.iterator.basic]
-
-    template<class Category, class T, class Distance = ptrdiff_t,
-             class Pointer = T*, class Reference = T&>
-X     struct iterator {
-T         typedef T         value_type;
-T         typedef Distance  difference_type;
-T         typedef Pointer   pointer;
-T         typedef Reference reference;
-T         typedef Category  iterator_category;
-    };
-
-   24.3.3  Standard iterator tags                 [lib.std.iterator.tags]
-
-T   struct input_iterator_tag {};
-T   struct output_iterator_tag {};
-T   struct forward_iterator_tag: public input_iterator_tag {};
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
-
-
-   24.4.1  Reverse iterators                      [lib.reverse.iterators]
-
-    template <class Iterator>
-X   class reverse_iterator : public
-          iterator<typename iterator_traits<Iterator>::iterator_category,
-                   typename iterator_traits<Iterator>::value_type,
-                   typename iterator_traits<Iterator>::difference_type,
-                   typename iterator_traits<Iterator>::pointer,
-                   typename iterator_traits<Iterator>::reference> {
-    protected:
-T     Iterator current;
-    public:
-T     typedef Iterator
-          iterator_type;
-T     typedef typename iterator_traits<Iterator>::difference_type
-          difference_type;
-T     typedef typename iterator_traits<Iterator>::reference
-          reference;
-T     typedef typename iterator_traits<Iterator>::pointer
-          pointer;
-
-T     reverse_iterator();
-T     explicit reverse_iterator(Iterator x);
-T     template <class U> reverse_iterator(const reverse_iterator<U>& u);
-T     Iterator base() const;      // explicit
-T     reference operator*() const;
-T     pointer   operator->() const;
-T     reverse_iterator& operator++();
-T     reverse_iterator  operator++(int);
-T     reverse_iterator& operator--();
-T     reverse_iterator  operator--(int);
-
-T     reverse_iterator  operator+ (difference_type n) const;
-T     reverse_iterator& operator+=(difference_type n);
-T     reverse_iterator  operator- (difference_type n) const;
-T     reverse_iterator& operator-=(difference_type n);
-T     reference operator[](difference_type n) const;
-    };
-T   template <class Iterator>
-      bool operator==(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator<(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator!=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator>(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator>=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      bool operator<=(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      typename reverse_iterator<Iterator>::difference_type operator-(
-        const reverse_iterator<Iterator>& x,
-        const reverse_iterator<Iterator>& y);
-T   template <class Iterator>
-      reverse_iterator<Iterator> operator+(
-        typename reverse_iterator<Iterator>::difference_type n,
-        const reverse_iterator<Iterator>& x);
-
-
-   24.4.2.1  Template class                    [lib.back.insert.iterator]
-       back_insert_iterator
-
-    template <class Container>
-X   class back_insert_iterator :
-          public iterator<output_iterator_tag,void,void,void,void> {
-    protected:
-T     Container* container;
-    public:
-T     typedef Container container_type;
-T     explicit back_insert_iterator(Container& x);
-T     back_insert_iterator<Container>&
-        operator=(typename Container::const_reference value);
-
-T     back_insert_iterator<Container>& operator*();
-T     back_insert_iterator<Container>& operator++();
-T     back_insert_iterator<Container>  operator++(int);
-    };
-T   template <class Container>
-      back_insert_iterator<Container> back_inserter(Container& x);
-
-
-
-   24.4.2.3  Template class                   [lib.front.insert.iterator]
-       front_insert_iterator
-
-    template <class Container>
-X   class front_insert_iterator :
-          public iterator<output_iterator_tag,void,void,void,void> {
-    protected:
-T     Container* container;
-    public:
-T     typedef Container container_type;
-T     explicit front_insert_iterator(Container& x);
-T     front_insert_iterator<Container>&
-        operator=(typename Container::const_reference value);
-T     front_insert_iterator<Container>& operator*();
-T     front_insert_iterator<Container>& operator++();
-T     front_insert_iterator<Container>  operator++(int);
-    };
-T   template <class Container>
-      front_insert_iterator<Container> front_inserter(Container& x);
-
-
-   24.4.2.5  Template class insert_iterator         [lib.insert.iterator]
-
-    template <class Container>
-X   class insert_iterator :
-          public iterator<output_iterator_tag,void,void,void,void> {
-    protected:
-T     Container* container;
-T     typename Container::iterator iter;
-    public:
-T     typedef Container container_type;
-T     insert_iterator(Container& x, typename Container::iterator i);
-T     insert_iterator<Container>&
-        operator=(typename Container::const_reference value);
-T     insert_iterator<Container>& operator*();
-T     insert_iterator<Container>& operator++();
-T     insert_iterator<Container>& operator++(int);
-    };
-T   template <class Container, class Iterator>
-      insert_iterator<Container> inserter(Container& x, Iterator i);
-
-   24.5.1  Template class istream_iterator         [lib.istream.iterator]
-
-    template <class T, class charT = char, class traits = char_traits<charT>,
-        class Distance = ptrdiff_t>
-X   class istream_iterator:
-      public iterator<input_iterator_tag, T, Distance, const T*, const T&> {
-    public:
-T     typedef charT char_type
-T     typedef traits traits_type;
-T     typedef basic_istream<charT,traits> istream_type;
-T     istream_iterator();
-T     istream_iterator(istream_type& s);
-T     istream_iterator(const istream_iterator<T,charT,traits,Distance>& x);
-T    ~istream_iterator();
-
-T     const T& operator*() const;
-T     const T* operator->() const;
-T     istream_iterator<T,charT,traits,Distance>& operator++();
-T     istream_iterator<T,charT,traits,Distance>  operator++(int);
-    };
-
-T   template <class T, class charT, class traits, class Distance>
-      bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
-                      const istream_iterator<T,charT,traits,Distance>& y);
-T   template <class T, class charT, class traits, class Distance>
-      bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
-                      const istream_iterator<T,charT,traits,Distance>& y);
-
-
-   24.5.2  Template class ostream_iterator         [lib.ostream.iterator]
-
-    template <class T, class charT = char, class traits = char_traits<charT> >
-X   class ostream_iterator:
-      public iterator<output_iterator_tag, void, void, void, void> {
-    public:
-T     typedef charT char_type;
-T     typedef traits traits_type;
-T     typedef basic_ostream<charT,traits> ostream_type;
-T     ostream_iterator(ostream_type& s);
-T     ostream_iterator(ostream_type& s, const charT* delimiter);
-T     ostream_iterator(const ostream_iterator<T,charT,traits>& x);
-T    ~ostream_iterator();
-T     ostream_iterator<T,charT,traits>& operator=(const T& value);
-
-T     ostream_iterator<T,charT,traits>& operator*();
-T     ostream_iterator<T,charT,traits>& operator++();
-T     ostream_iterator<T,charT,traits>& operator++(int);
-    };
-
-
-   24.5.3  Template class                       [lib.istreambuf.iterator]
-       istreambuf_iterator
-
-    template<class charT, class traits = char_traits<charT> >
-X   class istreambuf_iterator
-       : public iterator<input_iterator_tag, charT,
-                         typename traits::off_type, charT*, charT&> {
-    public:
-T     typedef charT                         char_type;
-T     typedef traits                        traits_type;
-T     typedef typename traits::int_type     int_type;
-T     typedef basic_streambuf<charT,traits> streambuf_type;
-T     typedef basic_istream<charT,traits>   istream_type;
-T     class proxy;                        // exposition only
-T     istreambuf_iterator() throw();
-T     istreambuf_iterator(istream_type& s) throw();
-T     istreambuf_iterator(streambuf_type* s) throw();
-T     istreambuf_iterator(const proxy& p) throw();
-T     charT operator*() const;
-T     istreambuf_iterator<charT,traits>& operator++();
-T     proxy operator++(int);
-X     bool equal(istreambuf_iterator& b);
-    };
-
-T   template <class charT, class traits>
-      bool operator==(const istreambuf_iterator<charT,traits>& a,
-                      const istreambuf_iterator<charT,traits>& b);
-
-T   template <class charT, class traits>
-      bool operator!=(const istreambuf_iterator<charT,traits>& a,
-                      const istreambuf_iterator<charT,traits>& b);
-
-   24.5.3.1  Template class              [lib.istreambuf.iterator::proxy]
-       istreambuf_iterator::proxy
-
-    template <class charT, class traits = char_traits<charT> >
-T     class istreambuf_iterator<charT, traits>::proxy
-    {
-T     charT keep_;
-T     basic_streambuf<charT,traits>* sbuf_;
-T     proxy(charT c,
-            basic_streambuf<charT,traits>* sbuf);
-        : keep_(c), sbuf_(sbuf) {}
-    public:
-T     charT operator*() { return keep_; }
-    };
-
-
-
-   24.5.4  Template class                       [lib.ostreambuf.iterator]
-       ostreambuf_iterator
-
-    template <class charT, class traits = char_traits<charT> >
-T   class ostreambuf_iterator:
-      public iterator<output_iterator_tag, void, void, void, void> {
-    public:
-T     typedef charT                         char_type;
-T     typedef traits                        traits_type;
-T     typedef basic_streambuf<charT,traits> streambuf_type;
-T     typedef basic_ostream<charT,traits>   ostream_type;
-    public:
-T     ostreambuf_iterator(ostream_type& s) throw();
-T     ostreambuf_iterator(streambuf_type* s) throw();
-T     ostreambuf_iterator& operator=(charT c);
-T     ostreambuf_iterator& operator*();
-T     ostreambuf_iterator& operator++();
-T     ostreambuf_iterator& operator++(int);
-T     bool failed() const throw();
-    };
-
-
-   Header <algorithm> synopsis
-
-
-    // _lib.alg.nonmodifying_, non-modifying sequence operations:
-T   template<class InputIterator, class Function>
-      Function for_each(InputIterator first, InputIterator last, Function f);
-T   template<class InputIterator, class T>
-      InputIterator find(InputIterator first, InputIterator last,
-                         const T& value);
-T   template<class InputIterator, class Predicate>
-      InputIterator find_if(InputIterator first, InputIterator last,
-                            Predicate pred);
-T   template<class ForwardIterator1, class ForwardIterator2>
-      ForwardIterator1
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2);
-T   template<class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate>
-      ForwardIterator1
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2,
-                 BinaryPredicate pred);
-T   template<class ForwardIterator1, class ForwardIterator2>
-      ForwardIterator1
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                      ForwardIterator2 first2, ForwardIterator2 last2);
-T   template<class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate>
-      ForwardIterator1
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2,
-                 BinaryPredicate pred);
-T   template<class ForwardIterator>
-      ForwardIterator adjacent_find(ForwardIterator first,
-                                    ForwardIterator last);
-T   template<class ForwardIterator, class BinaryPredicate>
-      ForwardIterator adjacent_find(ForwardIterator first,
-          ForwardIterator last, BinaryPredicate pred);
-T   template<class InputIterator, class T>
-      typename iterator_traits<InputIterator>::difference_type
-        count(InputIterator first, InputIterator last, const T& value);
-T   template<class InputIterator, class Predicate>
-      typename iterator_traits<InputIterator>::difference_type
-        count_if(InputIterator first, InputIterator last, Predicate pred);
-T   template<class InputIterator1, class InputIterator2>
-      pair<InputIterator1, InputIterator2>
-        mismatch(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2);
-T   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
-      pair<InputIterator1, InputIterator2>
-        mismatch(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2, BinaryPredicate pred);
-
-T   template<class InputIterator1, class InputIterator2>
-      bool equal(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2);
-T   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
-      bool equal(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2, BinaryPredicate pred);
-T   template<class ForwardIterator1, class ForwardIterator2>
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                              ForwardIterator2 first2, ForwardIterator2 last2);
-T   template<class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate>
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                              ForwardIterator2 first2, ForwardIterator2 last2,
-                              BinaryPredicate pred);
-T   template<class ForwardIterator, class Size, class T>
-      ForwardIterator  search_n(ForwardIterator first, ForwardIterator last,
-                              Size count, const T& value);
-T   template<class ForwardIterator, class Size, class T, class BinaryPredicate>
-      ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
-                              Size count, const T& value,
-                              BinaryPredicate pred);
-    // _lib.alg.modifying.operations_, modifying sequence operations:
-    // _lib.alg.copy_, copy:
-T   template<class InputIterator, class OutputIterator>
-      OutputIterator copy(InputIterator first, InputIterator last,
-                          OutputIterator result);
-T   template<class BidirectionalIterator1, class BidirectionalIterator2>
-      BidirectionalIterator2
-        copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
-                      BidirectionalIterator2 result);
-    // _lib.alg.swap_, swap:
-T   template<class T> void swap(T& a, T& b);
-T   template<class ForwardIterator1, class ForwardIterator2>
-      ForwardIterator2 swap_ranges(ForwardIterator1 first1,
-          ForwardIterator1 last1, ForwardIterator2 first2);
-T   template<class ForwardIterator1, class ForwardIterator2>
-      void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
-T   template<class InputIterator, class OutputIterator, class UnaryOperation>
-      OutputIterator transform(InputIterator first, InputIterator last,
-                               OutputIterator result, UnaryOperation op);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class BinaryOperation>
-      OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, OutputIterator result,
-                               BinaryOperation binary_op);
-
-T   template<class ForwardIterator, class T>
-      void replace(ForwardIterator first, ForwardIterator last,
-                   const T& old_value, const T& new_value);
-T   template<class ForwardIterator, class Predicate, class T>
-      void replace_if(ForwardIterator first, ForwardIterator last,
-                      Predicate pred, const T& new_value);
-T   template<class InputIterator, class OutputIterator, class T>
-      OutputIterator replace_copy(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  const T& old_value, const T& new_value);
-T   template<class Iterator, class OutputIterator, class Predicate, class T>
-      OutputIterator replace_copy_if(Iterator first, Iterator last,
-                                     OutputIterator result,
-                                     Predicate pred, const T& new_value);
-T   template<class ForwardIterator, class T>
-      void fill(ForwardIterator first, ForwardIterator last, const T& value);
-T   template<class OutputIterator, class Size, class T>
-      void fill_n(OutputIterator first, Size n, const T& value);
-T   template<class ForwardIterator, class Generator>
-      void generate(ForwardIterator first, ForwardIterator last, Generator gen);
-T   template<class OutputIterator, class Size, class Generator>
-      void generate_n(OutputIterator first, Size n, Generator gen);
-T   template<class ForwardIterator, class T>
-      ForwardIterator remove(ForwardIterator first, ForwardIterator last,
-                             const T& value);
-T   template<class ForwardIterator, class Predicate>
-      ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
-                                Predicate pred);
-T   template<class InputIterator, class OutputIterator, class T>
-      OutputIterator remove_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result, const T& value);
-T   template<class InputIterator, class OutputIterator, class Predicate>
-      OutputIterator remove_copy_if(InputIterator first, InputIterator last,
-                                    OutputIterator result, Predicate pred);
-T   template<class ForwardIterator>
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last);
-T   template<class ForwardIterator, class BinaryPredicate>
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last,
-                             BinaryPredicate pred);
-T   template<class InputIterator, class OutputIterator>
-      OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result);
-T   template<class InputIterator, class OutputIterator, class BinaryPredicate>
-      OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result, BinaryPredicate pred);
-T   template<class BidirectionalIterator>
-      void reverse(BidirectionalIterator first, BidirectionalIterator last);
-T   template<class BidirectionalIterator, class OutputIterator>
-      OutputIterator reverse_copy(BidirectionalIterator first,
-                                  BidirectionalIterator last,
-                                  OutputIterator result);
-
-T   template<class ForwardIterator>
-      void rotate(ForwardIterator first, ForwardIterator middle,
-                  ForwardIterator last);
-T   template<class ForwardIterator, class OutputIterator>
-      OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,
-                                 ForwardIterator last, OutputIterator result);
-T   template<class RandomAccessIterator>
-      void random_shuffle(RandomAccessIterator first,
-                          RandomAccessIterator last);
-T   template<class RandomAccessIterator, class RandomNumberGenerator>
-      void random_shuffle(RandomAccessIterator first,
-                          RandomAccessIterator last,
-                          RandomNumberGenerator& rand);
-    // _lib.alg.partitions_, partitions:
-T   template<class BidirectionalIterator, class Predicate>
-      BidirectionalIterator partition(BidirectionalIterator first,
-                                      BidirectionalIterator last,
-                                      Predicate pred);
-T   template<class BidirectionalIterator, class Predicate>
-      BidirectionalIterator stable_partition(BidirectionalIterator first,
-                                             BidirectionalIterator last,
-                                             Predicate pred);
-    // _lib.alg.sorting_, sorting and related operations:
-    // _lib.alg.sort_, sorting:
-T   template<class RandomAccessIterator>
-      void sort(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void sort(RandomAccessIterator first, RandomAccessIterator last,
-                Compare comp);
-T   template<class RandomAccessIterator>
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
-                       Compare comp);
-T   template<class RandomAccessIterator>
-      void partial_sort(RandomAccessIterator first,
-                        RandomAccessIterator middle,
-                        RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void partial_sort(RandomAccessIterator first,
-                        RandomAccessIterator middle,
-                        RandomAccessIterator last, Compare comp);
-T   template<class InputIterator, class RandomAccessIterator>
-      RandomAccessIterator
-        partial_sort_copy(InputIterator first, InputIterator last,
-                          RandomAccessIterator result_first,
-                          RandomAccessIterator result_last);
-T   template<class InputIterator, class RandomAccessIterator, class Compare>
-      RandomAccessIterator
-        partial_sort_copy(InputIterator first, InputIterator last,
-                          RandomAccessIterator result_first,
-                          RandomAccessIterator result_last,
-                          Compare comp);
-
-T   template<class RandomAccessIterator>
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                       RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                       RandomAccessIterator last, Compare comp);
-    // _lib.alg.binary.search_, binary search:
-T   template<class ForwardIterator, class T>
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                  const T& value);
-T   template<class ForwardIterator, class T, class Compare>
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                  const T& value, Compare comp);
-T   template<class ForwardIterator, class T>
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                  const T& value);
-T   template<class ForwardIterator, class T, class Compare>
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                  const T& value, Compare comp);
-T   template<class ForwardIterator, class T>
-      pair<ForwardIterator, ForwardIterator>
-        equal_range(ForwardIterator first, ForwardIterator last,
-                    const T& value);
-T   template<class ForwardIterator, class T, class Compare>
-      pair<ForwardIterator, ForwardIterator>
-        equal_range(ForwardIterator first, ForwardIterator last,
-                    const T& value, Compare comp);
-T   template<class ForwardIterator, class T>
-      bool binary_search(ForwardIterator first, ForwardIterator last,
-                         const T& value);
-T   template<class ForwardIterator, class T, class Compare>
-      bool binary_search(ForwardIterator first, ForwardIterator last,
-                         const T& value, Compare comp);
-    // _lib.alg.merge_, merge:
-T   template<class InputIterator1, class InputIterator2, class OutputIterator>
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                           InputIterator2 first2, InputIterator2 last2,
-                           OutputIterator result);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                           InputIterator2 first2, InputIterator2 last2,
-                           OutputIterator result, Compare comp);
-T   template<class BidirectionalIterator>
-      void inplace_merge(BidirectionalIterator first,
-                         BidirectionalIterator middle,
-                         BidirectionalIterator last);
-T   template<class BidirectionalIterator, class Compare>
-      void inplace_merge(BidirectionalIterator first,
-                         BidirectionalIterator middle,
-                         BidirectionalIterator last, Compare comp);
-
-    // _lib.alg.set.operations_, set operations:
-T   template<class InputIterator1, class InputIterator2>
-      bool includes(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, InputIterator2 last2);
-T   template<class InputIterator1, class InputIterator2, class Compare>
-      bool includes(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, InputIterator2 last2, Compare comp);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator>
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result, Compare comp);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator>
-      OutputIterator set_intersection
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-      OutputIterator set_intersection
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result, Compare comp);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator>
-      OutputIterator set_difference
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare>
-      OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-                                    InputIterator2 first2, InputIterator2 last2,
-                                    OutputIterator result, Compare comp);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator>
-      OutputIterator
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                 InputIterator2 first2, InputIterator2 last2,
-                                 OutputIterator result);
-T   template<class InputIterator1, class InputIterator2, class OutputIterator,
-              class Compare>
-      OutputIterator
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                 InputIterator2 first2, InputIterator2 last2,
-                                 OutputIterator result, Compare comp);
-    // _lib.alg.heap.operations_, heap operations:
-T   template<class RandomAccessIterator>
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-
-T   template<class RandomAccessIterator>
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
-                    Compare comp);
-T   template<class RandomAccessIterator>
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-T   template<class RandomAccessIterator>
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template<class RandomAccessIterator, class Compare>
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-    // _lib.alg.min.max_, minimum and maximum:
-T   template<class T> const T& min(const T& a, const T& b);
-T   template<class T, class Compare>
-      const T& min(const T& a, const T& b, Compare comp);
-T   template<class T> const T& max(const T& a, const T& b);
-T   template<class T, class Compare>
-      const T& max(const T& a, const T& b, Compare comp);
-T   template<class ForwardIterator>
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
-T   template<class ForwardIterator, class Compare>
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
-                                Compare comp);
-T   template<class ForwardIterator>
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
-T   template<class ForwardIterator, class Compare>
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
-                                Compare comp);
-T   template<class InputIterator1, class InputIterator2>
-      bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2);
-T   template<class InputIterator1, class InputIterator2, class Compare>
-      bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           Compare comp);
-
-    // _lib.alg.permutation.generators_, permutations
-T   template<class BidirectionalIterator>
-      bool next_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last);
-T   template<class BidirectionalIterator, class Compare>
-      bool next_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last, Compare comp);
-T   template<class BidirectionalIterator>
-      bool prev_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last);
-T   template<class BidirectionalIterator, class Compare>
-      bool prev_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last, Compare comp);
-
-
-   25.4  C library algorithms                         [lib.alg.c.library]
-
-   1 Header <cstdlib> (partial, Table 2):
-
-                    Table 2--Header <cstdlib> synopsis
-
-                      Functions:   bsearch   qsort
-
-
-X  extern "C" void *bsearch(const void *key, const void *base,
-                          size_t nmemb, size_t size,
-                          int (*compar)(const void *, const void *));
-X  extern "C++" void *bsearch(const void *key, const void *base,
-                          size_t nmemb, size_t size,
-                          int (*compar)(const void *, const void *));
-
-X  extern "C" void qsort(void* base, size_t nmemb, size_t size,
-                  int (*compar)(const void*, const void*));
-X  extern "C++" void qsort(void* base, size_t nmemb, size_t size,
-                  int (*compar)(const void*, const void*));
-
-
-
-   26.2  Complex numbers                            [lib.complex.numbers]
-
-
-   26.2.1  Header <complex> synopsis               [lib.complex.synopsis]
-
-T   template<class T> class complex;
-T   template<> class complex<float>;
-T   template<> class complex<double>;
-T   template<> class complex<long double>;
-    // _lib.complex.ops_ operators:
-T   template<class T>
-      complex<T> operator+(const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator+(const complex<T>&, const T&);
-T   template<class T> complex<T> operator+(const T&, const complex<T>&);
-T   template<class T> complex<T> operator-
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator-(const complex<T>&, const T&);
-T   template<class T> complex<T> operator-(const T&, const complex<T>&);
-T   template<class T> complex<T> operator*
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator*(const complex<T>&, const T&);
-T   template<class T> complex<T> operator*(const T&, const complex<T>&);
-T   template<class T> complex<T> operator/
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator/(const complex<T>&, const T&);
-T   template<class T> complex<T> operator/(const T&, const complex<T>&);
-T   template<class T> complex<T> operator+(const complex<T>&);
-T   template<class T> complex<T> operator-(const complex<T>&);
-T   template<class T> bool operator==
-      (const complex<T>&, const complex<T>&);
-T   template<class T> bool operator==(const complex<T>&, const T&);
-T   template<class T> bool operator==(const T&, const complex<T>&);
-T   template<class T> bool operator!=(const complex<T>&, const complex<T>&);
-T   template<class T> bool operator!=(const complex<T>&, const T&);
-T   template<class T> bool operator!=(const T&, const complex<T>&);
-T   template<class T, class charT, class traits>
-      basic_istream<charT, traits>&
-      operator>>(basic_istream<charT, traits>&, complex<T>&);
-
-T   template<class T, class charT, class traits>
-      basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>&, const complex<T>&);
-    // _lib.complex.value.ops_ values:
-T   template<class T> T real(const complex<T>&);
-T   template<class T> T imag(const complex<T>&);
-
-T   template<class T> T abs(const complex<T>&);
-T   template<class T> T arg(const complex<T>&);
-T   template<class T> T norm(const complex<T>&);
-T   template<class T> complex<T> conj(const complex<T>&);
-T   template<class T> complex<T> polar(const T&, const T&);
-    // _lib.complex.transcendentals_ transcendentals:
-T   template<class T> complex<T> cos  (const complex<T>&);
-T   template<class T> complex<T> cosh (const complex<T>&);
-T   template<class T> complex<T> exp  (const complex<T>&);
-T   template<class T> complex<T> log  (const complex<T>&);
-T   template<class T> complex<T> log10(const complex<T>&);
-T   template<class T> complex<T> pow(const complex<T>&, int);
-T   template<class T> complex<T> pow(const complex<T>&, const T&);
-T   template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> pow(const T&, const complex<T>&);
-T   template<class T> complex<T> sin  (const complex<T>&);
-T   template<class T> complex<T> sinh (const complex<T>&);
-T   template<class T> complex<T> sqrt (const complex<T>&);
-T   template<class T> complex<T> tan  (const complex<T>&);
-T   template<class T> complex<T> tanh (const complex<T>&);
-   }
-
-   26.2.2  Template class complex                           [lib.complex]
-
-    template<class T>
-T   class complex {
-    public:
-T     typedef T value_type;
-
-T     complex(const T& re = T(), const T& im = T());
-T     complex(const complex&);
-T     template<class X> complex(const complex<X>&);
-
-T     T real() const;
-T     T imag() const;
-
-T     complex<T>& operator= (const T&);
-T     complex<T>& operator+=(const T&);
-T     complex<T>& operator-=(const T&);
-T     complex<T>& operator*=(const T&);
-T     complex<T>& operator/=(const T&);
-
-T     complex& operator=(const complex&);
-T     template<class X> complex<T>& operator= (const complex<X>&);
-T     template<class X> complex<T>& operator+=(const complex<X>&);
-T     template<class X> complex<T>& operator-=(const complex<X>&);
-T     template<class X> complex<T>& operator*=(const complex<X>&);
-T     template<class X> complex<T>& operator/=(const complex<X>&);
-    };
-
-T   template<class T> complex<T> operator+
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator+(const complex<T>&, const T&);
-T   template<class T> complex<T> operator+(const T&, const complex<T>&);
-
-T   template<class T> complex<T> operator-
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator-(const complex<T>&, const T&);
-T   template<class T> complex<T> operator-(const T&, const complex<T>&);
-
-T   template<class T> complex<T> operator*
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator*(const complex<T>&, const T&);
-T   template<class T> complex<T> operator*(const T&, const complex<T>&);
-
-T   template<class T> complex<T> operator/
-      (const complex<T>&, const complex<T>&);
-T   template<class T> complex<T> operator/(const complex<T>&, const T&);
-T   template<class T> complex<T> operator/(const T&, const complex<T>&);
-
-T   template<class T> complex<T> operator+(const complex<T>&);
-T   template<class T> complex<T> operator-(const complex<T>&);
-
-T   template<class T> bool operator==(const complex<T>&, const complex<T>&);
-T   template<class T> bool operator==(const complex<T>&, const T&);
-T   template<class T> bool operator==(const T&, const complex<T>&);
-
-T   template<class T> bool operator!=(const complex<T>&, const complex<T>&);
-T   template<class T> bool operator!=(const complex<T>&, const T&);
-T   template<class T> bool operator!=(const T&, const complex<T>&);
-
-T   template<class T, class charT, class traits>
-      basic_istream<charT, traits>&
-      operator>>(basic_istream<charT, traits>&, complex<T>&);
-
-T   template<class T, class charT, class traits>
-      basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>&, const complex<T>&);
-
-
-   26.2.3  complex specializations                  [lib.complex.special]
-
-T   template<> class complex<float> {
-    public:
-T     typedef float value_type;
-
-T     complex(float re = 0.0f, float im = 0.0f);
-T     explicit complex(const complex<double>&);
-T     explicit complex(const complex<long double>&);
-T     float real() const;
-T     float imag() const;
-
-T     complex<float>& operator= (float);
-T     complex<float>& operator+=(float);
-T     complex<float>& operator-=(float);
-T     complex<float>& operator*=(float);
-T     complex<float>& operator/=(float);
-
-T     complex<float>& operator=(const complex<float>&);
-T     template<class X> complex<float>& operator= (const complex<X>&);
-T     template<class X> complex<float>& operator+=(const complex<X>&);
-T     template<class X> complex<float>& operator-=(const complex<X>&);
-T     template<class X> complex<float>& operator*=(const complex<X>&);
-T     template<class X> complex<float>& operator/=(const complex<X>&);
-    };
-T   template<> class complex<double> {
-    public:
-T     typedef double value_type;
-
-T     complex(double re = 0.0, double im = 0.0);
-T     complex(const complex<float>&);
-T     explicit complex(const complex<long double>&);
-T     double real() const;
-T     double imag() const;
-
-T     complex<double>& operator= (double);
-T     complex<double>& operator+=(double);
-T     complex<double>& operator-=(double);
-T     complex<double>& operator*=(double);
-T     complex<double>& operator/=(double);
-
-T     complex<double>& operator=(const complex<double>&);
-T     template<class X> complex<double>& operator= (const complex<X>&);
-T     template<class X> complex<double>& operator+=(const complex<X>&);
-T     template<class X> complex<double>& operator-=(const complex<X>&);
-T     template<class X> complex<double>& operator*=(const complex<X>&);
-T     template<class X> complex<double>& operator/=(const complex<X>&);
-    };
-
-T   template<> class complex<long double> {
-    public:
-T     typedef long double value_type;
-
-T     complex(long double re = 0.0L, long double im = 0.0L);
-T     complex(const complex<float>&);
-T     complex(const complex<double>&);
-T     long double real() const;
-T     long double imag() const;
-
-T     complex<long double>& operator=(const complex<long double>&);
-T     complex<long double>& operator= (long double);
-T     complex<long double>& operator+=(long double);
-T     complex<long double>& operator-=(long double);
-T     complex<long double>& operator*=(long double);
-T     complex<long double>& operator/=(long double);
-
-T     template<class X> complex<long double>& operator= (const complex<X>&);
-T     template<class X> complex<long double>& operator+=(const complex<X>&);
-T     template<class X> complex<long double>& operator-=(const complex<X>&);
-T     template<class X> complex<long double>& operator*=(const complex<X>&);
-T     template<class X> complex<long double>& operator/=(const complex<X>&);
-    };
-
-   26.3  Numeric arrays                                    [lib.numarray]
-
-   26.3.1  Header <valarray> synopsis             [lib.valarray.synopsis]
-
-T   template<class T> class valarray;         // An array of type T
-T   class slice;
-T   template<class T> class slice_array;
-T   class gslice;
-T   template<class T> class gslice_array;
-T   template<class T> class mask_array;       // a masked array
-T   template<class T> class indirect_array;   // an indirected array
-
-T   template<class T> valarray<T> operator*
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator* (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator* (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator/
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator%
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator% (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator% (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator+
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator-
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator- (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator- (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator^
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator&
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator& (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator& (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator|
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator| (const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator| (const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator<<
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
-T   template<class T> valarray<T> operator>>
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
-T   template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
-T   template<class T> valarray<bool> operator&&
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
-T   template<class T> valarray<bool> operator||
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator||(const T&, const valarray<T>&);
-
-T   template<class T>
-      valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
-T   template<class T>
-      valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
-T   template<class T>
-      valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
-T   template<class T>
-      valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
-T   template<class T>
-      valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
-T   template<class T>
-      valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
-T   template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
-T   template<class T> valarray<T> abs  (const valarray<T>&);
-T   template<class T> valarray<T> acos (const valarray<T>&);
-T   template<class T> valarray<T> asin (const valarray<T>&);
-T   template<class T> valarray<T> atan (const valarray<T>&);
-T   template<class T> valarray<T> atan2
-      (const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> atan2(const valarray<T>&, const T&);
-T   template<class T> valarray<T> atan2(const T&, const valarray<T>&);
-T   template<class T> valarray<T> cos  (const valarray<T>&);
-T   template<class T> valarray<T> cosh (const valarray<T>&);
-T   template<class T> valarray<T> exp  (const valarray<T>&);
-T   template<class T> valarray<T> log  (const valarray<T>&);
-T   template<class T> valarray<T> log10(const valarray<T>&);
-T   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
-T   template<class T> valarray<T> pow(const valarray<T>&, const T&);
-T   template<class T> valarray<T> pow(const T&, const valarray<T>&);
-T   template<class T> valarray<T> sin  (const valarray<T>&);
-T   template<class T> valarray<T> sinh (const valarray<T>&);
-T   template<class T> valarray<T> sqrt (const valarray<T>&);
-T   template<class T> valarray<T> tan  (const valarray<T>&);
-T   template<class T> valarray<T> tanh (const valarray<T>&);
-   }
-
-
-   26.3.2  Template class valarray                [lib.template.valarray]
-
-T   template<class T> class valarray {
-    public:
-T     typedef T value_type;
-
-      // _lib.valarray.cons_ construct/destroy:
-T     valarray();
-T     explicit valarray(size_t);
-T     valarray(const T&, size_t);
-T     valarray(const T*, size_t);
-T     valarray(const valarray&);
-T     valarray(const slice_array<T>&);
-T     valarray(const gslice_array<T>&);
-T     valarray(const mask_array<T>&);
-T     valarray(const indirect_array<T>&);
-T    ~valarray();
-
-      // _lib.valarray.assign_ assignment:
-T     valarray<T>& operator=(const valarray<T>&);
-T     valarray<T>& operator=(const T&);
-T     valarray<T>& operator=(const slice_array<T>&);
-T     valarray<T>& operator=(const gslice_array<T>&);
-T     valarray<T>& operator=(const mask_array<T>&);
-T     valarray<T>& operator=(const indirect_array<T>&);
-      // _lib.valarray.access_ element access:
-T     T                 operator[](size_t) const;
-T     T&                operator[](size_t);
-      // _lib.valarray.sub_ subset operations:
-T     valarray<T>       operator[](slice) const;
-T     slice_array<T>    operator[](slice);
-T     valarray<T>       operator[](const gslice&) const;
-T     gslice_array<T>   operator[](const gslice&);
-T     valarray<T>       operator[](const valarray<bool>&) const;
-T     mask_array<T>     operator[](const valarray<bool>&);
-T     valarray<T>       operator[](const valarray<size_t>&) const;
-T     indirect_array<T> operator[](const valarray<size_t>&);
-      // _lib.valarray.unary_ unary operators:
-T     valarray<T> operator+() const;
-T     valarray<T> operator-() const;
-T     valarray<T> operator~() const;
-T     valarray<T> operator!() const;
-      // _lib.valarray.cassign_ computed assignment:
-T     valarray<T>& operator*= (const T&);
-T     valarray<T>& operator/= (const T&);
-T     valarray<T>& operator%= (const T&);
-T     valarray<T>& operator+= (const T&);
-T     valarray<T>& operator-= (const T&);
-T     valarray<T>& operator^= (const T&);
-T     valarray<T>& operator&= (const T&);
-T     valarray<T>& operator|= (const T&);
-T     valarray<T>& operator<<=(const T&);
-T     valarray<T>& operator>>=(const T&);
-T     valarray<T>& operator*= (const valarray<T>&);
-T     valarray<T>& operator/= (const valarray<T>&);
-T     valarray<T>& operator%= (const valarray<T>&);
-T     valarray<T>& operator+= (const valarray<T>&);
-T     valarray<T>& operator-= (const valarray<T>&);
-T     valarray<T>& operator^= (const valarray<T>&);
-T     valarray<T>& operator|= (const valarray<T>&);
-T     valarray<T>& operator&= (const valarray<T>&);
-T     valarray<T>& operator<<=(const valarray<T>&);
-T     valarray<T>& operator>>=(const valarray<T>&);
-      // _lib.valarray.members_ member functions:
-T     size_t size() const;
-T     T    sum() const;
-T     T    min() const;
-T     T    max() const;
-
-T     valarray<T> shift (int) const;
-T     valarray<T> cshift(int) const;
-T     valarray<T> apply(T func(T)) const;
-T     valarray<T> apply(T func(const T&)) const;
-T     void resize(size_t sz, T c = T());
-    };
-   }
-
-
-
-   26.3.4  Class slice                                  [lib.class.slice]
-
-T   class slice {
-    public:
-T     slice();
-T     slice(size_t, size_t, size_t);
-
-T     size_t start() const;
-T     size_t size() const;
-T     size_t stride() const;
-    };
-   }
-
-
-
-   26.3.5  Template class slice_array          [lib.template.slice.array]
-
-T   template <class T> class slice_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray<T>&) const;
-T     void operator*= (const valarray<T>&) const;
-T     void operator/= (const valarray<T>&) const;
-T     void operator%= (const valarray<T>&) const;
-T     void operator+= (const valarray<T>&) const;
-T     void operator-= (const valarray<T>&) const;
-T     void operator^= (const valarray<T>&) const;
-T     void operator&= (const valarray<T>&) const;
-T     void operator|= (const valarray<T>&) const;
-T     void operator<<=(const valarray<T>&) const;
-T     void operator>>=(const valarray<T>&) const;
-T     void operator=(const T&);
-T    ~slice_array();
-    private:
-T     slice_array();
-T     slice_array(const slice_array&);
-T     slice_array& operator=(const slice_array&);
-    };
-   }
-
-
-
-   26.3.6  The gslice class                            [lib.class.gslice]
-
-T   class gslice {
-    public:
-T     gslice();
-T     gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d);
-
-T     size_t           start() const;
-T     valarray<size_t> size() const;
-T     valarray<size_t> stride() const;
-    };
-
-
-   26.3.7  Template class gslice_array        [lib.template.gslice.array]
-
-T   template <class T> class gslice_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray<T>&) const;
-T     void operator*= (const valarray<T>&) const;
-T     void operator/= (const valarray<T>&) const;
-T     void operator%= (const valarray<T>&) const;
-T     void operator+= (const valarray<T>&) const;
-T     void operator-= (const valarray<T>&) const;
-T     void operator^= (const valarray<T>&) const;
-T     void operator&= (const valarray<T>&) const;
-T     void operator|= (const valarray<T>&) const;
-T     void operator<<=(const valarray<T>&) const;
-T     void operator>>=(const valarray<T>&) const;
-T     void operator=(const T&);
-T    ~gslice_array();
-    private:
-T     gslice_array();
-T     gslice_array(const gslice_array&);
-T     gslice_array& operator=(const gslice_array&);
-    };
-
-
-   26.3.8  Template class mask_array            [lib.template.mask.array]
-
-T   template <class T> class mask_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray<T>&) const;
-T     void operator*= (const valarray<T>&) const;
-T     void operator/= (const valarray<T>&) const;
-T     void operator%= (const valarray<T>&) const;
-T     void operator+= (const valarray<T>&) const;
-T     void operator-= (const valarray<T>&) const;
-T     void operator^= (const valarray<T>&) const;
-T     void operator&= (const valarray<T>&) const;
-T     void operator|= (const valarray<T>&) const;
-T     void operator<<=(const valarray<T>&) const;
-T     void operator>>=(const valarray<T>&) const;
-T     void operator=(const T&);
-T    ~mask_array();
-    private:
-T     mask_array();
-T     mask_array(const mask_array&);
-T     mask_array& operator=(const mask_array&);
-      //  remainder implementation defined
-    };
-
-
-   26.3.9  Template class                   [lib.template.indirect.array]
-       indirect_array
-
-T   template <class T> class indirect_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray<T>&) const;
-T     void operator*= (const valarray<T>&) const;
-T     void operator/= (const valarray<T>&) const;
-T     void operator%= (const valarray<T>&) const;
-T     void operator+= (const valarray<T>&) const;
-T     void operator-= (const valarray<T>&) const;
-T     void operator^= (const valarray<T>&) const;
-T     void operator&= (const valarray<T>&) const;
-T     void operator|= (const valarray<T>&) const;
-T     void operator<<=(const valarray<T>&) const;
-T     void operator>>=(const valarray<T>&) const;
-T     void operator=(const T&);
-T    ~indirect_array();
-    private:
-T     indirect_array();
-T     indirect_array(const indirect_array&);
-T     indirect_array& operator=(const indirect_array&);
-      //  remainder implementation defined
-    };
-
-   26.4  Generalized numeric operations                 [lib.numeric.ops]
-
-   Header <numeric> synopsis
-
-T   template <class InputIterator, class T>
-      T accumulate(InputIterator first, InputIterator last, T init);
-
-T   template <class InputIterator, class T, class BinaryOperation>
-      T accumulate(InputIterator first, InputIterator last, T init,
-                   BinaryOperation binary_op);
-
-T   template <class InputIterator1, class InputIterator2, class T>
-      T inner_product(InputIterator1 first1, InputIterator1 last1,
-                      InputIterator2 first2, T init);
-
-T   template <class InputIterator1, class InputIterator2, class T,
-              class BinaryOperation1, class BinaryOperation2>
-      T inner_product(InputIterator1 first1, InputIterator1 last1,
-                      InputIterator2 first2, T init,
-                      BinaryOperation1 binary_op1,
-                      BinaryOperation2 binary_op2);
-
-T   template <class InputIterator, class OutputIterator>
-      OutputIterator partial_sum(InputIterator first,
-                                 InputIterator last,
-                                 OutputIterator result);
-
-T   template <class InputIterator, class OutputIterator,
-              class BinaryOperation>
-      OutputIterator partial_sum(InputIterator first,
-                                 InputIterator last,
-                                 OutputIterator result,
-                                 BinaryOperation binary_op);
-
-T   template <class InputIterator, class OutputIterator>
-      OutputIterator adjacent_difference(InputIterator first,
-                                         InputIterator last,
-                                         OutputIterator result);
-
-T   template <class InputIterator, class OutputIterator,
-              class BinaryOperation>
-      OutputIterator adjacent_difference(InputIterator first,
-                                         InputIterator last,
-                                         OutputIterator result,
-                                         BinaryOperation binary_op);
-
-
-   26.5  C Library                                           [lib.c.math]
-
-                     Table 2--Header <cmath> synopsis
-X               Macro:   HUGE_VAL
-                Functions:
-X               acos     cos        fmod    modf   tan
-X               asin     cosh       frexp   pow    tanh
-X               atan     exp        ldexp   sin
-X               atan2    fabs       log     sinh
-X               ceil     floor      log10   sqrt
-
-                    Table 3--Header <cstdlib> synopsis
-X                     Macros:   RAND_MAX
-X                     Types:    div_t      ldiv_t
-                      Functions:
-X                     abs       labs       srand
-X                     div       ldiv       rand
-
-X  long   abs(long);               // labs()
-X  ldiv_t div(long, long);         // ldiv()
-
-X  float abs  (float);
-X  float acos (float);
-X  float asin (float);
-X  float atan (float);
-X  float atan2(float, float);
-X  float ceil (float);
-X  float cos  (float);
-X  float cosh (float);
-X  float exp  (float);
-X  float fabs (float);
-X  float floor(float);
-X  float fmod (float, float);
-X  float frexp(float, int*);
-X  float ldexp(float, int);
-X  float log  (float);
-X  float log10(float);
-X  float modf (float, float*);
-X  float pow  (float, float);
-X  float pow  (float, int);
-X  float sin  (float);
-X  float sinh (float);
-X  float sqrt (float);
-X  float tan  (float);
-X  float tanh (float);
-
-X  double abs(double);            // fabs()
-X  double pow(double, int);
-
-X  long double abs  (long double);
-X  long double acos (long double);
-X  long double asin (long double);
-X  long double atan (long double);
-X  long double atan2(long double, long double);
-X  long double ceil (long double);
-X  long double cos  (long double);
-X  long double cosh (long double);
-X  long double exp  (long double);
-X  long double fabs (long double);
-X  long double floor(long double);
-X  long double fmod (long double, long double);
-X  long double frexp(long double, int*);
-X  long double ldexp(long double, int);
-X  long double log  (long double);
-X  long double log10(long double);
-X  long double modf (long double, long double*);
-X  long double pow  (long double, long double);
-X  long double pow  (long double, int);
-X  long double sin  (long double);
-X  long double sinh (long double);
-X  long double sqrt (long double);
-X  long double tan  (long double);
-X  long double tanh (long double);
-
-   Header <iosfwd> synopsis
-
-X   template<class charT> class char_traits;
-X   template<> class char_traits<char>;
-X   template<> class char_traits<wchar_t>;
-X   template<class T> class allocator;
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ios;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_streambuf;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_istream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ostream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_iostream;
-
-X   template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-      class basic_stringbuf;
-
-X   template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-      class basic_istringstream;
-
-X   template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-      class basic_ostringstream;
-
-X   template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-      class basic_stringstream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_filebuf;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ifstream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ofstream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_fstream;
-X   template <class charT, class traits = char_traits<charT> >
-      class istreambuf_iterator;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class ostreambuf_iterator;
-X   typedef basic_ios<char>       ios;
-X   typedef basic_ios<wchar_t>    wios;
-X   typedef basic_streambuf<char> streambuf;
-X   typedef basic_istream<char>   istream;
-X   typedef basic_ostream<char>   ostream;
-X   typedef basic_iostream<char>  iostream;
-X   typedef basic_stringbuf<char>     stringbuf;
-X   typedef basic_istringstream<char> istringstream;
-X   typedef basic_ostringstream<char> ostringstream;
-X   typedef basic_stringstream<char>  stringstream;
-X   typedef basic_filebuf<char>  filebuf;
-X   typedef basic_ifstream<char> ifstream;
-X   typedef basic_ofstream<char> ofstream;
-X   typedef basic_fstream<char>  fstream;
-X   typedef basic_streambuf<wchar_t> wstreambuf;
-X   typedef basic_istream<wchar_t>   wistream;
-X   typedef basic_ostream<wchar_t>   wostream;
-X   typedef basic_iostream<wchar_t>  wiostream;
-X   typedef basic_stringbuf<wchar_t>     wstringbuf;
-X   typedef basic_istringstream<wchar_t> wistringstream;
-X   typedef basic_ostringstream<wchar_t> wostringstream;
-X   typedef basic_stringstream<wchar_t>  wstringstream;
-
-X   typedef basic_filebuf<wchar_t>  wfilebuf;
-X   typedef basic_ifstream<wchar_t> wifstream;
-X   typedef basic_ofstream<wchar_t> wofstream;
-X   typedef basic_fstream<wchar_t>  wfstream;
-X   template <class state> class fpos;
-X   typedef fpos<char_traits<char>::state_type>    streampos;
-X   typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
-
-   27.3  Standard iostream objects                 [lib.iostream.objects]
-
-   Header <iostream> synopsis
-
-T  [must also include <istream> and <ostream>]
-T   extern istream cin;
-T   extern ostream cout;
-T   extern ostream cerr;
-T   extern ostream clog;
-
-T   extern wistream wcin;
-T   extern wostream wcout;
-T   extern wostream wcerr;
-T   extern wostream wclog;
-
-   27.4  Iostreams base classes                      [lib.iostreams.base]
-
-   Header <ios> synopsis
-
-   #include <iosfwd>
-
-T   typedef OFF_T  streamoff;
-T   typedef SZ_T streamsize;
-T   template <class stateT> class fpos;
-
-    class ios_base;
-    template <class charT, class traits = char_traits<charT> >
-      class basic_ios;
-   // _lib.std.ios.manip_, manipulators:
-T   ios_base& boolalpha  (ios_base& str);
-T   ios_base& noboolalpha(ios_base& str);
-T   ios_base& showbase   (ios_base& str);
-T   ios_base& noshowbase (ios_base& str);
-T   ios_base& showpoint  (ios_base& str);
-T   ios_base& noshowpoint(ios_base& str);
-T   ios_base& showpos    (ios_base& str);
-T   ios_base& noshowpos  (ios_base& str);
-T   ios_base& skipws     (ios_base& str);
-T   ios_base& noskipws   (ios_base& str);
-T   ios_base& nouppercase(ios_base& str);
-T   ios_base& uppercase  (ios_base& str);
-M   ios_base& unitbuf    (ios_base& str);
-M   ios_base& nounitbuf  (ios_base& str);
-   // _lib.adjustfield.manip_ adjustfield:
-T   ios_base& internal   (ios_base& str);
-T   ios_base& left       (ios_base& str);
-T   ios_base& right      (ios_base& str);
-   // _lib.basefield.manip_ basefield:
-T   ios_base& dec        (ios_base& str);
-T   ios_base& hex        (ios_base& str);
-T   ios_base& oct        (ios_base& str);
-
-   // _lib.floatfield.manip_ floatfield:
-T   ios_base& fixed      (ios_base& str);
-T   ios_base& scientific (ios_base& str);
-
-
-   27.4.2  Class ios_base                                  [lib.ios.base]
-
-T   class ios_base {
-    public:
-      class failure;
-T     typedef T1 fmtflags;
-T     static const fmtflags boolalpha;
-T     static const fmtflags dec;
-T     static const fmtflags fixed;
-T     static const fmtflags hex;
-T     static const fmtflags internal;
-T     static const fmtflags left;
-T     static const fmtflags oct;
-T     static const fmtflags right;
-T     static const fmtflags scientific;
-T     static const fmtflags showbase;
-T     static const fmtflags showpoint;
-T     static const fmtflags showpos;
-T     static const fmtflags skipws;
-X     static const fmtflags unitbuf;
-T     static const fmtflags uppercase;
-T     static const fmtflags adjustfield;
-T     static const fmtflags basefield;
-T     static const fmtflags floatfield;
-
-      typedef T2 iostate;
-T     static const iostate badbit;
-T     static const iostate eofbit;
-T     static const iostate failbit;
-T     static const iostate goodbit;
-T     typedef T3 openmode;
-T     static const openmode app;
-T     static const openmode ate;
-T     static const openmode binary;
-T     static const openmode in;
-T     static const openmode out;
-T     static const openmode trunc;
-T     typedef T4 seekdir;
-T     static const seekdir beg;
-T     static const seekdir cur;
-T     static const seekdir end;
-T     class Init;
-      // _lib.fmtflags.state_ fmtflags state:
-T     fmtflags flags() const;
-T     fmtflags flags(fmtflags fmtfl);
-T     fmtflags setf(fmtflags fmtfl);
-T     fmtflags setf(fmtflags fmtfl, fmtflags mask);
-T     void unsetf(fmtflags mask);
-T     streamsize precision() const;
-T     streamsize precision(streamsize prec);
-T     streamsize width() const;
-T     streamsize width(streamsize wide);
-      // _lib.ios.base.locales_ locales:
-T     locale imbue(const locale& loc);
-T     locale getloc() const;
-      // _lib.ios.base.storage_ storage:
-T     static int xalloc();
-T     long&  iword(int index);
-T     void*& pword(int index);
-      // destructor
-T     virtual ~ios_base();
-      // _lib.ios.base.callback_ callbacks;
-T     enum event { erase_event, imbue_event, copyfmt_event };
-T     typedef void (*event_callback)(event, ios_base&, int index);
-T     void register_callback(event_call_back fn, int index);
-T     static bool sync_with_stdio(bool sync = true);
-    protected:
-T     ios_base();
-    };
-
-   27.4.2.1.1  Class ios_base::failure                 [lib.ios::failure]
-
-T   class ios_base::failure : public exception {
-    public:
-T     explicit failure(const string& msg);
-T     virtual ~failure();
-T     virtual const char* what() const throw();
-    };
-
-
-   27.4.2.1.6  Class ios_base::Init                       [lib.ios::Init]
-
-T   class ios_base::Init {
-    public:
-T     Init();
-T    ~Init();
-    };
-
-
-   27.4.3  Template class fpos                                 [lib.fpos]
-
-X   template <class stateT> class fpos {
-    public:
-      // _lib.fpos.members_ Members
-T     stateT state() const;
-T     void state(stateT);
-    private;
-T     stateT st; // exposition only
-    };
-
-
-   27.4.5  Template class basic_ios                             [lib.ios]
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_ios : public ios_base {
-    public:
-
-      // Types:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-T     operator void*() const
-T     bool operator!() const
-T     iostate rdstate() const;
-T     void clear(iostate state = goodbit);
-T     void setstate(iostate state);
-T     bool good() const;
-T     bool eof()  const;
-T     bool fail() const;
-T     bool bad()  const;
-T     iostate exceptions() const;
-T     void exceptions(iostate except);
-      // _lib.basic.ios.cons_ Constructor/destructor:
-T     explicit basic_ios(basic_streambuf<charT,traits>* sb);
-T     virtual ~basic_ios();
-      // _lib.basic.ios.members_ Members:
-T     basic_ostream<charT,traits>* tie() const;
-T     basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
-T     basic_streambuf<charT,traits>* rdbuf() const;
-T     basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
-X     basic_ios& copyfmt(const basic_ios& rhs);
-T     char_type fill() const;
-T     char_type fill(char_type ch);
-      // _lib.ios.base.locales_ locales:
-T     locale imbue(const locale& loc);
-X     char     narrow(char_type c, char dfault) const;
-X     char_type widen(char c) const;
-    protected:
-      basic_ios();
-T     void init(basic_streambuf<charT,traits>* sb);
-   private:
-T     basic_ios(const basic_ios& );       // not defined
-T     basic_ios& operator=(const basic_ios&);     // not defined
-    };
-
-
-   27.5  Stream buffers                              [lib.stream.buffers]
-
-   Header <streambuf> synopsis
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_streambuf;
-T   typedef basic_streambuf<char>     streambuf;
-T   typedef basic_streambuf<wchar_t> wstreambuf;
-
-   27.5.2  Template class                                 [lib.streambuf]
-       basic_streambuf<charT,traits>
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_streambuf {
-    public:
-
-      // Types:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-T     virtual ~basic_streambuf();
-      // _lib.streambuf.locales_ locales:
-T     locale   pubimbue(const locale &loc);
-T     locale   getloc() const;
-      // _lib.streambuf.buffer_ buffer and positioning:
-T     basic_streambuf<char_type,traits>*
-               pubsetbuf(char_type* s, streamsize n);
-T     pos_type pubseekoff(off_type off, ios_base::seekdir way,
-                          ios_base::openmode which =
-                              ios_base::in | ios_base::out);
-T     pos_type pubseekpos(pos_type sp,
-                          ios_base::openmode which =
-                              ios_base::in | ios_base::out);
-T     int      pubsync();
-
-      // Get and put areas:
-      // _lib.streambuf.pub.get_ Get area:
-T     streamsize in_avail();
-T     int_type snextc();
-T     int_type sbumpc();
-T     int_type sgetc();
-T     streamsize sgetn(char_type* s, streamsize n);
-      // _lib.streambuf.pub.pback_ Putback:
-X     int_type sputbackc(char_type c);
-X     int_type sungetc();
-      // _lib.streambuf.pub.put_ Put area:
-T     int_type   sputc(char_type c);
-X     streamsize sputn(const char_type* s, streamsize n);
-    protected:
-T     basic_streambuf();
-      // _lib.streambuf.get.area_ Get area:
-T     char_type* eback() const;
-T     char_type* gptr()  const;
-T     char_type* egptr() const;
-T     void       gbump(int n);
-T     void       setg(char_type* gbeg, char_type* gnext, char_type* gend);
-      // _lib.streambuf.put.area_ Put area:
-T     char_type* pbase() const;
-T     char_type* pptr() const;
-T     char_type* epptr() const;
-T     void       pbump(int n);
-T     void       setp(char_type* pbeg, char_type* pend);
-      // _lib.streambuf.virtuals_ virtual functions:
-      // _lib.streambuf.virt.locales_ Locales:
-T     virtual void imbue(const locale &loc);
-      // _lib.streambuf.virt.buffer_ Buffer management and positioning:
-T     virtual basic_streambuf<char_type,traits>*
-                       setbuf(char_type* s, streamsize n);
-T     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                ios_base::openmode which = ios_base::in | ios_base::out);
-T     virtual pos_type seekpos(pos_type sp,
-                ios_base::openmode which = ios_base::in | ios_base::out);
-T     virtual int      sync();
-      // _lib.streambuf.virt.get_ Get area:
-T     virtual int        showmanyc();
-T     virtual streamsize xsgetn(char_type* s, streamsize n);
-T     virtual int_type   underflow();
-T     virtual int_type   uflow();
-      // _lib.streambuf.virt.pback_ Putback:
-T     virtual int_type   pbackfail(int_type c = traits::eof());
-      // _lib.streambuf.virt.put_ Put area:
-X     virtual streamsize xsputn(const char_type* s, streamsize n);
-T     virtual int_type   overflow (int_type c = traits::eof());
-    };
-
-   27.6  Formatting and manipulators                [lib.iostream.format]
-
-   Header <istream> synopsis
-
-T   template <class charT, class traits = char_traits<charT> >
-      class basic_istream;
-T   typedef basic_istream<char>     istream;
-T   typedef basic_istream<wchar_t> wistream;
-
-T   template <class charT, class traits = char_traits<charT> >
-      class basic_iostream;
-T   typedef basic_iostream<char>    iostream;
-T   typedef basic_iostream<wchar_t> wiostream;
-
-X   template <class charT, class traits>
-      basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
-
-   Header <ostream> synopsis
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ostream;
-T   typedef basic_ostream<char>     ostream;
-T   typedef basic_ostream<wchar_t> wostream;
-
-T   template <class charT, class traits>
-      basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
-T   template <class charT, class traits>
-      basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
-T   template <class charT, class traits>
-      basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
-
-   Header <iomanip> synopsis
-
-      // Types T1, T2, ... are unspecified implementation types
-T     T1 resetiosflags(ios_base::fmtflags mask);
-T     T2 setiosflags  (ios_base::fmtflags mask);
-T     T3 setbase(int base);
-T     template<charT> T4 setfill(charT c);
-T     T5 setprecision(int n);
-T     T6 setw(int n);
-
-
-   27.6.1.1  Template class basic_istream                   [lib.istream]
-
-    template <class charT, class traits = char_traits<charT> >
-T   class basic_istream : virtual public basic_ios<charT,traits> {
-    public:
-    // Types (inherited from basic_ios (_lib.ios_)):
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.istream.cons_ Constructor/destructor:
-T     explicit basic_istream(basic_streambuf<charT,traits>* sb);
-T     virtual ~basic_istream();
-      // _lib.istream::sentry_ Prefix/suffix:
-T     class sentry;
-
-      // _lib.istream.formatted_ Formatted input:
-T     basic_istream<charT,traits>& operator>>
-          (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
-T     basic_istream<charT,traits>& operator>>
-          (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
-T     basic_istream<charT,traits>& operator>>
-          (ios_base& (*pf)(ios_base&))
-S     basic_istream<charT,traits>& operator>>(bool& n);
-S     basic_istream<charT,traits>& operator>>(short& n);
-S     basic_istream<charT,traits>& operator>>(unsigned short& n);
-S     basic_istream<charT,traits>& operator>>(int& n);
-S     basic_istream<charT,traits>& operator>>(unsigned int& n);
-S     basic_istream<charT,traits>& operator>>(long& n);
-S     basic_istream<charT,traits>& operator>>(unsigned long& n);
-S     basic_istream<charT,traits>& operator>>(float& f);
-S     basic_istream<charT,traits>& operator>>(double& f);
-S     basic_istream<charT,traits>& operator>>(long double& f);
-S     basic_istream<charT,traits>& operator>>(void*& p);
-S     basic_istream<charT,traits>& operator>>
-          (basic_streambuf<char_type,traits>* sb);
-      // _lib.istream.unformatted_ Unformatted input:
-T     streamsize gcount() const;
-S     int_type get();
-S     basic_istream<charT,traits>& get(char_type& c);
-S     basic_istream<charT,traits>& get(char_type* s, streamsize n);
-S     basic_istream<charT,traits>& get(char_type* s, streamsize n,
-                        char_type delim);
-S     basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
-S     basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
-                        char_type delim);
-S     basic_istream<charT,traits>& getline(char_type* s, streamsize n);
-S     basic_istream<charT,traits>& getline(char_type* s, streamsize n,
-                        char_type delim);
-S     basic_istream<charT,traits>& ignore
-          (streamsize n = 1, int_type delim = traits::eof());
-S     int_type                     peek();
-S     basic_istream<charT,traits>& read    (char_type* s, streamsize n);
-S     streamsize                   readsome(char_type* s, streamsize n);
-S     basic_istream<charT,traits>& putback(char_type c);
-S     basic_istream<charT,traits>& unget();
-S     int sync();
-
-S     pos_type tellg();
-S     basic_istream<charT,traits>& seekg(pos_type);
-S     basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir);
-    };
-
-    // _lib.istream::extractors_ character extraction templates:
-S   template<class charT, class traits>
-      basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
-                                              charT&);
-S   template<class traits>
-      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                             unsigned char&);
-S   template<class traits>
-      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                             signed char&);
-
-S   template<class charT, class traits>
-      basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
-                                              charT*);
-S   template<class traits>
-      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                             unsigned char*);
-S   template<class traits>
-      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
-                                             signed char*);
-
-   27.6.1.1.2  Class basic_istream::sentry          [lib.istream::sentry]
-
-
-    template <class charT,class traits = char_traits<charT> >
-S   class basic_istream<charT,traits>::sentry {
-      typedef traits traits_type;
-S     bool ok_; // exposition only
-     public:
-S     explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
-S     ~sentry();
-S     operator bool() const { return ok_; }
-     private:
-T     sentry(const sentry&); //   not defined
-T     sentry& operator=(const sentry&); //   not defined
-    };
-
-
-   27.6.1.5  Template class basic_iostream            [lib.iostreamclass]
-
-    template <class charT, class traits = char_traits<charT> >
-T   class basic_iostream :
-      public basic_istream<charT,traits>,
-      public basic_ostream<charT,traits> {
-    public:
-      // constructor/destructor
-T     explicit basic_iostream(basic_streambuf<charT,traits>* sb);
-T     virtual ~basic_iostream();
-    };
-
-
-   27.6.2.1  Template class basic_ostream                   [lib.ostream]
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_ostream : virtual public basic_ios<charT,traits> {
-    public:
-    // Types (inherited from basic_ios (_lib.ios_)):
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ostream.cons_ Constructor/destructor:
-T     explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
-T     virtual ~basic_ostream();
-      // _lib.ostream::sentry_ Prefix/suffix:
-T     class sentry;
-      // _lib.ostream.formatted_ Formatted output:
-T     basic_ostream<charT,traits>& operator<<
-          (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
-T     basic_ostream<charT,traits>& operator<<
-          (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
-T     basic_ostream<charT,traits>& operator<<
-          (ios_base& (*pf)(ios_base&));
-T     basic_ostream<charT,traits>& operator<<(bool n);
-T     basic_ostream<charT,traits>& operator<<(short n);
-T     basic_ostream<charT,traits>& operator<<(unsigned short n);
-T     basic_ostream<charT,traits>& operator<<(int n);
-T     basic_ostream<charT,traits>& operator<<(unsigned int n);
-T     basic_ostream<charT,traits>& operator<<(long n);
-T     basic_ostream<charT,traits>& operator<<(unsigned long n);
-S     basic_ostream<charT,traits>& operator<<(float f);
-S     basic_ostream<charT,traits>& operator<<(double f);
-S     basic_ostream<charT,traits>& operator<<(long double f);
-T     basic_ostream<charT,traits>& operator<<(const void* p);
-X     basic_ostream<charT,traits>& operator<<
-          (basic_streambuf<char_type,traits>* sb);
-      // _lib.ostream.unformatted_ Unformatted output:
-T     basic_ostream<charT,traits>& put(char_type c);
-T     basic_ostream<charT,traits>& write(const char_type* s, streamsize n);
-X     basic_ostream<charT,traits>& flush();
-
-      // _lib.ostream.seeks_ seeks:
-S     pos_type tellp();
-S     basic_ostream<charT,traits>& seekp(pos_type);
-S     basic_ostream<charT,traits>& seekp(off_type, ios_base::seekdir);
-    };
-    // _lib.ostream.inserters.character_ character inserters
-X   template<class charT, class traits>
-    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                            charT);
-X   template<class charT, class traits>
-    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                            char);
-    // specialization
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             char);
-    // signed and unsigned
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             signed char);
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             unsigned char)
-X   template<class charT, class traits>
-      basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                              const charT*);
-X   template<class charT, class traits>
-      basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                              const char*);
-    // partial specializationss
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             const char*);
-    //  signed and unsigned
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             const signed char*);
-X   template<class traits>
-      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                             const unsigned char*);
-
-
-   27.6.2.3  Class basic_ostream::sentry            [lib.ostream::sentry]
-
-    template <class charT,class traits = char_traits<charT> >
-X   class basic_ostream<charT,traits>::sentry {
-      bool ok_; // exposition only
-     public:
-X     explicit sentry(basic_ostream<charT,traits>& os);
-X     ~sentry();
-X     operator bool() const { return ok_; }
-     private
-X     sentry(const sentry&); //   not defined
-X     sentry& operator=(const sentry&); //   not defined
-    };
-
-   27.7  String-based streams                        [lib.string.streams]
-
-   Header <sstream> synopsis
-
-X   template <class charT, class traits = char_traits<charT>,
-                      class Allocator = allocator<charT> >
-      class basic_stringbuf;
-
-T   typedef basic_stringbuf<char>     stringbuf;
-T   typedef basic_stringbuf<wchar_t> wstringbuf;
-
-    template <class charT, class traits = char_traits<charT>,
-                      class Allocator = allocator<charT> >
-X     class basic_istringstream;
-
-T   typedef basic_istringstream<char>     istringstream;
-T   typedef basic_istringstream<wchar_t> wistringstream;
-
-    template <class charT, class traits = char_traits<charT>,
-                      class Allocator = allocator<charT> >
-X     class basic_ostringstream;
-T   typedef basic_ostringstream<char>     ostringstream;
-T   typedef basic_ostringstream<wchar_t> wostringstream;
-
-    template <class charT, class traits = char_traits<charT>,
-                      class Allocator = allocator<charT> >
-X     class basic_stringstream;
-T   typedef basic_stringstream<char>     stringstream;
-T   typedef basic_stringstream<wchar_t> wstringstream;
-
-   27.7.1  Template class basic_stringbuf                 [lib.stringbuf]
-
-    template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-X   class basic_stringbuf : public basic_streambuf<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.stringbuf.cons_ Constructors:
-S     explicit basic_stringbuf(ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-S     explicit basic_stringbuf
-          (const basic_string<charT,traits,Allocator>& str,
-           ios_base::openmode which = ios_base::in | ios_base::out);
-      // _lib.stringbuf.members_ Get and set:
-S     basic_string<charT,traits,Allocator> str() const;
-S     void               str(const basic_string<charT,traits,Allocator>& s);
-
-    protected:
-      // _lib.stringbuf.virtuals_ Overridden virtual functions:
-S     virtual int_type   underflow();
-S     virtual int_type   pbackfail(int_type c = traits::eof());
-S     virtual int_type   overflow (int_type c = traits::eof());
-S     virtual  basic_streambuf<charT,traits>* setbuf(charT*, streamsize);
-
-S     virtual pos_type   seekoff(off_type off, ios_base::seekdir way,
-                                 ios_base::openmode which
-                                  = ios_base::in | ios_base::out);
-S     virtual pos_type   seekpos(pos_type sp,
-                                 ios_base::openmode which
-                                  = ios_base::in | ios_base::out);
-    };
-
-
-   27.7.2  Template class basic_istringstream         [lib.istringstream]
-
-    template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-X   class basic_istringstream : public basic_istream<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.istringstream.cons_ Constructors:
-S     explicit basic_istringstream(ios_base::openmode which = ios_base::in);
-S     explicit basic_istringstream(
-                         const basic_string<charT,traits,Allocator>& str,
-                         ios_base::openmode which = ios_base::in);
-
-      // _lib.istringstream.members_ Members:
-S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
-S     basic_string<charT,traits,Allocator> str() const;
-S     void str(const basic_string<charT,traits,Allocator>& s);
-   private:
-   //  basic_stringbuf<charT,traits,Allocator> sb;   exposition only
-    };
-
-   27.7.3  Class basic_ostringstream                  [lib.ostringstream]
-
-    template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-X   class basic_ostringstream : public basic_ostream<charT,traits> {
-    public:
-
-      // Types:
-T     typedef charT            char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-      // _lib.ostringstream.cons_ Constructors/destructor:
-S     explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
-S     explicit basic_ostringstream(
-                           const basic_string<charT,traits,Allocator>& str,
-                           ios_base::openmode which = ios_base::out);
-      // _lib.ostringstream.members_ Members:
-S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
-S     basic_string<charT,traits,Allocator> str() const;
-S     void    str(const basic_string<charT,traits,Allocator>& s);
-    };
-
-
-   27.7.4  Template class basic_stringstream           [lib.stringstream]
-
-    template <class charT, class traits = char_traits<charT>,
-              class Allocator = allocator<charT> >
-X   class basic_stringstream
-      : public basic_iostream<charT,traits> {
-    public:
-      // Types
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-      // constructors/destructors
-S     explicit basic_stringstream(
-          ios_base::openmode which = ios_base::out|ios_base::in);
-S     explicit basic_stringstream(
-          const basic_string<charT,traits,Allocator>& str,
-          ios_base::openmode which = ios_base::out|ios_base::in);
-      // Members:
-S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
-S     basic_string<charT,traits,Allocator> str() const;
-S     void str(const basic_string<charT,traits,Allocator>& str);
-    };
-
-
-
-   27.8.1  File streams                                    [lib.fstreams]
-
-
-   Header <fstream> synopsis
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_filebuf;
-T   typedef basic_filebuf<char>    filebuf;
-T   typedef basic_filebuf<wchar_t> wfilebuf;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ifstream;
-T   typedef basic_ifstream<char>    ifstream;
-T   typedef basic_ifstream<wchar_t> wifstream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_ofstream;
-T   typedef basic_ofstream<char>    ofstream;
-T   typedef basic_ofstream<wchar_t> wofstream;
-
-X   template <class charT, class traits = char_traits<charT> >
-      class basic_fstream;
-T   typedef basic_fstream<char>     fstream;
-T   typedef basic_fstream<wchar_t> wfstream;
-
-   27.8.1.1  Template class basic_filebuf                   [lib.filebuf]
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_filebuf : public basic_streambuf<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.filebuf.cons_ Constructors/destructor:
-X     basic_filebuf();
-X     virtual ~basic_filebuf();
-       // _lib.filebuf.members_ Members:
-T     bool is_open() const;
-X     basic_filebuf<charT,traits>* open
-          (const char* s, ios_base::openmode mode);
-X     basic_filebuf<charT,traits>* close();
-    protected:
-      // _lib.filebuf.virtuals_ Overridden virtual functions:
-X     virtual streamsize showmanyc();
-X     virtual int_type underflow();
-X     virtual int_type uflow();
-X     virtual int_type pbackfail(int_type c = traits::eof());
-X     virtual int_type overflow (int_type c = traits::eof());
-S     virtual basic_streambuf<charT,traits>*
-                       setbuf(char_type* s, streamsize n);
-S     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                               ios_base::openmode which
-                                 = ios_base::in | ios_base::out);
-S     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
-                                 = ios_base::in | ios_base::out);
-S     virtual int      sync();
-S     virtual void     imbue(const locale& loc);
-    };
-
-
-
-   27.8.1.5  Template class basic_ifstream                 [lib.ifstream]
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_ifstream : public basic_istream<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ifstream.cons_ Constructors:
-S     basic_ifstream();
-S     explicit basic_ifstream(const char* s,
-                              ios_base::openmode mode = ios_base::in);
-      // _lib.ifstream.members_ Members:
-S     basic_filebuf<charT,traits>* rdbuf() const;
-S     bool is_open();
-S     void open(const char* s, ios_base::openmode mode = ios_base::in);
-S     void close();
-    };
-
-
-   27.8.1.8  Template class basic_ofstream                 [lib.ofstream]
-
-    template <class charT, class traits = char_traits<charT> >
-X   class basic_ofstream : public basic_ostream<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ofstream.cons_ Constructors:
-X     basic_ofstream();
-X     explicit basic_ofstream(const char* s,
-                              ios_base::openmode mode
-                                = ios_base::out);
-      // _lib.ofstream.members_ Members:
-X     basic_filebuf<charT,traits>* rdbuf() const;
-T     bool is_open();
-X     void open(const char* s, ios_base::openmode mode = ios_base::out);
-X     void close();
-    };
-
-
-   27.8.1.11  Template class basic_fstream                  [lib.fstream]
-
-    template <class charT, class traits=char_traits<charT> >
-X   class basic_fstream
-      : public basic_iostream<charT,traits> {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // constructors/destructor
-S     basic_fstream();
-S     explicit basic_fstream(
-          const char* s,
-          ios_base::openmode mode = ios_base::in|ios_base::out);
-
-      // Members:
-S     basic_filebuf<charT,traits>* rdbuf() const;
-S     bool is_open();
-S     void open(
-          const char* s,
-          ios_base::openmode mode = ios_base::in|ios_base::out);
-S     void close();
-    };
-
-
-
-   27.8.2  C Library files                                  [lib.c.files]
-
-
-                    Table 13--Header <cstdio> synopsis
-    Macros:
-X   BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX
-X   EOF            NULL <cstdio>   stderr     _IOFBF
-X   FILENAME_MAX   SEEK_CUR        stdin      _IOLBF
-X   FOPEN_MAX      SEEK_END        stdout     _IONBF
-
-X   Types:         FILE            fpos_t     size_t <cstdio>
-    Functions:
-X   clearerr       fgets           fscanf     gets     rewind
-X   fclose         fopen           fseek      perror   scanf     tmpnam
-X   feof           fprintf         fsetpos    printf   setbuf    ungetc
-X   ferror         fputc           ftell      putc     setvbuf   vprintf
-X   fflush         fputs           fwrite     puts     sprintf   vfprintf
-X   fgetc          fread           getc       remove   sscanf    vsprintf
-X   fgetpos        freopen         getchar    putchar  rename    tmpfile
-
-
-
-
-   1.5  Standard C library headers                       [depr.c.headers]
-
-X     <assert.h>   <iso646.h>   <setjmp.h>   <stdio.h>    <wchar.h>
-      <ctype.h>    <limits.h>   <signal.h>   <stdlib.h>   <wctype.h>
-      <errno.h>    <locale.h>   <stdarg.h>   <string.h>
-      <float.h>    <math.h>     <stddef.h>   <time.h>
-
-   1.6  Old iostreams members                          [depr.ios.members]
-
-   [Note: these should be #ifdef'd to permit diagnostics if used.]
-   namespace std {
-    class ios_base {
-    public:
-T     typedef T1  io_state;
-T     typedef T2 open_mode;
-T     typedef T3  seek_dir;
-T     typedef OFF_T  streamoff;
-T     typedef OFF_T  streampos;
-      // remainder unchanged
-    };
-   }
-
-   [Note: these should be #ifdef'd to permit diagnostics if used.]
-   namespace std {
-    template<class charT, class traits = char_traits<charT> >
-    class basic_streambuf {
-    public:
-T     void stossc();
-      // remainder unchanged
-    };
-   }
-
-   8 An implementation may provide  the  following  member  functions  that
-   overload signatures specified in clause _lib.iostreams_:
-
-   [Note: the following overloads should be #ifdef'd to permit
-    diagnostics to be emitted, by default, if used.]
-
-    template<class charT, class Traits> class basic_ios {
-    public:
-M     void clear(io_state state);
-M     void setstate(io_state state);
-      // remainder unchanged
-    };
-    class ios_base {
-    public:
-M     void exceptions(io_state);
-      // remainder unchanged
-    };
-    template<class charT, class traits = char_traits<charT> >
-    class basic_streambuf {
-    public:
-M     pos_type pubseekoff(off_type off, ios_base::seek_dir way,
-                ios_base::open_mode which = ios_base::in | ios_base::out);
-M     pos_type pubseekpos(pos_type sp,
-                ios_base::open_mode which = ios_base::in | ios_base::out);
-      // remainder unchanged
-    };
-    template <class charT, class traits = char_traits<charT> >
-    class basic_filebuf : public basic_streambuf<charT,traits> {
-    public:
-M     basic_filebuf<charT,traits>* open
-          (const char* s, ios_base::open_mode mode);
-      // remainder unchanged
-    };
-    template <class charT, class traits = char_traits<charT> >
-    class basic_ifstream : public basic_istream<charT,traits> {
-    public:
-M     void open(const char* s, ios_base::open_mode mode = in);
-      // remainder unchanged
-    };
-    template <class charT, class traits = char_traits<charT> >
-    class basic_ofstream : public basic_ostream<charT,traits> {
-    public:
-M     void open(const char* s, ios_base::open_mode mode = out | trunc);
-      // remainder unchanged
-    };
-   }
-
-
-
-   1.7.1  Class strstreambuf                          [depr.strstreambuf]
-
-   [Note: It should be possible to adopt these components with only
-    minor changes from the 2.8 version of the library.]
-
-M   class strstreambuf : public basic_streambuf<char> {
-    public:
-M     explicit strstreambuf(streamsize alsize_arg = 0);
-M     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
-M     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
-M     strstreambuf(const char* gnext_arg, streamsize n);
-M     strstreambuf(signed char* gnext_arg, streamsize n,
-                   signed char* pbeg_arg = 0);
-M     strstreambuf(const signed char* gnext_arg, streamsize n);
-M     strstreambuf(unsigned char* gnext_arg, streamsize n,
-                   unsigned char* pbeg_arg = 0);
-M     strstreambuf(const unsigned char* gnext_arg, streamsize n);
-M     virtual ~strstreambuf();
-M     void  freeze(bool freezefl = true);
-M     char* str();
-M     int   pcount();
-    protected:
-M     virtual int_type overflow (int_type c = EOF);
-M     virtual int_type pbackfail(int_type c = EOF);
-M     virtual int_type underflow();
-M     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                               ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-M     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-M     virtual streambuf<char>* setbuf(char* s, streamsize n);
-   }
-
-   1.7.4  Class strstream                                [depr.strstream]
-
-M   class strstream
-      : public basic_iostream<char> {
-    public:
-      // Types
-M     typedef char                                char_type;
-M     typedef typename char_traits<char>::int_type int_type
-M     typedef typename char_traits<char>::pos_type pos_type;
-M     typedef typename char_traits<char>::off_type off_type;
-      // consturctors/destructor
-M     strstream();
-M     strstream(char* s, int n,
-                ios_base::openmode mode = ios_base::in|ios_base::out);
-M     virtual ~strstream();
-      // Members:
-M     strstreambuf* rdbuf() const;
-M     void freeze(bool freezefl = true);
-M     int pcount() const;
-M     char* str();
-    };
-

Implementation Specific Behavior

- The ISO standard defines the following phrase: -

- [1.3.5] implementation-defined behavior -

- Behavior, for a well-formed program construct and correct data, that - depends on the implementation and that each implementation - shall document. -

- 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. Everything listed - in Annex B, Implementation Qualities, are also part of the - compiler, not the library. -

- For each entry, we give the section number of the standard, when - applicable. This list is probably incomplet and inkorrekt. -

- [1.9]/11 #3 If isatty(3) is true, then - interactive stream support is implied. -

- [17.4.4.5] Non-reentrant functions are probably best - discussed in the various sections on multithreading (see above). -

[18.1]/4 The type of NULL is described - here. -

[18.3]/8 Even though it's listed in the library - sections, libstdc++ has zero control over what the cleanup code hands - back to the runtime loader. Talk to the compiler people. :-) -

[18.4.2.1]/5 (bad_alloc), - [18.5.2]/5 (bad_cast), - [18.5.3]/5 (bad_typeid), - [18.6.1]/8 (exception), - [18.6.2.1]/5 (bad_exception): The what() - member function of class std::exception, and these other - classes publicly derived from it, simply returns the name of the - class. But they are the mangled names; you will need to call - c++filt and pass the names as command-line parameters to - demangle them, or call a - runtime demangler function. - (The classes in <stdexcept> have constructors which - require an argument to use later for what() calls, so the - problem of what()'s value does not arise in most - user-defined exceptions.) -

[18.5.1]/7 The return value of - std::type_info::name() is the mangled type name (see the - previous entry for more). -

[20.1.5]/5 "Implementors are encouraged to - supply libraries that can accept allocators that encapsulate more - general memory models and that support non-equal instances. In such - implementations, any requirements imposed on allocators by containers - beyond those requirements that appear in Table 32, and the semantics - of containers and algorithms when allocator instances compare - non-equal, are implementation-defined." As yet we don't - have any allocators which compare non-equal, so we can't describe how - they behave. -

[21.1.3.1]/3,4, - [21.1.3.2]/2, - [23.*]'s foo::iterator, - [27.*]'s foo::*_type, - others... - Nope, these types are called implementation-defined because you - shouldn't be taking advantage of their underlying types. Listing them - here would defeat the purpose. :-) -

[21.1.3.1]/5 I don't really know about the mbstate_t - stuff... see the chapter 22 notes - for what does exist. -

[22.*] Anything and everything we have on locale - implementation will be described - over here. -

[26.2.8]/9 I have no idea what - complex<T>'s pow(0,0) returns. -

[27.4.2.4]/2 Calling - std::ios_base::sync_with_stdio after I/O has already been - performed on the standard stream objects will - flush the buffers, and - destroy and recreate the underlying buffer instances. Whether or not - the previously-written I/O is destroyed in this process depends mostly - on the --enable-libio choice: for stdio, if the written data is - already in the stdio buffer, the data may be completely safe! -

[27.6.1.1.2], - [27.6.2.3] The I/O sentry ctor and dtor can perform - additional work than the minimum required. We are not currently taking - advantage of this yet. -

[27.7.1.3]/16, - [27.8.1.4]/10 - The effects of pubsetbuf/setbuf are described - in this chapter. -

[27.8.1.4]/16 Calling fstream::sync when - a get area exists will... whatever fflush() does, I think. -

C++ TR1

-This table is based on the table of contents of ISO/IEC DTR 19768 -Doc No: N1836=05-0096 Date: 2005-06-24 -Draft Technical Report on C++ Library Extensions -

-In this implementation the header names are prefixed by -tr1/, for instance <tr1/functional>, -<tr1/memory>, and so on. -

-This page describes the TR1 support in mainline GCC SVN, not in any particular -release. -

Table 1.1. C++ TR1 Implementation Status

SectionDescriptionDoneBrokenMissingComments
2General Utilities
2.1Reference wrappersdone   
2.1.1Additions to header <functional> synopsisdone   
2.1.2Class template reference_wrapperdone   
2.1.2.1reference_wrapper construct/copy/destroydone   
2.1.2.2reference_wrapper assignmentdone   
2.1.2.3reference_wrapper accessdone   
2.1.2.4reference_wrapper invocationdone   
2.1.2.5reference_wrapper helper functionsdone   
2.2Smart pointersdone   
2.2.1Additions to header <memory> synopsisdone   
2.2.2Class bad_weak_ptrdone   
2.2.3Class template shared_ptrdone  See Footnotes
2.2.3.1shared_ptr constructorsdone   
2.2.3.2shared_ptr destructordone   
2.2.3.3shared_ptr assignmentdone   
2.2.3.4shared_ptr modifiersdone   
2.2.3.5shared_ptr observersdone   
2.2.3.6shared_ptr comparisondone   
2.2.3.7shared_ptr I/Odone   
2.2.3.8shared_ptr specialized algorithmsdone   
2.2.3.9shared_ptr castsdone   
2.2.3.10get_deleterdone   
2.2.4Class template weak_ptrdone   
2.2.4.1weak_ptr constructorsdone   
2.2.4.2weak_ptr destructordone   
2.2.4.3weak_ptr assignmentdone   
2.2.4.4weak_ptr modifiersdone   
2.2.4.5weak_ptr observersdone   
2.2.4.6weak_ptr comparisondone   
2.2.4.7weak_ptr specialized algorithmsdone   
2.2.5Class template enable_shared_from_thisdone   
3Function Objects
3.1Definitionsdone   
3.2Additions to <functional> synopsisdone   
3.3Requirementsdone   
3.4Function return typesdone   
3.5Function template mem_fndone   
3.6Function object bindersdone   
3.6.1Class template is_bind_expressiondone   
3.6.2Class template is_placeholderdone   
3.6.3Function template binddone   
3.6.4Placeholdersdone   
3.7Polymorphic function wrappersdone   
3.7.1Class bad_function_calldone   
3.7.1.1bad_function_call constructordone   
3.7.2Class template functiondone   
3.7.2.1function construct/copy/destroydone   
3.7.2.2function modifiersdone   
3.7.2.3function capacitydone   
3.7.2.4function invocationdone   
3.7.2.5function target accessdone   
3.7.2.6undefined operatorsdone   
3.7.2.7null pointer comparison operatorsdone   
3.7.2.8specialized algorithmsdone   
4Metaprogramming and type traits
4.1Requirementsdone   
4.2Header <type_traits> synopsisdone   
4.3Helper classesdone   
4.4General Requirementsdone   
4.5Unary Type Traitsdone   
4.5.1Primary Type Categoriesdone   
4.5.2Composite type traitsdone   
4.5.3Type propertiesdone   
4.6Relationships between typesdone   
4.7Transformations between typesdone   
4.7.1Const-volatile modificationsdone   
4.7.2Reference modificationsdone   
4.7.3Array modificationsdone   
4.7.4Pointer modificationsdone   
4.8Other transformationsdone   
4.9Implementation requirementsdone   
5Numerical Facilities
5.1Random number generationdone   
5.1.1Requirementsdone   
5.1.2Header <random> synopsisdone   
5.1.3Class template variate_generatordone   
5.1.4Random number engine class templatesdone   
5.1.4.1Class template linear_congruentialdone   
5.1.4.2Class template mersenne_twisterdone   
5.1.4.3Class template subtract_with_carrydone   
5.1.4.4Class template subtract_with_carry_01done   
5.1.4.5Class template discard_blockdone   
5.1.4.6Class template xor_combinedone  operator()() per N2079
5.1.5Engines with predefined parametersdone   
5.1.6Class random_devicedone   
5.1.7Random distribution class templatesdone   
5.1.7.1Class template uniform_intdone   
5.1.7.2Class bernoulli_distributiondone   
5.1.7.3Class template geometric_distributiondone   
5.1.7.4Class template poisson_distributiondone   
5.1.7.5Class template binomial_distributiondone   
5.1.7.6Class template uniform_realdone   
5.1.7.7Class template exponential_distributiondone   
5.1.7.8Class template normal_distributiondone   
5.1.7.9Class template gamma_distributiondone   
5.2Mathematical special functionsdone   
5.2.1Additions to header <cmath> synopsisdone   
5.2.1.1associated Laguerre polynomialsdone   
5.2.1.2associated Legendre functionsdone   
5.2.1.3beta functiondone   
5.2.1.4(complete) elliptic integral of the first kinddone   
5.2.1.5(complete) elliptic integral of the second kinddone   
5.2.1.6(complete) elliptic integral of the third kinddone   
5.2.1.7confluent hypergeometric functionsdone   
5.2.1.8regular modified cylindrical Bessel functionsdone   
5.2.1.9cylindrical Bessel functions (of the first kind)done   
5.2.1.10irregular modified cylindrical Bessel functionsdone   
5.2.1.11cylindrical Neumann functionsdone   
5.2.1.12(incomplete) elliptic integral of the first kinddone   
5.2.1.13(incomplete) elliptic integral of the second kinddone   
5.2.1.14(incomplete) elliptic integral of the third kinddone   
5.2.1.15exponential integraldone   
5.2.1.16Hermite polynomialsdone   
5.2.1.17hypergeometric functionsdone   
5.2.1.18Laguerre polynomialsdone   
5.2.1.19Legendre polynomialsdone   
5.2.1.20Riemann zeta functiondone   
5.2.1.21spherical Bessel functions (of the first kind)done   
5.2.1.22spherical associated Legendre functionsdone   
5.2.1.23spherical Neumann functionsdone   
5.2.2Additions to header <math.h> synopsisdone   
6Containers
6.1Tuple typesdone   
6.1.1Header <tuple> synopsisdone   
6.1.2Additions to header <utility> synopsisdone   
6.1.3Class template tupledone   
6.1.3.1Constructiondone   
6.1.3.2Tuple creation functionsdone   
6.1.3.3Tuple helper classesdone   
6.1.3.4Element accessdone   
6.1.3.5Relational operatorsdone   
6.1.4Pairsdone   
6.2Fixed size arraydone   
6.2.1Header <array> synopsisdone   
6.2.2Class template arraydone   
6.2.2.1array constructors, copy, and assignmentdone   
6.2.2.2array specialized algorithmsdone   
6.2.2.3array sizedone   
6.2.2.4Zero sized arraysdone   
6.2.2.5Tuple interface to class template arraydone   
6.3Unordered associative containersdone   
6.3.1Unordered associative container requirementsdone   
6.3.1.1Exception safety guaranteesdone   
6.3.2Additions to header <functional> synopsisdone   
6.3.3Class template hashdone   
6.3.4Unordered associative container classesdone   
6.3.4.1Header <unordered_set> synopsisdone   
6.3.4.2Header <unordered_map> synopsisdone   
6.3.4.3Class template unordered_setdone   
6.3.4.3.1unordered_set constructorsdone   
6.3.4.3.2unordered_set swapdone   
6.3.4.4Class template unordered_mapdone   
6.3.4.4.1unordered_map constructorsdone   
6.3.4.4.2unordered_map element accessdone   
6.3.4.4.3unordered_map swapdone   
6.3.4.5Class template unordered_multisetdone   
6.3.4.5.1unordered_multiset constructorsdone   
6.3.4.5.2unordered_multiset swapdone   
6.3.4.6Class template unordered_multimapdone   
6.3.4.6.1unordered_multimap constructorsdone   
6.3.4.6.2unordered_multimap swapdone   
7Regular Expressions
7.1Definitions  missing 
7.2Requirements  missing 
7.3Regular expressions summary  missing 
7.4Header <regex> synopsis  missing 
7.5Namespace tr1::regex_constants  missing 
7.5.1Bitmask Type syntax_option_type  missing 
7.5.2Bitmask Type regex_constants::match_flag_type  missing 
7.5.3Implementation defined error_type  missing 
7.6Class regex_error  missing 
7.7Class template regex_traits  missing 
7.8Class template basic_regex  missing 
7.8.1basic_regex constants  missing 
7.8.2basic_regex constructors  missing 
7.8.3basic_regex assign  missing 
7.8.4basic_regex constant operations  missing 
7.8.5basic_regex locale  missing 
7.8.6basic_regex swap  missing 
7.8.7basic_regex non-member functions  missing 
7.8.7.1basic_regex non-member swap  missing 
7.9Class template sub_match  missing 
7.9.1sub_match members  missing 
7.9.2sub_match non-member operators  missing 
7.10Class template match_results  missing 
7.10.1match_results constructors  missing 
7.10.2match_results size  missing 
7.10.3match_results element access  missing 
7.10.4match_results formatting  missing 
7.10.5match_results allocator  missing 
7.10.6match_results swap  missing 
7.11Regular expression algorithms  missing 
7.11.1exceptions  missing 
7.11.2regex_match  missing 
7.11.3regex_search  missing 
7.11.4regex_replace  missing 
7.12Regular expression Iterators  missing 
7.12.1Class template regex_iterator  missing 
7.12.1.1regex_iterator constructors  missing 
7.12.1.2regex_iterator comparisons  missing 
7.12.1.3regex_iterator dereference  missing 
7.12.1.4regex_iterator increment  missing 
7.12.2Class template regex_token_iterator  missing 
7.12.2.1regex_token_iterator constructors  missing 
7.12.2.2regex_token_iterator comparisons  missing 
7.12.2.3regex_token_iterator dereference  missing 
7.12.2.4regex_token_iterator increment  missing 
7.13Modified ECMAScript regular expression grammar  missing 
8C Compatibility
8.1Additions to header <complex>done   
8.1.1Synopsisdone   
8.1.2Function acosdone   
8.1.3Function asindone   
8.1.4Function atandone   
8.1.5Function acoshdone   
8.1.6Function asinhdone   
8.1.7Function atanhdone   
8.1.8Function fabsdone   
8.1.9Additional Overloadsdone   
8.2Header <ccomplex>  missingDR 551
8.3Header <complex.h>  missingDR 551
8.4Additions to header <cctype>done   
8.4.1Synopsisdone   
8.4.2Function isblankdone   
8.5Additions to header <ctype.h>done   
8.6Header <cfenv>done   
8.6.1Synopsisdone   
8.6.2Definitionsdone   
8.7Header <fenv.h>done   
8.8Additions to header <cfloat>done   
8.9Additions to header <float.h>done   
8.10Additions to header <ios>  missing 
8.10.1Synopsis  missing 
8.10.2Function hexfloat  missing 
8.11Header <cinttypes>done   
8.11.1Synopsisdone  DR 557
8.11.2Definitionsdone   
8.12Header <inttypes.h>done   
8.13Additions to header <climits>done   
8.14Additions to header <limits.h>done   
8.15Additions to header <locale>  missing 
8.16Additions to header <cmath>done   
8.16.1Synopsisdone   
8.16.2Definitionsdone   
8.16.3Function template definitionsdone   
8.16.4Additional overloadsdone  DR 568; DR 550
8.17Additions to header <math.h>done   
8.18Additions to header <cstdarg>done   
8.19Additions to header <stdarg.h>done   
8.20The header <cstdbool>done   
8.21The header <stdbool.h>done   
8.22The header <cstdint>done   
8.22.1Synopsisdone   
8.22.2Definitionsdone   
8.23The header <stdint.h>done   
8.24Additions to header <cstdio>done   
8.24.1Synopsisdone   
8.24.2Definitionsdone   
8.24.3Additional format specifiersdone  C library responsibility
8.24.4Additions to header <stdio.h>done   
8.25Additions to header <cstdlib>done   
8.25.1Synopsisdone   
8.25.2Definitionsdone   
8.25.3Function absdone   
8.25.4Function divdone   
8.26Additions to header <stdlib.h>done   
8.27Header <ctgmath>done  DR 551
8.28Header <tgmath.h>done  DR 551
8.29Additions to header <ctime>done  C library responsibility
8.30Additions to header <cwchar>done   
8.30.1Synopsisdone   
8.30.2Definitionsdone   
8.30.3Additional wide format specifiersdone  C library responsibility
8.31Additions to header <wchar.h>done   
8.32Additions to header <cwctype>done   
8.32.1Synopsisdone   
8.32.2Function iswblankdone   
8.33Additions to header <wctype.h>done   

-Footnotes -

- The shared_ptr implementation uses some code from the - Boost - shared_ptr library. -

C++ 200x

-This table is based on the table of contents of ISO/IEC -Doc No: N2461=07-0331 Date: 2007-10-22 -Working Draft, Standard for Programming Language C++ -

-In this implementation -std=gnu++0x or --std=c++0x flags must be used to enable language and -library features. The pre-defined symbol -__GXX_EXPERIMENTAL_CXX0X__ is used to check for the -presence of the required flag. -

-This page describes the C++0x support in mainline GCC SVN, not in any -particular release. -

Table 1.2. C++ 200x Implementation Status

SectionDescriptionDoneBrokenMissingComments
20General Utilities
20.2Utility Components  incomplete 
20.2.1Operators  partial 
20.2.2forward/move helpers  partial 
20.2.3Pairsdone   
20.3Header <tuple> synopsisdone   
20.3.1Class template tupledone   
20.3.1.1Constructiondone   
20.3.1.2Tuple creation functionsdone   
20.3.1.3Tuple helper classesdone   
20.3.1.4Element accessdone   
20.3.1.5Relational operatorsdone   
20.4Metaprogramming and type traits
20.4.1Requirementsdone   
20.4.2Header <type_traits> synopsisdone   
20.4.3Helper classesdone   
20.4.4General Requirementsdone   
20.4.5Unary Type Traitsdone   
20.4.5.1Primary Type Categoriesdone   
20.4.5.2Composite type traitsdone   
20.4.5.3Type propertiesdone   
20.4.6Relationships between typesdone   
20.4.7Transformations between typesdone   
20.4.7.1Const-volatile modificationsdone   
20.4.7.2Reference modificationsdone   
20.4.7.3Array modificationsdone   
20.4.7.4Pointer modificationsdone   
20.4.8Other transformationsdone   
20.4.9Implementation requirementsdone   
20.5 Function Objectsdone   
20.5Additions to header <functional> synopsisdone   
20.5.1Definitionsdone   
20.5.2Requirementsdone   
20.5.3Basedone   
20.5.4Function return typesdone   
20.5.5Class template reference_wrapperdone   
20.5.5.1reference_wrapper construct/copy/destroydone   
20.5.5.2reference_wrapper assignmentdone   
20.5.5.3reference_wrapper accessdone   
20.5.5.4reference_wrapper invocationdone   
20.5.5.5reference_wrapper helper functionsdone   
20.5.14Function template mem_fndone   
20.5.11Template function binddone   
20.5.11.1Function object bindersdone   
20.5.11.1.1Class template is_bind_expressiondone   
20.5.11.1.2Class template is_placeholderdone   
20.5.11.1.3Function template binddone   
20.5.11.1.4Placeholdersdone   
20.5.15Polymorphic function wrappersdone   
20.5.15.1Class bad_function_calldone   
20.5.15.1.1bad_function_call constructordone   
20.5.15.2Class template functiondone   
20.5.15.2.1function construct/copy/destroydone   
20.5.15.2.2function modifiersdone   
20.5.15.2.3function capacitydone   
20.5.15.2.4function invocationdone   
20.5.15.2.5function target accessdone   
20.5.15.2.7null pointer comparison operatorsdone   
20.5.15.2.8specialized algorithmsdone   
20.5.16Class template hashdone   
20.6Additions to header <memory> synopsis  partialmissing unique_ptr
20.6.5Class template unique_ptr  missing 
20.6.6Smart pointersdone   
20.6.6.1Class bad_weak_ptrdone   
20.6.6.2Class template shared_ptrdone  See Footnotes.
20.6.6.2.1shared_ptr constructorsdone   
20.6.6.2.2shared_ptr destructordone   
20.6.6.2.3shared_ptr assignmentdone   
20.6.6.2.4shared_ptr modifiersdone   
20.6.6.2.5shared_ptr observersdone   
20.6.6.2.6shared_ptr creationdone   - N2351 -
20.6.6.2.7shared_ptr comparisondone   
20.6.6.2.8shared_ptr I/Odone   
20.6.6.2.9shared_ptr specialized algorithmsdone   
20.6.6.2.10shared_ptr castsdone   
20.6.6.2.11get_deleterdone   
20.6.6.3Class template weak_ptrdone   
20.6.6.3.1weak_ptr constructorsdone   
20.6.6.3.2weak_ptr destructordone   
20.6.6.3.3weak_ptr assignmentdone   
20.6.6.3.4weak_ptr modifiersdone   
20.6.6.3.5weak_ptr observersdone   
20.6.6.3.6weak_ptr comparisondone   
20.6.6.3.7weak_ptr specialized algorithmsdone   
20.6.6.4Class template enable_shared_from_thisdone   
23Containers
23.2.1Header <array> synopsisdone   
23.2.1Class template arraydone   
23.2.1.1array constructors, copy, and assignmentdone   
23.2.1.2array specialized algorithmsdone   
23.2.1.3array sizedone   
23.2.1.4array datadone   
23.2.1.5Zero sized arraysdone   
23.2.1.6Tuple interface to class template arraydone   
23.4Unordered associative containersdone   
23.4.1Class template unordered_mapdone   
23.4.1.1unordered_map constructorsdone   
23.4.1.2unordered_map element accessdone   
23.4.1.3unordered_map swapdone   
23.4.2Class template unordered_multimapdone   
23.4.2.1unordered_multimap constructorsdone   
23.4.2.2unordered_multimap swapdone   
23.4.3Class template unordered_setdone   
23.4.3.1unordered_set constructorsdone   
23.4.3.2unordered_set swapdone   
23.4.4Class template unordered_multisetdone   
23.4.4.1unordered_multiset constructorsdone   
23.4.4.2unordered_multiset swapdone   
26Numerics
26.4Random number generationdone   
26.4.1Requirementsdone   
26.4.2Header <random> synopsis  partial 
26.4.3Random number engine class templatesdone   
26.4.3.1Class template linear_congruential_enginedone   
26.4.3.2Class template mersenne_twister_enginedone   
26.4.3.3Class template subtract_with_carry_enginedone   
26.4.4Random number engine adaptor class templatesdone   
26.4.4.1Class template discard_block_enginedone   
26.4.4.2Class template independent_bits_enginedone   
26.4.4.3Class template shuffle_order_enginedone   
26.4.4.4Class template xor_combine_enginedone  operator()() per N2079
26.4.5Engines and engine adaptors with predefined parametersdone   
26.4.6Class random_devicedone   
26.4.7Utilitiesdone   
26.4.7.1Class seed_seq  missing 
26.4.7.2Function template generate_canonical  missing 
26.4.8Random number generation class templatesdone   
26.4.8.1Uniform distributions  partial 
26.4.8.1Class template uniform_int_distribution  missing 
26.4.8.1Class template uniform_real_distribution  missing 
26.4.8.2Bernoulli distributions  partial 
26.4.8.2.1Class bernoulli_distributiondone   
26.4.8.2.2Class template binomial_distributiondone   
26.4.8.2.3Class template geometric_distributiondone   
26.4.8.2.4Class template negative_binomial_distribution  missing 
26.4.8.3Poisson distributions  partial 
26.4.8.3.1Class template poisson_distributiondone   
26.4.8.3.2Class template exponential_distributiondone   
26.4.8.3.3Class template gamma_distributiondone   
26.4.8.3.4Class template weibull_distribution  missing 
26.4.8.3.5Class template extreme_value_distribution  missing 
26.4.8.4Normal distributions  partial 
26.4.8.4.1Class template normal_distributiondone   
26.4.8.4.2Class template lognormal_distribution  missing 
26.4.8.4.3Class template chi_squared_distribution  missing 
26.4.8.4.4Class template cauchy_distribution  missing 
26.4.8.4.5Class template fisher_f_distribution  missing 
26.4.8.4.6Class template student_t_distribution  missing 
26.4.8.5Sampling distributions  missing 
26.4.8.5.1Class template discrete_distribution  missing 
26.4.8.5.1Class template piecewise_constant_distribution  missing 
26.4.8.5.1Class template general_pdf_distribution  missing 
28Regular Expressions
28.1Definitions  missing 
28.2Requirements  missing 
28.3Regular expressions summary  missing 
28.4Header <regex> synopsis  missing 
28.5Namespace tr1::regex_constants  missing 
28.5.1Bitmask Type syntax_option_type  missing 
28.5.2Bitmask Type regex_constants::match_flag_type  missing 
28.5.3Implementation defined error_type  missing 
28.6Class regex_error  missing 
28.7Class template regex_traits  missing 
28.8Class template basic_regex  missing 
28.8.1basic_regex constants  missing 
28.8.2basic_regex constructors  missing 
28.8.3basic_regex assign  missing 
28.8.4basic_regex constant operations  missing 
28.8.5basic_regex locale  missing 
28.8.6basic_regex swap  missing 
28.8.7basic_regex non-member functions  missing 
28.8.7.1basic_regex non-member swap  missing 
28.9Class template sub_match  missing 
28.9.1sub_match members  missing 
28.9.2sub_match non-member operators  missing 
28.10Class template match_results  missing 
28.10.1match_results constructors  missing 
28.10.2match_results size  missing 
28.10.3match_results element access  missing 
28.10.4match_results formatting  missing 
28.10.5match_results allocator  missing 
28.10.6match_results swap  missing 
28.11Regular expression algorithms  missing 
28.11.1exceptions  missing 
28.11.2regex_match  missing 
28.11.3regex_search  missing 
28.11.4regex_replace  missing 
28.12Regular expression Iterators  missing 
28.12.1Class template regex_iterator  missing 
28.12.1.1regex_iterator constructors  missing 
28.12.1.2regex_iterator comparisons  missing 
28.12.1.3regex_iterator dereference  missing 
28.12.1.4regex_iterator increment  missing 
28.12.2Class template regex_token_iterator  missing 
28.12.2.1regex_token_iterator constructors  missing 
28.12.2.2regex_token_iterator comparisons  missing 
28.12.2.3regex_token_iterator dereference  missing 
28.12.2.4regex_token_iterator increment  missing 
28.13Modified ECMAScript regular expression grammar  missing 
CC Compatibility
C2.1Additions to header <complex>done   
C2.1.1Synopsisdone   
C2.1.2Function acosdone   
C2.1.3Function asindone   
C2.1.4Function atandone   
C2.1.5Function acoshdone   
C2.1.6Function asinhdone   
C2.1.7Function atanhdone   
C2.1.8Function fabsdone   
C2.1.9Additional Overloadsdone   
C2.2Header <ccomplex>  missingDR 551
C2.3Header <complex.h>  missingDR 551
C2.4Additions to header <cctype>done   
C2.4.1Synopsisdone   
C2.4.2Function isblankdone   
C2.5Additions to header <ctype.h>done   
C2.6Header <cfenv>done   
C2.6.1Synopsisdone   
C2.6.2Definitionsdone   
C2.7Header <fenv.h>done   
C2.8Additions to header <cfloat>done   
C2.9Additions to header <float.h>done   
C2.10Additions to header <ios>  missing 
C2.10.1Synopsis  missing 
C2.10.2Function hexfloat  missing 
C2.11Header <cinttypes>done   
C2.11.1Synopsisdone  DR 557
C2.11.2Definitionsdone   
C2.12Header <inttypes.h>done   
C2.13Additions to header <climits>done   
C2.14Additions to header <limits.h>done   
C2.15Additions to header <locale>  missing 
C2.16Additions to header <cmath>done   
C2.16.1Synopsisdone   
C2.16.2Definitionsdone   
C2.16.3Function template definitionsdone   
C2.16.4Additional overloadsdone  DR 568; DR 550
C2.17Additions to header <math.h>done   
C2.18Additions to header <cstdarg>done   
C2.19Additions to header <stdarg.h>done   
C2.20The header <cstdbool>done   
C2.21The header <stdbool.h>done   
C2.22The header <cstdint>done   
C2.22.1Synopsisdone   
C2.22.2Definitionsdone   
C2.23The header <stdint.h>done   
C2.24Additions to header <cstdio>done   
C2.24.1Synopsisdone   
C2.24.2Definitionsdone   
C2.24.3Additional format specifiersdone  C library responsibility
C2.24.4Additions to header <stdio.h>done   
C2.25Additions to header <cstdlib>done   
C2.25.1Synopsisdone   
C2.25.2Definitionsdone   
C2.25.3Function absdone   
C2.25.4Function divdone   
C2.26Additions to header <stdlib.h>done   
C2.27Header <ctgmath>done  DR 551
C2.28Header <tgmath.h>done  DR 551
C2.29Additions to header <ctime>done  C library responsibility
C2.30Additions to header <cwchar>done   
C2.30.1Synopsisdone   
C2.30.2Definitionsdone   
C2.30.3Additional wide format specifiersdone  C library responsibility
C2.31Additions to header <wchar.h>done   
C2.32Additions to header <cwctype>done   
C2.32.1Synopsisdone   
C2.32.2Function iswblankdone   
C2.33Additions to header <wctype.h>done   
DCompatibility Features
D.6Old iostream membersdone   
D.8Bindersdone  33911
D.9Class template auto_ptrdone  33911

-Footnotes -

- The shared_ptr implementation uses some code from the - Boost - shared_ptr library. -

Prev Up Next
Part I. Introduction Home License
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch01s02.html b/libstdc++-v3/doc/html/manual/bk01pt01ch01s02.html deleted file mode 100644 index efdbda2cb172..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch01s02.html +++ /dev/null @@ -1,40 +0,0 @@ - - -License
License
Prev Chapter 1. Status Next

License

- There are two licenses affecting GNU libstdc++: one for the code, - and one for the documentation. -

- There is a license section in the FAQ regarding common questions. If you have more - questions, ask the FSF or the gcc mailing list. -

The Code: GPL

- The source code is distributed under the GNU General Public License version 2, - with the so-called “Runtime Exception” - as follows (or see any header or implementation file): -


-      As a special exception, you may use this file as part of a free software
-      library without restriction.  Specifically, if other files instantiate
-      templates or use macros or inline functions from this file, or you compile
-      this file and link it with other files to produce an executable, this
-      file does not by itself cause the resulting executable to be covered by
-      the GNU General Public License.  This exception does not however
-      invalidate any other reasons why the executable file might be covered by
-      the GNU General Public License.
-    

- Hopefully that text is self-explanatory. If it isn't, you need to speak - to your lawyer, or the Free Software Foundation. -

The Documentation: GPL, FDL

- The documentation shipped with the library and made available over - the web, excluding the pages generated from source comments, are - copyrighted by the Free Software Foundation, and placed under the - GNU Free Documentation - License version 1.2. There are no Front-Cover Texts, no - Back-Cover Texts, and no Invariant Sections. -

- For documentation generated by doxygen or other automated tools - via processing source code comments and markup, the original source - code license applies to the generated files. Thus, the doxygen - documents are licensed GPL. -

- If you plan on making copies of the documentation, please let us know. - We can probably offer suggestions. -

Prev Up Next
Chapter 1. Status Home Bugs
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch01s03.html b/libstdc++-v3/doc/html/manual/bk01pt01ch01s03.html deleted file mode 100644 index d8ecde5fd114..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch01s03.html +++ /dev/null @@ -1,330 +0,0 @@ - - -Bugs
Bugs
Prev Chapter 1. Status Next

Bugs

Implementation Bugs

- Information on known bugs, details on efforts to fix them, and - fixed bugs are all available as part of the GCC bug tracking - system, bugzilla, with the - category set to libstdc++. -

Standard Bugs

- Everybody's got issues. Even the C++ Standard Library. -

- The Library Working Group, or LWG, is the ISO subcommittee responsible - for making changes to the library. They periodically publish an - Issues List containing problems and possible solutions. As they reach - a consensus on proposed solutions, we often incorporate the solution. -

- Here are the issues which have resulted in code changes to the library. - The links are to the specific defect reports from a partial - copy of the Issues List. You can read the full version online - at the ISO C++ - Committee homepage, linked to on the - GCC "Readings" - page. If - you spend a lot of time reading the issues, we recommend downloading - the ZIP file and reading them locally. -

- (NB: partial copy means that not all - links within the lwg-*.html pages will work. Specifically, - links to defect reports that have not been accorded full DR - status will probably break. Rather than trying to mirror the - entire issues list on our overworked web server, we recommend - you go to the LWG homepage instead.) -

- If a DR is not listed here, we may simply not have gotten to - it yet; feel free to submit a patch. Search the include/bits - and src directories for appearances of - _GLIBCXX_RESOLVE_LIB_DEFECTS for examples - of style. Note that we usually do not make changes to the - code until an issue has reached DR status. -

5: - string::compare specification questionable -

This should be two overloaded functions rather than a single function. -

17: - Bad bool parsing -

Apparently extracting Boolean values was messed up... -

19: - "Noconv" definition too vague -

If codecvt::do_in returns noconv there are - no changes to the values in [to, to_limit). -

22: - Member open vs flags -

Re-opening a file stream does not clear the state flags. -

23: - Num_get overflow result -

Implement the proposed resolution. -

25: - String operator<< uses width() value wrong -

Padding issues. -

48: - Use of non-existent exception constructor -

An instance of ios_base::failure is constructed instead. -

49: - Underspecification of ios_base::sync_with_stdio -

The return type is the previous state of synchronization. -

50: - Copy constructor and assignment operator of ios_base -

These members functions are declared private and are - thus inaccessible. Specifying the correct semantics of - "copying stream state" was deemed too complicated. -

60: - What is a formatted input function? -

This DR made many widespread changes to basic_istream - and basic_ostream all of which have been implemented. -

63: - Exception-handling policy for unformatted output -

Make the policy consistent with that of formatted input, unformatted - input, and formatted output. -

68: - Extractors for char* should store null at end -

And they do now. An editing glitch in the last item in the list of - [27.6.1.2.3]/7. -

74: - Garbled text for codecvt::do_max_length -

The text of the standard was gibberish. Typos gone rampant. -

75: - Contradiction in codecvt::length's argument types -

Change the first parameter to stateT& and implement - the new effects paragraph. -

83: - string::npos vs. string::max_size() -

Safety checks on the size of the string should test against - max_size() rather than npos. -

90: - Incorrect description of operator>> for strings -

The effect contain isspace(c,getloc()) which must be - replaced by isspace(c,is.getloc()). -

91: - Description of operator>> and getline() for string<> - might cause endless loop -

They behave as a formatted input function and as an unformatted - input function, respectively (except that getline is - not required to set gcount). -

103: - set::iterator is required to be modifiable, but this allows - modification of keys. -

For associative containers where the value type is the same as - the key type, both iterator and const_iterator - are constant iterators. -

109: - Missing binders for non-const sequence elements -

The binder1st and binder2nd didn't have an - operator() taking a non-const parameter. -

110: - istreambuf_iterator::equal not const -

This was not a const member function. Note that the DR says to - replace the function with a const one; we have instead provided an - overloaded version with identical contents. -

117: - basic_ostream uses nonexistent num_put member functions -

num_put::put() was overloaded on the wrong types. -

118: - basic_istream uses nonexistent num_get member functions -

Same as 117, but for num_get::get(). -

129: - Need error indication from seekp() and seekg() -

These functions set failbit on error now. -

136: - seekp, seekg setting wrong streams? -

seekp should only set the output stream, and - seekg should only set the input stream. -

167: - Improper use of traits_type::length() -

op<< with a const char* was - calculating an incorrect number of characters to write. -

169: - Bad efficiency of overflow() mandated -

Grow efficiently the internal array object. -

171: - Strange seekpos() semantics due to joint position -

Quite complex to summarize... -

181: - make_pair() unintended behavior -

This function used to take its arguments as reference-to-const, now - it copies them (pass by value). -

195: - Should basic_istream::sentry's constructor ever set eofbit? -

Yes, it can, specifically if EOF is reached while skipping whitespace. -

211: - operator>>(istream&, string&) doesn't set failbit -

If nothing is extracted into the string, op>> now - sets failbit (which can cause an exception, etc., etc.). -

214: - set::find() missing const overload -

Both set and multiset were missing - overloaded find, lower_bound, upper_bound, and equal_range functions - for const instances. -

231: - Precision in iostream? -

For conversion from a floating-point type, str.precision() - is specified in the conversion specification. -

233: - Insertion hints in associative containers -

Implement N1780, first check before then check after, insert as close - to hint as possible. -

235: - No specification of default ctor for reverse_iterator -

The declaration of reverse_iterator lists a default constructor. - However, no specification is given what this constructor should do. -

241: - Does unique_copy() require CopyConstructible and Assignable? -

Add a helper for forward_iterator/output_iterator, fix the existing - one for input_iterator/output_iterator to not rely on Assignability. -

243: - get and getline when sentry reports failure -

Store a null character only if the character array has a non-zero size. -

251: - basic_stringbuf missing allocator_type -

This nested typedef was originally not specified. -

253: - valarray helper functions are almost entirely useless -

Make the copy constructor and copy-assignment operator declarations - public in gslice_array, indirect_array, mask_array, slice_array; provide - definitions. -

265: - std::pair::pair() effects overly restrictive -

The default ctor would build its members from copies of temporaries; - now it simply uses their respective default ctors. -

266: - bad_exception::~bad_exception() missing Effects clause -

The bad_* classes no longer have destructors (they - are trivial), since no description of them was ever given. -

271: - basic_iostream missing typedefs -

The typedefs it inherits from its base classes can't be used, since - (for example) basic_iostream<T>::traits_type is ambiguous. -

275: - Wrong type in num_get::get() overloads -

Similar to 118. -

280: - Comparison of reverse_iterator to const reverse_iterator -

Add global functions with two template parameters. - (NB: not added for now a templated assignment operator) -

292: - Effects of a.copyfmt (a) -

If (this == &rhs) do nothing. -

300: - List::merge() specification incomplete -

If (this == &x) do nothing. -

303: - Bitset input operator underspecified -

Basically, compare the input character to - is.widen(0) and is.widen(1). -

305: - Default behavior of codecvt<wchar_t, char, - mbstate_t>::length() -

Do not specify what codecvt<wchar_t, char, - mbstate_t>::do_length must return. -

328: - Bad sprintf format modifier in - money_put<>::do_put() -

Change the format string to "%.0Lf". -

365: - Lack of const-qualification in clause 27 -

Add const overloads of is_open. -

387: - std::complex over-encapsulated -

Add the real(T) and imag(T) - members; in C++0x mode, also adjust the existing - real() and imag() members and - free functions. -

389: - Const overload of valarray::operator[] returns - by value -

Change it to return a const T&. -

396: - what are characters zero and one -

Implement the proposed resolution. -

402: - Wrong new expression in [some_]allocator::construct -

Replace "new" with "::new". -

409: - Closing an fstream should clear the error state -

Have open clear the error flags. -

431: - Swapping containers with unequal allocators -

Implement Option 3, as per N1599. -

432: - stringbuf::overflow() makes only one write position - available -

Implement the resolution, beyond DR 169. -

434: - bitset::to_string() hard to use -

Add three overloads, taking fewer template arguments. -

438: - Ambiguity in the "do the right thing" clause -

Implement the resolution, basically cast less. -

453: - basic_stringbuf::seekoff need not always fail for an empty stream -

Don't fail if the next pointer is null and newoff is zero. -

455: - cerr::tie() and wcerr::tie() are overspecified -

Initialize cerr tied to cout and wcerr tied to wcout. -

464: - Suggestion for new member functions in standard containers -

Add data() to std::vector and - at(const key_type&) to std::map. -

508: - Bad parameters for ranlux64_base_01 -

Fix the parameters. -

512: - Seeding subtract_with_carry_01 from a single unsigned long -

Construct a linear_congruential engine and seed with it. -

526: - Is it undefined if a function in the standard changes in - parameters? -

Use &value. -

538: - 241 again: Does unique_copy() require CopyConstructible - and Assignable? -

In case of input_iterator/output_iterator rely on Assignability of - input_iterator' value_type. -

541: - shared_ptr template assignment and void -

Add an auto_ptr<void> specialization. -

543: - valarray slice default constructor -

Follow the straightforward proposed resolution. -

550: - What should the return type of pow(float,int) be? -

In C++0x mode, remove the pow(float,int), etc., signatures. -

586: - string inserter not a formatted function -

Change it to be a formatted output function (i.e. catch exceptions). -

596: - 27.8.1.3 Table 112 omits "a+" and "a+b" modes -

Add the missing modes to fopen_mode. -

660: - Missing bitwise operations -

Add the missing operations. -

691: - const_local_iterator cbegin, cend missing from TR1 -

In C++0x mode add cbegin(size_type) and cend(size_type) - to the unordered containers. -

693: - std::bitset::all() missing -

Add it, consistently with the discussion. -

695: - ctype<char>::classic_table() not accessible -

Make the member functions table and classic_table public. -

761: - unordered_map needs an at() member function -

In C++0x mode, add at() and at() const. -

775: - Tuple indexing should be unsigned? -

Implement the int -> size_t replacements. -

776: - Undescribed assign function of std::array -

In C++0x mode, remove assign, add fill. -

781: - std::complex should add missing C99 functions -

In C++0x mode, add std::proj. -

809: - std::swap should be overloaded for array types -

Add the overload. -

844: - complex pow return type is ambiguous -

In C++0x mode, remove the pow(complex<T>, int) signature. -

853: - to_string needs updating with zero and one -

Update / add the signatures. -

Prev Up Next
License Home Chapter 2. Setup
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch02.html b/libstdc++-v3/doc/html/manual/bk01pt01ch02.html deleted file mode 100644 index b6738731ea61..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch02.html +++ /dev/null @@ -1,98 +0,0 @@ - - -Chapter 2. Setup
Chapter 2. Setup
Prev Part I. Introduction Next

Chapter 2. Setup

Table of Contents

Prerequisites
Configure
Make
Test
Organization
Running the Testsuite
Writing a new test case
Test Harness and Utilities

To transform libstdc++ sources into installed include files - and properly built binaries useful for linking to other software is - a multi-step process. Steps include getting the sources, - configuring and building the sources, testing, and installation. -

The general outline of commands is something like: - 

-   get gcc sources
-   extract into gccsrcdir
-   mkdir gccbuilddir
-   cd gccbuilddir
-   gccsrcdir/configure --prefix=destdir --other-opts...
-   make
-   make check
-   make install
-

- Each step is described in more detail in the following sections. -

Prerequisites

- Because libstdc++ is part of GCC, the primary source for - installation instructions is - the GCC install page. - In particular, list of prerequisite software needed to build the library - - starts with those requirements. The same pages also list - the tools you will need if you wish to modify the source. -

- Additional data is given here only where it applies to libstdc++. -

As of GCC 4.0.1 the minimum version of binutils required to build - libstdc++ is 2.15.90.0.1.1. You can get snapshots - (as well as releases) of binutils from - - ftp://sources.redhat.com/pub/binutils. - Older releases of libstdc++ do not require such a recent version, - but to take full advantage of useful space-saving features and - bug-fixes you should use a recent binutils whenever possible. - The configure process will automatically detect and use these - features if the underlying support is present. -

- Finally, a few system-specific requirements: -

linux

- If gcc 3.1.0 or later on is being used on linux, an attempt - will be made to use "C" library functionality necessary for - C++ named locale support. For gcc 3.2.1 and later, this - means that glibc 2.2.5 or later is required and the "C" - library de_DE locale information must be installed. -

- Note however that the sanity checks involving the de_DE - locale are skipped when an explicit --enable-clocale=gnu - configure option is used: only the basic checks are carried - out, defending against misconfigurations. -

- If the 'gnu' locale model is being used, the following - locales are used and tested in the libstdc++ testsuites. - The first column is the name of the locale, the second is - the character set it is expected to use. - 

-de_DE               ISO-8859-1
-de_DE@euro          ISO-8859-15
-en_HK               ISO-8859-1
-en_PH               ISO-8859-1
-en_US               ISO-8859-1
-en_US.ISO-8859-1    ISO-8859-1
-en_US.ISO-8859-15   ISO-8859-15
-en_US.UTF-8         UTF-8
-es_ES               ISO-8859-1
-es_MX               ISO-8859-1
-fr_FR               ISO-8859-1
-fr_FR@euro          ISO-8859-15
-is_IS               UTF-8
-it_IT               ISO-8859-1
-ja_JP.eucjp         EUC-JP
-se_NO.UTF-8         UTF-8
-ta_IN               UTF-8
-zh_TW               BIG5
-

Failure to have the underlying "C" library locale - information installed will mean that C++ named locales for the - above regions will not work: because of this, the libstdc++ - testsuite will skip the named locale tests. If this isn't an - issue, don't worry about it. If named locales are needed, the - underlying locale information must be installed. Note that - rebuilding libstdc++ after the "C" locales are installed is not - necessary. -

- To install support for locales, do only one of the following: -

  • install all locales

    • with RedHat Linux: -

      export LC_ALL=C -

      rpm -e glibc-common --nodeps -

      - rpm -i --define "_install_langs all" - glibc-common-2.2.5-34.i386.rpm - -

    • - Instructions for other operating systems solicited. -

  • install just the necessary locales

    • with Debian Linux:

      Add the above list, as shown, to the file - /etc/locale.gen

      run /usr/sbin/locale-gen

    • on most Unix-like operating systems:

      localedef -i de_DE -f ISO-8859-1 de_DE

      (repeat for each entry in the above list)

    • - Instructions for other operating systems solicited. -

Prev Up Next
Bugs Home Configure
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch02s03.html b/libstdc++-v3/doc/html/manual/bk01pt01ch02s03.html deleted file mode 100644 index 51d0c8c99d18..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch02s03.html +++ /dev/null @@ -1,9 +0,0 @@ - - -Make
Make
Prev Chapter 2. Setup Next

Make

If you have never done this before, you should read the basic - GCC Installation - Instructions first. Read all of them. - Twice. -

Then type:make, and congratulations, you're -started to build. -

Prev Up Next
Configure Home Test
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch03s02.html b/libstdc++-v3/doc/html/manual/bk01pt01ch03s02.html deleted file mode 100644 index 537a34b31710..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch03s02.html +++ /dev/null @@ -1,101 +0,0 @@ - - -Headers
Headers
Prev Chapter 3. Using Next

Headers

Header Files

- The C++ standard specifies the entire set of header files that - must be available to all hosted implementations. Actually, the - word "files" is a misnomer, since the contents of the - headers don't necessarily have to be in any kind of external - file. The only rule is that when one #include's a - header, the contents of that header become available, no matter - how. -

- That said, in practice files are used. -

- There are two main types of include files: header files related - to a specific version of the ISO C++ standard (called Standard - Headers), and all others (TR1, C++ ABI, and Extensions). -

- Two dialects of standard headers are supported, corresponding to - the 1998 standard as updated for 2003, and the draft of the - upcoming 200x standard. -

- C++98/03 include files. These are available in the default compilation mode, i.e. -std=c++98 or -std=gnu++98. -

Table 3.1. C++ 1998 Library Headers

algorithmbitsetcomplexdequeexception
fstreamfunctionaliomanipiosiosfwd
iostreamistreamiteratorlimitslist
localemapmemorynewnumeric
ostreamqueuesetsstreamstack
stdexceptstreambufstringutilitytypeinfo
valarrayvector   

Table 3.2. C++ 1998 Library Headers for C Library Facilities

cassertcerrnocctypecfloatciso646
climitsclocalecmathcsetjmpcsignal
cstdargcstddefcstdiocstdlibcstring
ctimecwcharcwctype  

-C++0x include files. These are only available in C++0x compilation -mode, i.e. -std=c++0x or -std=gnu++0x. -

Table 3.3. C++ 200x Library Headers

algorithmarraybitsetchronocomplex
condition_variabledequeexceptionforward_listfstream
functionalinitalizer_listiomanipiosiosfwd
iostreamistreamiteratorlimitslist
localemapmemorymutexnew
numericostreamqueuerandomratio
regexsetsstreamstackstdexcept
streambufstringsystem_errorthreadtuple
type_traitstypeinfounordered_mapunordered_setutility
valarrayvector   

Table 3.4. C++ 200x Library Headers for C Library Facilities

cassertccomplexcctypecerrnocfenv
cfloatcinttypesciso646climitsclocale
cmathcsetjmpcsignalcstdargcstdatomic
cstdboolcstddefcstdintcstdlibcstdio
cstringctgmathctimecucharcwchar
cwctypestdatomic.h   

- In addition, TR1 includes as: -

Table 3.5. C++ TR1 Library Headers

tr1/arraytr1/complextr1/memorytr1/functionaltr1/random
tr1/regextr1/tupletr1/type_traitstr1/unordered_maptr1/unordered_set
tr1/utility    

Table 3.6. C++ TR1 Library Headers for C Library Facilities

tr1/ccomplextr1/cfenvtr1/cfloattr1/cmathtr1/cinttypes
tr1/climitstr1/cstdargtr1/cstdbooltr1/cstdinttr1/cstdio
tr1/cstdlibtr1/ctgmathtr1/ctimetr1/cwchartr1/cwctype

- Also included are files for the C++ ABI interface: -

Table 3.7. C++ ABI Headers

cxxabi.hcxxabi_forced.h

- And a large variety of extensions. -

Table 3.8. Extension Headers

ext/algorithmext/atomicity.hext/array_allocator.hext/bitmap_allocator.hext/cast.h
ext/codecvt_specializations.hext/concurrence.hext/debug_allocator.hext/enc_filebuf.hext/extptr_allocator.h
ext/functionalext/iteratorext/malloc_allocator.hext/memoryext/mt_allocator.h
ext/new_allocator.hext/numericext/numeric_traits.hext/pb_ds/assoc_container.hext/pb_ds/priority_queue.h
ext/pod_char_traits.hext/pool_allocator.hext/rb_treeext/ropeext/slist
ext/stdio_filebuf.hext/stdio_sync_filebuf.hext/throw_allocator.hext/typelist.hext/type_traits.h
ext/vstring.h    

Table 3.9. Extension Debug Headers

debug/bitsetdebug/dequedebug/listdebug/mapdebug/set
debug/stringdebug/unordered_mapdebug/unordered_setdebug/vector 

Table 3.10. Extension Parallel Headers

parallel/algorithmparallel/numeric

Mixing Headers

A few simple rules. -

First, mixing different dialects of the standard headers is not -possible. It's an all-or-nothing affair. Thus, code like -

-#include <array>
-#include <functional>
-

Implies C++0x mode. To use the entities in <array>, the C++0x -compilation mode must be used, which implies the C++0x functionality -(and deprecations) in <functional> will be present. -

Second, the other headers can be included with either dialect of -the standard headers, although features and types specific to C++0x -are still only enabled when in C++0x compilation mode. So, to use -rvalue references with __gnu_cxx::vstring, or to use the -debug-mode versions of std::unordered_map, one must use -the std=gnu++0x compiler flag. (Or std=c++0x, of course.) -

A special case of the second rule is the mixing of TR1 and C++0x -facilities. It is possible (although not especially prudent) to -include both the TR1 version and the C++0x version of header in the -same translation unit: -

-#include <tr1/type_traits>
-#include <type_traits>
-

Several parts of C++0x diverge quite substantially from TR1 predecessors. -

The C Headers and namespace std

- The standard specifies that if one includes the C-style header - (<math.h> in this case), the symbols will be available - in the global namespace and perhaps in - namespace std:: (but this is no longer a firm - requirement.) One the other hand, including the C++-style - header (<cmath>) guarantees that the entities will be - found in namespace std and perhaps in the global namespace. -

-Usage of C++-style headers is recommended, as then -C-linkage names can be disambiguated by explicit qualification, such -as by std::abort. In addition, the C++-style headers can -use function overloading to provide a simpler interface to certain -families of C-functions. For instance in <cmath>, the -function std::sin has overloads for all the builtin -floating-point types. This means that std::sin can be -used uniformly, instead of a combination -of std::sinf, std::sin, -and std::sinl. -

Precompiled Headers

There are three base header files that are provided. They can be -used to precompile the standard headers and extensions into binary -files that may the be used to speed compiles that use these headers. -

  • stdc++.h

    Includes all standard headers. Actual content varies depending on -language dialect. -

  • stdtr1c++.h

    Includes all of <stdc++.h>, and adds all the TR1 headers. -

  • extc++.h

    Includes all of <stdtr1c++.h>, and adds all the Extension headers. -

How to construct a .gch file from one of these base header files.

First, find the include directory for the compiler. One way to do -this is:

-g++ -v hello.cc
-
-#include <...> search starts here:
- /mnt/share/bld/H-x86-gcc.20071201/include/c++/4.3.0
-...
-End of search list.
-

Then, create a precompiled header file with the same flags that -will be used to compile other projects.

-g++ -Winvalid-pch -x c++-header -g -O2 -o ./stdc++.h.gch /mnt/share/bld/H-x86-gcc.20071201/include/c++/4.3.0/x86_64-unknown-linux-gnu/bits/stdc++.h
-

The resulting file will be quite large: the current size is around -thirty megabytes.

How to use the resulting file.

-g++ -I. -include stdc++.h  -H -g -O2 hello.cc 
-

Verification that the PCH file is being used is easy:

-g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe
-! ./stdc++.h.gch
-. /mnt/share/bld/H-x86-gcc.20071201/include/c++/4.3.0/iostream
-. /mnt/share/bld/H-x86-gcc.20071201include/c++/4.3.0/string
-

The exclamation point to the left of the stdc++.h.gch listing means that the generated PCH file was used, and thus the

Detailed information about creating precompiled header files can be found in the GCC documentation. -

Prev Up Next
Chapter 3. Using Home Namespaces
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch03s03.html b/libstdc++-v3/doc/html/manual/bk01pt01ch03s03.html deleted file mode 100644 index 2250ea69fec9..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch03s03.html +++ /dev/null @@ -1,61 +0,0 @@ - - -Namespaces
Namespaces
Prev Chapter 3. Using Next

Namespaces

Available Namespaces

There are three main namespaces. -

  • std

    The ISO C++ standards specify that "all library entities are defined -within namespace std." This includes namespaces nested -within namespace std, such as namespace -std::tr1. -

  • abi

    Specified by the C++ ABI. This ABI specifies a number of type and -function APIs supplemental to those required by the ISO C++ Standard, -but necessary for interoperability. -

  • __gnu_

    Indicating one of several GNU extensions. Choices -include __gnu_cxx, __gnu_debug, __gnu_parallel, -and __gnu_pbds. -

A complete list of implementation namespaces (including namespace contents) is available in the generated source documentation. -

namespace std

- One standard requirement is that the library components are defined - in namespace std::. Thus, in order to use these types or - functions, one must do one of two things: -

  • put a kind of using-declaration in your source -(either using namespace std; or i.e. using -std::string;) This approach works well for individual source files, but -should not be used in a global context, like header files. -

  • use a fully -qualified namefor each library symbol -(i.e. std::string, std::cout) Always can be -used, and usually enhanced, by strategic use of typedefs. (In the -cases where the qualified verbiage becomes unwieldy.) -

Using Namespace Composition

-Best practice in programming suggests sequestering new data or -functionality in a sanely-named, unique namespace whenever -possible. This is considered an advantage over dumping everything in -the global namespace, as then name look-up can be explicitly enabled or -disabled as above, symbols are consistently mangled without repetitive -naming prefixes or macros, etc. -

For instance, consider a project that defines most of its classes in namespace gtk. It is possible to - adapt namespace gtk to namespace std by using a C++-feature called - namespace composition. This is what happens if - a using-declaration is put into a - namespace-definition: the imported symbol(s) gets imported into the - currently active namespace(s). For example: -

-namespace gtk 
-{
-  using std::string;
-  using std::tr1::array;
-
-  class Window { ... };
-}
-

- In this example, std::string gets imported into - namespace gtk. The result is that use of - std::string inside namespace gtk can just use string, without the explicit qualification. - As an added bonus, - std::string does not get imported into - the global namespace. Additionally, a more elaborate arrangement can be made for backwards compatibility and portability, whereby the - using-declarations can wrapped in macros that - are set based on autoconf-tests to either "" or i.e. using - std::string; (depending on whether the system has - libstdc++ in std:: or not). (ideas from - , Karl Nelson ) -

Prev Up Next
Headers Home Macros
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch03s04.html b/libstdc++-v3/doc/html/manual/bk01pt01ch03s04.html deleted file mode 100644 index 3d839e9afe3f..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch03s04.html +++ /dev/null @@ -1,70 +0,0 @@ - - -Macros
Macros
Prev Chapter 3. Using Next

Macros

All pre-processor switches and configurations are all gathered - in the file c++config.h, which is generated during - the libstdc++ configuration and build process, and included by - files part of the public libstdc++ API. Most of these macros - should not be used by consumers of libstdc++, and are reserved - for internal implementation use. These macros cannot be - redefined. However, a select handful of these macro - control libstdc++ extensions and extra features, or provide - versioning information for the API, and are able to be used. -

All library macros begin with _GLIBCXX_ (except for - versions 3.1.x to 3.3.x, which use _GLIBCPP_). -

Below is the macro which users may check for library version - information.

__GLIBCXX__

The current version of - libstdc++ in compressed ISO date format, form of an unsigned - long. For details on the value of this particular macro for a - particular release, please consult this - document. -

Below are the macros which users may change with #define/#undef or - with -D/-U compiler flags. The default state of the symbol is - listed.

“Configurable” (or “Not configurable”) means - that the symbol is initially chosen (or not) based on - --enable/--disable options at library build and configure time - (documented here), with the - various --enable/--disable choices being translated to - #define/#undef). -

ABI means that changing from the default value may - mean changing the ABI of compiled code. In other words, these - choices control code which has already been compiled (i.e., in a - binary such as libstdc++.a/.so). If you explicitly #define or - #undef these macros, the headers may see different code - paths, but the libraries which you link against will not. - Experimenting with different values with the expectation of - consistent linkage requires changing the config headers before - building/installing the library. -

_GLIBCXX_DEPRECATED

- Defined by default. Not configurable. ABI-changing. Turning this off - removes older ARM-style iostreams code, and other anachronisms - from the API. This macro is dependent on the version of the - standard being tracked, and as a result may give different results for - -std=c++98 and -std=c++0x. This may - be useful in updating old C++ code which no longer meet the - requirements of the language, or for checking current code - against new language standards. -

_GLIBCXX_FORCE_NEW

- Undefined by default. When defined, memory allocation and - allocators controlled by libstdc++ call operator new/delete - without caching and pooling. Configurable via - --enable-libstdcxx-allocator. ABI-changing. -

_GLIBCXX_CONCEPT_CHECKS

- Undefined by default. Configurable via - --enable-concept-checks. When defined, performs - compile-time checking on certain template instantiations to - detect violations of the requirements of the standard. This - is described in more detail here. -

_GLIBCXX_DEBUG

- Undefined by default. When defined, compiles - user code using the libstdc++ debug - mode. -

_GLIBCXX_DEBUG_PEDANTIC

- Undefined by default. When defined while - compiling with the libstdc++ debug - mode, makes the debug mode extremely picky by making the use - of libstdc++ extensions and libstdc++-specific behavior into - errors. -

_GLIBCXX_PARALLEL

Undefined by default. When defined, compiles - user code using the libstdc++ parallel - mode. -

Prev Up Next
Namespaces Home Concurrency
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch03s05.html b/libstdc++-v3/doc/html/manual/bk01pt01ch03s05.html deleted file mode 100644 index d814ad6034ee..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch03s05.html +++ /dev/null @@ -1,219 +0,0 @@ - - -Concurrency
Concurrency
Prev Chapter 3. Using Next

Concurrency

This section discusses issues surrounding the proper compilation - of multithreaded applications which use the Standard C++ - library. This information is GCC-specific since the C++ - standard does not address matters of multithreaded applications. -

Prerequisites

All normal disclaimers aside, multithreaded C++ application are - only supported when libstdc++ and all user code was built with - compilers which report (via gcc/g++ -v ) the same thread - model and that model is not single. As long as your - final application is actually single-threaded, then it should be - safe to mix user code built with a thread model of - single with a libstdc++ and other C++ libraries built - with another thread model useful on the platform. Other mixes - may or may not work but are not considered supported. (Thus, if - you distribute a shared C++ library in binary form only, it may - be best to compile it with a GCC configured with - --enable-threads for maximal interchangeability and usefulness - with a user population that may have built GCC with either - --enable-threads or --disable-threads.) -

When you link a multithreaded application, you will probably - need to add a library or flag to g++. This is a very - non-standardized area of GCC across ports. Some ports support a - special flag (the spelling isn't even standardized yet) to add - all required macros to a compilation (if any such flags are - required then you must provide the flag for all compilations not - just linking) and link-library additions and/or replacements at - link time. The documentation is weak. Here is a quick summary - to display how ad hoc this is: On Solaris, both -pthreads and - -threads (with subtly different meanings) are honored. On OSF, - -pthread and -threads (with subtly different meanings) are - honored. On Linux/i386, -pthread is honored. On FreeBSD, - -pthread is honored. Some other ports use other switches. - AFAIK, none of this is properly documented anywhere other than - in ``gcc -dumpspecs'' (look at lib and cpp entries). -

Thread Safety

-We currently use the SGI STL definition of thread safety. -

The library strives to be thread-safe when all of the following - conditions are met: -

  • The system's libc is itself thread-safe, -

  • - The compiler in use reports a thread model other than - 'single'. This can be tested via output from gcc - -v. Multi-thread capable versions of gcc output - something like this: - 

    -%gcc -v
-Using built-in specs.
-...
-Thread model: posix
-gcc version 4.1.2 20070925 (Red Hat 4.1.2-33)
-

    Look for "Thread model" lines that aren't equal to "single."

  • - Requisite command-line flags are used for atomic operations - and threading. Examples of this include -pthread - and -march=native, although specifics vary - depending on the host environment. See Machine - Dependent Options. -

  • - An implementation of atomicity.h functions - exists for the architecture in question. See the internals documentation for more details. -

The user-code must guard against concurrent method calls which may - access any particular library object's state. Typically, the - application programmer may infer what object locks must be held - based on the objects referenced in a method call. Without getting - into great detail, here is an example which requires user-level - locks: - 

-     library_class_a shared_object_a;
-
-     thread_main () {
-       library_class_b *object_b = new library_class_b;
-       shared_object_a.add_b (object_b);   // must hold lock for shared_object_a
-       shared_object_a.mutate ();          // must hold lock for shared_object_a
-     }
-
-     // Multiple copies of thread_main() are started in independent threads.

Under the assumption that object_a and object_b are never exposed to - another thread, here is an example that should not require any - user-level locks: - 

-     thread_main () {
-       library_class_a object_a;
-       library_class_b *object_b = new library_class_b;
-       object_a.add_b (object_b);
-       object_a.mutate ();
-     }

All library objects are safe to use in a multithreaded program as - long as each thread carefully locks out access by any other - thread while it uses any object visible to another thread, i.e., - treat library objects like any other shared resource. In general, - this requirement includes both read and write access to objects; - unless otherwise documented as safe, do not assume that two threads - may access a shared standard library object at the same time. -

See chapters 17 (library - introduction), 23 - (containers), and 27 (I/O) for - more information. -

Atomics

-

IO

I'll assume that you have already read the - general notes on library threads, - and the - notes on threaded container - access (you might not think of an I/O stream as a container, but - the points made there also hold here). If you have not read them, - please do so first. -

This gets a bit tricky. Please read carefully, and bear with me. -

Structure

A wrapper - type called __basic_file provides our abstraction layer - for the std::filebuf classes. Nearly all decisions dealing - with actual input and output must be made in __basic_file. -

A generic locking mechanism is somewhat in place at the filebuf layer, - but is not used in the current code. Providing locking at any higher - level is akin to providing locking within containers, and is not done - for the same reasons (see the links above). -

Defaults

The __basic_file type is simply a collection of small wrappers around - the C stdio layer (again, see the link under Structure). We do no - locking ourselves, but simply pass through to calls to fopen, - fwrite, and so forth. -

So, for 3.0, the question of "is multithreading safe for I/O" - must be answered with, "is your platform's C library threadsafe - for I/O?" Some are by default, some are not; many offer multiple - implementations of the C library with varying tradeoffs of threadsafety - and efficiency. You, the programmer, are always required to take care - with multiple threads. -

(As an example, the POSIX standard requires that C stdio FILE* - operations are atomic. POSIX-conforming C libraries (e.g, on Solaris - and GNU/Linux) have an internal mutex to serialize operations on - FILE*s. However, you still need to not do stupid things like calling - fclose(fs) in one thread followed by an access of - fs in another.) -

So, if your platform's C library is threadsafe, then your - fstream I/O operations will be threadsafe at the lowest - level. For higher-level operations, such as manipulating the data - contained in the stream formatting classes (e.g., setting up callbacks - inside an std::ofstream), you need to guard such accesses - like any other critical shared resource. -

Future

A - second choice may be available for I/O implementations: libio. This is - disabled by default, and in fact will not currently work due to other - issues. It will be revisited, however. -

The libio code is a subset of the guts of the GNU libc (glibc) I/O - implementation. When libio is in use, the __basic_file - type is basically derived from FILE. (The real situation is more - complex than that... it's derived from an internal type used to - implement FILE. See libio/libioP.h to see scary things done with - vtbls.) The result is that there is no "layer" of C stdio - to go through; the filebuf makes calls directly into the same - functions used to implement fread, fwrite, - and so forth, using internal data structures. (And when I say - "makes calls directly," I mean the function is literally - replaced by a jump into an internal function. Fast but frightening. - *grin*) -

Also, the libio internal locks are used. This requires pulling in - large chunks of glibc, such as a pthreads implementation, and is one - of the issues preventing widespread use of libio as the libstdc++ - cstdio implementation. -

But we plan to make this work, at least as an option if not a future - default. Platforms running a copy of glibc with a recent-enough - version will see calls from libstdc++ directly into the glibc already - installed. For other platforms, a copy of the libio subsection will - be built and included in libstdc++. -

Alternatives

Don't forget that other cstdio implementations are possible. You could - easily write one to perform your own forms of locking, to solve your - "interesting" problems. -

Containers

This section discusses issues surrounding the design of - multithreaded applications which use Standard C++ containers. - All information in this section is current as of the gcc 3.0 - release and all later point releases. Although earlier gcc - releases had a different approach to threading configuration and - proper compilation, the basic code design rules presented here - were similar. For information on all other aspects of - multithreading as it relates to libstdc++, including details on - the proper compilation of threaded code (and compatibility between - threaded and non-threaded code), see Chapter 17. -

Two excellent pages to read when working with the Standard C++ - containers and threads are - SGI's - http://www.sgi.com/tech/stl/thread_safety.html and - SGI's - http://www.sgi.com/tech/stl/Allocators.html. -

However, please ignore all discussions about the user-level - configuration of the lock implementation inside the STL - container-memory allocator on those pages. For the sake of this - discussion, libstdc++ configures the SGI STL implementation, - not you. This is quite different from how gcc pre-3.0 worked. - In particular, past advice was for people using g++ to - explicitly define _PTHREADS or other macros or port-specific - compilation options on the command line to get a thread-safe - STL. This is no longer required for any port and should no - longer be done unless you really know what you are doing and - assume all responsibility. -

Since the container implementation of libstdc++ uses the SGI - code, we use the same definition of thread safety as SGI when - discussing design. A key point that beginners may miss is the - fourth major paragraph of the first page mentioned above - ("For most clients,"...), which points out that - locking must nearly always be done outside the container, by - client code (that'd be you, not us). There is a notable - exceptions to this rule. Allocators called while a container or - element is constructed uses an internal lock obtained and - released solely within libstdc++ code (in fact, this is the - reason STL requires any knowledge of the thread configuration). -

For implementing a container which does its own locking, it is - trivial to provide a wrapper class which obtains the lock (as - SGI suggests), performs the container operation, and then - releases the lock. This could be templatized to a certain - extent, on the underlying container and/or a locking - mechanism. Trying to provide a catch-all general template - solution would probably be more trouble than it's worth. -

The STL implementation is currently configured to use the - high-speed caching memory allocator. Some people like to - test and/or normally run threaded programs with a different - default. For all details about how to globally override this - at application run-time see here. -

There is a better way (not standardized yet): It is possible to - force the malloc-based allocator on a per-case-basis for some - application code. The library team generally believes that this - is a better way to tune an application for high-speed using this - implementation of the STL. There is - more information on allocators here. -

Prev Up Next
Macros Home Exceptions
diff --git a/libstdc++-v3/doc/html/manual/bk01pt01ch03s06.html b/libstdc++-v3/doc/html/manual/bk01pt01ch03s06.html deleted file mode 100644 index 3fbe4e440d3c..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt01ch03s06.html +++ /dev/null @@ -1,6 +0,0 @@ - - -Exceptions
Exceptions
Prev Chapter 3. Using Next

Exceptions

Propagating Exceptions aka Exception Neutrality

-

Exception Safety

-

Support for -fno-exceptions

-

Prev Up Next
Concurrency Home Debugging Support
diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch04.html b/libstdc++-v3/doc/html/manual/bk01pt02ch04.html deleted file mode 100644 index fd3c1ecc41b1..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch04.html +++ /dev/null @@ -1,40 +0,0 @@ - - -Chapter 4. Types
Chapter 4. Types
Prev Part II. Support Next

Chapter 4. Types

Table of Contents

Fundamental Types
Numeric Properties
NULL

Fundamental Types

- C++ has the following builtin types: -

  • - char -

  • - signed char -

  • - unsigned char -

  • - signed short -

  • - signed int -

  • - signed long -

  • - unsigned short -

  • - unsigned int -

  • - unsigned long -

  • - bool -

  • - wchar_t -

  • - float -

  • - double -

  • - long double -

- These fundamental types are always available, without having to - include a header file. These types are exactly the same in - either C++ or in C. -

- Specializing parts of the library on these types is prohibited: - instead, use a POD. -

Prev Up Next
 Home Numeric Properties
diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch05.html b/libstdc++-v3/doc/html/manual/bk01pt02ch05.html deleted file mode 100644 index e48894d697fa..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch05.html +++ /dev/null @@ -1,66 +0,0 @@ - - -Chapter 5. Dynamic Memory
Chapter 5. Dynamic Memory
Prev Part II. Support Next

Chapter 5. Dynamic Memory

- There are six flavors each of new and - delete, so make certain that you're using the right - ones. Here are quickie descriptions of new: -

  • - single object form, throwing a - bad_alloc on errors; this is what most - people are used to using -

  • - Single object "nothrow" form, returning NULL on errors -

  • - Array new, throwing - bad_alloc on errors -

  • - Array nothrow new, returning - NULL on errors -

  • - Placement new, which does nothing (like - it's supposed to) -

  • - Placement array new, which also does - nothing -

- They are distinguished by the parameters that you pass to them, like - any other overloaded function. The six flavors of delete - are distinguished the same way, but none of them are allowed to throw - an exception under any circumstances anyhow. (They match up for - completeness' sake.) -

- Remember that it is perfectly okay to call delete on a - NULL pointer! Nothing happens, by definition. That is not the - same thing as deleting a pointer twice. -

- By default, if one of the “throwing news” can't - allocate the memory requested, it tosses an instance of a - bad_alloc exception (or, technically, some class derived - from it). You can change this by writing your own function (called a - new-handler) and then registering it with set_new_handler(): - 

-   typedef void (*PFV)(void);
-
-   static char*  safety;
-   static PFV    old_handler;
-
-   void my_new_handler ()
-   {
-       delete[] safety;
-       popup_window ("Dude, you are running low on heap memory.  You
-                      should, like, close some windows, or something.
-                      The next time you run out, we're gonna burn!");
-       set_new_handler (old_handler);
-       return;
-   }
-
-   int main ()
-   {
-       safety = new char[500000];
-       old_handler = set_new_handler (&my_new_handler);
-       ...
-   }
-

- bad_alloc is derived from the base exception - class defined in Chapter 19. -

Prev Up Next
NULL Home Chapter 6. Termination
diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch06.html b/libstdc++-v3/doc/html/manual/bk01pt02ch06.html deleted file mode 100644 index f3ec92185056..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch06.html +++ /dev/null @@ -1,45 +0,0 @@ - - -Chapter 6. Termination
Chapter 6. Termination
Prev Part II. Support Next

Chapter 6. Termination

Table of Contents

Termination Handlers
Verbose Terminate Handler

Termination Handlers

- Not many changes here to cstdlib. You should note that the - abort() function does not call the - destructors of automatic nor static objects, so if you're - depending on those to do cleanup, it isn't going to happen. - (The functions registered with atexit() - don't get called either, so you can forget about that - possibility, too.) -

- The good old exit() function can be a bit - funky, too, until you look closer. Basically, three points to - remember are: -

  1. - Static objects are destroyed in reverse order of their creation. -

  2. - Functions registered with atexit() are called in - reverse order of registration, once per registration call. - (This isn't actually new.) -

  3. - The previous two actions are “interleaved,” that is, - given this pseudocode: - 

    -  extern "C or C++" void  f1 (void);
-  extern "C or C++" void  f2 (void);
-  
-  static Thing obj1;
-  atexit(f1);
-  static Thing obj2;
-  atexit(f2);
-

    - then at a call of exit(), - f2 will be called, then - obj2 will be destroyed, then - f1 will be called, and finally - obj1 will be destroyed. If - f1 or f2 allow an - exception to propagate out of them, Bad Things happen. -

- Note also that atexit() is only required to store 32 - functions, and the compiler/library might already be using some of - those slots. If you think you may run out, we recommend using - the xatexit/xexit combination from libiberty, which has no such limit. -

Prev Up Next
Chapter 5. Dynamic Memory Home Verbose Terminate Handler
diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch06s02.html b/libstdc++-v3/doc/html/manual/bk01pt02ch06s02.html deleted file mode 100644 index 9f3f4017e910..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch06s02.html +++ /dev/null @@ -1,76 +0,0 @@ - - -Verbose Terminate Handler
Verbose Terminate Handler
Prev Chapter 6. Termination Next

Verbose Terminate Handler

- If you are having difficulty with uncaught exceptions and want a - little bit of help debugging the causes of the core dumps, you can - make use of a GNU extension, the verbose terminate handler. - 

-#include <exception>
-  
-int main()
-{
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
-  ...
-
-  throw anything;
-}
-

- The __verbose_terminate_handler function - obtains the name of the current exception, attempts to demangle - it, and prints it to stderr. If the exception is derived from - exception then the output from - what() will be included. -

- Any replacement termination function is required to kill the - program without returning; this one calls abort. -

- For example: - 

-#include <exception>
-#include <stdexcept>
-
-struct argument_error : public std::runtime_error
-{  
-  argument_error(const std::string& s): std::runtime_error(s) { }
-};
-
-int main(int argc)
-{
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
-  if (argc > 5)
-    throw argument_error(“argc is greater than 5!”);
-  else
-    throw argc;
-}
-

- With the verbose terminate handler active, this gives: - 

-   
-   % ./a.out
-   terminate called after throwing a `int'
-   Aborted
-   % ./a.out f f f f f f f f f f f
-   terminate called after throwing an instance of `argument_error'
-   what(): argc is greater than 5!
-   Aborted
-   
-

- The 'Aborted' line comes from the call to - abort(), of course. -

- This is the default termination handler; nothing need be done to - use it. To go back to the previous “silent death” - method, simply include exception and - cstdlib, and call - 

-     std::set_terminate(std::abort);
-

- After this, all calls to terminate will use - abort as the terminate handler. -

- Note: the verbose terminate handler will attempt to write to - stderr. If your application closes stderr or redirects it to an - inappropriate location, - __verbose_terminate_handler will behave in - an unspecified manner. -

Prev Up Next
Chapter 6. Termination Home Part III. Diagnostics
diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch07.html b/libstdc++-v3/doc/html/manual/bk01pt03ch07.html deleted file mode 100644 index c8d622ce223e..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch07.html +++ /dev/null @@ -1,16 +0,0 @@ - - -Chapter 7. Exceptions
Chapter 7. Exceptions
Prev Part III. Diagnostics Next

Chapter 7. Exceptions

Table of Contents

Exception Classes
Adding Data to Exceptions
Cancellation

Exception Classes

- All exception objects are defined in one of the standard header - files: exception, - stdexcept, new, and - typeinfo. -

- The base exception object is exception, - located in exception. This object has no - string member. -

- Derived from this are several classes that may have a - string member: a full hierarchy can be - found in the source documentation. -

Prev Up Next
Part III. Diagnostics Home Adding Data to Exceptions
diff --git a/libstdc++-v3/doc/html/manual/bk01pt04ch09.html b/libstdc++-v3/doc/html/manual/bk01pt04ch09.html deleted file mode 100644 index 9182ef7ae8fb..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt04ch09.html +++ /dev/null @@ -1,9 +0,0 @@ - - -Chapter 9. Functors
Chapter 9. Functors
Prev Part IV. Utilities Next

Chapter 9. Functors

If you don't know what functors are, you're not alone. Many people - get slightly the wrong idea. In the interest of not reinventing - the wheel, we will refer you to the introduction to the functor - concept written by SGI as part of their STL, in - their - http://www.sgi.com/tech/stl/functors.html. -

Prev Up Next
Part IV. Utilities Home Chapter 10. Pairs
diff --git a/libstdc++-v3/doc/html/manual/bk01pt04ch10.html b/libstdc++-v3/doc/html/manual/bk01pt04ch10.html deleted file mode 100644 index 84177cd3a4c2..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt04ch10.html +++ /dev/null @@ -1,39 +0,0 @@ - - -Chapter 10. Pairs
Chapter 10. Pairs
Prev Part IV. Utilities Next

Chapter 10. Pairs

The pair<T1,T2> is a simple and handy way to - carry around a pair of objects. One is of type T1, and another of - type T2; they may be the same type, but you don't get anything - extra if they are. The two members can be accessed directly, as - .first and .second. -

Construction is simple. The default ctor initializes each member - with its respective default ctor. The other simple ctor, - 

-    pair (const T1& x, const T2& y);
-

does what you think it does, first getting x - and second getting y. -

There is a copy constructor, but it requires that your compiler - handle member function templates: - 

-    template <class U, class V> pair (const pair<U,V>& p);
-

The compiler will convert as necessary from U to T1 and from - V to T2 in order to perform the respective initializations. -

The comparison operators are done for you. Equality - of two pair<T1,T2>s is defined as both first - members comparing equal and both second members comparing - equal; this simply delegates responsibility to the respective - operator== functions (for types like MyClass) or builtin - comparisons (for types like int, char, etc). -

- The less-than operator is a bit odd the first time you see it. It - is defined as evaluating to: - 

-    x.first  <  y.first  ||
-        ( !(y.first  <  x.first)  &&  x.second  <  y.second )
-

The other operators are not defined using the rel_ops - functions above, but their semantics are the same. -

Finally, there is a template function called make_pair - that takes two references-to-const objects and returns an - instance of a pair instantiated on their respective types: - 

-    pair<int,MyClass> p = make_pair(4,myobject);
-
Prev Up Next
Chapter 9. Functors Home Chapter 11. Memory
diff --git a/libstdc++-v3/doc/html/manual/bk01pt04ch11.html b/libstdc++-v3/doc/html/manual/bk01pt04ch11.html deleted file mode 100644 index 24d4a7f2ab03..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt04ch11.html +++ /dev/null @@ -1,346 +0,0 @@ - - -Chapter 11. Memory
Chapter 11. Memory
Prev Part IV. Utilities Next

Chapter 11. Memory

Table of Contents

Allocators
Requirements
Design Issues
Implementation
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Use
Acknowledgments

- Memory contains three general areas. First, function and operator - calls via new and delete - operator or member function calls. Second, allocation via - allocator. And finally, smart pointer and - intelligent pointer abstractions. -

Allocators

- Memory management for Standard Library entities is encapsulated in a - class template called allocator. The - allocator abstraction is used throughout the - library in string, container classes, - algorithms, and parts of iostreams. This class, and base classes of - it, are the superset of available free store (“heap”) - management classes. -

Requirements

- The C++ standard only gives a few directives in this area: -

  • - When you add elements to a container, and the container must - allocate more memory to hold them, the container makes the - request via its Allocator template - parameter, which is usually aliased to - allocator_type. This includes adding chars - to the string class, which acts as a regular STL container in - this respect. -

  • - The default Allocator argument of every - container-of-T is allocator<T>. -

  • - The interface of the allocator<T> class is - extremely simple. It has about 20 public declarations (nested - typedefs, member functions, etc), but the two which concern us most - are: - 

    -	 T*    allocate   (size_type n, const void* hint = 0);
-	 void  deallocate (T* p, size_type n);
-

    - The n arguments in both those - functions is a count of the number of - T's to allocate space for, not their - total size. - (This is a simplification; the real signatures use nested typedefs.) -

  • - The storage is obtained by calling ::operator - new, but it is unspecified when or how - often this function is called. The use of the - hint is unspecified, but intended as an - aid to locality if an implementation so - desires. [20.4.1.1]/6 -

- Complete details cam be found in the C++ standard, look in - [20.4 Memory]. -

Design Issues

- The easiest way of fulfilling the requirements is to call - operator new each time a container needs - memory, and to call operator delete each time - the container releases memory. This method may be slower - than caching the allocations and re-using previously-allocated - memory, but has the advantage of working correctly across a wide - variety of hardware and operating systems, including large - clusters. The __gnu_cxx::new_allocator - implements the simple operator new and operator delete semantics, - while __gnu_cxx::malloc_allocator - implements much the same thing, only with the C language functions - std::malloc and free. -

- Another approach is to use intelligence within the allocator - class to cache allocations. This extra machinery can take a variety - of forms: a bitmap index, an index into an exponentially increasing - power-of-two-sized buckets, or simpler fixed-size pooling cache. - The cache is shared among all the containers in the program: when - your program's std::vector<int> gets - cut in half and frees a bunch of its storage, that memory can be - reused by the private - std::list<WonkyWidget> brought in from - a KDE library that you linked against. And operators - new and delete are not - always called to pass the memory on, either, which is a speed - bonus. Examples of allocators that use these techniques are - __gnu_cxx::bitmap_allocator, - __gnu_cxx::pool_allocator, and - __gnu_cxx::__mt_alloc. -

- Depending on the implementation techniques used, the underlying - operating system, and compilation environment, scaling caching - allocators can be tricky. In particular, order-of-destruction and - order-of-creation for memory pools may be difficult to pin down - with certainty, which may create problems when used with plugins - or loading and unloading shared objects in memory. As such, using - caching allocators on systems that do not support - abi::__cxa_atexit is not recommended. -

Implementation

Interface Design

- The only allocator interface that - is support is the standard C++ interface. As such, all STL - containers have been adjusted, and all external allocators have - been modified to support this change. -

- The class allocator just has typedef, - constructor, and rebind members. It inherits from one of the - high-speed extension allocators, covered below. Thus, all - allocation and deallocation depends on the base class. -

- The base class that allocator is derived from - may not be user-configurable. -

Selecting Default Allocation Policy

- It's difficult to pick an allocation strategy that will provide - maximum utility, without excessively penalizing some behavior. In - fact, it's difficult just deciding which typical actions to measure - for speed. -

- Three synthetic benchmarks have been created that provide data - that is used to compare different C++ allocators. These tests are: -

  1. - Insertion. -

    - Over multiple iterations, various STL container - objects have elements inserted to some maximum amount. A variety - of allocators are tested. - Test source for sequence - and associative - containers. -

  2. - Insertion and erasure in a multi-threaded environment. -

    - This test shows the ability of the allocator to reclaim memory - on a pre-thread basis, as well as measuring thread contention - for memory resources. - Test source - here. -

  3. - A threaded producer/consumer model. -

    - Test source for - sequence - and - associative - containers. -

- The current default choice for - allocator is - __gnu_cxx::new_allocator. -

Disabling Memory Caching

- In use, allocator may allocate and - deallocate using implementation-specified strategies and - heuristics. Because of this, every call to an allocator object's - allocate member function may not actually - call the global operator new. This situation is also duplicated - for calls to the deallocate member - function. -

- This can be confusing. -

- In particular, this can make debugging memory errors more - difficult, especially when using third party tools like valgrind or - debug versions of new. -

- There are various ways to solve this problem. One would be to use - a custom allocator that just called operators - new and delete - directly, for every allocation. (See - include/ext/new_allocator.h, for instance.) - However, that option would involve changing source code to use - a non-default allocator. Another option is to force the - default allocator to remove caching and pools, and to directly - allocate with every call of allocate and - directly deallocate with every call of - deallocate, regardless of efficiency. As it - turns out, this last option is also available. -

- To globally disable memory caching within the library for the - default allocator, merely set - GLIBCXX_FORCE_NEW (with any value) in the - system's environment before running the program. If your program - crashes with GLIBCXX_FORCE_NEW in the - environment, it likely means that you linked against objects - built against the older library (objects which might still using the - cached allocations...). -

Using a Specific Allocator

- You can specify different memory management schemes on a - per-container basis, by overriding the default - Allocator template parameter. For example, an easy - (but non-portable) method of specifying that only malloc or free - should be used instead of the default node allocator is: - 

-    std::list <int, __gnu_cxx::malloc_allocator<int> >  malloc_list;

- Likewise, a debugging form of whichever allocator is currently in use: - 

-    std::deque <int, __gnu_cxx::debug_allocator<std::allocator<int> > >  debug_deque;
-

Custom Allocators

- Writing a portable C++ allocator would dictate that the interface - would look much like the one specified for - allocator. Additional member functions, but - not subtractions, would be permissible. -

- Probably the best place to start would be to copy one of the - extension allocators: say a simple one like - new_allocator. -

Extension Allocators

- Several other allocators are provided as part of this - implementation. The location of the extension allocators and their - names have changed, but in all cases, functionality is - equivalent. Starting with gcc-3.4, all extension allocators are - standard style. Before this point, SGI style was the norm. Because of - this, the number of template arguments also changed. Here's a simple - chart to track the changes. -

- More details on each of these extension allocators follows. -

  1. - new_allocator -

    - Simply wraps ::operator new - and ::operator delete. -

  2. - malloc_allocator -

    - Simply wraps malloc and - free. There is also a hook for an - out-of-memory handler (for - new/delete this is - taken care of elsewhere). -

  3. - array_allocator -

    - Allows allocations of known and fixed sizes using existing - global or external storage allocated via construction of - std::tr1::array objects. By using this - allocator, fixed size containers (including - std::string) can be used without - instances calling ::operator new and - ::operator delete. This capability - allows the use of STL abstractions without runtime - complications or overhead, even in situations such as program - startup. For usage examples, please consult the testsuite. -

  4. - debug_allocator -

    - A wrapper around an arbitrary allocator A. It passes on - slightly increased size requests to A, and uses the extra - memory to store size information. When a pointer is passed - to deallocate(), the stored size is - checked, and assert() is used to - guarantee they match. -

  5. - throw_allocator -

    - Includes memory tracking and marking abilities as well as hooks for - throwing exceptions at configurable intervals (including random, - all, none). -

  6. - __pool_alloc -

    - A high-performance, single pool allocator. The reusable - memory is shared among identical instantiations of this type. - It calls through ::operator new to - obtain new memory when its lists run out. If a client - container requests a block larger than a certain threshold - size, then the pool is bypassed, and the allocate/deallocate - request is passed to ::operator new - directly. -

    - Older versions of this class take a boolean template - parameter, called thr, and an integer template - parameter, called inst. -

    - The inst number is used to track additional memory - pools. The point of the number is to allow multiple - instantiations of the classes without changing the semantics at - all. All three of - 

    -    typedef  __pool_alloc<true,0>    normal;
-    typedef  __pool_alloc<true,1>    private;
-    typedef  __pool_alloc<true,42>   also_private;
-

    - behave exactly the same way. However, the memory pool for each type - (and remember that different instantiations result in different types) - remains separate. -

    - The library uses 0 in all its instantiations. If you - wish to keep separate free lists for a particular purpose, use a - different number. -

    The thr boolean determines whether the - pool should be manipulated atomically or not. When - thr = true, the allocator - is is thread-safe, while thr = - false, and is slightly faster but unsafe for - multiple threads. -

    - For thread-enabled configurations, the pool is locked with a - single big lock. In some situations, this implementation detail - may result in severe performance degradation. -

    - (Note that the GCC thread abstraction layer allows us to provide - safe zero-overhead stubs for the threading routines, if threads - were disabled at configuration time.) -

  7. - __mt_alloc -

    - A high-performance fixed-size allocator with - exponentially-increasing allocations. It has its own - documentation, found here. -

  8. - bitmap_allocator -

    - A high-performance allocator that uses a bit-map to keep track - of the used and unused memory locations. It has its own - documentation, found here. -

Bibliography

- ISO/IEC 14882:1998 Programming languages - C++ - . - isoc++_1998 - 20.4 Memory.

The Standard Librarian: What Are Allocators Good - . - austernm - Matt Austern. - C/C++ Users Journal - . - - - .

The Hoard Memory Allocator. - emeryb - Emery Berger. - - - .

Reconsidering Custom Memory Allocation. - bergerzorn - Emery Berger. Ben Zorn. Kathryn McKinley. Copyright © 2002 OOPSLA. - - - .

Allocator Types. - kreftlanger - Klaus Kreft. Angelika Langer. - C/C++ Users Journal - . - - - .

The C++ Programming Language. - tcpl - Bjarne Stroustrup. Copyright © 2000 . 19.4 Allocators. - Addison Wesley - .

Yalloc: A Recycling C++ Allocator. - yenf - Felix Yen. Copyright © . - - - .

Prev Up Next
Chapter 10. Pairs Home auto_ptr
diff --git a/libstdc++-v3/doc/html/manual/bk01pt04ch12.html b/libstdc++-v3/doc/html/manual/bk01pt04ch12.html deleted file mode 100644 index b771aaf4d2a2..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt04ch12.html +++ /dev/null @@ -1,4 +0,0 @@ - - -Chapter 12. Traits
Chapter 12. Traits
Prev Part IV. Utilities Next

Chapter 12. Traits

-

Prev Up Next
shared_ptr Home Part V. Strings
diff --git a/libstdc++-v3/doc/html/manual/bk01pt06ch14.html b/libstdc++-v3/doc/html/manual/bk01pt06ch14.html deleted file mode 100644 index c9886822aa87..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt06ch14.html +++ /dev/null @@ -1,422 +0,0 @@ - - -Chapter 14. Locales
Chapter 14. Locales
Prev Part VI. Localization Next

Chapter 14. Locales

Table of Contents

locale
Requirements
Design
Implementation
Future

locale

-Describes the basic locale object, including nested -classes id, facet, and the reference-counted implementation object, -class _Impl. -

Requirements

-Class locale is non-templatized and has two distinct types nested -inside of it: -

- -class facet -22.1.1.1.2 Class locale::facet - -

-Facets actually implement locale functionality. For instance, a facet -called numpunct is the data objects that can be used to query for the -thousands separator is in the German locale. -

-Literally, a facet is strictly defined: -

  • - Containing the following public data member: -

    - static locale::id id; -

  • - Derived from another facet: -

    - class gnu_codecvt: public std::ctype<user-defined-type> -

-Of interest in this class are the memory management options explicitly -specified as an argument to facet's constructor. Each constructor of a -facet class takes a std::size_t __refs argument: if __refs == 0, the -facet is deleted when the locale containing it is destroyed. If __refs -== 1, the facet is not destroyed, even when it is no longer -referenced. -

- -class id -22.1.1.1.3 - Class locale::id - -

-Provides an index for looking up specific facets. -

Design

-The major design challenge is fitting an object-orientated and -non-global locale design on top of POSIX and other relevant standards, -which include the Single Unix (nee X/Open.) -

-Because C and earlier versions of POSIX fall down so completely, -portability is an issue. -

Implementation

Interacting with "C" locales

  • - `locale -a` displays available locales. - 

    -af_ZA
-ar_AE
-ar_AE.utf8
-ar_BH
-ar_BH.utf8
-ar_DZ
-ar_DZ.utf8
-ar_EG
-ar_EG.utf8
-ar_IN
-ar_IQ
-ar_IQ.utf8
-ar_JO
-ar_JO.utf8
-ar_KW
-ar_KW.utf8
-ar_LB
-ar_LB.utf8
-ar_LY
-ar_LY.utf8
-ar_MA
-ar_MA.utf8
-ar_OM
-ar_OM.utf8
-ar_QA
-ar_QA.utf8
-ar_SA
-ar_SA.utf8
-ar_SD
-ar_SD.utf8
-ar_SY
-ar_SY.utf8
-ar_TN
-ar_TN.utf8
-ar_YE
-ar_YE.utf8
-be_BY
-be_BY.utf8
-bg_BG
-bg_BG.utf8
-br_FR
-bs_BA
-C
-ca_ES
-ca_ES@euro
-ca_ES.utf8
-ca_ES.utf8@euro
-cs_CZ
-cs_CZ.utf8
-cy_GB
-da_DK
-da_DK.iso885915
-da_DK.utf8
-de_AT
-de_AT@euro
-de_AT.utf8
-de_AT.utf8@euro
-de_BE
-de_BE@euro
-de_BE.utf8
-de_BE.utf8@euro
-de_CH
-de_CH.utf8
-de_DE
-de_DE@euro
-de_DE.utf8
-de_DE.utf8@euro
-de_LU
-de_LU@euro
-de_LU.utf8
-de_LU.utf8@euro
-el_GR
-el_GR.utf8
-en_AU
-en_AU.utf8
-en_BW
-en_BW.utf8
-en_CA
-en_CA.utf8
-en_DK
-en_DK.utf8
-en_GB
-en_GB.iso885915
-en_GB.utf8
-en_HK
-en_HK.utf8
-en_IE
-en_IE@euro
-en_IE.utf8
-en_IE.utf8@euro
-en_IN
-en_NZ
-en_NZ.utf8
-en_PH
-en_PH.utf8
-en_SG
-en_SG.utf8
-en_US
-en_US.iso885915
-en_US.utf8
-en_ZA
-en_ZA.utf8
-en_ZW
-en_ZW.utf8
-es_AR
-es_AR.utf8
-es_BO
-es_BO.utf8
-es_CL
-es_CL.utf8
-es_CO
-es_CO.utf8
-es_CR
-es_CR.utf8
-es_DO
-es_DO.utf8
-es_EC
-es_EC.utf8
-es_ES
-es_ES@euro
-es_ES.utf8
-es_ES.utf8@euro
-es_GT
-es_GT.utf8
-es_HN
-es_HN.utf8
-es_MX
-es_MX.utf8
-es_NI
-es_NI.utf8
-es_PA
-es_PA.utf8
-es_PE
-es_PE.utf8
-es_PR
-es_PR.utf8
-es_PY
-es_PY.utf8
-es_SV
-es_SV.utf8
-es_US
-es_US.utf8
-es_UY
-es_UY.utf8
-es_VE
-es_VE.utf8
-et_EE
-et_EE.utf8
-eu_ES
-eu_ES@euro
-eu_ES.utf8
-eu_ES.utf8@euro
-fa_IR
-fi_FI
-fi_FI@euro
-fi_FI.utf8
-fi_FI.utf8@euro
-fo_FO
-fo_FO.utf8
-fr_BE
-fr_BE@euro
-fr_BE.utf8
-fr_BE.utf8@euro
-fr_CA
-fr_CA.utf8
-fr_CH
-fr_CH.utf8
-fr_FR
-fr_FR@euro
-fr_FR.utf8
-fr_FR.utf8@euro
-fr_LU
-fr_LU@euro
-fr_LU.utf8
-fr_LU.utf8@euro
-ga_IE
-ga_IE@euro
-ga_IE.utf8
-ga_IE.utf8@euro
-gl_ES
-gl_ES@euro
-gl_ES.utf8
-gl_ES.utf8@euro
-gv_GB
-gv_GB.utf8
-he_IL
-he_IL.utf8
-hi_IN
-hr_HR
-hr_HR.utf8
-hu_HU
-hu_HU.utf8
-id_ID
-id_ID.utf8
-is_IS
-is_IS.utf8
-it_CH
-it_CH.utf8
-it_IT
-it_IT@euro
-it_IT.utf8
-it_IT.utf8@euro
-iw_IL
-iw_IL.utf8
-ja_JP.eucjp
-ja_JP.utf8
-ka_GE
-kl_GL
-kl_GL.utf8
-ko_KR.euckr
-ko_KR.utf8
-kw_GB
-kw_GB.utf8
-lt_LT
-lt_LT.utf8
-lv_LV
-lv_LV.utf8
-mi_NZ
-mk_MK
-mk_MK.utf8
-mr_IN
-ms_MY
-ms_MY.utf8
-mt_MT
-mt_MT.utf8
-nl_BE
-nl_BE@euro
-nl_BE.utf8
-nl_BE.utf8@euro
-nl_NL
-nl_NL@euro
-nl_NL.utf8
-nl_NL.utf8@euro
-nn_NO
-nn_NO.utf8
-no_NO
-no_NO.utf8
-oc_FR
-pl_PL
-pl_PL.utf8
-POSIX
-pt_BR
-pt_BR.utf8
-pt_PT
-pt_PT@euro
-pt_PT.utf8
-pt_PT.utf8@euro
-ro_RO
-ro_RO.utf8
-ru_RU
-ru_RU.koi8r
-ru_RU.utf8
-ru_UA
-ru_UA.utf8
-se_NO
-sk_SK
-sk_SK.utf8
-sl_SI
-sl_SI.utf8
-sq_AL
-sq_AL.utf8
-sr_YU
-sr_YU@cyrillic
-sr_YU.utf8
-sr_YU.utf8@cyrillic
-sv_FI
-sv_FI@euro
-sv_FI.utf8
-sv_FI.utf8@euro
-sv_SE
-sv_SE.iso885915
-sv_SE.utf8
-ta_IN
-te_IN
-tg_TJ
-th_TH
-th_TH.utf8
-tl_PH
-tr_TR
-tr_TR.utf8
-uk_UA
-uk_UA.utf8
-ur_PK
-uz_UZ
-vi_VN
-vi_VN.tcvn
-wa_BE
-wa_BE@euro
-yi_US
-zh_CN
-zh_CN.gb18030
-zh_CN.gbk
-zh_CN.utf8
-zh_HK
-zh_HK.utf8
-zh_TW
-zh_TW.euctw
-zh_TW.utf8
-

  • - `locale` displays environmental variables that - impact how locale("") will be deduced. - 

    -LANG=en_US
-LC_CTYPE="en_US"
-LC_NUMERIC="en_US"
-LC_TIME="en_US"
-LC_COLLATE="en_US"
-LC_MONETARY="en_US"
-LC_MESSAGES="en_US"
-LC_PAPER="en_US"
-LC_NAME="en_US"
-LC_ADDRESS="en_US"
-LC_TELEPHONE="en_US"
-LC_MEASUREMENT="en_US"
-LC_IDENTIFICATION="en_US"
-LC_ALL=
-

-From Josuttis, p. 697-698, which says, that "there is only *one* -relation (of the C++ locale mechanism) to the C locale mechanism: the -global C locale is modified if a named C++ locale object is set as the -global locale" (emphasis Paolo), that is: -

std::locale::global(std::locale(""));

affects the C functions as if the following call was made:

std::setlocale(LC_ALL, "");

- On the other hand, there is *no* vice versa, that is, calling - setlocale has *no* whatsoever on the C++ locale mechanism, in - particular on the working of locale(""), which constructs the locale - object from the environment of the running program, that is, in - practice, the set of LC_ALL, LANG, etc. variable of the shell. -

Future

  • - Locale initialization: at what point does _S_classic, _S_global - get initialized? Can named locales assume this initialization - has already taken place? -

  • - Document how named locales error check when filling data - members. I.e., a fr_FR locale that doesn't have - numpunct::truename(): does it use "true"? Or is it a blank - string? What's the convention? -

  • - Explain how locale aliasing happens. When does "de_DE" use "de" - information? What is the rule for locales composed of just an - ISO language code (say, "de") and locales with both an ISO - language code and ISO country code (say, "de_DE"). -

  • - What should non-required facet instantiations do? If the - generic implementation is provided, then how to end-users - provide specializations? -

Bibliography

- The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

- Correspondence - . Ulrich Drepper. Copyright © 2002 .

- ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

- ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

- System Interface Definitions, Issue 6 (IEEE Std. 1003.1-200x) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - - - .

- The C++ Programming Language, Special Edition - . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. - Addison Wesley - .

- Standard C++ IOStreams and Locales - . - Advanced Programmer's Guide and Reference - . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. - Addison Wesley Longman - .

Prev Up Next
Part VI. Localization Home Chapter 15. Facets aka Categories
diff --git a/libstdc++-v3/doc/html/manual/bk01pt06ch15.html b/libstdc++-v3/doc/html/manual/bk01pt06ch15.html deleted file mode 100644 index fdb34a45aa85..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt06ch15.html +++ /dev/null @@ -1,74 +0,0 @@ - - -Chapter 15. Facets aka Categories
Chapter 15. Facets aka Categories
Prev Part VI. Localization Next

Chapter 15. Facets aka Categories

Table of Contents

ctype
Implementation
Future
codecvt
Requirements
Design
Implementation
Use
Future
messages
Requirements
Design
Implementation
Use
Future

ctype

Implementation

Specializations

-For the required specialization codecvt<wchar_t, char, mbstate_t> , -conversions are made between the internal character set (always UCS4 -on GNU/Linux) and whatever the currently selected locale for the -LC_CTYPE category implements. -

-The two required specializations are implemented as follows: -

- -ctype<char> - -

-This is simple specialization. Implementing this was a piece of cake. -

- -ctype<wchar_t> - -

-This specialization, by specifying all the template parameters, pretty -much ties the hands of implementors. As such, the implementation is -straightforward, involving mcsrtombs for the conversions between char -to wchar_t and wcsrtombs for conversions between wchar_t and char. -

-Neither of these two required specializations deals with Unicode -characters. -

Future

  • - How to deal with the global locale issue? -

  • - How to deal with different types than char, wchar_t?

  • - Overlap between codecvt/ctype: narrow/widen -

  • - Mask typedef in codecvt_base, argument types in codecvt. what - is know about this type? -

  • - Why mask* argument in codecvt? -

  • - Can this be made (more) generic? is there a simple way to - straighten out the configure-time mess that is a by-product of - this class? -

  • - Get the ctype<wchar_t>::mask stuff under control. Need to - make some kind of static table, and not do lookup every time - somebody hits the do_is... functions. Too bad we can't just - redefine mask for ctype<wchar_t> -

  • - Rename abstract base class. See if just smash-overriding is a - better approach. Clarify, add sanity to naming. -

Bibliography

- The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

- Correspondence - . Ulrich Drepper. Copyright © 2002 .

- ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

- ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

- System Interface Definitions, Issue 6 (IEEE Std. 1003.1-200x) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - - - .

- The C++ Programming Language, Special Edition - . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. - Addison Wesley - .

- Standard C++ IOStreams and Locales - . - Advanced Programmer's Guide and Reference - . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. - Addison Wesley Longman - .

Prev Up Next
Chapter 14. Locales Home codecvt
diff --git a/libstdc++-v3/doc/html/manual/bk01pt07ch16.html b/libstdc++-v3/doc/html/manual/bk01pt07ch16.html deleted file mode 100644 index 3d1b251973a3..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt07ch16.html +++ /dev/null @@ -1,37 +0,0 @@ - - -Chapter 16. Sequences
Chapter 16. Sequences
Prev Part VII. Containers Next

Chapter 16. Sequences

Table of Contents

list
list::size() is O(n)
vector
Space Overhead Management

list

list::size() is O(n)

- Yes it is, and that's okay. This is a decision that we preserved - when we imported SGI's STL implementation. The following is - quoted from their FAQ: -

- The size() member function, for list and slist, takes time - proportional to the number of elements in the list. This was a - deliberate tradeoff. The only way to get a constant-time - size() for linked lists would be to maintain an extra member - variable containing the list's size. This would require taking - extra time to update that variable (it would make splice() a - linear time operation, for example), and it would also make the - list larger. Many list algorithms don't require that extra - word (algorithms that do require it might do better with - vectors than with lists), and, when it is necessary to maintain - an explicit size count, it's something that users can do - themselves. -

- This choice is permitted by the C++ standard. The standard says - that size() “should” be constant time, and - “should” does not mean the same thing as - “shall”. This is the officially recommended ISO - wording for saying that an implementation is supposed to do - something unless there is a good reason not to. -

- One implication of linear time size(): you should never write - 

-         if (L.size() == 0)
-             ...
-

- Instead, you should write - 

-         if (L.empty())
-             ...
-
Prev Up Next
Part VII. Containers Home vector
diff --git a/libstdc++-v3/doc/html/manual/bk01pt07ch16s02.html b/libstdc++-v3/doc/html/manual/bk01pt07ch16s02.html deleted file mode 100644 index f1561554143c..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt07ch16s02.html +++ /dev/null @@ -1,16 +0,0 @@ - - -vector
vector
Prev Chapter 16. Sequences Next

vector

-

Space Overhead Management

- In this - message to the list, Daniel Kostecky announced work on an - alternate form of std::vector that would support - hints on the number of elements to be over-allocated. The design - was also described, along with possible implementation choices. -

- The first two alpha releases were announced here - and here. - The releases themselves are available at - - http://www.kotelna.sk/dk/sw/caphint/. -

Prev Up Next
Chapter 16. Sequences Home Chapter 17. Associative
diff --git a/libstdc++-v3/doc/html/manual/bk01pt07ch17.html b/libstdc++-v3/doc/html/manual/bk01pt07ch17.html deleted file mode 100644 index 53259e143114..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt07ch17.html +++ /dev/null @@ -1,84 +0,0 @@ - - -Chapter 17. Associative
Chapter 17. Associative
Prev Part VII. Containers Next

Chapter 17. Associative

Table of Contents

Insertion Hints
bitset
Size Variable
Type String

Insertion Hints

- Section [23.1.2], Table 69, of the C++ standard lists this - function for all of the associative containers (map, set, etc): - 

-      a.insert(p,t);
-

- where 'p' is an iterator into the container 'a', and 't' is the - item to insert. The standard says that “t is - inserted as close as possible to the position just prior to - p.” (Library DR #233 addresses this topic, - referring to N1780. - Since version 4.2 GCC implements the resolution to DR 233, so - that insertions happen as close as possible to the hint. For - earlier releases the hint was only used as described below. -

- Here we'll describe how the hinting works in the libstdc++ - implementation, and what you need to do in order to take - advantage of it. (Insertions can change from logarithmic - complexity to amortized constant time, if the hint is properly - used.) Also, since the current implementation is based on the - SGI STL one, these points may hold true for other library - implementations also, since the HP/SGI code is used in a lot of - places. -

- In the following text, the phrases greater - than and less than refer to the - results of the strict weak ordering imposed on the container by - its comparison object, which defaults to (basically) - “<”. Using those phrases is semantically sloppy, - but I didn't want to get bogged down in syntax. I assume that if - you are intelligent enough to use your own comparison objects, - you are also intelligent enough to assign “greater” - and “lesser” their new meanings in the next - paragraph. *grin* -

- If the hint parameter ('p' above) is equivalent to: -

  • - begin(), then the item being inserted should - have a key less than all the other keys in the container. - The item will be inserted at the beginning of the container, - becoming the new entry at begin(). -

  • - end(), then the item being inserted should have - a key greater than all the other keys in the container. The - item will be inserted at the end of the container, becoming - the new entry at end(). -

  • - neither begin() nor end(), then: - Let h be the entry in the container pointed to - by hint, that is, h = *hint. Then - the item being inserted should have a key less than that of - h, and greater than that of the item preceding - h. The new item will be inserted between - h and h's predecessor. -

- For multimap and multiset, the - restrictions are slightly looser: “greater than” - should be replaced by “not less than”and “less - than” should be replaced by “not greater - than.” (Why not replace greater with - greater-than-or-equal-to? You probably could in your head, but - the mathematicians will tell you that it isn't the same thing.) -

- If the conditions are not met, then the hint is not used, and the - insertion proceeds as if you had called a.insert(t) - instead. (Note that GCC releases - prior to 3.0.2 had a bug in the case with hint == - begin() for the map and set - classes. You should not use a hint argument in those releases.) -

- This behavior goes well with other containers' - insert() functions which take an iterator: if used, - the new item will be inserted before the iterator passed as an - argument, same as the other containers. -

- Note also that the hint in this - implementation is a one-shot. The older insertion-with-hint - routines check the immediately surrounding entries to ensure that - the new item would in fact belong there. If the hint does not - point to the correct place, then no further local searching is - done; the search begins from scratch in logarithmic time. -

Prev Up Next
vector Home bitset
diff --git a/libstdc++-v3/doc/html/manual/bk01pt07ch17s02.html b/libstdc++-v3/doc/html/manual/bk01pt07ch17s02.html deleted file mode 100644 index 1d4e3f90403b..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt07ch17s02.html +++ /dev/null @@ -1,105 +0,0 @@ - - -bitset
bitset
Prev Chapter 17. Associative Next

bitset

Size Variable

- No, you cannot write code of the form - 

-      #include <bitset>
-
-      void foo (size_t n)
-      {
-          std::bitset<n>   bits;
-          ....
-      } 
-

- because n must be known at compile time. Your - compiler is correct; it is not a bug. That's the way templates - work. (Yes, it is a feature.) -

- There are a couple of ways to handle this kind of thing. Please - consider all of them before passing judgement. They include, in - no particular order: -

  • A very large N in bitset<N>.

  • A container<bool>.

  • Extremely weird solutions.

- A very large N in - bitset<N>.   It has been - pointed out a few times in newsgroups that N bits only takes up - (N/8) bytes on most systems, and division by a factor of eight is - pretty impressive when speaking of memory. Half a megabyte given - over to a bitset (recall that there is zero space overhead for - housekeeping info; it is known at compile time exactly how large - the set is) will hold over four million bits. If you're using - those bits as status flags (e.g., - “changed”/“unchanged” flags), that's a - lot of state. -

- You can then keep track of the “maximum bit used” - during some testing runs on representative data, make note of how - many of those bits really need to be there, and then reduce N to - a smaller number. Leave some extra space, of course. (If you - plan to write code like the incorrect example above, where the - bitset is a local variable, then you may have to talk your - compiler into allowing that much stack space; there may be zero - space overhead, but it's all allocated inside the object.) -

- A container<bool>.   The - Committee made provision for the space savings possible with that - (N/8) usage previously mentioned, so that you don't have to do - wasteful things like Container<char> or - Container<short int>. Specifically, - vector<bool> is required to be specialized for - that space savings. -

- The problem is that vector<bool> doesn't - behave like a normal vector anymore. There have been recent - journal articles which discuss the problems (the ones by Herb - Sutter in the May and July/August 1999 issues of C++ Report cover - it well). Future revisions of the ISO C++ Standard will change - the requirement for vector<bool> - specialization. In the meantime, deque<bool> - is recommended (although its behavior is sane, you probably will - not get the space savings, but the allocation scheme is different - than that of vector). -

- Extremely weird solutions.   If - you have access to the compiler and linker at runtime, you can do - something insane, like figuring out just how many bits you need, - then writing a temporary source code file. That file contains an - instantiation of bitset for the required number of - bits, inside some wrapper functions with unchanging signatures. - Have your program then call the compiler on that file using - Position Independent Code, then open the newly-created object - file and load those wrapper functions. You'll have an - instantiation of bitset<N> for the exact - N that you need at the time. Don't forget to delete - the temporary files. (Yes, this can be, and - has been, done.) -

- This would be the approach of either a visionary genius or a - raving lunatic, depending on your programming and management - style. Probably the latter. -

- Which of the above techniques you use, if any, are up to you and - your intended application. Some time/space profiling is - indicated if it really matters (don't just guess). And, if you - manage to do anything along the lines of the third category, the - author would love to hear from you... -

- Also note that the implementation of bitset used in libstdc++ has - some extensions. -

Type String

-

- Bitmasks do not take char* nor const char* arguments in their - constructors. This is something of an accident, but you can read - about the problem: follow the library's “Links” from - the homepage, and from the C++ information “defect - reflector” link, select the library issues list. Issue - number 116 describes the problem. -

- For now you can simply make a temporary string object using the - constructor expression: - 

-      std::bitset<5> b ( std::string(“10110”) );
-

- instead of - 

-      std::bitset<5> b ( “10110” );    // invalid
-
Prev Up Next
Chapter 17. Associative Home Chapter 18. Interacting with C
diff --git a/libstdc++-v3/doc/html/manual/bk01pt07ch18.html b/libstdc++-v3/doc/html/manual/bk01pt07ch18.html deleted file mode 100644 index af7bb752411b..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt07ch18.html +++ /dev/null @@ -1,60 +0,0 @@ - - -Chapter 18. Interacting with C
Chapter 18. Interacting with C
Prev Part VII. Containers Next

Chapter 18. Interacting with C

Table of Contents

Containers vs. Arrays

Containers vs. Arrays

- You're writing some code and can't decide whether to use builtin - arrays or some kind of container. There are compelling reasons - to use one of the container classes, but you're afraid that - you'll eventually run into difficulties, change everything back - to arrays, and then have to change all the code that uses those - data types to keep up with the change. -

- If your code makes use of the standard algorithms, this isn't as - scary as it sounds. The algorithms don't know, nor care, about - the kind of “container” on which they work, since - the algorithms are only given endpoints to work with. For the - container classes, these are iterators (usually - begin() and end(), but not always). - For builtin arrays, these are the address of the first element - and the past-the-end element. -

- Some very simple wrapper functions can hide all of that from the - rest of the code. For example, a pair of functions called - beginof can be written, one that takes an array, - another that takes a vector. The first returns a pointer to the - first element, and the second returns the vector's - begin() iterator. -

- The functions should be made template functions, and should also - be declared inline. As pointed out in the comments in the code - below, this can lead to beginof being optimized out - of existence, so you pay absolutely nothing in terms of increased - code size or execution time. -

- The result is that if all your algorithm calls look like - 

-   std::transform(beginof(foo), endof(foo), beginof(foo), SomeFunction);
-

- then the type of foo can change from an array of ints to a vector - of ints to a deque of ints and back again, without ever changing - any client code. -

- This author has a collection of such functions, called - “*of” because they all extend the builtin - “sizeof”. It started with some Usenet discussions - on a transparent way to find the length of an array. A - simplified and much-reduced version for easier reading is given here. -

- Astute readers will notice two things at once: first, that the - container class is still a vector<T> instead - of a more general Container<T>. This would - mean that three functions for deque would have to be - added, another three for list, and so on. This is - due to problems with getting template resolution correct; I find - it easier just to give the extra three lines and avoid confusion. -

- Second, the line - 

-    inline unsigned int lengthof (T (&)[sz]) { return sz; } 
-

- looks just weird! Hint: unused parameters can be left nameless. -

Prev Up Next
bitset Home Part VIII. Iterators
diff --git a/libstdc++-v3/doc/html/manual/bk01pt10ch21.html b/libstdc++-v3/doc/html/manual/bk01pt10ch21.html deleted file mode 100644 index f1c82056d39b..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt10ch21.html +++ /dev/null @@ -1,19 +0,0 @@ - - -Chapter 21. Complex
Chapter 21. Complex
Prev Part X. Numerics Next

Chapter 21. Complex

Table of Contents

complex Processing

-

complex Processing

-

Using complex<> becomes even more comple- er, sorry, - complicated, with the not-quite-gratuitously-incompatible - addition of complex types to the C language. David Tribble has - compiled a list of C++98 and C99 conflict points; his description of - C's new type versus those of C++ and how to get them playing together - nicely is -here. -

complex<> is intended to be instantiated with a - floating-point type. As long as you meet that and some other basic - requirements, then the resulting instantiation has all of the usual - math operators defined, as well as definitions of op<< - and op>> that work with iostreams: op<< - prints (u,v) and op>> can read u, - (u), and (u,v). -

Prev Up Next
Part X. Numerics Home Chapter 22. Generalized Operations
diff --git a/libstdc++-v3/doc/html/manual/bk01pt10ch22.html b/libstdc++-v3/doc/html/manual/bk01pt10ch22.html deleted file mode 100644 index a278eccd5731..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt10ch22.html +++ /dev/null @@ -1,26 +0,0 @@ - - -Chapter 22. Generalized Operations
Chapter 22. Generalized Operations
Prev Part X. Numerics Next

Chapter 22. Generalized Operations

-

There are four generalized functions in the <numeric> header - that follow the same conventions as those in <algorithm>. Each - of them is overloaded: one signature for common default operations, - and a second for fully general operations. Their names are - self-explanatory to anyone who works with numerics on a regular basis: -

  • accumulate

  • inner_product

  • partial_sum

  • adjacent_difference

Here is a simple example of the two forms of accumulate. - 

-   int   ar[50];
-   int   someval = somefunction();
-
-   // ...initialize members of ar to something...
-
-   int  sum       = std::accumulate(ar,ar+50,0);
-   int  sum_stuff = std::accumulate(ar,ar+50,someval);
-   int  product   = std::accumulate(ar,ar+50,1,std::multiplies<int>());
-

The first call adds all the members of the array, using zero as an - initial value for sum. The second does the same, but uses - someval as the starting value (thus, sum_stuff == sum + - someval). The final call uses the second of the two signatures, - and multiplies all the members of the array; here we must obviously - use 1 as a starting value instead of 0. -

The other three functions have similar dual-signature forms. -

Prev Up Next
Chapter 21. Complex Home Chapter 23. Interacting with C
diff --git a/libstdc++-v3/doc/html/manual/bk01pt10ch23.html b/libstdc++-v3/doc/html/manual/bk01pt10ch23.html deleted file mode 100644 index a3902b3df290..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt10ch23.html +++ /dev/null @@ -1,18 +0,0 @@ - - -Chapter 23. Interacting with C
Chapter 23. Interacting with C
Prev Part X. Numerics Next

Chapter 23. Interacting with C

Table of Contents

Numerics vs. Arrays
C99

Numerics vs. Arrays

One of the major reasons why FORTRAN can chew through numbers so well - is that it is defined to be free of pointer aliasing, an assumption - that C89 is not allowed to make, and neither is C++98. C99 adds a new - keyword, restrict, to apply to individual pointers. The - C++ solution is contained in the library rather than the language - (although many vendors can be expected to add this to their compilers - as an extension). -

That library solution is a set of two classes, five template classes, - and "a whole bunch" of functions. The classes are required - to be free of pointer aliasing, so compilers can optimize the - daylights out of them the same way that they have been for FORTRAN. - They are collectively called valarray, although strictly - speaking this is only one of the five template classes, and they are - designed to be familiar to people who have worked with the BLAS - libraries before. -

Prev Up Next
Chapter 22. Generalized Operations Home C99
diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch24.html b/libstdc++-v3/doc/html/manual/bk01pt11ch24.html deleted file mode 100644 index 1c8976e1dc11..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch24.html +++ /dev/null @@ -1,113 +0,0 @@ - - -Chapter 24. Iostream Objects
Chapter 24. Iostream Objects
Prev Part XI. Input and Output Next

Chapter 24. Iostream Objects

To minimize the time you have to wait on the compiler, it's good to - only include the headers you really need. Many people simply include - <iostream> when they don't need to -- and that can penalize - your runtime as well. Here are some tips on which header to use - for which situations, starting with the simplest. -

<iosfwd> should be included whenever you simply - need the name of an I/O-related class, such as - "ofstream" or "basic_streambuf". Like the name - implies, these are forward declarations. (A word to all you fellow - old school programmers: trying to forward declare classes like - "class istream;" won't work. Look in the iosfwd header if - you'd like to know why.) For example, - 

-    #include <iosfwd>
-
-    class MyClass
-    {
-        ....
-        std::ifstream&   input_file;
-    };
-
-    extern std::ostream& operator<< (std::ostream&, MyClass&);
-

<ios> declares the base classes for the entire - I/O stream hierarchy, std::ios_base and std::basic_ios<charT>, the - counting types std::streamoff and std::streamsize, the file - positioning type std::fpos, and the various manipulators like - std::hex, std::fixed, std::noshowbase, and so forth. -

The ios_base class is what holds the format flags, the state flags, - and the functions which change them (setf(), width(), precision(), - etc). You can also store extra data and register callback functions - through ios_base, but that has been historically underused. Anything - which doesn't depend on the type of characters stored is consolidated - here. -

The template class basic_ios is the highest template class in the - hierarchy; it is the first one depending on the character type, and - holds all general state associated with that type: the pointer to the - polymorphic stream buffer, the facet information, etc. -

<streambuf> declares the template class - basic_streambuf, and two standard instantiations, streambuf and - wstreambuf. If you need to work with the vastly useful and capable - stream buffer classes, e.g., to create a new form of storage - transport, this header is the one to include. -

<istream>/<ostream> are - the headers to include when you are using the >>/<< - interface, or any of the other abstract stream formatting functions. - For example, - 

-    #include <istream>
-
-    std::ostream& operator<< (std::ostream& os, MyClass& c)
-    {
-       return os << c.data1() << c.data2();
-    }
-

The std::istream and std::ostream classes are the abstract parents of - the various concrete implementations. If you are only using the - interfaces, then you only need to use the appropriate interface header. -

<iomanip> provides "extractors and inserters - that alter information maintained by class ios_base and its derived - classes," such as std::setprecision and std::setw. If you need - to write expressions like os << setw(3); or - is >> setbase(8);, you must include <iomanip>. -

<sstream>/<fstream> - declare the six stringstream and fstream classes. As they are the - standard concrete descendants of istream and ostream, you will already - know about them. -

Finally, <iostream> provides the eight standard - global objects (cin, cout, etc). To do this correctly, this header - also provides the contents of the <istream> and <ostream> - headers, but nothing else. The contents of this header look like - 

-    #include <ostream>
-    #include <istream>
-
-    namespace std
-    {
-        extern istream cin;
-        extern ostream cout;
-        ....
-
-        // this is explained below
-        static ios_base::Init __foo;    // not its real name
-    }
-

Now, the runtime penalty mentioned previously: the global objects - must be initialized before any of your own code uses them; this is - guaranteed by the standard. Like any other global object, they must - be initialized once and only once. This is typically done with a - construct like the one above, and the nested class ios_base::Init is - specified in the standard for just this reason. -

How does it work? Because the header is included before any of your - code, the __foo object is constructed before any of - your objects. (Global objects are built in the order in which they - are declared, and destroyed in reverse order.) The first time the - constructor runs, the eight stream objects are set up. -

The static keyword means that each object file compiled - from a source file containing <iostream> will have its own - private copy of __foo. There is no specified order - of construction across object files (it's one of those pesky NP - problems that make life so interesting), so one copy in each object - file means that the stream objects are guaranteed to be set up before - any of your code which uses them could run, thereby meeting the - requirements of the standard. -

The penalty, of course, is that after the first copy of - __foo is constructed, all the others are just wasted - processor time. The time spent is merely for an increment-and-test - inside a function call, but over several dozen or hundreds of object - files, that time can add up. (It's not in a tight loop, either.) -

The lesson? Only include <iostream> when you need to use one of - the standard objects in that source file; you'll pay less startup - time. Only include the header files you need to in general; your - compile times will go down when there's less parsing work to do. -

Prev Up Next
Part XI. Input and Output Home Chapter 25. Stream Buffers
diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch25.html b/libstdc++-v3/doc/html/manual/bk01pt11ch25.html deleted file mode 100644 index a3bbfded4225..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch25.html +++ /dev/null @@ -1,57 +0,0 @@ - - -Chapter 25. Stream Buffers
Chapter 25. Stream Buffers
Prev Part XI. Input and Output Next

Chapter 25. Stream Buffers

Table of Contents

Derived streambuf Classes
Buffering

Derived streambuf Classes

-

Creating your own stream buffers for I/O can be remarkably easy. - If you are interested in doing so, we highly recommend two very - excellent books: - Standard C++ - IOStreams and Locales by Langer and Kreft, ISBN 0-201-18395-1, and - The C++ Standard Library - by Nicolai Josuttis, ISBN 0-201-37926-0. Both are published by - Addison-Wesley, who isn't paying us a cent for saying that, honest. -

Here is a simple example, io/outbuf1, from the Josuttis text. It - transforms everything sent through it to uppercase. This version - assumes many things about the nature of the character type being - used (for more information, read the books or the newsgroups): - 

-    #include <iostream>
-    #include <streambuf>
-    #include <locale>
-    #include <cstdio>
-
-    class outbuf : public std::streambuf
-    {
-      protected:
-	/* central output function
-	 * - print characters in uppercase mode
-	 */
-	virtual int_type overflow (int_type c) {
-	    if (c != EOF) {
-		// convert lowercase to uppercase
-		c = std::toupper(static_cast<char>(c),getloc());
-
-		// and write the character to the standard output
-		if (putchar(c) == EOF) {
-		    return EOF;
-		}
-	    }
-	    return c;
-	}
-    };
-
-    int main()
-    {
-	// create special output buffer
-	outbuf ob;
-	// initialize output stream with that output buffer
-	std::ostream out(&ob);
-
-	out << "31 hexadecimal: "
-	    << std::hex << 31 << std::endl;
-	return 0;
-    }
-

Try it yourself! More examples can be found in 3.1.x code, in - include/ext/*_filebuf.h, and on - Dietmar - Kühl's IOStreams page. -

Prev Up Next
Chapter 24. Iostream Objects Home Buffering
diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch26.html b/libstdc++-v3/doc/html/manual/bk01pt11ch26.html deleted file mode 100644 index 23c5189868a4..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch26.html +++ /dev/null @@ -1,34 +0,0 @@ - - -Chapter 26. Memory Based Streams
Chapter 26. Memory Based Streams
Prev Part XI. Input and Output Next

Chapter 26. Memory Based Streams

Table of Contents

Compatibility With strstream

Compatibility With strstream

-

Stringstreams (defined in the header <sstream>) - are in this author's opinion one of the coolest things since - sliced time. An example of their use is in the Received Wisdom - section for Chapter 21 (Strings), - describing how to - format strings. -

The quick definition is: they are siblings of ifstream and ofstream, - and they do for std::string what their siblings do for - files. All that work you put into writing << and - >> functions for your classes now pays off - again! Need to format a string before passing the string - to a function? Send your stuff via << to an - ostringstream. You've read a string as input and need to parse it? - Initialize an istringstream with that string, and then pull pieces - out of it with >>. Have a stringstream and need to - get a copy of the string inside? Just call the str() - member function. -

This only works if you've written your - <</>> functions correctly, though, - and correctly means that they take istreams and ostreams as - parameters, not ifstreams and ofstreams. If they - take the latter, then your I/O operators will work fine with - file streams, but with nothing else -- including stringstreams. -

If you are a user of the strstream classes, you need to update - your code. You don't have to explicitly append ends to - terminate the C-style character array, you don't have to mess with - "freezing" functions, and you don't have to manage the - memory yourself. The strstreams have been officially deprecated, - which means that 1) future revisions of the C++ Standard won't - support them, and 2) if you use them, people will laugh at you. -

Prev Up Next
Buffering Home Chapter 27. File Based Streams
diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch27.html b/libstdc++-v3/doc/html/manual/bk01pt11ch27.html deleted file mode 100644 index ac7cf9e2feb0..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch27.html +++ /dev/null @@ -1,49 +0,0 @@ - - -Chapter 27. File Based Streams
Chapter 27. File Based Streams
Prev Part XI. Input and Output Next

Chapter 27. File Based Streams

Table of Contents

Copying a File
Binary Input and Output
More Binary Input and Output

Copying a File

-

So you want to copy a file quickly and easily, and most important, - completely portably. And since this is C++, you have an open - ifstream (call it IN) and an open ofstream (call it OUT): - 

-   #include <fstream>
-
-   std::ifstream  IN ("input_file");
-   std::ofstream  OUT ("output_file");

Here's the easiest way to get it completely wrong: - 

-   OUT << IN;

For those of you who don't already know why this doesn't work - (probably from having done it before), I invite you to quickly - create a simple text file called "input_file" containing - the sentence - 

-      The quick brown fox jumped over the lazy dog.

surrounded by blank lines. Code it up and try it. The contents - of "output_file" may surprise you. -

Seriously, go do it. Get surprised, then come back. It's worth it. -

The thing to remember is that the basic_[io]stream classes - handle formatting, nothing else. In particular, they break up on - whitespace. The actual reading, writing, and storing of data is - handled by the basic_streambuf family. Fortunately, the - operator<< is overloaded to take an ostream and - a pointer-to-streambuf, in order to help with just this kind of - "dump the data verbatim" situation. -

Why a pointer to streambuf and not just a streambuf? Well, - the [io]streams hold pointers (or references, depending on the - implementation) to their buffers, not the actual - buffers. This allows polymorphic behavior on the part of the buffers - as well as the streams themselves. The pointer is easily retrieved - using the rdbuf() member function. Therefore, the easiest - way to copy the file is: - 

-   OUT << IN.rdbuf();

So what was happening with OUT<<IN? Undefined - behavior, since that particular << isn't defined by the Standard. - I have seen instances where it is implemented, but the character - extraction process removes all the whitespace, leaving you with no - blank lines and only "Thequickbrownfox...". With - libraries that do not define that operator, IN (or one of IN's - member pointers) sometimes gets converted to a void*, and the output - file then contains a perfect text representation of a hexadecimal - address (quite a big surprise). Others don't compile at all. -

Also note that none of this is specific to o*f*streams. - The operators shown above are all defined in the parent - basic_ostream class and are therefore available with all possible - descendants. -

Prev Up Next
Chapter 26. Memory Based Streams Home Binary Input and Output
diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch28.html b/libstdc++-v3/doc/html/manual/bk01pt11ch28.html deleted file mode 100644 index 8745a398e4ec..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch28.html +++ /dev/null @@ -1,8 +0,0 @@ - - -Chapter 28. Interacting with C
Chapter 28. Interacting with C
Prev Part XI. Input and Output Next

Chapter 28. Interacting with C

Table of Contents

Using FILE* and file descriptors
Performance

Using FILE* and file descriptors

- See the extensions for using - FILE and file descriptors with - ofstream and - ifstream. -

Prev Up Next
More Binary Input and Output Home Performance
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch29.html b/libstdc++-v3/doc/html/manual/bk01pt12ch29.html deleted file mode 100644 index 6766b33537e7..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch29.html +++ /dev/null @@ -1,37 +0,0 @@ - - -Chapter 29. Compile Time Checks
Chapter 29. Compile Time Checks
Prev Part XII. Extensions Next

Chapter 29. Compile Time Checks

- Also known as concept checking. -

In 1999, SGI added concept checkers to their implementation - of the STL: code which checked the template parameters of - instantiated pieces of the STL, in order to insure that the parameters - being used met the requirements of the standard. For example, - the Standard requires that types passed as template parameters to - vector be “Assignable” (which means what you think - it means). The checking was done during compilation, and none of - the code was executed at runtime. -

Unfortunately, the size of the compiler files grew significantly - as a result. The checking code itself was cumbersome. And bugs - were found in it on more than one occasion. -

The primary author of the checking code, Jeremy Siek, had already - started work on a replacement implementation. The new code has been - formally reviewed and accepted into - the - Boost libraries, and we are pleased to incorporate it into the - GNU C++ library. -

The new version imposes a much smaller space overhead on the generated - object file. The checks are also cleaner and easier to read and - understand. -

They are off by default for all versions of GCC from 3.0 to 3.4 (the - latest release at the time of writing). - They can be enabled at configure time with - --enable-concept-checks. - You can enable them on a per-translation-unit basis with - #define _GLIBCXX_CONCEPT_CHECKS for GCC 3.4 and higher - (or with #define _GLIBCPP_CONCEPT_CHECKS for versions - 3.1, 3.2 and 3.3). -

Please note that the upcoming C++ standard has first-class - support for template parameter constraints based on concepts in the core - language. This will obviate the need for the library-simulated concept - checking described above. -

Prev Up Next
 Home Chapter 30. Debug Mode
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32.html b/libstdc++-v3/doc/html/manual/bk01pt12ch32.html deleted file mode 100644 index ddc6e7079318..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32.html +++ /dev/null @@ -1,394 +0,0 @@ - - -Chapter 32. Allocators
Chapter 32. Allocators
Prev Part XII. Extensions Next

Chapter 32. Allocators

Table of Contents

mt_allocator
Intro
Design Issues
Implementation
Single Thread Example
Multiple Thread Example
bitmap_allocator
Design
Implementation

mt_allocator

-

Intro

- The mt allocator [hereinafter referred to simply as "the allocator"] - is a fixed size (power of two) allocator that was initially - developed specifically to suit the needs of multi threaded - applications [hereinafter referred to as an MT application]. Over - time the allocator has evolved and been improved in many ways, in - particular it now also does a good job in single threaded - applications [hereinafter referred to as a ST application]. (Note: - In this document, when referring to single threaded applications - this also includes applications that are compiled with gcc without - thread support enabled. This is accomplished using ifdef's on - __GTHREADS). This allocator is tunable, very flexible, and capable - of high-performance. -

- The aim of this document is to describe - from an application point of - view - the "inner workings" of the allocator. -

Design Issues

Overview

There are three general components to the allocator: a datum -describing the characteristics of the memory pool, a policy class -containing this pool that links instantiation types to common or -individual pools, and a class inheriting from the policy class that is -the actual allocator. -

The datum describing pools characteristics is -

-  template<bool _Thread>
-    class __pool
-

This class is parametrized on thread support, and is explicitly -specialized for both multiple threads (with bool==true) -and single threads (via bool==false.) It is possible to -use a custom pool datum instead of the default class that is provided. -

There are two distinct policy classes, each of which can be used -with either type of underlying pool datum. -

-  template<bool _Thread>
-    struct __common_pool_policy
-
-  template<typename _Tp, bool _Thread>
-    struct __per_type_pool_policy
-

The first policy, __common_pool_policy, implements a -common pool. This means that allocators that are instantiated with -different types, say char and long will both -use the same pool. This is the default policy. -

The second policy, __per_type_pool_policy, implements -a separate pool for each instantiating type. Thus, char -and long will use separate pools. This allows per-type -tuning, for instance. -

Putting this all together, the actual allocator class is -

-  template<typename _Tp, typename _Poolp = __default_policy>
-    class __mt_alloc : public __mt_alloc_base<_Tp>,  _Poolp
-

This class has the interface required for standard library allocator -classes, namely member functions allocate and -deallocate, plus others. -

Implementation

Tunable Parameters

Certain allocation parameters can be modified, or tuned. There -exists a nested struct __pool_base::_Tune that contains all -these parameters, which include settings for -

  • Alignment

  • Maximum bytes before calling ::operator new directly

  • Minimum bytes

  • Size of underlying global allocations

  • Maximum number of supported threads

  • Migration of deallocations to the global free list

  • Shunt for global new and delete

Adjusting parameters for a given instance of an allocator can only -happen before any allocations take place, when the allocator itself is -initialized. For instance: -

-#include <ext/mt_allocator.h>
-
-struct pod
-{
-  int i;
-  int j;
-};
-
-int main()
-{
-  typedef pod value_type;
-  typedef __gnu_cxx::__mt_alloc<value_type> allocator_type;
-  typedef __gnu_cxx::__pool_base::_Tune tune_type;
-
-  tune_type t_default;
-  tune_type t_opt(16, 5120, 32, 5120, 20, 10, false);
-  tune_type t_single(16, 5120, 32, 5120, 1, 10, false);
-
-  tune_type t;
-  t = allocator_type::_M_get_options();  
-  allocator_type::_M_set_options(t_opt);
-  t = allocator_type::_M_get_options();  
-
-  allocator_type a;
-  allocator_type::pointer p1 = a.allocate(128);
-  allocator_type::pointer p2 = a.allocate(5128);
-
-  a.deallocate(p1, 128);
-  a.deallocate(p2, 5128);
-
-  return 0;
-}
-

Initialization

-The static variables (pointers to freelists, tuning parameters etc) -are initialized as above, or are set to the global defaults. -

-The very first allocate() call will always call the -_S_initialize_once() function. In order to make sure that this -function is called exactly once we make use of a __gthread_once call -in MT applications and check a static bool (_S_init) in ST -applications. -

-The _S_initialize() function: -- If the GLIBCXX_FORCE_NEW environment variable is set, it sets the bool - _S_force_new to true and then returns. This will cause subsequent calls to - allocate() to return memory directly from a new() call, and deallocate will - only do a delete() call. -

-- If the GLIBCXX_FORCE_NEW environment variable is not set, both ST and MT - applications will: - - Calculate the number of bins needed. A bin is a specific power of two size - of bytes. I.e., by default the allocator will deal with requests of up to - 128 bytes (or whatever the value of _S_max_bytes is when _S_init() is - called). This means that there will be bins of the following sizes - (in bytes): 1, 2, 4, 8, 16, 32, 64, 128. - - - Create the _S_binmap array. All requests are rounded up to the next - "large enough" bin. I.e., a request for 29 bytes will cause a block from - the "32 byte bin" to be returned to the application. The purpose of - _S_binmap is to speed up the process of finding out which bin to use. - I.e., the value of _S_binmap[ 29 ] is initialized to 5 (bin 5 = 32 bytes). -

- - Create the _S_bin array. This array consists of bin_records. There will be - as many bin_records in this array as the number of bins that we calculated - earlier. I.e., if _S_max_bytes = 128 there will be 8 entries. - Each bin_record is then initialized: - - bin_record->first = An array of pointers to block_records. There will be - as many block_records pointers as there are maximum number of threads - (in a ST application there is only 1 thread, in a MT application there - are _S_max_threads). - This holds the pointer to the first free block for each thread in this - bin. I.e., if we would like to know where the first free block of size 32 - for thread number 3 is we would look this up by: _S_bin[ 5 ].first[ 3 ] - - The above created block_record pointers members are now initialized to - their initial values. I.e. _S_bin[ n ].first[ n ] = NULL; -

-- Additionally a MT application will: - - Create a list of free thread id's. The pointer to the first entry - is stored in _S_thread_freelist_first. The reason for this approach is - that the __gthread_self() call will not return a value that corresponds to - the maximum number of threads allowed but rather a process id number or - something else. So what we do is that we create a list of thread_records. - This list is _S_max_threads long and each entry holds a size_t thread_id - which is initialized to 1, 2, 3, 4, 5 and so on up to _S_max_threads. - Each time a thread calls allocate() or deallocate() we call - _S_get_thread_id() which looks at the value of _S_thread_key which is a - thread local storage pointer. If this is NULL we know that this is a newly - created thread and we pop the first entry from this list and saves the - pointer to this record in the _S_thread_key variable. The next time - we will get the pointer to the thread_record back and we use the - thread_record->thread_id as identification. I.e., the first thread that - calls allocate will get the first record in this list and thus be thread - number 1 and will then find the pointer to its first free 32 byte block - in _S_bin[ 5 ].first[ 1 ] - When we create the _S_thread_key we also define a destructor - (_S_thread_key_destr) which means that when the thread dies, this - thread_record is returned to the front of this list and the thread id - can then be reused if a new thread is created. - This list is protected by a mutex (_S_thread_freelist_mutex) which is only - locked when records are removed or added to the list. -

- - Initialize the free and used counters of each bin_record: - - bin_record->free = An array of size_t. This keeps track of the number - of blocks on a specific thread's freelist in each bin. I.e., if a thread - has 12 32-byte blocks on it's freelists and allocates one of these, this - counter would be decreased to 11. - - - bin_record->used = An array of size_t. This keeps track of the number - of blocks currently in use of this size by this thread. I.e., if a thread - has made 678 requests (and no deallocations...) of 32-byte blocks this - counter will read 678. - - The above created arrays are now initialized with their initial values. - I.e. _S_bin[ n ].free[ n ] = 0; -

- - Initialize the mutex of each bin_record: The bin_record->mutex - is used to protect the global freelist. This concept of a global - freelist is explained in more detail in the section "A multi - threaded example", but basically this mutex is locked whenever a - block of memory is retrieved or returned to the global freelist - for this specific bin. This only occurs when a number of blocks - are grabbed from the global list to a thread specific list or when - a thread decides to return some blocks to the global freelist. -

Deallocation Notes

Notes about deallocation. This allocator does not explicitly -release memory. Because of this, memory debugging programs like -valgrind or purify may notice leaks: sorry about this -inconvenience. Operating systems will reclaim allocated memory at -program termination anyway. If sidestepping this kind of noise is -desired, there are three options: use an allocator, like -new_allocator that releases memory while debugging, use -GLIBCXX_FORCE_NEW to bypass the allocator's internal pools, or use a -custom pool datum that releases resources on destruction. -

- On systems with the function __cxa_atexit, the -allocator can be forced to free all memory allocated before program -termination with the member function -__pool_type::_M_destroy. However, because this member -function relies on the precise and exactly-conforming ordering of -static destructors, including those of a static local -__pool object, it should not be used, ever, on systems -that don't have the necessary underlying support. In addition, in -practice, forcing deallocation can be tricky, as it requires the -__pool object to be fully-constructed before the object -that uses it is fully constructed. For most (but not all) STL -containers, this works, as an instance of the allocator is constructed -as part of a container's constructor. However, this assumption is -implementation-specific, and subject to change. For an example of a -pool that frees memory, see the following - - example. -

Single Thread Example

-Let's start by describing how the data on a freelist is laid out in memory. -This is the first two blocks in freelist for thread id 3 in bin 3 (8 bytes): -

-+----------------+
-| next* ---------|--+  (_S_bin[ 3 ].first[ 3 ] points here)
-|                |  |
-|                |  |
-|                |  |
-+----------------+  |
-| thread_id = 3  |  |
-|                |  |
-|                |  |
-|                |  |
-+----------------+  |
-| DATA           |  |  (A pointer to here is what is returned to the
-|                |  |   the application when needed)
-|                |  |
-|                |  |
-|                |  |
-|                |  |
-|                |  |
-|                |  |
-+----------------+  |
-+----------------+  |
-| next*          |<-+  (If next == NULL it's the last one on the list)
-|                |
-|                |
-|                |
-+----------------+
-| thread_id = 3  |
-|                |
-|                |
-|                |
-+----------------+
-| DATA           |
-|                |
-|                |
-|                |
-|                |
-|                |
-|                |
-|                |
-+----------------+
-

-With this in mind we simplify things a bit for a while and say that there is -only one thread (a ST application). In this case all operations are made to -what is referred to as the global pool - thread id 0 (No thread may be -assigned this id since they span from 1 to _S_max_threads in a MT application). -

-When the application requests memory (calling allocate()) we first look at the -requested size and if this is > _S_max_bytes we call new() directly and return. -

-If the requested size is within limits we start by finding out from which -bin we should serve this request by looking in _S_binmap. -

-A quick look at _S_bin[ bin ].first[ 0 ] tells us if there are any blocks of -this size on the freelist (0). If this is not NULL - fine, just remove the -block that _S_bin[ bin ].first[ 0 ] points to from the list, -update _S_bin[ bin ].first[ 0 ] and return a pointer to that blocks data. -

-If the freelist is empty (the pointer is NULL) we must get memory from the -system and build us a freelist within this memory. All requests for new memory -is made in chunks of _S_chunk_size. Knowing the size of a block_record and -the bytes that this bin stores we then calculate how many blocks we can create -within this chunk, build the list, remove the first block, update the pointer -(_S_bin[ bin ].first[ 0 ]) and return a pointer to that blocks data. -

-Deallocation is equally simple; the pointer is casted back to a block_record -pointer, lookup which bin to use based on the size, add the block to the front -of the global freelist and update the pointer as needed -(_S_bin[ bin ].first[ 0 ]). -

-The decision to add deallocated blocks to the front of the freelist was made -after a set of performance measurements that showed that this is roughly 10% -faster than maintaining a set of "last pointers" as well. -

Multiple Thread Example

-In the ST example we never used the thread_id variable present in each block. -Let's start by explaining the purpose of this in a MT application. -

-The concept of "ownership" was introduced since many MT applications -allocate and deallocate memory to shared containers from different -threads (such as a cache shared amongst all threads). This introduces -a problem if the allocator only returns memory to the current threads -freelist (I.e., there might be one thread doing all the allocation and -thus obtaining ever more memory from the system and another thread -that is getting a longer and longer freelist - this will in the end -consume all available memory). -

-Each time a block is moved from the global list (where ownership is -irrelevant), to a threads freelist (or when a new freelist is built -from a chunk directly onto a threads freelist or when a deallocation -occurs on a block which was not allocated by the same thread id as the -one doing the deallocation) the thread id is set to the current one. -

-What's the use? Well, when a deallocation occurs we can now look at -the thread id and find out if it was allocated by another thread id -and decrease the used counter of that thread instead, thus keeping the -free and used counters correct. And keeping the free and used counters -corrects is very important since the relationship between these two -variables decides if memory should be returned to the global pool or -not when a deallocation occurs. -

-When the application requests memory (calling allocate()) we first -look at the requested size and if this is >_S_max_bytes we call new() -directly and return. -

-If the requested size is within limits we start by finding out from which -bin we should serve this request by looking in _S_binmap. -

-A call to _S_get_thread_id() returns the thread id for the calling thread -(and if no value has been set in _S_thread_key, a new id is assigned and -returned). -

-A quick look at _S_bin[ bin ].first[ thread_id ] tells us if there are -any blocks of this size on the current threads freelist. If this is -not NULL - fine, just remove the block that _S_bin[ bin ].first[ -thread_id ] points to from the list, update _S_bin[ bin ].first[ -thread_id ], update the free and used counters and return a pointer to -that blocks data. -

-If the freelist is empty (the pointer is NULL) we start by looking at -the global freelist (0). If there are blocks available on the global -freelist we lock this bins mutex and move up to block_count (the -number of blocks of this bins size that will fit into a _S_chunk_size) -or until end of list - whatever comes first - to the current threads -freelist and at the same time change the thread_id ownership and -update the counters and pointers. When the bins mutex has been -unlocked, we remove the block that _S_bin[ bin ].first[ thread_id ] -points to from the list, update _S_bin[ bin ].first[ thread_id ], -update the free and used counters, and return a pointer to that blocks -data. -

-The reason that the number of blocks moved to the current threads -freelist is limited to block_count is to minimize the chance that a -subsequent deallocate() call will return the excess blocks to the -global freelist (based on the _S_freelist_headroom calculation, see -below). -

-However if there isn't any memory on the global pool we need to get -memory from the system - this is done in exactly the same way as in a -single threaded application with one major difference; the list built -in the newly allocated memory (of _S_chunk_size size) is added to the -current threads freelist instead of to the global. -

-The basic process of a deallocation call is simple: always add the -block to the front of the current threads freelist and update the -counters and pointers (as described earlier with the specific check of -ownership that causes the used counter of the thread that originally -allocated the block to be decreased instead of the current threads -counter). -

-And here comes the free and used counters to service. Each time a -deallocation() call is made, the length of the current threads -freelist is compared to the amount memory in use by this thread. -

-Let's go back to the example of an application that has one thread -that does all the allocations and one that deallocates. Both these -threads use say 516 32-byte blocks that was allocated during thread -creation for example. Their used counters will both say 516 at this -point. The allocation thread now grabs 1000 32-byte blocks and puts -them in a shared container. The used counter for this thread is now -1516. -

-The deallocation thread now deallocates 500 of these blocks. For each -deallocation made the used counter of the allocating thread is -decreased and the freelist of the deallocation thread gets longer and -longer. But the calculation made in deallocate() will limit the length -of the freelist in the deallocation thread to _S_freelist_headroom % -of it's used counter. In this case, when the freelist (given that the -_S_freelist_headroom is at it's default value of 10%) exceeds 52 -(516/10) blocks will be returned to the global pool where the -allocating thread may pick them up and reuse them. -

-In order to reduce lock contention (since this requires this bins -mutex to be locked) this operation is also made in chunks of blocks -(just like when chunks of blocks are moved from the global freelist to -a threads freelist mentioned above). The "formula" used can probably -be improved to further reduce the risk of blocks being "bounced back -and forth" between freelists. -

Prev Up Next
Testing Home bitmap_allocator
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch33.html b/libstdc++-v3/doc/html/manual/bk01pt12ch33.html deleted file mode 100644 index d2fb6a77f85d..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch33.html +++ /dev/null @@ -1,6 +0,0 @@ - - -Chapter 33. Containers
Chapter 33. Containers
Prev Part XII. Extensions Next

Chapter 33. Containers

Table of Contents

Policy Based Data Structures
HP/SGI
Deprecated HP/SGI

-

Policy Based Data Structures

- More details here. -

Prev Up Next
bitmap_allocator Home HP/SGI
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch34.html b/libstdc++-v3/doc/html/manual/bk01pt12ch34.html deleted file mode 100644 index 505d11f34a18..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch34.html +++ /dev/null @@ -1,38 +0,0 @@ - - -Chapter 34. Utilities
Chapter 34. Utilities
Prev Part XII. Extensions Next

Chapter 34. Utilities

- The <functional> header contains many additional functors - and helper functions, extending section 20.3. They are - implemented in the file stl_function.h: -

  • identity_element for addition and multiplication. * -

  • The functor identity, whose operator() - returns the argument unchanged. * -

  • Composition functors unary_function and - binary_function, and their helpers compose1 - and compose2. * -

  • select1st and select2nd, to strip pairs. * -

  • project1st and project2nd. *

  • A set of functors/functions which always return the same result. They - are constant_void_fun, constant_binary_fun, - constant_unary_fun, constant0, - constant1, and constant2. *

  • The class subtractive_rng. *

  • mem_fun adaptor helpers mem_fun1 and - mem_fun1_ref are provided for backwards compatibility.

- 20.4.1 can use several different allocators; they are described on the - main extensions page. -

- 20.4.3 is extended with a special version of - get_temporary_buffer taking a second argument. The - argument is a pointer, which is ignored, but can be used to specify - the template type (instead of using explicit function template - arguments like the standard version does). That is, in addition to -

-get_temporary_buffer<int>(5);
-

-you can also use -

-get_temporary_buffer(5, (int*)0);
-

- A class temporary_buffer is given in stl_tempbuf.h. * -

- The specialized algorithms of section 20.4.4 are extended with - uninitialized_copy_n. * -

Prev Up Next
Deprecated HP/SGI Home Chapter 35. Algorithms
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch35.html b/libstdc++-v3/doc/html/manual/bk01pt12ch35.html deleted file mode 100644 index 2db6be689c5b..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch35.html +++ /dev/null @@ -1,20 +0,0 @@ - - -Chapter 35. Algorithms
Chapter 35. Algorithms
Prev Part XII. Extensions Next

Chapter 35. Algorithms

25.1.6 (count, count_if) is extended with two more versions of count - and count_if. The standard versions return their results. The - additional signatures return void, but take a final parameter by - reference to which they assign their results, e.g., -

-   void count (first, last, value, n);

25.2 (mutating algorithms) is extended with two families of signatures, - random_sample and random_sample_n. -

25.2.1 (copy) is extended with -

-   copy_n (_InputIter first, _Size count, _OutputIter result);

which copies the first 'count' elements at 'first' into 'result'. -

25.3 (sorting 'n' heaps 'n' stuff) is extended with some helper - predicates. Look in the doxygen-generated pages for notes on these. -

  • is_heap tests whether or not a range is a heap.

  • is_sorted tests whether or not a range is sorted in - nondescending order.

25.3.8 (lexicographical_compare) is extended with -

-   lexicographical_compare_3way(_InputIter1 first1, _InputIter1 last1,
-                                 _InputIter2 first2, _InputIter2 last2)

which does... what? -

Prev Up Next
Chapter 34. Utilities Home Chapter 36. Numerics
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch36.html b/libstdc++-v3/doc/html/manual/bk01pt12ch36.html deleted file mode 100644 index 3f120ae6022c..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch36.html +++ /dev/null @@ -1,17 +0,0 @@ - - -Chapter 36. Numerics
Chapter 36. Numerics
Prev Part XII. Extensions Next

Chapter 36. Numerics

26.4, the generalized numeric operations such as accumulate, are extended - with the following functions: -

-   power (x, n);
-   power (x, n, moniod_operation);

Returns, in FORTRAN syntax, "x ** n" where n>=0. In the - case of n == 0, returns the identity element for the - monoid operation. The two-argument signature uses multiplication (for - a true "power" implementation), but addition is supported as well. - The operation functor must be associative. -

The iota function wins the award for Extension With the - Coolest Name. It "assigns sequentially increasing values to a range. - That is, it assigns value to *first, value + 1 to *(first + 1) and so - on." Quoted from SGI documentation. -

-   void iota(_ForwardIter first, _ForwardIter last, _Tp value);
Prev Up Next
Chapter 35. Algorithms Home Chapter 37. Iterators
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch37.html b/libstdc++-v3/doc/html/manual/bk01pt12ch37.html deleted file mode 100644 index ea5e1fa7e79b..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch37.html +++ /dev/null @@ -1,11 +0,0 @@ - - -Chapter 37. Iterators
Chapter 37. Iterators
Prev Part XII. Extensions Next

Chapter 37. Iterators

24.3.2 describes struct iterator, which didn't exist in the - original HP STL implementation (the language wasn't rich enough at the - time). For backwards compatibility, base classes are provided which - declare the same nested typedefs: -

  • input_iterator

  • output_iterator

  • forward_iterator

  • bidirectional_iterator

  • random_access_iterator

24.3.4 describes iterator operation distance, which takes - two iterators and returns a result. It is extended by another signature - which takes two iterators and a reference to a result. The result is - modified, and the function returns nothing. -

Prev Up Next
Chapter 36. Numerics Home Chapter 38. Input and Output
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch38.html b/libstdc++-v3/doc/html/manual/bk01pt12ch38.html deleted file mode 100644 index 84c110d3ad5c..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch38.html +++ /dev/null @@ -1,48 +0,0 @@ - - -Chapter 38. Input and Output
Chapter 38. Input and Output
Prev Part XII. Extensions Next

Chapter 38. Input and Output

Table of Contents

Derived filebufs

- Extensions allowing filebufs to be constructed from - "C" types like FILE*s and file descriptors. -

Derived filebufs

The v2 library included non-standard extensions to construct - std::filebufs from C stdio types such as - FILE*s and POSIX file descriptors. - Today the recommended way to use stdio types with libstdc++ - IOStreams is via the stdio_filebuf class (see below), - but earlier releases provided slightly different mechanisms. -

  • 3.0.x filebufs have another ctor with this signature: - basic_filebuf(__c_file_type*, ios_base::openmode, int_type); - - This comes in very handy in a number of places, such as - attaching Unix sockets, pipes, and anything else which uses file - descriptors, into the IOStream buffering classes. The three - arguments are as follows: -

    • __c_file_type* F - // the __c_file_type typedef usually boils down to stdio's FILE -

    • ios_base::openmode M - // same as all the other uses of openmode -

    • int_type B - // buffer size, defaults to BUFSIZ if not specified -

    - For those wanting to use file descriptors instead of FILE*'s, I - invite you to contemplate the mysteries of C's fdopen(). -

  • In library snapshot 3.0.95 and later, filebufs bring - back an old extension: the fd() member function. The - integer returned from this function can be used for whatever file - descriptors can be used for on your platform. Naturally, the - library cannot track what you do on your own with a file descriptor, - so if you perform any I/O directly, don't expect the library to be - aware of it. -

  • Beginning with 3.1, the extra filebuf constructor and - the fd() function were removed from the standard - filebuf. Instead, <ext/stdio_filebuf.h> contains - a derived class called - __gnu_cxx::stdio_filebuf. - This class can be constructed from a C FILE* or a file - descriptor, and provides the fd() function. -

If you want to access a filebuf's file descriptor to - implement file locking (e.g. using the fcntl() system - call) then you might be interested in Henry Suter's - RWLock - class. -

-

Prev Up Next
Chapter 37. Iterators Home Chapter 39. Demangling
diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch39.html b/libstdc++-v3/doc/html/manual/bk01pt12ch39.html deleted file mode 100644 index 82a673f19ab6..000000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch39.html +++ /dev/null @@ -1,71 +0,0 @@ - - -Chapter 39. Demangling
Chapter 39. Demangling
Prev Part XII. Extensions Next

Chapter 39. Demangling

- Transforming C++ ABI identifiers (like RTTI symbols) into the - original C++ source identifiers is called - “demangling.” -

- If you have read the source - documentation for namespace abi then you are - aware of the cross-vendor C++ ABI in use by GCC. One of the - exposed functions is used for demangling, - abi::__cxa_demangle. -

- In programs like c++filt, the linker, and other tools - have the ability to decode C++ ABI names, and now so can you. -

- (The function itself might use different demanglers, but that's the - whole point of abstract interfaces. If we change the implementation, - you won't notice.) -

- Probably the only times you'll be interested in demangling at runtime - are when you're seeing typeid strings in RTTI, or when - you're handling the runtime-support exception classes. For example: - 

-#include <exception>
-#include <iostream>
-#include <cxxabi.h>
-
-struct empty { };
-
-template <typename T, int N>
-  struct bar { };
-
-
-int main()
-{
-  int     status;
-  char   *realname;
-
-  // exception classes not in <stdexcept>, thrown by the implementation
-  // instead of the user
-  std::bad_exception  e;
-  realname = abi::__cxa_demangle(e.what(), 0, 0, &status);
-  std::cout << e.what() << "\t=> " << realname << "\t: " << status << '\n';
-  free(realname);
-
-
-  // typeid
-  bar<empty,17>          u;
-  const std::type_info  &ti = typeid(u);
-
-  realname = abi::__cxa_demangle(ti.name(), 0, 0, &status);
-  std::cout << ti.name() << "\t=> " << realname << "\t: " << status << '\n';
-  free(realname);
-
-  return 0;
-}
-

- This prints - 

-   
-      St13bad_exception       => std::bad_exception   : 0
-      3barI5emptyLi17EE       => bar<empty, 17>       : 0 
-   
-

- The demangler interface is described in the source documentation - linked to above. It is actually written in C, so you don't need to - be writing C++ in order to demangle C++. (That also means we have to - use crummy memory management facilities, so don't forget to free() - the returned char array.) -

Prev Up Next
Chapter 38. Input and Output Home Chapter 40. Concurrency
diff --git a/libstdc++-v3/doc/html/manual/concurrency.html b/libstdc++-v3/doc/html/manual/concurrency.html deleted file mode 100644 index b201c7639321..000000000000 --- a/libstdc++-v3/doc/html/manual/concurrency.html +++ /dev/null @@ -1,88 +0,0 @@ - - -Chapter 40. Concurrency
Chapter 40. Concurrency
Prev Part XII. Extensions Next

Chapter 40. Concurrency

Table of Contents

Design
Interface to Locks and Mutexes
Interface to Atomic Functions
Implementation
Using Builtin Atomic Functions
Thread Abstraction
Use

Design

Interface to Locks and Mutexes

The file <ext/concurrence.h> contains all the higher-level -constructs for playing with threads. In contrast to the atomics layer, -the concurrence layer consists largely of types. All types are defined within namespace __gnu_cxx. -

-These types can be used in a portable manner, regardless of the -specific environment. They are carefully designed to provide optimum -efficiency and speed, abstracting out underlying thread calls and -accesses when compiling for single-threaded situations (even on hosts -that support multiple threads.) -

The enumerated type _Lock_policy details the set of -available locking -policies: _S_single, _S_mutex, -and _S_atomic. -

  • _S_single

    Indicates single-threaded code that does not need locking. -

  • _S_mutex

    Indicates multi-threaded code using thread-layer abstractions. -

  • _S_atomic

    Indicates multi-threaded code using atomic operations. -

The compile-time constant __default_lock_policy is set -to one of the three values above, depending on characteristics of the -host environment and the current compilation flags. -

Two more datatypes make up the rest of the -interface: __mutex, and __scoped_lock. -

-

The scoped lock idiom is well-discussed within the C++ -community. This version takes a __mutex reference, and -locks it during construction of __scoped_locke and -unlocks it during destruction. This is an efficient way of locking -critical sections, while retaining exception-safety. -

Interface to Atomic Functions

-Two functions and one type form the base of atomic support. -

The type _Atomic_word is a signed integral type -supporting atomic operations. -

-The two functions functions are: -

-_Atomic_word
-__exchange_and_add_dispatch(volatile _Atomic_word*, int);
-
-void
-__atomic_add_dispatch(volatile _Atomic_word*, int);
-

Both of these functions are declared in the header file -<ext/atomicity.h>, and are in namespace __gnu_cxx. -

  • - -__exchange_and_add_dispatch - -

    Adds the second argument's value to the first argument. Returns the old value. -

  • - -__atomic_add_dispatch - -

    Adds the second argument's value to the first argument. Has no return value. -

-These functions forward to one of several specialized helper -functions, depending on the circumstances. For instance, -

- -__exchange_and_add_dispatch - -

-Calls through to either of: -

  • __exchange_and_add -

    Multi-thread version. Inlined if compiler-generated builtin atomics -can be used, otherwise resolved at link time to a non-builtin code -sequence. -

  • __exchange_and_add_single -

    Single threaded version. Inlined.

However, only __exchange_and_add_dispatch -and __atomic_add_dispatch should be used. These functions -can be used in a portable manner, regardless of the specific -environment. They are carefully designed to provide optimum efficiency -and speed, abstracting out atomic accesses when they are not required -(even on hosts that support compiler intrinsics for atomic -operations.) -

-In addition, there are two macros -

- -_GLIBCXX_READ_MEM_BARRIER - -

- -_GLIBCXX_WRITE_MEM_BARRIER - -

-Which expand to the appropriate write and read barrier required by the -host hardware and operating system. -

Prev Up Next
Chapter 39. Demangling Home Implementation