diff options
| author | bkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4> | 2008-01-18 08:16:51 +0000 |
|---|---|---|
| committer | bkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4> | 2008-01-18 08:16:51 +0000 |
| commit | 0aeadebf36eab6d537b67b38c5dcacf648f2f69f (patch) | |
| tree | 0fd3dc60ac26e2ec9502783b72d38867bcb418d8 /libstdc++-v3/doc/html/17_intro | |
| parent | 9e61be0719e3f9d3bda483eaaf71ee67f02e81ae (diff) | |
| download | ppe42-gcc-0aeadebf36eab6d537b67b38c5dcacf648f2f69f.tar.gz ppe42-gcc-0aeadebf36eab6d537b67b38c5dcacf648f2f69f.zip | |
2008-01-18 Benjamin Kosnik <bkoz@redhat.com>
* docs/*: To...
* doc/*: ...here.
* testsuite/Makefile.am: Move doc-performance to...
* Makefile.am: Add doc to SUBDIRS, move doxygen-* rules to...
* doc/Makefile.am: Consolidate documentation creation here.
(doc-doxygen-html): New.
(doc-doxygen-man): New.
(doc-performance): New.
* doc/Makefile.in: New.
* acinclude.m4 (glibcxx_SUBDIRS): Add doc directory.
* doc/doxygen/guide.html: Edit for unified html configuration.
* doc/doxygen/mainpage.html: Same.
* doc/doxygen/run_doxygen: Same, more namespace fixups for man
generation.
* doc/doxygen/user.cfg.in: Update for doxygen 1.5.4.
* include/tr1_impl/random: Remove maint from doxygen markup.
* include/tr1_impl/functional: Same.
* include/std/tuple: Same.
* include/std/streambuf: Same.
* include/std/bitset: Same.
* include/std/limits: Same.
* include/std/fstream: Same.
* include/std/istream: Same.
* include/std/sstream: Same.
* include/ext/pool_allocator.h: Same.
* include/ext/rc_string_base.h: Same.
* include/bits/basic_ios.h: Same.
* include/bits/stl_list.h: Same.
* include/bits/stl_map.h: Same.
* include/bits/locale_classes.h: Same.
* include/bits/stl_set.h: Same.
* include/bits/stl_iterator_base_types.h: Same.
* include/bits/basic_string.h: Same.
* include/bits/stl_multimap.h: Same.
* include/bits/stl_vector.h: Same.
* include/bits/ios_base.h: Same.
* include/bits/stl_deque.h: Same.
* include/bits/postypes.h: Same.
* include/bits/stl_multiset.h: Same.
* include/bits/stl_algo.h: Same.
* include/bits/stl_iterator.h: Same.
* include/bits/stl_tempbuf.h: Same.
* include/bits/stl_construct.h: Same.
* include/bits/stl_relops.h: Same.
* include/tr1/tuple: Same.
* include/backward/auto_ptr.h: Same.
* testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
Fixups for line number changes.
* testsuite/23_containers/vector/requirements/dr438/insert_neg.cc: Same.
* testsuite/23_containers/vector/requirements/dr438/
constructor_1_neg.cc: Same.
* testsuite/23_containers/vector/requirements/dr438/
constructor_2_neg.cc: Same.
* testsuite/23_containers/deque/requirements/dr438/assign_neg.cc: Same.
* testsuite/23_containers/deque/requirements/dr438/insert_neg.cc: Same.
* testsuite/23_containers/deque/requirements/dr438/
constructor_1_neg.cc: Same.
* testsuite/23_containers/deque/requirements/dr438/
constructor_2_neg.cc: Same.
* testsuite/23_containers/list/requirements/dr438/assign_neg.cc: Same.
* testsuite/23_containers/list/requirements/dr438/insert_neg.cc: Same.
* testsuite/23_containers/list/requirements/dr438/
constructor_1_neg.cc: Same.
* testsuite/23_containers/list/requirements/dr438/
constructor_2_neg.cc: Same.
* testsuite/20_util/auto_ptr/assign_neg.cc: Same.
* aclocal.m4: Regenerate.
* config.h.in: Regenerate.
* configure: Regenerate.
* Makefile.in: Regenerate.
* src/Makefile.in: Regenerate.
* po/Makefile.in: Regenerate.
* libmath/Makefile.in: Regenerate.
* include/Makefile.in: Regenerate.
* libsupc++/Makefile.in: Regenerate.
* testsuite/Makefile.in: Regenerate.
* scripts/make_graphs.py: Correct paths for new layout.
2008-01-17 Benjamin Kosnik <bkoz@redhat.com>
* acinclude.m4 (AC_LC_MESSAGES): Remove serial.
* linkage.m4 (AC_REPLACE_MATHFUNCS): Same.
* configure: Regenerate.
* aclocal.m4: Regenerate.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@131625 138bc75d-0d04-0410-961f-82ee72b054a4
Diffstat (limited to 'libstdc++-v3/doc/html/17_intro')
20 files changed, 18141 insertions, 0 deletions
diff --git a/libstdc++-v3/doc/html/17_intro/BADNAMES b/libstdc++-v3/doc/html/17_intro/BADNAMES new file mode 100644 index 00000000000..a904704ee39 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/BADNAMES @@ -0,0 +1,182 @@ + +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 Solarix: +_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_* + +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 diff --git a/libstdc++-v3/doc/html/17_intro/C++STYLE b/libstdc++-v3/doc/html/17_intro/C++STYLE new file mode 100644 index 00000000000..9eca719a32b --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/C++STYLE @@ -0,0 +1,399 @@ + +C++ Standard Library Coding Style Guidelines +------------------------------------- + +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 readibility. + + +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 + ie + + public: + int foo; + + -NOT- + public: + + int foo; + +13. Spacing WRT return statements. + no extra spacing before returns, no parenthesis + ie + + } + return __ret; + + -NOT- + } + + return __ret; + + -NOT- + + } + return (__ret); + + +14. Location of global variables. + All global variables of class type, whether in the "user visable" + 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 + + + diff --git a/libstdc++-v3/doc/html/17_intro/COPYING b/libstdc++-v3/doc/html/17_intro/COPYING new file mode 100644 index 00000000000..623b6258a13 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 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. + + 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. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 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. + + 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. + + 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: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) 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. + + c) 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. + + 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: + + a) 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, + + b) 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, + + c) 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. + + 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. + + 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. + + 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. + + 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. + + 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. + + 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. + + 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 + + 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. + + 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 + + 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. diff --git a/libstdc++-v3/doc/html/17_intro/COPYING.DOC b/libstdc++-v3/doc/html/17_intro/COPYING.DOC new file mode 100644 index 00000000000..1a864561bd4 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/COPYING.DOC @@ -0,0 +1,355 @@ + GNU Free Documentation License + Version 1.1, March 2000 + + Copyright (C) 2000 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. + + +0. PREAMBLE + +The purpose of this License is to make a manual, textbook, or other +written 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 that contains a +notice placed by the copyright holder saying it can be distributed +under the terms of this License. The "Document", below, refers to any +such manual or work. Any member of the public is a licensee, and is +addressed as "you". + +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. (For example, 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. + +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 "Transparent" copy of the Document means a machine-readable copy, +represented in a format whose specification is available to the +general public, whose contents can be viewed and edited directly and +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 has been designed to thwart or discourage +subsequent modification by readers is not Transparent. 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 designed for human modification. Opaque formats include +PostScript, PDF, 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 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. + + +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 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 publicly-accessible computer-network location containing a complete +Transparent copy of the Document, free of added material, which the +general network-using public has access to download anonymously at no +charge using public-standard network protocols. 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: + +A. 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. +B. 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 less than five). +C. State on the Title page the name of the publisher of the + Modified Version, as the publisher. +D. Preserve all the copyright notices of the Document. +E. Add an appropriate copyright notice for your modifications + adjacent to the other copyright notices. +F. 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. +G. Preserve in that license notice the full lists of Invariant Sections + and required Cover Texts given in the Document's license notice. +H. Include an unaltered copy of this License. +I. Preserve the section entitled "History", and 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. +J. 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. +K. In any section entitled "Acknowledgements" or "Dedications", + preserve the section's title, and preserve in the section all the + substance and tone of each of the contributor acknowledgements + and/or dedications given therein. +L. 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. +M. Delete any section entitled "Endorsements". Such a section + may not be included in the Modified Version. +N. Do not retitle any existing section as "Endorsements" + or to conflict in title with any Invariant Section. + +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. + +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, does not as a whole count as a Modified Version +of the Document, provided no compilation copyright is claimed for the +compilation. Such a compilation is called an "aggregate", and this +License does not apply to the other self-contained works thus compiled +with the Document, on account of their being thus compiled, if they +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 quarter +of the entire aggregate, the Document's Cover Texts may be placed on +covers that surround only the Document within the aggregate. +Otherwise they must appear on covers around 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 provided that you also include the +original English version of this License. In case of a disagreement +between the translation and the original English version of this +License, the original English version will prevail. + + +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.1 + or any later version published by the Free Software Foundation; + with the Invariant Sections being LIST THEIR TITLES, with the + Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. + A copy of the license is included in the section entitled "GNU + Free Documentation License". + +If you have no Invariant Sections, write "with no Invariant Sections" +instead of saying which ones are invariant. If you have no +Front-Cover Texts, write "no Front-Cover Texts" instead of +"Front-Cover Texts being LIST"; likewise for Back-Cover Texts. + +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. diff --git a/libstdc++-v3/doc/html/17_intro/DESIGN b/libstdc++-v3/doc/html/17_intro/DESIGN new file mode 100644 index 00000000000..5af3d9aed3b --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/DESIGN @@ -0,0 +1,859 @@ + +Standard C++ Library Design Document +------------------------------------ + +This is an overview of libstdc++-v3, with particular attention +to projects to be done and how they fit into the whole. + +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 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 instantiatiations 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 encapulation 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. + diff --git a/libstdc++-v3/doc/html/17_intro/TODO b/libstdc++-v3/doc/html/17_intro/TODO new file mode 100644 index 00000000000..a0a257c4876 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/TODO @@ -0,0 +1,164 @@ +std::allocator + + - persistent allocator + + - shared memory allocator (use or link to boost::shmem::allocator) + +std::string + + - document __gnu_cxx::__versa_string, add new policies + (Policy-based design incorporating COW + vs. deep copy issues, MT scalability + See Andrei Alexandrescu, June 2001, C/C++ Users Journal + "Generic<Programming>: A Policy-Based basic_string Implementation" + http://www.cuj.com/documents/s=7994/cujcexp1906alexandr/) + + - operator!= and utility/rel_ops operators need to be made safe with + string and vector iterator classes. basic_string::reverse_iterator may + be implemented incorrectly, or need things like + operator==(__normal_iterator, const char*&), and swap(vector) + + - 'do the right thing' ctor fixing needs to be done for string. This + is still subject to some debate on the library issues list, so I + suggest punting till the dust clears. + + - fix template members of basic_string<> to overload iterators and + non-iterators properly. (This is the infamous hack as in vector<> etc + 23.1.1 para 10.) + +std::locale + + - implement __convert_to_v and __convert_from_v without "C" library + functions and and LANG environment variable dependencies. + + - use localedata to implement generic named (non-MT-safe) locales? + Figure out a way to use ICU data, like libjava? Re-package and use + the glibc localedata, even if we aren't on linux? Need a generic + locale model that does something besides the "C" locale. + + - make locale::classic() separate from named locale code. This will + improve the static linkage situation, but will require new + initialization code. In particular, we need lazy-initialization of + locale::classic(), and maybe the has_facet/use_facet functions for all + the required facets. The end goal is a self-contained + locale_init.cc, or one with transitive closure without the locale + instantiations (locale-inst.cc) or the named locale bits + (localename.cc). + + - Jerry(?)/Paolo(?) work on __float_to_char. + + - minimize ctype convertion in data facets, see numpunct/num_put/num_get + +std::basic_filebuf, 27_io + + - wfilebuf, get variable-encoding working and tested, including + positioning and seeking. (I think this may be done now) + + - wfilebuf testsuite (getting there...) + + - look ahead for unbuffered io, so know when multiple putc's can be + coalesced. + + - unlocked __basic_file + new mutext class + + - optimized the sentries for istream/ostream + + - v2 vs. v3 speed + + - add optimization hooks (esp. whitespace eating) to streambuf + - add _M_begin() and _M_end() to streambuf + - add algorithm specializations for [io]streambuf_iterator (copy find etc.) + +testsuite + + - valgrind hooks into make check so can tell memory leakage + Some commentary on the valgrind users list + + - add hooks for qmtest, pychart, other for visual diffs + + - automatic testing of interactive tests + + - diffing generated output files + + - provide testsuites for numerics. + + - make check-abi needs to have full symbol checking. Scope the LSB + testsuite, see what's going on with the typeinfo etc. bits. + + - try to do a better job of ABI testing, with instantiations of all + standard-specified types checked, not just exported symbols. + +g++/binutils + + - compression for wide versions of basic types, not just narrow + +threads + + - create MT abstraction layer for atomicity to pthreads. + + - solution for threads + C++. + +other/random + +- relocations, work on getting these down + +- issues with __builtin_memcpy and std::copy from Jerry Quinn + http://gcc.gnu.org/ml/libstdc++/2003-02/msg00056.html + http://gcc.gnu.org/ml/libstdc++/2003-02/msg00302.html + http://gcc.gnu.org/ml/gcc/2003-10/msg01305.html + +- fix dependency tracking for includes (.h, .tcc) during build process. + +- coordinate with "C" library people the "C" compatibility headers. + +- Think about naming all member data and member functions consistently + as per + funtions: _M_verb_adverb + data: _M_noun_adjective + +- A C++STYLE guide that deals with nested namespaces, and that +everybody can live with. + +- exception specifications need to be reviewed for all parts of the +library support and utility areas, particularly <new>. Part of this is +a standards issue, where the 27_io standard is really in an odd +spot. Do the work to make this consistent. + +- C-related issues WRT to io and filepos, mbstate_t. Seeking in wide +streams. May need to define operators for mbstate_t so that +'mbstate_t& == mbstate_t' is something that can be done. + +- scoping/linking issues WRT to C structs need to be worked out. See +Nathan's commentary on cantrip, http://www.cantrip.org/cheaders.html + +- auto_ptr: seems to be some disagreement on what is +standards-conformant behavior, specially on conversion operators. + +- list::assignment operator needs const_cast + +- a cleaner division between pointers-to-value_type and true iterators +needs to be drawn throughout the entire STL implementation. + +- priority_queue conversions may be non-conformant + +- Protect valarray::result_type (not Standard) and make it work with + the various helper classes. + +- Make sure `valarray<bool> & == _Expr<_BinClos<logical_or,_ValArray,_ValArray,double,double>,bool>' + is defined + +- All of the Library working group closed issues need to be +addressed. Some of them proposed resolutions are already in the v-3 +sources, with macro-guards. Also, same with the TR. + +- need to think about doing a .texi or DocBook manual, instead of all +these HTML pages. In addition, it would be nice to have a full manual, +instead of a lot of ad-hoc pages. Weaknesses include numerics, locale, +and io. + +- add FAQ entries -- improve the install instructions + +- add HOWTO entries + +- do more doxygen manpages + diff --git a/libstdc++-v3/doc/html/17_intro/abi.html b/libstdc++-v3/doc/html/17_intro/abi.html new file mode 100644 index 00000000000..c27de61515c --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/abi.html @@ -0,0 +1,991 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta name="AUTHOR" content="bkoz@gcc.gnu.org (Benjamin Kosnik)" /> + <meta name="KEYWORDS" content="C++, libstdc++, dynamic, shared, library, ABI, version" /> + <meta name="DESCRIPTION" content="C++ Standard Library ABI" /> + <meta name="GENERATOR" content="emacs and ten fingers" /> + <title>Standard C++ Library ABI</title> +<link rel="StyleSheet" href="lib3styles.css" type="text/css" /> +<link rel="Start" href="documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +<link rel="Copyright" href="17_intro/license.html" type="text/html" /> +</head> +<body> + +<h1 class="centered"><a name="top">C++ Standard Library ABI</a></h1> + +<p class="fineprint"><em> + The latest version of this document is always available at + <a href="http://gcc.gnu.org/onlinedocs/libstdc++/abi.html"> + http://gcc.gnu.org/onlinedocs/libstdc++/abi.html</a>. +</em></p> + +<p><em> + To the <a href="http://gcc.gnu.org/libstdc++/">libstdc++ homepage</a>. +</em></p> + +<!-- ####################################################### --> +<hr /> +<h3 class="left"> + <a name="CXXinterface">The C++ interface</a> +</h3> + +<p> C++ applications often dependent on specific language support +routines, say for throwing exceptions, or catching exceptions, and +perhaps also dependent on features in the C++ Standard Library. +</p> + +<p> The C++ Standard Library has many include files, types defined in +those include files, specific named functions, and other behavior. The +text of these behaviors, as written in source include files, is called +the Application Programing Interface, or API. +</p> + +<p> Furthermore, C++ source that is compiled into object files is + transformed by the compiler: it arranges objects with specific + alignment and in a particular layout, mangling names according to a + well-defined algorithm, has specific arrangements for the support of + virtual functions, etc. These details are defined as the compiler + Application Binary Interface, or ABI. The GNU C++ compiler uses an + industry-standard C++ ABI starting with version 3. Details can be + found in the <a href="http://www.codesourcery.com/cxx-abi/abi.html"> + ABI specification</a>. +</p> + +<p> + The GNU C++ compiler, g++, has a compiler command line option to + switch between various different C++ ABIs. This explicit version + switch is the flag <code> -fabi-version</code>. In addition, some + g++ command line options may change the ABI as a side-effect of + use. Such flags include <code>-fpack-struct</code> and + <code>-fno-exceptions</code>, but include others: see the complete + list in the GCC manual under the heading <a + href="http://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code%20Gen%20Options">Options + for Code Generation Conventions</a>. +</p> + +<p> The configure options used when building a specific libstdc++ +version may also impact the resulting library ABI. The available +configure options, and their impact on the library ABI, are documented +<a href="http://gcc.gnu.org/onlinedocs/libstdc++/configopts.html"> +here</a>. +</p> + +<p> Putting all of these ideas together results in the C++ Standard +library ABI, which is the compilation of a given library API by a +given compiler ABI. In a nutshell: +</p> + +<code> library API + compiler ABI = library ABI</code> + +<p> + The library ABI is mostly of interest for end-users who have + unresolved symbols and are linking dynamically to the C++ Standard + library, and who thus must be careful to compile their application + with a compiler that is compatible with the available C++ Standard + library binary. In this case, compatible is defined with the equation + above: given an application compiled with a given compiler ABI and + library API, it will work correctly with a Standard C++ Library + created with the same constraints. +</p> + +<p> + To use a specific version of the C++ ABI, one must use a + corresponding GNU C++ toolchain (Ie, g++ and libstdc++) that + implements the C++ ABI in question. +</p> + +<h3 class="left"> + <a name="ABI_versioning">Versioning</a> +</h3> + +<p> The C++ interface has evolved throughout the history of the GNU +C++ toolchain. With each release, various details have been changed so +as to give distinct versions to the C++ interface. +</p> + +<h5 class="left"> + <a name="goals">Goals of versioning</a> +</h5> + +<p>Extending existing, stable ABIs. Versioning gives subsequent stable +releases series libraries the ability to add new symbols and add +functionality, all the while retaining backwards compatibility with +the previous releases in the series. Note: the reverse is not true. It +is not possible to take binaries linked with the latest version of a +release series (if symbols have been added) and expect the initial +release of the series to remain link compatible. +</p> + +<p>Allows multiple, incompatible ABIs to coexist at the same time. +</p> + +<p> +</p> + +<h5 class="left"> + <a name="details"> Version History </a> +</h5> +<p> + How can this complexity be managed? What does C++ versioning mean? + Because library and compiler changes often make binaries compiled + with one version of the GNU tools incompatible with binaries + compiled with other (either newer or older) versions of the same GNU + tools, specific techniques are used to make managing this complexity + easier. +</p> + +<p> + The following techniques are used: +</p> + + <ul> + + <li> <p>Release versioning on the libgcc_s.so binary. This is +implemented via file names and the ELF DT_SONAME mechanism (at least +on ELF systems).</p> + + <p>It is versioned as follows: + </p> + <ul> + <li>gcc-3.0.0: libgcc_s.so.1</li> + <li>gcc-3.0.1: libgcc_s.so.1</li> + <li>gcc-3.0.2: libgcc_s.so.1</li> + <li>gcc-3.0.3: libgcc_s.so.1</li> + <li>gcc-3.0.4: libgcc_s.so.1</li> + <li>gcc-3.1.0: libgcc_s.so.1</li> + <li>gcc-3.1.1: libgcc_s.so.1</li> + <li>gcc-3.2.0: libgcc_s.so.1</li> + <li>gcc-3.2.1: libgcc_s.so.1</li> + <li>gcc-3.2.2: libgcc_s.so.1</li> + <li>gcc-3.2.3: libgcc_s.so.1</li> + <li>gcc-3.3.0: libgcc_s.so.1</li> + <li>gcc-3.3.1: libgcc_s.so.1</li> + <li>gcc-3.3.2: libgcc_s.so.1</li> + <li>gcc-3.3.3: libgcc_s.so.1</li> + <li>gcc-3.4.x, gcc-4.0.x, gcc-4.1.x, gcc-4.2.x: on m68k-linux and + hppa-linux this is either libgcc_s.so.1 (when configuring + <code>--with-sjlj-exceptions</code>) or libgcc_s.so.2. For all + others, this is libgcc_s.so.1. </li> </ul> + <p></p> + </li> + + <li>Symbol versioning on the libgcc_s.so binary. + <p>mapfile: gcc/libgcc-std.ver</p> + + <p>It is versioned with the following labels and version + definitions, where the version definition is the maximum for a + particular release. Labels are cumulative. If a particular release + is not listed, it has the same version labels as the preceeding + release.</p> + <ul> + <li>gcc-3.0.0: GCC_3.0</li> + <li>gcc-3.3.0: GCC_3.3</li> + <li>gcc-3.3.1: GCC_3.3.1</li> + <li>gcc-3.3.2: GCC_3.3.2</li> + <li>gcc-3.3.4: GCC_3.3.4</li> + <li>gcc-3.4.0: GCC_3.4</li> + <li>gcc-3.4.2: GCC_3.4.2</li> + <li>gcc-3.4.4: GCC_3.4.4</li> + <li>gcc-4.0.0: GCC_4.0.0</li> + <li>gcc-4.1.0: GCC_4.1.0</li> + <li>gcc-4.2.0: GCC_4.2.0</li> + </ul> + <p></p> + </li> + + <li>Release versioning on the libstdc++.so binary, implemented in the same was as the libgcc_s.so binary, above. + + <p>It is versioned as follows: + </p> + <ul> + <li>gcc-3.0.0: libstdc++.so.3.0.0</li> + <li>gcc-3.0.1: libstdc++.so.3.0.1</li> + <li>gcc-3.0.2: libstdc++.so.3.0.2</li> + <li>gcc-3.0.3: libstdc++.so.3.0.2 (Error should be libstdc++.so.3.0.3)</li> + <li>gcc-3.0.4: libstdc++.so.3.0.4</li> + <li>gcc-3.1.0: libstdc++.so.4.0.0</li> + <li>gcc-3.1.1: libstdc++.so.4.0.1</li> + <li>gcc-3.2.0: libstdc++.so.5.0.0</li> + <li>gcc-3.2.1: libstdc++.so.5.0.1</li> + <li>gcc-3.2.2: libstdc++.so.5.0.2</li> + <li>gcc-3.2.3: libstdc++.so.5.0.3 (Not strictly required)</li> + <li>gcc-3.3.0: libstdc++.so.5.0.4</li> + <li>gcc-3.3.1: libstdc++.so.5.0.5</li> + <li>gcc-3.3.2: libstdc++.so.5.0.5</li> + <li>gcc-3.3.3: libstdc++.so.5.0.5</li> + <li>gcc-3.4.0: libstdc++.so.6.0.0</li> + <li>gcc-3.4.1: libstdc++.so.6.0.1</li> + <li>gcc-3.4.2: libstdc++.so.6.0.2</li> + <li>gcc-3.4.3: libstdc++.so.6.0.3</li> + <li>gcc-3.4.4: libstdc++.so.6.0.3</li> + <li>gcc-3.4.5: libstdc++.so.6.0.3</li> + <li>gcc-3.4.6: libstdc++.so.6.0.3</li> + <li>gcc-4.0.0: libstdc++.so.6.0.4</li> + <li>gcc-4.0.1: libstdc++.so.6.0.5</li> + <li>gcc-4.0.2: libstdc++.so.6.0.6</li> + <li>gcc-4.0.3: libstdc++.so.6.0.7</li> + <li>gcc-4.1.0: libstdc++.so.6.0.7</li> + <li>gcc-4.1.1: libstdc++.so.6.0.8</li> + <li>gcc-4.1.2: libstdc++.so.6.0.8</li> + <li>gcc-4.2.0: libstdc++.so.6.0.9</li> + </ul> + <p></p> + </li> + + <li>Symbol versioning on the libstdc++.so binary. + + <p>mapfile: libstdc++/config/linker-map.gnu</p> + <p>It is versioned with the following labels and version + definitions, where the version definition is the maximum for a + particular release. Note, only symbol which are newly introduced + will use the maximum version definition. Thus, for release series + with the same label, but incremented version definitions, the later + release has both versions. (An example of this would be the + gcc-3.2.1 release, which has GLIBCPP_3.2.1 for new symbols and + GLIBCPP_3.2 for symbols that were introduced in the gcc-3.2.0 + release.) If a particular release is not listed, it has the same + version labels as the preceeding release. + </p> + <ul> + <li>gcc-3.0.0: (Error, not versioned)</li> + <li>gcc-3.0.1: (Error, not versioned)</li> + <li>gcc-3.0.2: (Error, not versioned)</li> + <li>gcc-3.0.3: (Error, not versioned)</li> + <li>gcc-3.0.4: (Error, not versioned)</li> + <li>gcc-3.1.0: GLIBCPP_3.1, CXXABI_1</li> + <li>gcc-3.1.1: GLIBCPP_3.1, CXXABI_1</li> + <li>gcc-3.2.0: GLIBCPP_3.2, CXXABI_1.2</li> + <li>gcc-3.2.1: GLIBCPP_3.2.1, CXXABI_1.2</li> + <li>gcc-3.2.2: GLIBCPP_3.2.2, CXXABI_1.2</li> + <li>gcc-3.2.3: GLIBCPP_3.2.2, CXXABI_1.2</li> + <li>gcc-3.3.0: GLIBCPP_3.2.2, CXXABI_1.2.1</li> + <li>gcc-3.3.1: GLIBCPP_3.2.3, CXXABI_1.2.1</li> + <li>gcc-3.3.2: GLIBCPP_3.2.3, CXXABI_1.2.1</li> + <li>gcc-3.3.3: GLIBCPP_3.2.3, CXXABI_1.2.1</li> + <li>gcc-3.4.0: GLIBCXX_3.4, CXXABI_1.3</li> + <li>gcc-3.4.1: GLIBCXX_3.4.1, CXXABI_1.3</li> + <li>gcc-3.4.2: GLIBCXX_3.4.2</li> + <li>gcc-3.4.3: GLIBCXX_3.4.3</li> + <li>gcc-4.0.0: GLIBCXX_3.4.4, CXXABI_1.3.1</li> + <li>gcc-4.0.1: GLIBCXX_3.4.5</li> + <li>gcc-4.0.2: GLIBCXX_3.4.6</li> + <li>gcc-4.0.3: GLIBCXX_3.4.7</li> + <li>gcc-4.1.1: GLIBCXX_3.4.8</li> + <li>gcc-4.2.0: GLIBCXX_3.4.9</li> + </ul> + <p></p> + </li> + + <li> + <p>Incremental bumping of a compiler pre-defined macro, + __GXX_ABI_VERSION. This macro is defined as the version of the + compiler v3 ABI, with g++ 3.0.x being version 100. This macro will + be automatically defined whenever g++ is used (the curious can + test this by invoking g++ with the '-v' flag.) + </p> + + <p> + This macro was defined in the file "lang-specs.h" in the gcc/cp directory. + Later versions defined it in "c-common.c" in the gcc directory, and from + G++ 3.4 it is defined in c-cppbuiltin.c and its value determined by the + '-fabi-version' command line option. + </p> + + <p> + It is versioned as follows, where 'n' is given by '-fabi-version=n': + </p> + <ul> + <li>gcc-3.0.x: 100</li> + <li>gcc-3.1.x: 100 (Error, should be 101)</li> + <li>gcc-3.2.x: 102</li> + <li>gcc-3.3.x: 102</li> + <li>gcc-3.4.x, gcc-4.0.x, gcc-4.1.x, gcc-4.2.x: 102 (when n=1)</li> + <li>gcc-3.4.x, gcc-4.0.x, gcc-4.1.x, gcc-4.2.x: 1000 + n (when n>1)</li> + <li>gcc-3.4.x, gcc-4.0.x, gcc-4.1.x, gcc-4.2.x: 999999 (when n=0)</li> + </ul> + <p></p> + </li> + + <li> + <p>Changes to the default compiler option for + <code>-fabi-version</code>. + </p> + <p> + It is versioned as follows: + </p> + <ul> + <li>gcc-3.0.x: (Error, not versioned) </li> + <li>gcc-3.1.x: (Error, not versioned) </li> + <li>gcc-3.2.x: <code>-fabi-version=1</code></li> + <li>gcc-3.3.x: <code>-fabi-version=1</code></li> + <li>gcc-3.4.x, gcc-4.0.x, gcc-4.1.x, gcc-4.2.x: <code>-fabi-version=2</code></li> + </ul> + <p></p> + </li> + + <li> + <p>Incremental bumping of a library pre-defined macro. For releases + before 3.4.0, the macro is __GLIBCPP__. For later releases, it's + __GLIBCXX__. (The libstdc++ project generously changed from CPP to + CXX throughout its source to allow the "C" pre-processor the CPP + macro namespace.) These macros are defined as the date the library + was released, in compressed ISO date format, as an unsigned long. + </p> + + <p> + This macro is defined in the file "c++config" in the + "libstdc++/include/bits" directory. (Up to gcc-4.1.0, it was + changed every night by an automated script. Since gcc-4.1.0, it is + the same value as gcc/DATESTAMP.) + </p> + <p> + It is versioned as follows: + </p> + <ul> + <li>gcc-3.0.0: 20010615</li> + <li>gcc-3.0.1: 20010819</li> + <li>gcc-3.0.2: 20011023</li> + <li>gcc-3.0.3: 20011220</li> + <li>gcc-3.0.4: 20020220</li> + <li>gcc-3.1.0: 20020514</li> + <li>gcc-3.1.1: 20020725</li> + <li>gcc-3.2.0: 20020814</li> + <li>gcc-3.2.1: 20021119</li> + <li>gcc-3.2.2: 20030205</li> + <li>gcc-3.2.3: 20030422</li> + <li>gcc-3.3.0: 20030513</li> + <li>gcc-3.3.1: 20030804</li> + <li>gcc-3.3.2: 20031016</li> + <li>gcc-3.3.3: 20040214</li> + <li>gcc-3.4.0: 20040419</li> + <li>gcc-3.4.1: 20040701</li> + <li>gcc-3.4.2: 20040906</li> + <li>gcc-3.4.3: 20041105</li> + <li>gcc-3.4.4: 20050519</li> + <li>gcc-3.4.5: 20051201</li> + <li>gcc-3.4.6: 20060306</li> + <li>gcc-4.0.0: 20050421</li> + <li>gcc-4.0.1: 20050707</li> + <li>gcc-4.0.2: 20050921</li> + <li>gcc-4.0.3: 20060309</li> + <li>gcc-4.1.0: 20060228</li> + <li>gcc-4.1.1: 20060524</li> + <li>gcc-4.1.2: 20070214</li> + <li>gcc-4.2.0: 20070514</li> + </ul> + <p></p> + </li> + + <li> + <p> + Incremental bumping of a library pre-defined macro, + _GLIBCPP_VERSION. This macro is defined as the released version of + the library, as a string literal. This is only implemented in + gcc-3.1.0 releases and higher, and is deprecated in 3.4 (where it + is called _GLIBCXX_VERSION). + </p> + + <p> + This macro is defined in the file "c++config" in the + "libstdc++/include/bits" directory and is generated + automatically by autoconf as part of the configure-time generation + of config.h. + </p> + + <p> + It is versioned as follows: + </p> + <ul> + <li>gcc-3.0.0: "3.0.0"</li> + <li>gcc-3.0.1: "3.0.0" (Error, should be "3.0.1")</li> + <li>gcc-3.0.2: "3.0.0" (Error, should be "3.0.2")</li> + <li>gcc-3.0.3: "3.0.0" (Error, should be "3.0.3")</li> + <li>gcc-3.0.4: "3.0.0" (Error, should be "3.0.4")</li> + <li>gcc-3.1.0: "3.1.0"</li> + <li>gcc-3.1.1: "3.1.1"</li> + <li>gcc-3.2.0: "3.2"</li> + <li>gcc-3.2.1: "3.2.1"</li> + <li>gcc-3.2.2: "3.2.2"</li> + <li>gcc-3.2.3: "3.2.3"</li> + <li>gcc-3.3.0: "3.3"</li> + <li>gcc-3.3.1: "3.3.1"</li> + <li>gcc-3.3.2: "3.3.2"</li> + <li>gcc-3.3.3: "3.3.3"</li> + <li>gcc-3.4.x: "version-unused"</li> + <li>gcc-4.0.x: "version-unused"</li> + <li>gcc-4.1.x: "version-unused"</li> + <li>gcc-4.2.x: "version-unused"</li> + </ul> + <p></p> + </li> + + <li> + <p> + Matching each specific C++ compiler release to a specific set of + C++ include files. This is only implemented in gcc-3.1.1 releases + and higher. + </p> + <p> + All C++ includes are installed in include/c++, then nest in a + directory hierarchy corresponding to the C++ compiler's released + version. This version corresponds to the variable "gcc_version" in + "libstdc++/acinclude.m4," and more details can be found in that + file's macro GLIBCXX_CONFIGURE (GLIBCPP_CONFIGURE before gcc-3.4.0). + </p> + <p> + C++ includes are versioned as follows: + </p> + <ul> + <li>gcc-3.0.0: include/g++-v3</li> + <li>gcc-3.0.1: include/g++-v3</li> + <li>gcc-3.0.2: include/g++-v3</li> + <li>gcc-3.0.3: include/g++-v3</li> + <li>gcc-3.0.4: include/g++-v3</li> + <li>gcc-3.1.0: include/g++-v3</li> + <li>gcc-3.1.1: include/c++/3.1.1</li> + <li>gcc-3.2.0: include/c++/3.2</li> + <li>gcc-3.2.1: include/c++/3.2.1</li> + <li>gcc-3.2.2: include/c++/3.2.2</li> + <li>gcc-3.2.3: include/c++/3.2.3</li> + <li>gcc-3.3.0: include/c++/3.3</li> + <li>gcc-3.3.1: include/c++/3.3.1</li> + <li>gcc-3.3.2: include/c++/3.3.2</li> + <li>gcc-3.3.3: include/c++/3.3.3</li> + <li>gcc-3.4.0: include/c++/3.4.0</li> + <li>gcc-3.4.1: include/c++/3.4.1</li> + <li>gcc-3.4.2: include/c++/3.4.2</li> + <li>gcc-3.4.3: include/c++/3.4.3</li> + <li>gcc-3.4.4: include/c++/3.4.4</li> + <li>gcc-3.4.5: include/c++/3.4.5</li> + <li>gcc-3.4.6: include/c++/3.4.6</li> + <li>gcc-4.0.0: include/c++/4.0.0</li> + <li>gcc-4.0.1: include/c++/4.0.1</li> + <li>gcc-4.0.2: include/c++/4.0.2</li> + <li>gcc-4.0.3: include/c++/4.0.3</li> + <li>gcc-4.1.0: include/c++/4.1.0</li> + <li>gcc-4.1.1: include/c++/4.1.1</li> + <li>gcc-4.1.2: include/c++/4.1.2</li> + <li>gcc-4.2.0: include/c++/4.2.0</li> + </ul> + <p></p> + </li> + </ul> +<p> + Taken together, these techniques can accurately specify interface + and implementation changes in the GNU C++ tools themselves. Used + properly, they allow both the GNU C++ tools implementation, and + programs using them, an evolving yet controlled development that + maintains backward compatibility. +</p> + + + +<h5 class="left"> + <a name="requirements"> Minimum requirements for a versioned ABI </a> +</h5> +<p> + Minimum environment that supports a versioned ABI: A supported + dynamic linker, a GNU linker of sufficient vintage to understand + demangled C++ name globbing (ld), a shared executable compiled with + g++, and shared libraries (libgcc_s, libstdc++) compiled by a + compiler (g++) with a compatible ABI. Phew. +</p> + +<p> + On top of all that, an additional constraint: libstdc++ did not + attempt to version symbols (or age gracefully, really) until version + 3.1.0. +</p> + +<p> + Most modern Linux and BSD versions, particularly ones using + gcc-3.1.x tools and more recent vintages, will meet the requirements above. +</p> + + +<h5 class="left"> + <a name="config"> What configure options impact symbol versioning? </a> +</h5> +<p> + It turns out that most of the configure options that change default + behavior will impact the mangled names of exported symbols, and thus + impact versioning and compatibility. +</p> + +<p> + For more information on configure options, including ABI impacts, see: + http://gcc.gnu.org/onlinedocs/libstdc++/configopts.html +</p> + +<p> + There is one flag that explicitly deals with symbol versioning: + --enable-symvers. +</p> + +<p> + In particular, libstdc++/acinclude.m4 has a macro called + GLIBCXX_ENABLE_SYMVERS that defaults to yes (or the argument passed + in via --enable-symvers=foo). At that point, the macro attempts to + make sure that all the requirement for symbol versioning are in + place. For more information, please consult acinclude.m4. +</p> + + +<h5 class="left"> + <a name="active"> How to tell if symbol versioning is, indeed, active? </a> +</h5> +<p> + When the GNU C++ library is being built with symbol versioning on, + you should see the following at configure time for libstdc++: +</p> + + +<code> checking versioning on shared library symbols... gnu</code> + +<p> + If you don't see this line in the configure output, or if this line + appears but the last word is 'no', then you are out of luck. +</p> + +<p> + If the compiler is pre-installed, a quick way to test is to compile + the following (or any) simple C++ file and link it to the shared + libstdc++ library: +</p> + +<pre> +#include <iostream> + +int main() +{ std::cout << "hello" << std::endl; return 0; } + +%g++ hello.cc -o hello.out + +%ldd hello.out + libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000) + libm.so.6 => /lib/tls/libm.so.6 (0x004a8000) + libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40016000) + libc.so.6 => /lib/tls/libc.so.6 (0x0036d000) + /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) + +%nm hello.out +</pre> + +<p> +If you see symbols in the resulting output with "GLIBCXX_3" as part +of the name, then the executable is versioned. Here's an example: +</p> + + <code> U _ZNSt8ios_base4InitC1Ev@@GLIBCXX_3.4 </code> + +<h3 class="left"> + <a name="ABI_allowed">Library allowed ABI changes</a> +</h3> +<p> +The following will cause the library minor version number to +increase, say from "libstdc++.so.3.0.4" to "libstdc++.so.3.0.5". +</p> +<ul> + <li>adding an exported global or static data member</li> + <li>adding an exported function, static or non-virtual member function</li> + <li>adding an exported symbol or symbols by additional instantiations</li> +</ul> +<p> +</p> +<p> +Other allowed changes are possible. +</p> + + +<h3 class="left"> + <a name="ABI_disallowed">Library disallowed ABI changes</a> +</h3> + +<p> +The following non-exhaustive list will cause the library major version +number to increase, say from "libstdc++.so.3.0.4" to +"libstdc++.so.4.0.0". +</p> +<ul> + <li>changes in the gcc/g++ compiler ABI</li> +<li>changing size of an exported symbol</li> +<li>changing alignment of an exported symbol</li> +<li>changing the layout of an exported symbol</li> +<li>changing mangling on an exported symbol</li> +<li>deleting an exported symbol</li> +<li>changing the inheritance properties of a type by adding or removing + base classes</li> +<li> + changing the size, alignment, or layout of types + specified in the C++ standard. These may not necessarily be + instantiated or otherwise exported in the library binary, and + include all the required locale facets, as well as things like + std::basic_streambuf, et al. +</li> + +<li> adding an explicit copy constructor or destructor to a +class that would otherwise have implicit versions. This will change +the way the compiler deals with this class in by-value return +statements or parameters: instead of being passing instances of this +class in registers, the compiler will be forced to use memory. See <a +href="http://www.codesourcery.com/cxx-abi/abi.html#calls"> this part</a> + of the C++ ABI documentation for further details. + </li> + +</ul> + +<h3 class="left"> + <a name="implementation">Library implementation strategy</a> </h3> + +<ul> + <li>Separation of interface and implementation +<p>This is accomplished by two techniques that separate the API from +the ABI: forcing undefined references to link against a library binary +for definitions. +</p> + + <dl> + <dt>Include files have declarations, source files have defines</dt> + + <dd> For non-templatized types, such as much of <code>class + locale</code>, the appropriate standard C++ include, say + <code>locale</code>, can contain full declarations, while various + source files (say <code> locale.cc, locale_init.cc, + localename.cc</code>) contain definitions.</dd> + + <dt>Extern template on required types</dt> + + <dd>For parts of the standard that have an explicit list of required + instantiations, the GNU extension syntax <code> extern template + </code> can be used to control where template definitions + reside. By marking required instantiations as <code> extern + template </code> in include files, and providing explicit + instantiations in the appropriate instantiation files, non-inlined + template functions can be versioned. This technique is mostly used + on parts of the standard that require <code> char</code> and <code> + wchar_t</code> instantiations, and includes <code> + basic_string</code>, the locale facets, and the types in <code> + iostreams</code>.</dd> + + </dl> + <p> In addition, these techniques have the additional benefit that + they reduce binary size, which can increase runtime performance. + </p> + </li> + + <li>Namespaces linking symbol definitions to export mapfiles + +<p>All symbols in the shared library binary are processed by a linker +script at build time that either allows or disallows external +linkage. Because of this, some symbols, regardless of normal C/C++ +linkage, are not visible. Symbols that are internal have several +appealing characteristics: by not exporting the symbols, there are no +relocations when the shared library is started and thus this makes for +faster runtime loading performance by the underlying dynamic loading +mechanism. In addition, they have the possibility of changing without +impacting ABI compatibility. +</p> + +<p>The following namespaces are transformed by the mapfile:</p> + +<dl> +<dt><code>namespace std</code></dt> +<dd> Defaults to exporting all symbols in label +<code>GLIBCXX</code> that do not begin with an underscore, ie +<code>__test_func</code> would not be exported by default. Select +exceptional symbols are allowed to be visible.</dd> + +<dt><code>namespace __gnu_cxx</code></dt> +<dd> Defaults to not exporting any symbols in label +<code>GLIBCXX</code>, select items are allowed to be visible.</dd> + +<dt><code>namespace __gnu_internal</code></dt> +<dd> Defaults to not exported, no items are allowed to be visible.</dd> + +<dt><code>namespace __cxxabiv1</code>, aliased to <code> namespace abi</code></dt> +<dd> Defaults to not exporting any symbols in label +<code>CXXABI</code>, select items are allowed to be visible.</dd> +</dl> +<p> +</p> +</li> + + <li>Freezing the API + <p>Disallowed changes, as above, are not made on a stable release +branch. Enforcement tends to be less strict with GNU extensions that +standard includes.</p> +</li> +</ul> + +<h3 class="left"> + <a name="ABI_testing">Testing ABI changes</a> +</h3> + +<p> +Testing for GNU C++ ABI changes is composed of two distinct areas: +testing the C++ compiler (g++) for compiler changes, and testing the +C++ library (libstdc++) for library changes. +</p> + +<p> +Testing the C++ compiler ABI can be done various ways. +</p> + +<p> +One. +Intel ABI checker. More information can be obtained +<a href="http://developer.intel.com/software/products/opensource/">here.</a> +</p> + +<p> +Two. +The second is yet unreleased, but has been announced on the gcc +mailing list. It is yet unspecified if these tools will be freely +available, and able to be included in a GNU project. Please contact +Mark Mitchell (mark@codesourcery.com) for more details, and current +status. +</p> + +<p> +Three. +Involves using the vlad.consistency test framework. This has also been +discussed on the gcc mailing lists. +</p> + +<p> +Testing the C++ library ABI can also be done various ways. +</p> + +<p> +One. +(Brendan Kehoe, Jeff Law suggestion to run 'make check-c++' two ways, +one with a new compiler and an old library, and the other with an old +compiler and a new library, and look for testsuite regressions) +</p> + +<p> +Details on how to set this kind of test up can be found here: +http://gcc.gnu.org/ml/gcc/2002-08/msg00142.html +</p> + +<p> +Two. +Use the 'make check-abi' rule in the libstdc++ Makefile. +</p> + +<p> +This is a proactive check the library ABI. Currently, exported symbol +names that are either weak or defined are checked against a last known +good baseline. Currently, this baseline is keyed off of 3.4.0 +binaries, as this was the last time the .so number was incremented. In +addition, all exported names are demangled, and the exported objects +are checked to make sure they are the same size as the same object in +the baseline. + +Notice that each baseline is relative to a <strong>default</strong> +configured library and compiler: in particular, if options such as +--enable-clocale, or --with-cpu, in case of multilibs, are used at +configure time, the check may fail, either because of substantive +differences or because of limitations of the current checking +machinery. +</p> + +<p> +This dataset is insufficient, yet a start. Also needed is a +comprehensive check for all user-visible types part of the standard +library for sizeof() and alignof() changes. +</p> + +<p> +Verifying compatible layouts of objects is not even attempted. It +should be possible to use sizeof, alignof, and offsetof to compute +offsets for each structure and type in the standard library, saving to +another datafile. Then, compute this in a similar way for new +binaries, and look for differences. +</p> + +<p> +Another approach might be to use the -fdump-class-hierarchy flag to +get information. However, currently this approach gives insufficient +data for use in library testing, as class data members, their offsets, +and other detailed data is not displayed with this flag. +(See g++/7470 on how this was used to find bugs.) +</p> + +<p> +Perhaps there are other C++ ABI checkers. If so, please notify +us. We'd like to know about them! +</p> + +<h3 class="left"> + <a name="ABI_multi_testing">Testing Multi-ABI binaries</a> +</h3> + +<p> +A "C" application, dynamically linked to two shared libraries, liba, +libb. The dependent library liba is C++ shared library compiled with +gcc-3.3.x, and uses io, exceptions, locale, etc. The dependent library +libb is a C++ shared library compiled with gcc-3.4.x, and also uses io, +exceptions, locale, etc. +</p> + +<p> As above, libone is constructed as follows: </p> +<pre> +%$bld/H-x86-gcc-3.4.0/bin/g++ -fPIC -DPIC -c a.cc + +%$bld/H-x86-gcc-3.4.0/bin/g++ -shared -Wl,-soname -Wl,libone.so.1 -Wl,-O1 -Wl,-z,defs a.o -o libone.so.1.0.0 + +%ln -s libone.so.1.0.0 libone.so + +%$bld/H-x86-gcc-3.4.0/bin/g++ -c a.cc + +%ar cru libone.a a.o +</pre> + +<p> And, libtwo is constructed as follows: </p> + +<pre> +%$bld/H-x86-gcc-3.3.3/bin/g++ -fPIC -DPIC -c b.cc + +%$bld/H-x86-gcc-3.3.3/bin/g++ -shared -Wl,-soname -Wl,libtwo.so.1 -Wl,-O1 -Wl,-z,defs b.o -o libtwo.so.1.0.0 + +%ln -s libtwo.so.1.0.0 libtwo.so + +%$bld/H-x86-gcc-3.3.3/bin/g++ -c b.cc + +%ar cru libtwo.a b.o +</pre> + +<p> ...with the resulting libraries looking like </p> +<pre> +%ldd libone.so.1.0.0 + libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40016000) + libm.so.6 => /lib/tls/libm.so.6 (0x400fa000) + libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x4011c000) + libc.so.6 => /lib/tls/libc.so.6 (0x40125000) + /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) + +%ldd libtwo.so.1.0.0 + libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x40027000) + libm.so.6 => /lib/tls/libm.so.6 (0x400e1000) + libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40103000) + libc.so.6 => /lib/tls/libc.so.6 (0x4010c000) + /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) + +</pre> + +<p> Then, the "C" compiler is used to compile a source file that uses +functions from each library.</p> +<pre> +gcc test.c -g -O2 -L. -lone -ltwo /usr/lib/libstdc++.so.5 /usr/lib/libstdc++.so.6 +</pre> + +<p> +Which gives the expected: +</p> +<pre> +%ldd a.out + libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000) + libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40015000) + libc.so.6 => /lib/tls/libc.so.6 (0x0036d000) + libm.so.6 => /lib/tls/libm.so.6 (0x004a8000) + libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x400e5000) + /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) +</pre> + +<p> +This resulting binary, when executed, will be able to safely use code +from both liba, and the dependent libstdc++.so.6, and libb, with the +dependent libstdc++.so.5. +</p> + + +<h3 class="left"> + <a name="Outstanding Issues">Outstanding Issues</a> +</h3> + +<p> Some features in the C++ language make versioning especially +difficult. In particular, compiler generated constructs such as +implicit instantiations for templates, typeinfo information, and +virtual tables all may cause ABI leakage across shared library +boundaries. Because of this, mixing C++ ABI's is not recommended at +this time. +</p> + +<p>For more background on this issue, see these bugzilla entries:</p> + +<p> +<a href="http://gcc.gnu.org/PR24660">24660: versioning weak symbols in libstdc++</a> +</p> + +<p> +<a href="http://gcc.gnu.org/PR19664">19664: libstdc++ headers should have pop/push of the visibility around the declarations</a> +</p> + +<h3 class="left"> + <a name="references">Bibliography / Further Reading</a> +</h3> + +<p> +ABIcheck, a vague idea of checking ABI compatibility +<br /> +<a href="http://abicheck.sourceforge.net/">http://abicheck.sourceforge.net/</a> +</p> + +<p> +C++ ABI reference +<br /> +<a href="http://www.codesourcery.com/cxx-abi/">http://www.codesourcery.com/cxx-abi/</a> +</p> + +<p> +Intel ABI documentation, "Intel® Compilers for Linux* -Compatibility with the GNU Compilers" +<br /> +<a href="http://developer.intel.com/software/products/compilers/techtopics/LinuxCompilersCompatibility.htm">http://developer.intel.com/software/products/compilers/techtopics/LinuxCompilersCompatibility.htm</a> +</p> + +<p> +Sun Solaris 2.9 docs +<br /> +Linker and Libraries Guide (document 816-1386) +<br /> +C++ Migration Guide (document 816-2459) +<br /> +<a href="http://docs.sun.com/db/prod/solaris.9">http://docs.sun.com/db/prod/solaris.9</a> +<br /> +<a href="http://docs.sun.com/?p=/doc/816-1386&a=load">http://docs.sun.com/?p=/doc/816-1386&a=load</a> +</p> + +<p> +Ulrich Drepper, "ELF Symbol Versioning" +<br /> +<a href="http://people.redhat.com/drepper/symbol-versioning">http://people.redhat.com/drepper/symbol-versioning</a> +</p> + +<p> +C++ ABI for the ARM Architecture +<br /> +<a href="http://www.arm.com/miscPDFs/8033.pdf">http://www.arm.com/miscPDFs/8033.pdf</a> +</p> + +<p> +Benjamin Kosnik, ISO C++ J16/06-0046 +<br /> +<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1976.html">Dynamic Shared Objects: Survey and Issues</a> +</p> + +<p> +Benjamin Kosnik, ISO C++ J16/06-0083 +<br /> +<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2013.html">Versioning With Namespaces</a> +</p> + +</body> +</html> + diff --git a/libstdc++-v3/doc/html/17_intro/api.html b/libstdc++-v3/doc/html/17_intro/api.html new file mode 100644 index 00000000000..1d1e36d90d2 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/api.html @@ -0,0 +1,290 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta name="AUTHOR" content="bkoz@gcc.gnu.org (Benjamin Kosnik)" /> + <meta name="KEYWORDS" content="C++, libstdc++, API, evolution, deprecate" /> + <meta name="DESCRIPTION" content="API evolution and deprecation history" /> + <meta name="GENERATOR" content="emacs and ten fingers" /> + <title>API Evolution and Deprecation History</title> +<link rel="StyleSheet" href="lib3styles.css" type="text/css" /> +<link rel="Start" href="documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +<link rel="Copyright" href="17_intro/license.html" type="text/html" /> +</head> +<body> + +<h1 class="centered"><a name="top">API Evolution and Deprecation History</a></h1> + +<p class="fineprint"><em> + The latest version of this document is always available at + <a href="http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/api.html"> + http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/api.html</a>. +</em></p> + +<p><em> + To the <a href="http://gcc.gnu.org/libstdc++/">libstdc++ homepage</a>. +</em></p> + +<!-- ####################################################### --> + +<hr /> +<h3 class="left"> + <a name="intro">API Evolution, Deprecation, and History of User Visible Changes</a> +</h3> + +<p> A list of user-visible changes, by release version. +</p> + +<h3 class="left"> + <a name="3.0">3.0</a> +</h3> + +<p> +Extensions moved to <code>include/ext</code>. +</p> + +<p> +Include files from the SGI/HP sources that pre-date the ISO standard +are added. These files are placed into +the <code>include/backward</code> directory and a deprecated warning +is added that notifies on inclusion (<code>-Wno-deprecated</code> +deactivates the warning.) +</p> + +<p>Deprecated include <backward/strstream> added.</p> + +<p>Removal of include <builtinbuf.h>, <indstream.h>, <parsestream.h>, <PlotFile.h>, <SFile.h>, <stdiostream.h>, and <stream.h>.</p> + + +<h3 class="left"> + <a name="3.1">3.1</a> +</h3> + +<p> +Extensions from SGI/HP moved from <code>namespace std</code> +to <code>namespace __gnu_cxx</code>. As part of this, the following +new includes are +added: <ext/algorithm>, <ext/functional>, <ext/iterator>, <ext/memory>, and <ext/numeric>. +</p> + +<p> +Extensions to <code>basic_filebuf</code> introduced: <code>__gnu_cxx::enc_filebuf</code>, and <code>__gnu_cxx::stdio_filebuf</code>. +</p> + +<p> +Extensions to tree data structures added in <ext/rb_tree>. +</p> + +<p> +Removal of <ext/tree>, moved to <backward/tree.h>. +</p> + + +<h3 class="left"> + <a name="3.2">3.2</a> +</h3> +<p>Symbol versioning introduced for shared library.</p> + +<p>Removal of include <backward/strstream.h>.</p> + +<h3 class="left"> + <a name="3.3">3.3</a> +</h3> +<p>Allocator changes. Change <code>__malloc_alloc</code> to <code>malloc_allocator</code> and <code>__new_alloc</code> to <code>new_allocator</code>. </p> + +<p>Error handling in iostreams cleaned up, made consistent. </p> + + +<h3 class="left"> + <a name="3.4">3.4</a> +</h3> +<p> +Large file support. +</p> + +<p> Extensions for generic characters and <code>char_traits</code> added in <ext/pod_char_traits.h>. +</p> + +<p> +Support for <code>wchar_t</code> specializations of <code>basic_filebuf</code> enhanced to support <code>UTF-8</code> and <code>Unicode</code>, depending on host. More hosts support basic <code>wchar_t</code> functionality. +</p> + +<p> +Support for <code>char_traits</code> beyond builtin types. +</p> + +<p> +Conformant <code>allocator</code> class and usage in containers. As +part of this, the following extensions are +added: <ext/bitmap_allocator.h>, <ext/debug_allocator.h>, <ext/mt_allocator.h>, <ext/malloc_allocator.h>,<ext/new_allocator.h>, <ext/pool_allocator.h>. +</p> + + +<p> +Debug mode first appears. +</p> + +<p> +PCH support. +</p> + +<p> +Macro guard for libstdc++ changed, from _GLIBCPP_ to _GLIBCXX_. +</p> + +<p> +Extension <ext/stdio_sync_filebuf.h> added. +</p> + +<p> +Extension <ext/demangle.h> added. +</p> + + +<h3 class="left"> + <a name="4.0">4.0</a> +</h3> +<p> +TR1 features first appear. +</p> + +<p> +Extension allocator <ext/array_allocator.h> added. +</p> + +<p> +Extension <code>codecvt</code> specializations moved to <ext/codecvt_specializations.h>. +</p> + +<p> +Removal of <ext/demangle.h>. +</p> + + +<h3 class="left"> + <a name="4.1">4.1</a> +</h3> + +<p> +Removal of <cassert> from all standard headers: now has to be explicitly included for <code>std::assert</code> calls. +</p> + +<p> Extensions for policy-based data structures first added. New includes, +types, namespace <code>pb_assoc</code>. +</p> + + + +<p> Extensions for typelists added in <ext/typelist.h>. +</p> + +<p> Extension for policy-based <code>basic_string</code> first added: <code>__gnu_cxx::__versa_string</code> in <ext/vstring.h>. +</p> + +<h3 class="left"> + <a name="4.2">4.2</a> +</h3> + +<p> Default visibility attributes applied to <code>namespace std</code>. Support for <code>-fvisibility</code>. +</p> + +<p>TR1 <random>, <complex>, and C compatibility headers added.</p> + +<p> Extensions for concurrent programming consolidated +into <ext/concurrence.h> and <ext/atomicity.h>, +including change of namespace to <code>__gnu_cxx</code> in some +cases. Added types +include <code>_Lock_policy</code>, <code>__concurrence_lock_error</code>, <code>__concurrence_unlock_error</code>, <code>__mutex</code>, <code>__scoped_lock</code>.</p> + +<p> Extensions for type traits consolidated +into <ext/type_traits.h>. Additional traits are added +(<code>__conditional_type</code>, <code>__enable_if</code>, others.) +</p> + +<p> Extensions for policy-based data structures revised. New includes, +types, namespace moved to <code>__pb_ds</code>. +</p> + +<p> Extensions for debug mode modified: now nested in <code>namespace +std::__debug</code> and extensions in <code>namespace +__gnu_cxx::__debug</code>.</p> + +<p> Extensions added: <ext/typelist.h> +and <ext/throw_allocator.h>. +</p> + +<h3 class="left"> + <a name="4.3">4.3</a> +</h3> + +<p> +C++0X features first appear. +</p> + +<p>TR1 <regex> and <cmath>'s mathematical special function added.</p> + +<p> +Backward include edit. +</p> +<ul> + <li> Removed: <algobase.h> <algo.h> <alloc.h> <bvector.h> <complex.h> +defalloc.h> <deque.h> <fstream.h> <function.h> <hash_map.h> <hash_set.h> +hashtable.h> <heap.h> <iomanip.h> <iostream.h> <istream.h> <iterator.h> +list.h> <map.h> <multimap.h> <multiset.h> <new.h> <ostream.h> <pair.h> <queue.h> <rope.h> <set.h> <slist.h> <stack.h> <streambuf.h> <stream.h> <tempbuf.h> +<tree.h> <vector.h> + </li> + <li> Added: <hash_map> and <hash_set></li> + <li> Added in C++0x: <auto_ptr.h> and <binders.h></li> +</ul> + +<p> +Header dependency streamlining. +</p> + +<ul> + <li><algorithm> no longer includes <climits>, <cstring>, or <iosfwd> </li> + <li><bitset> no longer includes <istream> or <ostream>, adds <iosfwd> </li> + <li><functional> no longer includes <cstddef></li> + <li><iomanip> no longer includes <istream>, <istream>, or <functional>, adds <ioswd> </li> + <li><numeric> no longer includes <iterator></li> + <li><string> no longer includes <algorithm> or <memory></li> + + <li><valarray> no longer includes <numeric> or <cstdlib></li> + <li><tr1/hashtable> no longer includes <memory> or <functional></li> + <li><tr1/memory> no longer includes <algorithm></li> + <li><tr1/random> no longer includes <algorithm> or <fstream></li> +</ul> + +<p> +Debug mode for <unordered_map> and <unordered_set>. +</p> + +<p> +Parallel mode first appears. +</p> + +<p>Variadic template implementations of items in <tuple> and + <functional>. +</p> + +<p>Default <code>what</code> implementations give more elaborate + exception strings for <code>bad_cast</code>, + <code>bad_typeid</code>, <code>bad_exception</code>, and + <code>bad_alloc</code>. +</p> + +<p> +PCH binary files no longer installed. Instead, the source files are installed. +</p> + +<p> +Namespace pb_ds moved to __gnu_pb_ds. +</p> + +</body> +</html> + diff --git a/libstdc++-v3/doc/html/17_intro/backwards_compatibility.html b/libstdc++-v3/doc/html/17_intro/backwards_compatibility.html new file mode 100644 index 00000000000..c9af980f0fc --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/backwards_compatibility.html @@ -0,0 +1,1073 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta name="AUTHOR" content="bkoz@gcc.gnu.org (Benjamin Kosnik), Felix Natter" /> + <meta name="KEYWORDS" content="C++, libstdc++, API, backward, compatibility" /> + <meta name="DESCRIPTION" content="Backwards Compatibility" /> + <meta name="GENERATOR" content="emacs and ten fingers" /> + <title>Backwards Compatibility</title> +<link rel="StyleSheet" href="lib3styles.css" type="text/css" /> +<link rel="Start" href="documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +<link rel="Copyright" href="17_intro/license.html" type="text/html" /> +</head> +<body> + +<h1 class="centered"><a name="top">Backwards Compatibility</a></h1> + +<p class="fineprint"><em> + The latest version of this document is always available at + <a href="http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/backwards_compatibility.html"> + http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/backwards_compatibility.html</a>. +</em></p> + +<p><em> + To the <a href="http://gcc.gnu.org/libstdc++/">libstdc++ homepage</a>. +</em></p> + +<!-- ####################################################### --> +<hr /> +<h3 class="left"> + <a name="v1">First.</a> +</h3> + +<p> The first generation GNU C++ library was called libg++. It was a +separate GNU project, although reliably paired with GCC. Rumors imply +that it had a working relationship with at least two kinds of +dinosaur. +</p> + +<p>Known Issues include many of the limitations of its immediate ancestor.</p> + +<p>Portability notes and known implementation limitations are as follows.</p> + +<h5>No <code>ios_base</code></h5> + +<p> At least some older implementations don't have <code>std::ios_base</code>, so you should use <code>std::ios::badbit</code>, <code>std::ios::failbit</code> and <code>std::ios::eofbit</code> and <code>std::ios::goodbit</code>. +</p> + +<h5>No <code>cout</code> in <code>ostream.h</code>, no <code>cin</code> in <code>istream.h</code></h5> + +<p> + In earlier versions of the standard, + <tt><fstream.h></tt>, + <tt><ostream.h></tt> + and <tt><istream.h></tt> + used to define + <code>cout</code>, <code>cin</code> and so on. ISO C++ specifies that one needs to include + <tt><iostream></tt> + explicitly to get the required definitions. + </p> +<p> Some include adjustment may be required.</p> + + +<p>This project is no longer maintained or supported, and the sources +archived. The code is considered replaced and rewritten. +</p> + +<hr /> +<h3 class="left"> + <a name="v2">Second.</a> +</h3> +<p> The second generation GNU C++ library was called libstdc++, or +libstdc++-v2. It spans the time between libg++ and pre-ISO C++ +standardization and is usually associated with the following GCC +releases: egcs 1.x, gcc 2.95, and gcc 2.96. +</p> + +<p> The STL portions of this library are based on SGI/HP STL release 3.11. +</p> + +<p>Portability notes and known implementation limitations are as follows.</p> + +<h5>Namespace <code>std::</code> not supported</h5> + +<p> + Some care is required to support C++ compiler and or library + implementation that do not have the standard library in + <code>namespace std</code>. + </p> +<p> + The following sections list some possible solutions to support compilers + that cannot ignore <code>std::</code>-qualified names. + </p> + +<p> First, see if the compiler has a flag for this. Namespace + back-portability-issues are generally not a problem for g++ + compilers that do not have libstdc++ in <code>std::</code>, as + the compilers use <code>-fno-honor-std</code> (ignore + <code>std::</code>, <code>:: = std::</code>) by default. That + is, the responsibility for enabling or disabling + <code>std::</code> is on the user; the maintainer does not have + to care about it. This probably applies to some other compilers + as well. + </p> + +<p>Second, experiment with a variety of pre-processor tricks.</p> + +<p> By defining <code>std</code> as a macro, fully-qualified namespace calls become global. Volia. </p> + +<pre> +#ifdef WICKEDLY_OLD_COMPILER +# define std +#endif +</pre> +(thanks to Juergen Heinzl who posted this solution on gnu.gcc.help) + +<p>Another pre-processor based approach is to define a +macro <code>NAMESPACE_STD</code>, which is defined to either +"" or "std" based on a compile-type test. On GNU +systems, this can be done with autotools by means of an autoconf test +(see below) for <code>HAVE_NAMESPACE_STD</code>, then using that to +set a value for the <code>NAMESPACE_STD</code> macro. At that point, +one is able to use <code>NAMESPACE_STD::string</code>, which will +evaluate to <code>std::string</code> or +<code>::string</code> (ie, in the global namespace on systems that do +not put <code>string</code> in <code>std::</code>). </p> + +<pre style="background: #c0c0c0"> +dnl @synopsis AC_CXX_NAMESPACE_STD +dnl +dnl If the compiler supports namespace std, define +dnl HAVE_NAMESPACE_STD. +dnl +dnl @category Cxx +dnl @author Todd Veldhuizen +dnl @author Luc Maisonobe <luc@spaceroots.org> +dnl @version 2004-02-04 +dnl @license AllPermissive +AC_DEFUN([AC_CXX_NAMESPACE_STD], [ + AC_CACHE_CHECK(if g++ supports namespace std, + ac_cv_cxx_have_std_namespace, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <iostream> + std::istream& is = std::cin;],, + ac_cv_cxx_have_std_namespace=yes, ac_cv_cxx_have_std_namespace=no) + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_have_std_namespace" = yes; then + AC_DEFINE(HAVE_NAMESPACE_STD,,[Define if g++ supports namespace std. ]) + fi +]) +</pre> + +<h5>Illegal iterator usage</h5> +<p> + The following illustrate implementation-allowed illegal iterator + use, and then correct use. +</p> + +<ul> <li><p>you cannot do + <code>ostream::operator<<(iterator)</code> to print the + address of the iterator => use <code>operator<< + &*iterator</code> instead + </p></li> +<li><p>you cannot clear an iterator's reference + (<code>iterator = 0</code>) => use + <code>iterator = iterator_type();</code> + </p></li> +<li><p> +<code>if (iterator)</code> won't work any + more => use <code>if (iterator != iterator_type())</code> + </p></li> +</ul> + +<h5><code>isspace</code> from <tt><cctype></tt> is a macro +</h5> + +<p> Glibc 2.0.x and 2.1.x define <tt><ctype.h></tt> +functionality as macros (isspace, isalpha etc.). +</p> + +<p> +This implementations of libstdc++, however, keep these functions as +macros, and so it is not back-portable to use fully qualified +names. For example: +</p> + +<pre> +#include <cctype> +int main() { std::isspace('X'); } +</pre> + +<p>Results in something like this: +</p> + +<pre> +std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ; +</pre> + + +<p> A solution is to modify a header-file so that the compiler tells +<tt><ctype.h></tt> to define functions instead of macros: +</p> + +<pre> +// This keeps isalnum, et al from being propagated as macros. +#if __linux__ +# define __NO_CTYPE 1 +#endif +</pre> + +<p>Then, include <ctype.h> +</p> + +<p> +Another problem arises if you put a <code>using namespace std;</code> +declaration at the top, and include <tt><ctype.h></tt>. This +will result in ambiguities between the definitions in the global +namespace (<tt><ctype.h></tt>) and the definitions in namespace +<code>std::</code> (<code><cctype></code>). +</p> + +<h5>No <code>vector::at</code>, <code>deque::at</code>, <code>string::at</code></h5> + +<p> + One solution is to add an autoconf-test for this: +</p> +<pre style="background: #c0c0c0"> +AC_MSG_CHECKING(for container::at) +AC_TRY_COMPILE( +[ +#include <vector> +#include <deque> +#include <string> + +using namespace std; +], +[ +deque<int> test_deque(3); +test_deque.at(2); +vector<int> test_vector(2); +test_vector.at(1); +string test_string("test_string"); +test_string.at(3); +], +[AC_MSG_RESULT(yes) +AC_DEFINE(HAVE_CONTAINER_AT)], +[AC_MSG_RESULT(no)]) +</pre> + +<p> +If you are using other (non-GNU) compilers it might be a good idea +to check for <code>string::at</code> separately. +</p> + +<h5>No <code>std::char_traits<char>::eof</code></h5> + +<p> +Use some kind of autoconf test, plus this: +</p> +<pre> +#ifdef HAVE_CHAR_TRAITS +#define CPP_EOF std::char_traits<char>::eof() +#else +#define CPP_EOF EOF +#endif +</pre> + +<h5>No <code>string::clear</code></h5> + +<p> + There are two functions for deleting the contents of a string: + <code>clear</code> and <code>erase</code> (the latter + returns the string). +</p> + +<pre> +void +clear() { _M_mutate(0, this->size(), 0); } +</pre> +<pre> +basic_string& +erase(size_type __pos = 0, size_type __n = npos) +{ + return this->replace(_M_check(__pos), _M_fold(__pos, __n), + _M_data(), _M_data()); +} +</pre> + +<p> + Unfortunately, ut <code>clear</code> is not + implemented in this version, so you should use + <code>erase</code> (which is probably faster than + <code>operator=(charT*)</code>). +</p> + +<h5>Removal of <code>ostream::form</code> and +<code>istream::scan</code> extensions</h5> + +<p> These are no longer supported. Please use + <a href="#sec-stringstream" title="Using stringstreams"> + stringstreams</a> instead. +</p> + +<h5>No <code>basic_stringbuf</code>, <code>basic_stringstream</code></h5> + +<p> +Although the ISO standard +<code>i/ostringstream</code>-classes are provided, (<tt><sstream></tt>), for compatibility with older implementations the pre-ISO <code>i/ostrstream</code> (<tt><strstream></tt>) interface is also provided, with these caveats: +</p> + + <div class="itemizedlist"><ul type="disc"> +<li><p> <code>strstream</code> is considered to be + deprecated + </p></li> +<li><p> <code>strstream</code> is limited to + <code>char</code> + </p></li> +<li><p> with <code>ostringstream</code> you don't + have to take care of terminating the string or freeing its + memory + </p></li> +<li><p> <code>istringstream</code> can be re-filled + (clear(); str(input);) + </p></li> +</ul></div> +<p> + You can then use output-stringstreams like this: +</p> + +<pre> +#ifdef HAVE_SSTREAM +# include <sstream> +#else +# include <strstream> +#endif + +#ifdef HAVE_SSTREAM + std::ostringstream oss; +#else + std::ostrstream oss; +#endif + +oss << "Name=" << m_name << ", number=" << m_number << std::endl; +... +#ifndef HAVE_SSTREAM + oss << std::ends; // terminate the char*-string +#endif + +// str() returns char* for ostrstream and a string for ostringstream +// this also causes ostrstream to think that the buffer's memory +// is yours +m_label.set_text(oss.str()); +#ifndef HAVE_SSTREAM + // let the ostrstream take care of freeing the memory + oss.freeze(false); +#endif +</pre> + +<p> + Input-stringstreams can be used similarly: +</p> + +<pre> +std::string input; +... +#ifdef HAVE_SSTREAM +std::istringstream iss(input); +#else +std::istrstream iss(input.c_str()); +#endif + +int i; +iss >> i; +</pre> + +<p> One (the only?) restriction is that an istrstream cannot be re-filled: +</p> + +<pre> +std::istringstream iss(numerator); +iss >> m_num; +// this is not possible with istrstream +iss.clear(); +iss.str(denominator); +iss >> m_den; + </pre> + +<p> +If you don't care about speed, you can put these conversions in + a template-function: +</p> +<pre> +template <class X> +void fromString(const string& input, X& any) +{ +#ifdef HAVE_SSTREAM +std::istringstream iss(input); +#else +std::istrstream iss(input.c_str()); +#endif +X temp; +iss >> temp; +if (iss.fail()) +throw runtime_error(..) +any = temp; +} +</pre> + +<p> Another example of using stringstreams is in <a href="../21_strings/howto.html" target="_top">this howto</a>. +</p> + +<p> There is additional information in the libstdc++-v2 info files, in +particular "info iostream". +</p> + +<h5>Little or no wide character support</h5> + +<h5>No templatized iostreams</h5> + +<h5>Thread safety issues</h5> + +<p>This project is no longer maintained or supported, and the sources +archived. The code is considered replaced and rewritten. +</p> + + +<hr /> +<h3 class="left"> + <a name="v3">Third.</a> +</h3> +<p> The third generation GNU C++ library is called libstdc++, or +libstdc++-v3. +</p> + + <p>The subset commonly known as the Standard Template Library + (chapters 23 through 25, mostly) is adapted from the final release + of the SGI STL (version 3.3), with extensive changes. + </p> + + <p>A more formal description of the V3 goals can be found in the + official <a href="../17_intro/DESIGN">design document</a>. + </p> + +<p>Portability notes and known implementation limitations are as follows.</p> + +<h5>Pre-ISO headers moved to backwards or removed</h5> + +<p> The pre-ISO C++ headers + (<code>iostream.h</code>, <code>defalloc.h</code> etc.) are + available, unlike previous libstdc++ versions, but inclusion + generates a warning that you are using deprecated headers. +</p> + + <p>This compatibility layer is constructed by including the + standard C++ headers, and injecting any items in + <code>std::</code> into the global namespace. + </p> + <p>For those of you new to ISO C++ (welcome, time travelers!), no, + that isn't a typo. Yes, the headers really have new names. + Marshall Cline's C++ FAQ Lite has a good explanation in <a + href="http://www.parashift.com/c++-faq-lite/coding-standards.html#faq-27.4">item + [27.4]</a>. + </p> + +<p> Some include adjustment may be required. What follows is an +autoconf test that defines <code>PRE_STDCXX_HEADERS</code> when they +exist.</p> + +<pre style="background: #c0c0c0"> +# AC_HEADER_PRE_STDCXX +AC_DEFUN([AC_HEADER_PRE_STDCXX], [ + AC_CACHE_CHECK(for pre-ISO C++ include files, + ac_cv_cxx_pre_stdcxx, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -Wno-deprecated" + + # Omit defalloc.h, as compilation with newer compilers is problematic. + AC_TRY_COMPILE([ + #include <new.h> + #include <iterator.h> + #include <alloc.h> + #include <set.h> + #include <hashtable.h> + #include <hash_set.h> + #include <fstream.h> + #include <tempbuf.h> + #include <istream.h> + #include <bvector.h> + #include <stack.h> + #include <rope.h> + #include <complex.h> + #include <ostream.h> + #include <heap.h> + #include <iostream.h> + #include <function.h> + #include <multimap.h> + #include <pair.h> + #include <stream.h> + #include <iomanip.h> + #include <slist.h> + #include <tree.h> + #include <vector.h> + #include <deque.h> + #include <multiset.h> + #include <list.h> + #include <map.h> + #include <algobase.h> + #include <hash_map.h> + #include <algo.h> + #include <queue.h> + #include <streambuf.h> + ],, + ac_cv_cxx_pre_stdcxx=yes, ac_cv_cxx_pre_stdcxx=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_pre_stdcxx" = yes; then + AC_DEFINE(PRE_STDCXX_HEADERS,,[Define if pre-ISO C++ header files are present. ]) + fi +]) +</pre> + +<p>Porting between pre-ISO headers and ISO headers is simple: headers +like <vector.h> can be replaced with <vector> and a using +directive <code>using namespace std;</code> can be put at the global +scope. This should be enough to get this code compiling, assuming the +other usage is correct. +</p> + +<h5>Extension headers hash_map, hash_set moved to ext or backwards</h5> + +<p> Header files <code>hash_map</code> and <code>hash_set</code> moved +to <code>ext/hash_map</code> and <code>ext/hash_set</code>, +respectively. At the same time, all types in these files are enclosed +in <code>namespace __gnu_cxx</code>. Later versions move deprecate +these files, and suggest using TR1's <code>unordered_map</code> +and <code>unordered_set</code> instead. +</p> + +<p>The following autoconf tests check for working HP/SGI hash containers. +</p> + +<pre style="background: #c0c0c0"> +# AC_HEADER_EXT_HASH_MAP +AC_DEFUN([AC_HEADER_EXT_HASH_MAP], [ + AC_CACHE_CHECK(for ext/hash_map, + ac_cv_cxx_ext_hash_map, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -Werror" + AC_TRY_COMPILE([#include <ext/hash_map>], [using __gnu_cxx::hash_map;], + ac_cv_cxx_ext_hash_map=yes, ac_cv_cxx_ext_hash_map=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_ext_hash_map" = yes; then + AC_DEFINE(HAVE_EXT_HASH_MAP,,[Define if ext/hash_map is present. ]) + fi +]) +</pre> + +<pre style="background: #c0c0c0"> +# AC_HEADER_EXT_HASH_SET +AC_DEFUN([AC_HEADER_EXT_HASH_SET], [ + AC_CACHE_CHECK(for ext/hash_set, + ac_cv_cxx_ext_hash_set, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -Werror" + AC_TRY_COMPILE([#include <ext/hash_set>], [using __gnu_cxx::hash_set;], + ac_cv_cxx_ext_hash_set=yes, ac_cv_cxx_ext_hash_set=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_ext_hash_set" = yes; then + AC_DEFINE(HAVE_EXT_HASH_SET,,[Define if ext/hash_set is present. ]) + fi +]) +</pre> + + +<h5> +No <code>ios::nocreate/ios::noreplace</code>. +</h5> + +<p> The existence of <code>ios::nocreate</code> being used for +input-streams has been confirmed, most probably because the author +thought it would be more correct to specify nocreate explicitly. So +it can be left out for input-streams. +</p> + +<p>For output streams, "nocreate" is probably the default, +unless you specify <code>std::ios::trunc</code> ? To be safe, you can +open the file for reading, check if it has been opened, and then +decide whether you want to create/replace or not. To my knowledge, +even older implementations support <code>app</code>, <code>ate</code> +and <code>trunc</code> (except for <code>app</code> ?). +</p> + + +<h5> +No <code>stream::attach(int fd)</code> +</h5> + +<p> + Phil Edwards writes: It was considered and rejected for the ISO + standard. Not all environments use file descriptors. Of those + that do, not all of them use integers to represent them. + </p> + +<p> + For a portable solution (among systems which use + filedescriptors), you need to implement a subclass of + <code>std::streambuf</code> (or + <code>std::basic_streambuf<..></code>) which opens a file + given a descriptor, and then pass an instance of this to the + stream-constructor. + </p> + +<p> + An extension is available that implements this. + <code><ext/stdio_filebuf.h></code> contains a derived class called + <a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/class____gnu__cxx_1_1stdio__filebuf.html"><code>__gnu_cxx::stdio_filebuf</code></a>. + This class can be constructed from a C <code>FILE*</code> or a file + descriptor, and provides the <code>fd()</code> function. + </p> + +<p> + For another example of this, refer to + <a href="http://www.josuttis.com/cppcode/fdstream.html" target="_top">fdstream example</a> + by Nicolai Josuttis. +</p> + +<h5> +Support for C++98 dialect. +</h5> + +<p>Check for complete library coverage of the C++1998/2003 standard. +</p> + +<pre style="background: #c0c0c0"> + +# AC_HEADER_STDCXX_98 +AC_DEFUN([AC_HEADER_STDCXX_98], [ + AC_CACHE_CHECK(for ISO C++ 98 include files, + ac_cv_cxx_stdcxx_98, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([ + #include <cassert> + #include <cctype> + #include <cerrno> + #include <cfloat> + #include <ciso646> + #include <climits> + #include <clocale> + #include <cmath> + #include <csetjmp> + #include <csignal> + #include <cstdarg> + #include <cstddef> + #include <cstdio> + #include <cstdlib> + #include <cstring> + #include <ctime> + + #include <algorithm> + #include <bitset> + #include <complex> + #include <deque> + #include <exception> + #include <fstream> + #include <functional> + #include <iomanip> + #include <ios> + #include <iosfwd> + #include <iostream> + #include <istream> + #include <iterator> + #include <limits> + #include <list> + #include <locale> + #include <map> + #include <memory> + #include <new> + #include <numeric> + #include <ostream> + #include <queue> + #include <set> + #include <sstream> + #include <stack> + #include <stdexcept> + #include <streambuf> + #include <string> + #include <typeinfo> + #include <utility> + #include <valarray> + #include <vector> + ],, + ac_cv_cxx_stdcxx_98=yes, ac_cv_cxx_stdcxx_98=no) + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_stdcxx_98" = yes; then + AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ]) + fi +]) +</pre> + + +<h5> +Support for C++TR1 dialect. +</h5> + +<p>Check for library coverage of the TR1 standard. +</p> + +<pre style="background: #c0c0c0"> + +# AC_HEADER_STDCXX_TR1 +AC_DEFUN([AC_HEADER_STDCXX_TR1], [ + AC_CACHE_CHECK(for ISO C++ TR1 include files, + ac_cv_cxx_stdcxx_tr1, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([ + #include <tr1/array> + #include <tr1/ccomplex> + #include <tr1/cctype> + #include <tr1/cfenv> + #include <tr1/cfloat> + #include <tr1/cinttypes> + #include <tr1/climits> + #include <tr1/cmath> + #include <tr1/complex> + #include <tr1/cstdarg> + #include <tr1/cstdbool> + #include <tr1/cstdint> + #include <tr1/cstdio> + #include <tr1/cstdlib> + #include <tr1/ctgmath> + #include <tr1/ctime> + #include <tr1/cwchar> + #include <tr1/cwctype> + #include <tr1/functional> + #include <tr1/memory> + #include <tr1/random> + #include <tr1/regex> + #include <tr1/tuple> + #include <tr1/type_traits> + #include <tr1/unordered_set> + #include <tr1/unordered_map> + #include <tr1/utility> + ],, + ac_cv_cxx_stdcxx_tr1=yes, ac_cv_cxx_stdcxx_tr1=no) + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_stdcxx_tr1" = yes; then + AC_DEFINE(STDCXX_TR1_HEADERS,,[Define if ISO C++ TR1 header files are present. ]) + fi +]) +</pre> + +<p>An alternative is to check just for specific TR1 includes, such as <unordered_map> and <unordered_set>. +</p> + +<pre style="background: #c0c0c0"> +# AC_HEADER_TR1_UNORDERED_MAP +AC_DEFUN([AC_HEADER_TR1_UNORDERED_MAP], [ + AC_CACHE_CHECK(for tr1/unordered_map, + ac_cv_cxx_tr1_unordered_map, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <tr1/unordered_map>], [using std::tr1::unordered_map;], + ac_cv_cxx_tr1_unordered_map=yes, ac_cv_cxx_tr1_unordered_map=no) + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_tr1_unordered_map" = yes; then + AC_DEFINE(HAVE_TR1_UNORDERED_MAP,,[Define if tr1/unordered_map is present. ]) + fi +]) +</pre> + +<pre style="background: #c0c0c0"> +# AC_HEADER_TR1_UNORDERED_SET +AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [ + AC_CACHE_CHECK(for tr1/unordered_set, + ac_cv_cxx_tr1_unordered_set, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([#include <tr1/unordered_set>], [using std::tr1::unordered_set;], + ac_cv_cxx_tr1_unordered_set=yes, ac_cv_cxx_tr1_unordered_set=no) + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_tr1_unordered_set" = yes; then + AC_DEFINE(HAVE_TR1_UNORDERED_SET,,[Define if tr1/unordered_set is present. ]) + fi +]) +</pre> + + + +<h5> +Support for C++0x dialect. +</h5> + +<p>Check for baseline language coverage in the compiler for the C++0xstandard. +</p> + +<pre style="background: #c0c0c0"> +# AC_COMPILE_STDCXX_OX +AC_DEFUN([AC_COMPILE_STDCXX_0X], [ + AC_CACHE_CHECK(if g++ supports C++0x features without additional flags, + ac_cv_cxx_compile_cxx0x_native, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + AC_TRY_COMPILE([ + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + typedef check<check<bool>> right_angle_brackets; + + int a; + decltype(a) b; + + typedef check<int> check_type; + check_type c; + check_type&& cr = c;],, + ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no) + AC_LANG_RESTORE + ]) + + AC_CACHE_CHECK(if g++ supports C++0x features with -std=c++0x, + ac_cv_cxx_compile_cxx0x_cxx, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=c++0x" + AC_TRY_COMPILE([ + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + typedef check<check<bool>> right_angle_brackets; + + int a; + decltype(a) b; + + typedef check<int> check_type; + check_type c; + check_type&& cr = c;],, + ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + + AC_CACHE_CHECK(if g++ supports C++0x features with -std=gnu++0x, + ac_cv_cxx_compile_cxx0x_gxx, + [AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=gnu++0x" + AC_TRY_COMPILE([ + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + typedef check<check<bool>> right_angle_brackets; + + int a; + decltype(a) b; + + typedef check<int> check_type; + check_type c; + check_type&& cr = c;],, + ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + + if test "$ac_cv_cxx_compile_cxx0x_native" = yes || + test "$ac_cv_cxx_compile_cxx0x_cxx" = yes || + test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then + AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ]) + fi +]) +</pre> + + +<p>Check for library coverage of the C++0xstandard. +</p> + +<pre style="background: #c0c0c0"> + +# AC_HEADER_STDCXX_0X +AC_DEFUN([AC_HEADER_STDCXX_0X], [ + AC_CACHE_CHECK(for ISO C++ 0x include files, + ac_cv_cxx_stdcxx_0x, + [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=gnu++0x" + + AC_TRY_COMPILE([ + #include <cassert> + #include <ccomplex> + #include <cctype> + #include <cerrno> + #include <cfenv> + #include <cfloat> + #include <cinttypes> + #include <ciso646> + #include <climits> + #include <clocale> + #include <cmath> + #include <csetjmp> + #include <csignal> + #include <cstdarg> + #include <cstdbool> + #include <cstddef> + #include <cstdint> + #include <cstdio> + #include <cstdlib> + #include <cstring> + #include <ctgmath> + #include <ctime> + #include <cwchar> + #include <cwctype> + + #include <algorithm> + #include <array> + #include <bitset> + #include <complex> + #include <deque> + #include <exception> + #include <fstream> + #include <functional> + #include <iomanip> + #include <ios> + #include <iosfwd> + #include <iostream> + #include <istream> + #include <iterator> + #include <limits> + #include <list> + #include <locale> + #include <map> + #include <memory> + #include <new> + #include <numeric> + #include <ostream> + #include <queue> + #include <random> + #include <regex> + #include <set> + #include <sstream> + #include <stack> + #include <stdexcept> + #include <streambuf> + #include <string> + #include <tuple> + #include <typeinfo> + #include <type_traits> + #include <unordered_map> + #include <unordered_set> + #include <utility> + #include <valarray> + #include <vector> + ],, + ac_cv_cxx_stdcxx_0x=yes, ac_cv_cxx_stdcxx_0x=no) + AC_LANG_RESTORE + CXXFLAGS="$ac_save_CXXFLAGS" + ]) + if test "$ac_cv_cxx_stdcxx_0x" = yes; then + AC_DEFINE(STDCXX_0X_HEADERS,,[Define if ISO C++ 0x header files are present. ]) + fi +]) +</pre> + +<p>As is the case for TR1 support, these autoconf macros can be made for a finer-grained, per-header-file check. For <unordered_map> +</p> + +<pre style="background: #c0c0c0"> + +# AC_HEADER_UNORDERED_MAP +AC_DEFUN([AC_HEADER_UNORDERED_MAP], [ + AC_CACHE_CHECK(for unordered_map, + ac_cv_cxx_unordered_map, + [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=gnu++0x" + AC_TRY_COMPILE([#include <unordered_map>], [using std::unordered_map;], + ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_unordered_map" = yes; then + AC_DEFINE(HAVE_UNORDERED_MAP,,[Define if unordered_map is present. ]) + fi +]) +</pre> + +<pre style="background: #c0c0c0"> +# AC_HEADER_UNORDERED_SET +AC_DEFUN([AC_HEADER_UNORDERED_SET], [ + AC_CACHE_CHECK(for unordered_set, + ac_cv_cxx_unordered_set, + [AC_REQUIRE([AC_COMPILE_STDCXX_0X]) + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -std=gnu++0x" + AC_TRY_COMPILE([#include <unordered_set>], [using std::unordered_set;], + ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no) + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + if test "$ac_cv_cxx_unordered_set" = yes; then + AC_DEFINE(HAVE_UNORDERED_SET,,[Define if unordered_set is present. ]) + fi +]) +</pre> + + +<h5> +Container iterator_type is not necessarily container value_type* +</h5> + + +<hr /> +<h3 class="left"> + <a name="v4">Fourth, and future</a> +</h3> + +<hr /> +<h3 class="left"> + <a name="Links">Links</a> +</h3> + +<p> +<a href="http://www.kegel.com/gcc/gcc4.html">Migrating to gcc-4.1</a>, by Dan Kegel. +</p> + +<p> +<a href="http://lists.debian.org/debian-gcc/2006/03/msg00405.html">Building the whole Debian archive with GCC 4.1: a summary</a>, by Martin Michlmayr +</p> + +<p> +<a href="http://annwm.lbl.gov/~leggett/Atlas/gcc-3.2.html">Migration guide for GCC-3.2</a> +</p> + +</body> +</html> + diff --git a/libstdc++-v3/doc/html/17_intro/c++0x_status.html b/libstdc++-v3/doc/html/17_intro/c++0x_status.html new file mode 100644 index 00000000000..cfc28ed44a5 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/c++0x_status.html @@ -0,0 +1,2290 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> + +<head> + + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> + <link rev="made" href="mailto:gcc@gcc.gnu.org" /> + <link rel="shortcut icon" href="http://gcc.gnu.org/favicon.ico" /> + + <title> + Status of C++0x features in GCC + - GNU Project - Free Software Foundation (FSF) + </title> + +</head> + +<body> + +<h1 align="center"> + Status of C++0x features in GCC +</h1> + +<p> +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++ +</p> + +<p> +In this implementation <code>-std=gnu++0x</code> or +<code>-std=c++0x</code> flags must be used to enable language and +library features. The pre-defined symbol +<code>__GXX_EXPERIMENTAL_CXX0X__</code> is used to check for the +presence of the required flag. +</p> + +<p> +This page describes the C++0x support in mainline GCC SVN, not in any +particular release. +</p> + +<table border="1"> + <thead> + <tr> + <td><span style="font-weight: bold;">Section</span></td> + <td><span style="font-weight: bold;">Description</span></td> + <td><span style="font-weight: bold;">Done</span></td> + <td><span style="font-weight: bold;">Broken</span></td> + <td><span style="font-weight: bold;">Missing</span></td> + <td><span style="font-weight: bold;">Comments</span></td> + </tr> + </thead> + <tbody> + <tr> + <td><b>20</b></td> + <td colspan="5"><b>General Utilities</b></td> + </tr> + <tr> + <td>20.2</td> + <td>Utility Components</td> + <td></td> + <td></td> + <td>incomplete</td> + <td></td> + </tr> + <tr> + <td>20.2.1</td> + <td>Operators</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>20.2.2</td> + <td>forward/move helpers</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>20.2.3</td> + <td>Pairs</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td>20.3</td> + <td>Header <code><tuple></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1</td> + <td>Class template <code>tuple</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1.1</td> + <td>Construction</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1.2</td> + <td>Tuple creation functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1.3</td> + <td>Tuple helper classes</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1.4</td> + <td>Element access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.3.1.5</td> + <td>Relational operators</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td>20.4</td> + <td colspan="5">Metaprogramming and type traits</td> + </tr> + <tr> + <td>20.4.1</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.2</td> + <td>Header <code><type_traits></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.3</td> + <td>Helper classes</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.4</td> + <td>General Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.5</td> + <td>Unary Type Traits</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.5.1</td> + <td>Primary Type Categories</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.5.2</td> + <td>Composite type traits</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.5.3</td> + <td>Type properties</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.6</td> + <td>Relationships between types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.7</td> + <td>Transformations between types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.7.1</td> + <td>Const-volatile modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.7.2</td> + <td>Reference modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.7.3</td> + <td>Array modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.7.4</td> + <td>Pointer modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.8</td> + <td>Other transformations</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.4.9</td> + <td>Implementation requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5 </td> + <td>Function Objects</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5</td> + <td>Additions to header <code><functional></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.1</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.2</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.3</td> + <td>Base</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.4</td> + <td>Function return types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5</td> + <td>Class template <code>reference_wrapper</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5.1</td> + <td><code>reference_wrapper</code> construct/copy/destroy</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5.2</td> + <td><code>reference_wrapper</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5.3</td> + <td><code>reference_wrapper</code> access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5.4</td> + <td><code>reference_wrapper</code> invocation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.5.5</td> + <td><code>reference_wrapper</code> helper functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.14</td> + <td>Function template <code>mem_fn</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.11</td> + <td>Template function bind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td>20.5.11.1</td> + <td>Function object binders</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.11.1.1</td> + <td>Class template <code>is_bind_expression</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.11.1.2</td> + <td>Class template <code>is_placeholder</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.11.1.3</td> + <td>Function template <code>bind</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.11.1.4</td> + <td>Placeholders</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15</td> + <td>Polymorphic function wrappers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.1</td> + <td>Class <code>bad_function_call<code></code></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.1.1</td> + <td><code>bad_function_call</code> constructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2</td> + <td>Class template <code>function</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.1</td> + <td><code>function</code> construct/copy/destroy</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.2</td> + <td><code>function</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.3</td> + <td><code>function</code> capacity</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.4</td> + <td><code>function</code> invocation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.5</td> + <td><code>function</code> target access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.7</td> + <td>null pointer comparison operators</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.15.2.8</td> + <td>specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.5.16</td> + <td>Class template <code>hash</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6</td> + <td>Additions to header <code><memory></code> synopsis</td> + <td></td> + <td></td> + <td>partial</td> + <td>missing <code>unique_ptr</code></td> + </tr> + <tr> + <td>20.6.5</td> + <td>Class template <code>unique_ptr</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>20.6.6</td> + <td>Smart pointers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.1</td> + <td>Class <code>bad_weak_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2</td> + <td>Class template <code>shared_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td><a href="#1">1</a></td> + </tr> + <tr> + <td>20.6.6.2.1</td> + <td><code>shared_ptr</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.2</td> + <td><code>shared_ptr</code> destructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.3</td> + <td><code>shared_ptr</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.4</td> + <td><code>shared_ptr</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.5</td> + <td><code>shared_ptr</code> observers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.6</td> + <td><code>shared_ptr</code> creation</td> + <td>done</td> + <td></td> + <td></td> + <td> + <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm">N2351</a> + </td> + </tr> + <tr> + <td>20.6.6.2.7</td> + <td><code>shared_ptr</code> comparison</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.8</td> + <td><code>shared_ptr</code> I/O</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.9</td> + <td><code>shared_ptr</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.10</td> + <td><code>shared_ptr</code> casts</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.2.11</td> + <td><code>get_deleter</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3</td> + <td>Class template <code>weak_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.1</td> + <td><code>weak_ptr</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.2</td> + <td><code>weak_ptr</code> destructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.3</td> + <td><code>weak_ptr</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.4</td> + <td><code>weak_ptr</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.5</td> + <td><code>weak_ptr</code> observers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.6</td> + <td><code>weak_ptr</code> comparison</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.3.7</td> + <td><code>weak_ptr</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>20.6.6.4</td> + <td>Class template <code>enable_shared_from_this</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + + + <tr> + <td><b>23</b></td> + <td colspan="5"><b>Containers</b></td> + </tr> + <tr> + <td>23.2.1</td> + <td>Header <code><array></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1</td> + <td>Class template array</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.1</td> + <td><code>array</code> constructors, copy, and assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.2</td> + <td><code>array</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.3</td> + <td><code>array </code>size</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.4</td> + <td><code>array </code>data</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.5</td> + <td>Zero sized <code>array</code>s</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.2.1.6</td> + <td>Tuple interface to class template <code>array</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td>23.4</td> + <td>Unordered associative containers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.1</td> + <td>Class template <code>unordered_map</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.1.1</td> + <td><code>unordered_map</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.1.2</td> + <td><code>unordered_map</code> element access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.1.3</td> + <td><code>unordered_map</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.2</td> + <td>Class template <code>unordered_multimap</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.2.1</td> + <td><code>unordered_multimap</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.2.2</td> + <td><code>unordered_multimap</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.3</td> + <td>Class template <code>unordered_set</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.3.1</td> + <td><code>unordered_set</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.3.2</td> + <td><code>unordered_set</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.4</td> + <td>Class template <code>unordered_multiset<code></code></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.4.1</td> + <td><code>unordered_multiset</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>23.4.4.2</td> + <td><code>unordered_multiset</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td><b>26</b></td> + <td colspan="5"><b>Numerics</b></td> + </tr> + <tr> + <td>26.4</td> + <td>Random number generation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.1</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.2</td> + <td>Header <code><random></code> synopsis</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>26.4.3</td> + <td>Random number engine class templates</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.3.1</td> + <td>Class template <code>linear_congruential_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.3.2</td> + <td>Class template <code>mersenne_twister_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.3.3</td> + <td>Class template <code>subtract_with_carry_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.4</td> + <td>Random number engine adaptor class templates</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + + <tr> + <td>26.4.4.1</td> + <td>Class template <code>discard_block_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.4.2</td> + <td>Class template <code>independent_bits_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.4.3</td> + <td>Class template <code>shuffle_order_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.4.4</td> + <td>Class template <code>xor_combine_engine</code></td> + <td>done</td> + <td></td> + <td></td> + <td>operator()() per N2079</td> + </tr> + <tr> + <td>26.4.5</td> + <td>Engines and engine adaptors with predefined parameters</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.6</td> + <td>Class <code>random_device</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.7</td> + <td>Utilities</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.7.1</td> + <td>Class <code>seed_seq</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.7.2</td> + <td>Function template <code>generate_cannonical</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8</td> + <td>Random number generation class templates</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.1</td> + <td>Uniform distributions</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>26.4.8.1</td> + <td>Class template <code>uniform_int_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.1</td> + <td>Class template <code>uniform_real_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.2</td> + <td>Bernoulli distributions</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + + <tr> + <td>26.4.8.2.1</td> + <td>Class <code>bernoulli_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.2.2</td> + <td>Class template <code>binomial_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.2.3</td> + <td>Class template <code>geometric_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.2.4</td> + <td>Class template <code>negative_binomial_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.3</td> + <td>Poisson distributions</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>26.4.8.3.1</td> + <td>Class template <code>poisson_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.3.2</td> + <td>Class template <code>exponential_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.3.3</td> + <td>Class template <code>gamma_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.3.4</td> + <td>Class template <code>weibull_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.3.5</td> + <td>Class template <code>extreme_value_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4</td> + <td>Normal distributions</td> + <td></td> + <td></td> + <td>partial</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.1</td> + <td>Class template <code>normal_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.2</td> + <td>Class template <code>lognormal_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.3</td> + <td>Class template <code>chi_squared_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.4</td> + <td>Class template <code>cauchy_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.5</td> + <td>Class template <code>fisher_f_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.4.6</td> + <td>Class template <code>student_t_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.5</td> + <td>Sampling distributions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.5.1</td> + <td>Class template <code>discrete_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.5.1</td> + <td>Class template <code>piecewise_constant_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>26.4.8.5.1</td> + <td>Class template <code>general_pdf_distribution</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + + <tr> + <td><b>28</b></td> + <td colspan="5"><b>Regular expressions</b></td> + </tr> + <tr> + <td>28.1</td> + <td>Definitions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.2</td> + <td>Requirements</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.3</td> + <td>Regular expressions summary</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.4</td> + <td>Header <code><regex></code> synopsis</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.5</td> + <td>Namespace <code>tr1::regex_constants</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.5.1</td> + <td>Bitmask Type <code>syntax_option_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.5.2</td> + <td>Bitmask Type <code>regex_constants::match_flag_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.5.3</td> + <td>Implementation defined <code>error_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.6</td> + <td>Class <code>regex_error</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.7</td> + <td>Class template <code>regex_traits</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8</td> + <td>Class template <code>basic_regex</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.1</td> + <td><code>basic_regex</code> constants</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.2</td> + <td><code>basic_regex</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.3</td> + <td><code>basic_regex</code> assign</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.4</td> + <td><code>basic_regex</code> constant operations</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.5</td> + <td><code>basic_regex</code> locale</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.6</td> + <td><code>basic_regex</code> swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.7</td> + <td><code>basic_regex</code> non-member functions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.8.7.1</td> + <td><code>basic_regex</code> non-member swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.9</td> + <td>Class template <code>sub_match</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.9.1</td> + <td><code>sub_match</code> members</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.9.2</td> + <td><code>sub_match</code> non-member operators</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10</td> + <td>Class template <code>match_results</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.1</td> + <td><code>match_results</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.2</td> + <td><code>match_results</code> size</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.3</td> + <td><code>match_results</code> element access</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.4</td> + <td><code>match_results</code> formatting</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.5</td> + <td><code>match_results</code> allocator</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.10.6</td> + <td><code>match_results</code> swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.11</td> + <td>Regular expression algorithms</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.11.1</td> + <td>exceptions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.11.2</td> + <td><code>regex_match</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.11.3</td> + <td><code>regex_search</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.11.4</td> + <td><code>regex_replace</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12</td> + <td>Regular expression Iterators</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.1</td> + <td>Class template <code>regex_iterator</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.1.1</td> + <td><code>regex_iterator</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.1.2</td> + <td><code>regex_iterator</code> comparisons</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.1.3</td> + <td><code>regex_iterator</code> dereference</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.1.4</td> + <td><code>regex_iterator</code> increment</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.2</td> + <td>Class template <code>regex_token_iterator</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.2.1</td> + <td><code>regex_token_iterator</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.2.2</td> + <td><code>regex_token_iterator</code> comparisons</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.2.3</td> + <td><code>regex_token_iterator</code> dereference</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.12.2.4</td> + <td><code>regex_token_iterator</code> increment</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>28.13</td> + <td>Modified ECMAScript regular expression grammar</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td><b>C</b></td> + <td colspan="5"><b>C compatibility</b></td> + </tr> + <tr> + <td>C2.1</td> + <td>Additions to header <code><complex></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.2</td> + <td>Function <code>acos</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.3</td> + <td>Function <code>asin</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.4</td> + <td>Function <code>atan</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.5</td> + <td>Function <code>acosh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.6</td> + <td>Function <code>asinh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.7</td> + <td>Function <code>atanh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.8</td> + <td>Function <code>fabs</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.1.9</td> + <td>Additional Overloads</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.2</td> + <td>Header <code><ccomplex></code></td> + <td></td> + <td></td> + <td>missing</td> + <td>DR 551</td> + </tr> + <tr> + <td>C2.3</td> + <td>Header <code><complex.h></code></td> + <td></td> + <td></td> + <td>missing</td> + <td>DR 551</td> + </tr> + <tr> + <td>C2.4</td> + <td>Additions to header <code><cctype></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.4.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.4.2</td> + <td>Function <code>isblank</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.5</td> + <td>Additions to header <code><ctype.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.6</td> + <td>Header <code><cfenv></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.6.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.6.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.7</td> + <td>Header <code><fenv.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.8</td> + <td>Additions to header <code><cfloat></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.9</td> + <td>Additions to header <code><float.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.10</td> + <td>Additions to header <code><ios></code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>C2.10.1</td> + <td>Synopsis</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>C2.10.2</td> + <td>Function <code>hexfloat</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>C2.11</td> + <td>Header <code><cinttypes></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.11.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td>DR 557</td> + </tr> + <tr> + <td>C2.11.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.12</td> + <td>Header <code><inttypes.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.13</td> + <td>Additions to header <code><climits></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.14</td> + <td>Additions to header <code><limits.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.15</td> + <td>Additions to header <code><locale></code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>C2.16</td> + <td>Additions to header <code><cmath></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.16.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.16.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.16.3</td> + <td>Function template definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.16.4</td> + <td>Additional overloads</td> + <td>done</td> + <td></td> + <td></td> + <td>DR 568; DR 550</td> + </tr> + <tr> + <td>C2.17</td> + <td>Additions to header <code><math.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.18</td> + <td>Additions to header <code><cstdarg></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.19</td> + <td>Additions to header <code><stdarg.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.20</td> + <td>The header <code><cstdbool></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.21</td> + <td>The header <code><stdbool.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.22</td> + <td>The header <code><cstdint></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.22.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.22.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.23</td> + <td>The header <code><stdint.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.24</td> + <td>Additions to header <code><cstdio></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.24.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.24.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.24.3</td> + <td>Additional format specifiers</td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>C2.24.4</td> + <td>Additions to header <code><stdio.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.25</td> + <td>Additions to header <code><cstdlib></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.25.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.25.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.25.3</td> + <td>Function <code>abs</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.25.4</td> + <td>Function <code>div</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.26</td> + <td>Additions to header <code><stdlib.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.27</td> + <td>Header <code><ctgmath></code></td> + <td>done</td> + <td></td> + <td></td> + <td>DR 551</td> + </tr> + <tr> + <td>C2.28</td> + <td>Header <code><tgmath.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td>DR 551</td> + </tr> + <tr> + <td>C2.29</td> + <td>Additions to header <code><ctime></code></td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>C2.30</td> + <td>Additions to header <code><cwchar></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.30.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.30.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.30.3</td> + <td>Additional wide format specifiers</td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>C2.31</td> + <td>Additions to header <code><wchar.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.32</td> + <td>Additions to header <code><cwctype></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.32.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.32.2</td> + <td>Function <code>iswblank</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>C2.33</td> + <td>Additions to header <code><wctype.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>D</b></td> + <td colspan="5"><b>Compatibility Features</b></td> + </tr> + <tr> + <td>D.6</td> + <td>Old iostream members</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>D.8</td> + <td>Binders</td> + <td>done</td> + <td></td> + <td></td> + <td><a href="http://gcc.gnu.org/PR33911">33911</a></td> + </tr> + <tr> + <td>D.9</td> + <td>Class template <code>auto_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td><a href="http://gcc.gnu.org/PR33911">33911</a></td> + </tr> + + </tbody> +</table> + +<h3>Footnotes</h3> + +<ol> + + <li> + <a name="1"/> + The shared_ptr implementation uses some code from the + <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm">Boost + shared_ptr</a> library. + </li> + +</ol> + +<p> +Please send FSF & GNU inquiries & questions to +<a href="mailto:gnu@gnu.org">gnu@gnu.org</a>. +There are also <a href="http://www.gnu.org/home.html#ContactInfo">other ways +to contact</a> the FSF. +</p> + +<p> +These pages are maintained by +<a href="http://gcc.gnu.org/about.html">the GCC team</a>. +</p> + +<address> +For questions related to the use of GCC, please consult these web +pages and the <a href="http://gcc.gnu.org/onlinedocs/">GCC manuals</a>. If +that fails, the <a href="mailto:gcc-help@gcc.gnu.org">gcc-help@gcc.gnu.org</a> +mailing list might help.<br /> +Please send comments on these web pages and the development of GCC to our +developer mailing list at <a href="mailto:gcc@gnu.org">gcc@gnu.org</a> +or <a href="mailto:gcc@gcc.gnu.org">gcc@gcc.gnu.org</a>. All of our lists +have <a href="http://gcc.gnu.org/lists.html">public archives</a>. +</address> + +<p> +Copyright (C) Free Software Foundation, Inc., +51 Franklin St, Fifth Floor, Boston, MA 02110, USA. +</p> +<p> +Verbatim copying and distribution of this entire article is +permitted in any medium, provided this notice is preserved. +</p> + +<table width="100%" border="0"> +<tr> + <td> + <!-- IGNORE DIFF -->Last modified 2007-10-30 + </td> + <td align="right" valign="bottom"> + <a href="http://validator.w3.org/check/referer"> + <img src="http://www.w3.org/Icons/valid-xhtml10" + alt="Valid XHTML 1.0" border="0" width="88" height="31" /> + </a> + </td> +</tr> +</table> + +</body> +</html> diff --git a/libstdc++-v3/doc/html/17_intro/c++1998_status.html b/libstdc++-v3/doc/html/17_intro/c++1998_status.html new file mode 100644 index 00000000000..7865e649982 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/c++1998_status.html @@ -0,0 +1,6004 @@ +<pre> + + 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(); + }; + +</pre>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/17_intro/confdeps.dot b/libstdc++-v3/doc/html/17_intro/confdeps.dot new file mode 100644 index 00000000000..a62d28ce9dd --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/confdeps.dot @@ -0,0 +1,14 @@ +# Blatantly ripped out of the graphviz examples and modified. -pme +digraph v3conf { + size="6,6"; + node [color=lightblue2, style=filled]; + "aclocal.m4" -> "acinclude.m4"; + "configure" -> "aclocal.m4"; + "configure" -> "configure.ac"; + "configure" -> "crossconfig.m4"; + "configure" -> "linkage.m4"; + "[*/]Makefile.in" -> "Makefile.am"; + "[*/]Makefile.in" -> "configure.ac"; + "config.h.in" -> "acconfig.h"; + "config.h.in" -> "configure.ac"; +} diff --git a/libstdc++-v3/doc/html/17_intro/confdeps.png b/libstdc++-v3/doc/html/17_intro/confdeps.png Binary files differnew file mode 100644 index 00000000000..5075aa869b1 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/confdeps.png diff --git a/libstdc++-v3/doc/html/17_intro/configury.html b/libstdc++-v3/doc/html/17_intro/configury.html new file mode 100644 index 00000000000..a35ccf23996 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/configury.html @@ -0,0 +1,305 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> + <meta name="AUTHOR" content="pme@gcc.gnu.org (Phil Edwards)" /> + <meta name="DESCRIPTION" content="configury for libstdc++" /> + <meta name="GENERATOR" content="vi and eight fingers" /> + <title>libstdc++ configury</title> +<link rel="StyleSheet" href="../lib3styles.css" type='text/css' /> +<link rel="Start" href="../documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +</head> +<body> + +<h1><code>> open configury door</code></h1> +<h1><code>> look</code></h1> + +<p class="larger"><code>You are in a maze of twisty passages, all +different.</code></p> +<p class="larger"><code>It is dark. You are likely to be eaten by a +Canadian cross build.</code></p> + + +<hr /> +<h2>Notes on libstdc++ configury</h2> +<blockquote> +No problem is insoluble in all conceivable circumstances.<br /> +-- The Cosmic AC, +<a href="http://mit.edu/tylerc/www/twt/LQ1.htm">The +Last Question</a>, by Isaac Asimov +</blockquote> +<ul> + <li><a href="#prereq">Prerequisites for configure and make hacking</a></li> + <li><a href="#deps">Overview: what comes from where</a></li> + <li><a href="#breakout">Storing information in non-AC files, like + configure.host</a></li> + <li><a href="#general">Coding and commenting conventions</a></li> + <li><a href="#aclayout">The acinclude.m4 layout</a></li> + <li><a href="#enable"><code>GLIBCXX_ENABLE, the --enable</code> howto</a></li> +</ul> + +<hr /> +<h3><a name="prereq">Prerequisites for configure and make hacking</a></h3> + +<p> As +noted <a href="http://gcc.gnu.org/install/prerequisites.html">previously</a>, +certain other tools are necessary for hacking on files that control +configure (<code>configure.ac</code>, <code>acinclude.m4</code>) and +make (<code>Makefile.am</code>). These additional tools +(<code>automake</code>, and <code>autoconf</code>) are further +described in detail in their respective manuals. All the libraries in GCC try to stay in sync with each other in terms of versions of the auto-tools used, so please try to play nicely with the neighbors. +</p> + + +<hr /> +<h3><a name="deps">Overview: what comes from where</a></h3> +<p class="centered"><img src="confdeps.png" + alt="Dependency graph in PNG graphics format. (Get a better browser!)" /></p> + +<p>Regenerate all generated files by using the command sequence + <code>"autoreconf"</code> at the top level of the libstdc++ source + directory. The following will also work, but is much more complex: + <code>"aclocal-1.7 && autoconf-2.59 && + autoheader-2.59 && automake-1.7"</code> The version numbers + may be absent entirely or otherwise vary depending on + <a href="http://gcc.gnu.org/install/prerequisites.html">the current + requirements</a> and your vendor's choice of installation names. +</p> + + +<hr /> +<h3><a name="breakout">Storing information in non-AC files, like + configure.host</a></h3> +<p>Until that glorious day when we can use AC_TRY_LINK with a cross-compiler, + we have to hardcode the results of what the tests would have shown if + they could be run. So we have an inflexible mess like crossconfig.m4. +</p> + +<p>Wouldn't it be nice if we could store that information in files like + configure.host, which can be modified without needing to regenerate + anything, and can even be tweaked without really knowing how the configury + all works? Perhaps break the pieces of crossconfig.m4 out and place them in + their appropriate config/{cpu,os} directory. +</p> + +<p>Alas, writing macros like "<code>AC_DEFINE(HAVE_A_NICE_DAY)</code>" can + only be done inside files which are passed through autoconf. Files which + are pure shell script can be source'd at configure time. Files which + contain autoconf macros must be processed with autoconf. We could still + try breaking the pieces out into "config/*/cross.m4" bits, for instance, + but then we would need arguments to aclocal/autoconf to properly find + them all when generating configure. I would discourage that. +</p> + + +<hr /> +<h3><a name="general">Coding and commenting conventions</a></h3> +<p>Lots of stuff got thrown out because the new autotools kindly generate + the same (or better) shell code for us. +</p> + +<p>Most comments should use {octothorpes, shibboleths, hash marks, pound + signs, whatevers} rather than "dnl". Nearly all comments in configure.ac + should. Comments inside macros written in ancilliary .m4 files should. + About the only comments which should <em>not</em> use #, but use dnl + instead, are comments <em>outside</em> our own macros in the ancilliary + files. The difference is that # comments show up in <code>configure</code> + (which is most helpful for debugging), while dnl'd lines just vanish. + Since the macros in ancilliary files generate code which appears in odd + places, their "outside" comments tend to not be useful while reading + <code>configure</code>. +</p> + +<p>Do not use any <code>$target*</code> variables, such as + <code>$target_alias</code>. The single exception is in configure.ac, + for automake+dejagnu's sake. +</p> + +<p> +</p> + +<hr /> +<h3><a name="aclayout">The acinclude.m4 layout</a></h3> +<p>The nice thing about acinclude.m4/aclocal.m4 is that macros aren't actually + performed/called/expanded/whatever here, just loaded. So we can arrange + the contents however we like. As of this writing, acinclude.m4 is arranged + as follows: +</p> +<pre> + GLIBCXX_CHECK_HOST + GLIBCXX_TOPREL_CONFIGURE + GLIBCXX_CONFIGURE +</pre> +<p>All the major variable "discovery" is done here. CXX, multilibs, etc. +</p> +<pre> + fragments included from elsewhere +</pre> +<p>Right now, "fragments" == "the math/linkage bits". +</p> +<pre> + GLIBCXX_CHECK_COMPILER_FEATURES + GLIBCXX_CHECK_LINKER_FEATURES + GLIBCXX_CHECK_WCHAR_T_SUPPORT +</pre> +<p>Next come extra compiler/linker feature tests. Wide character support + was placed here because I couldn't think of another place for it. It will + probably get broken apart like the math tests, because we're still disabling + wchars on systems which could actually support them. +</p> +<pre> + GLIBCXX_CHECK_SETRLIMIT_ancilliary + GLIBCXX_CHECK_SETRLIMIT + GLIBCXX_CHECK_S_ISREG_OR_S_IFREG + GLIBCXX_CHECK_POLL + GLIBCXX_CHECK_WRITEV + + GLIBCXX_CONFIGURE_TESTSUITE +</pre> +<p>Feature tests which only get used in one place. Here, things used only in + the testsuite, plus a couple bits used in the guts of I/O. +</p> +<pre> + GLIBCXX_EXPORT_INCLUDES + GLIBCXX_EXPORT_FLAGS + GLIBCXX_EXPORT_INSTALL_INFO +</pre> +<p>Installation variables, multilibs, working with the rest of the compiler. + Many of the critical variables used in the makefiles are set here. +</p> +<pre> + GLIBGCC_ENABLE + GLIBCXX_ENABLE_C99 + GLIBCXX_ENABLE_CHEADERS + GLIBCXX_ENABLE_CLOCALE + GLIBCXX_ENABLE_CONCEPT_CHECKS + GLIBCXX_ENABLE_CSTDIO + GLIBCXX_ENABLE_CXX_FLAGS + GLIBCXX_ENABLE_C_MBCHAR + GLIBCXX_ENABLE_DEBUG + GLIBCXX_ENABLE_DEBUG_FLAGS + GLIBCXX_ENABLE_LONG_LONG + GLIBCXX_ENABLE_PCH + GLIBCXX_ENABLE_SJLJ_EXCEPTIONS + GLIBCXX_ENABLE_SYMVERS + GLIBCXX_ENABLE_THREADS +</pre> +<p>All the features which can be controlled with enable/disable configure + options. Note how they're alphabetized now? Keep them like that. :-) +</p> +<pre> + AC_LC_MESSAGES + libtool bits +</pre> +<p>Things which we don't seem to use directly, but just has to be present + otherwise stuff magically goes wonky. +</p> + + +<hr /> +<h3><a name="enable">GLIBCXX_ENABLE, the <code>--enable</code> howto</a></h3> +<p>All the GLIBCXX_ENABLE_FOO macros use a common helper, GLIBCXX_ENABLE. + (You don't have to use it, but it's easy.) The helper does two things + for us: +</p> + +<ol> + <li>Builds the call to the AC_ARG_ENABLE macro, with --help text properly + quoted and aligned. (Death to changequote!)</li> + <li>Checks the result against a list of allowed possibilities, and signals + a fatal error if there's no match. This means that the rest of the + GLIBCXX_ENABLE_FOO macro doesn't need to test for strange arguments, + nor do we need to protect against empty/whitespace strings with the + <code>"x$foo" = "xbar"</code> idiom.</li> +</ol> + +<p>Doing these things correctly takes some extra autoconf/autom4te code, + which made our macros nearly illegible. So all the ugliness is factored + out into this one helper macro. +</p> + +<p>Many of the macros take an argument, passed from when they are expanded + in configure.ac. The argument controls the default value of the + enable/disable switch. Previously, the arguments themselves had defaults. + Now they don't, because that's extra complexity with zero gain for us. +</p> + +<p>There are three "overloaded signatures". When reading the descriptions + below, keep in mind that the brackets are autoconf's quotation characters, + and that they will be stripped. Examples of just about everything occur + in acinclude.m4, if you want to look. +</p> + +<pre> + GLIBCXX_ENABLE (FEATURE, DEFAULT, HELP-ARG, HELP-STRING) + GLIBCXX_ENABLE (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c) + GLIBCXX_ENABLE (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER) +</pre> + +<ul> + <li><p>FEATURE is the string that follows --enable. The results of the test + (such as it is) will be in the variable $enable_FEATURE, where FEATURE + has been squashed. Example: <code>[extra-foo]</code>, controlled by the + --enable-extra-foo option and stored in $enable_extra_foo.</p></li> + <li><p>DEFAULT is the value to store in $enable_FEATURE if the user does not + pass --enable/--disable. It should be one of the permitted values + passed later. Examples: <code>[yes]</code>, or <code>[bar]</code>, or + <code>[$1]</code> (which passes the argument given to the + GLIBCXX_ENABLE_FOO macro as the default).</p> + <p>For cases where we need to probe for particular models + of things, it is useful to have an undocumented "auto" value here (see + GLIBCXX_ENABLE_CLOCALE for an example).</p></li> + <li><p>HELP-ARG is any text to append to the option string itself in the + --help output. Examples: <code>[]</code> (i.e., an empty string, + which appends nothing), + <code>[=BAR]</code>, which produces + <code>--enable-extra-foo=BAR</code>, and + <code>[@<:@=BAR@:>@]</code>, which produces + <code>--enable-extra-foo[=BAR]</code>. See the difference? See what + it implies to the user?</p> + <p>If you're wondering what that line noise in the last example was, + that's how you embed autoconf special characters in output text. + They're called +<a +href="http://www.gnu.org/software/autoconf/manual/autoconf-2.57/html_node/autoconf_95.html#SEC95"><em>quadrigraphs</em></a> + and you should use them whenever necessary.</p></li> + <li><p>HELP-STRING is what you think it is. Do not include the "default" + text like we used to do; it will be done for you by GLIBCXX_ENABLE. + By convention, these are not full English sentences. + Example: [turn on extra foo]</p></li> +</ul> + +<p>With no other arguments, only the standard autoconf patterns are + allowed: "<code>--{enable,disable}-foo[={yes,no}]</code>" The + $enable_FEATURE variable is guaranteed to equal either "yes" or "no" + after the macro. If the user tries to pass something else, an + explanatory error message will be given, and configure will halt. +</p> + +<p>The second signature takes a fifth argument, + "<code>[permit <em>a</em>|<em>b</em>|<em>c</em>|<em>...</em>]</code>" + This allows <em>a</em> or <em>b</em> or ... after the equals sign in the + option, and $enable_FEATURE is guaranteed to equal one of them after the + macro. Note that if you want to allow plain --enable/--disable with no + "=whatever", you must include "yes" and "no" in the list of permitted + values. Also note that whatever you passed as DEFAULT must be in the list. + If the user tries to pass something not on the list, a semi-explanatory + error message will be given, and configure will halt. + Example: <code>[permit generic|gnu|ieee_1003.1-2001|yes|no|auto]</code> +</p> + +<p>The third signature takes a fifth argument. It is arbitrary shell code + to execute if the user actually passes the enable/disable option. (If + the user does not, the default is used. Duh.) No argument checking at + all is done in this signature. See GLIBCXX_ENABLE_CXX_FLAGS for an + example of handling, and an error message. +</p> + +<hr /> +</body> +</html> diff --git a/libstdc++-v3/doc/html/17_intro/contribute.html b/libstdc++-v3/doc/html/17_intro/contribute.html new file mode 100644 index 00000000000..00c749a4490 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/contribute.html @@ -0,0 +1,135 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>How to contribute</title> +<link rel="StyleSheet" href="../lib3styles.css" type="text/css" /> +<link rel="Start" href="../documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +<link rel="Help" href="../faq/index.html" type="text/html" title="F.A.Q." /> +</head> +<!--990301 slightly modified version of the GCC contribute.html file--> +<!-- #include virtual="/include/header-subpages.html"--> +<body> +<h2>How to contribute</h2> +<p> The Standard C++ Library v3, follows an open development +model. Active contributors are assigned maintainer-ship +responsibility, and given write access to the SVN repository. First +time contributors should follow this procedure: +</p> + +<hr /> +<h4>ONE : read the documentation</h4> + +<ul> + <li> Get and read the relevant sections of the C++ language +specification. Copies of the full ISO 14882 standard are available on +line via the ISO mirror site for committee members. Non-members, or +those who have not paid for the privilege of sitting on the committee +and sustained their two meeting commitment for voting rights, may get +a copy of the standard from their respective national standards +organization. In the USA, this national standards organization is ANSI +and their web-site is right + + <a href="http://www.ansi.org">here.</a> +(And if you've already registered with them, clicking this link will take you to directly to the place where you can +<a href="http://webstore.ansi.org/ansidocstore/product.asp?sku=ISO%2FIEC+14882%3A2003">buy the standard on-line.)</a> +</li> + +<li> The library working group bugs, and known defects, can be obtained here: + <a href="http://www.open-std.org/jtc1/sc22/wg21/">http://www.open-std.org/jtc1/sc22/wg21 </a> +</li> + +<li> The newsgroup dedicated to standardization issues is comp.std.c++: this FAQ for this group is quite useful and can be found <a href="http://www.jamesd.demon.co.uk/csc/faq.html"> here </a>. +</li> + + <li> Peruse the <a href="http://www.gnu.org/prep/standards_toc.html">GNU Coding Standards</a>, and chuckle when you hit the part about "Using Languages Other Than C." +</li> + + <li> Be familiar with the extensions that preceded these general GNU rules. These style issues for libstdc++ can be found in the file C++STYLE, located in the root level of the distribution, or <a href="C++STYLE"> here. </a> +</li> + + <li> And last but certainly not least, read the library-specific information found <a href="../documentation.html"> here.</a> +</li> + +</ul> + + + +<hr /> +<h4>TWO : copyright assignment</h4> +<p> +Small changes can be accepted without a copyright assignment form on +file. New code and additions to the library need completed copyright +assignment form on file at the FSF. Note: your employer may be required +to fill out appropriate disclaimer forms as well. +</p> + +<p> Historically, the libstdc++ assignment form added the following question: +</p> + +<code>[Which Belgian comic book character is better, Tintin or +Asterix, and why?]</code> + +<p> +While not strictly necessary, humoring the maintainers and answering +this question would be appreciated. +</p> + +<p> +For more information about getting a copyright assignment, please see +<a href="http://www.gnu.org/prep/maintain/html_node/Legal-Matters.html">Legal +Matters</a>. +</p> + +<p> +Please contact <a href="mailto:bkoz+assign@redhat.com">Benjamin +Kosnik</a> if you are confused about the assignment or have general +licensing questions. When requesting an assignment form from <a +href="mailto:assign@gnu.org">assign@gnu.org</a>, please cc +the above libstdc++ maintainer so that progress can be monitored. +</p> + + +<hr /> +<h4>THREE : submitting patches</h4> + +<p> +Every patch must have several pieces of information before it can be +properly evaluated. Ideally (and to ensure the fastest possible +response from the maintainers) it would have all of these pieces: +</p> + +<ul> + + <li> A description of the bug and how your patch fixes this bug. For + new features a description of the feature and your implementation. </li> + + <li> A ChangeLog entry as plain text; see the various ChangeLog files + for format and content. If using you are using emacs as your editor, + simply position the insertion point at the beginning of your change + and hit CX-4a to bring up the appropriate ChangeLog + entry. See--magic! Similar functionality also exists for vi. </li> + + <li> A testsuite submission or sample program that will easily and + simply show the existing error or test new functionality. </li> + + <li> The patch itself. If you are accessing the SVN repository + use "svn update; svn diff NEW"; else, use "diff -cp OLD NEW" + ... If your version of diff does not support these options, then + get the latest version of GNU diff. The <a + href="http://gcc.gnu.org/wiki/SvnTricks">SVN Tricks</a> wiki page + has information on customising the output of <code>svn diff</code>.</li> + + <li> When you have all these pieces, bundle them up in a mail message +and send it to libstdc++@gcc.gnu.org. All patches and related +discussion should be sent to the libstdc++ mailing list. </li> + +</ul> + +</body> +</html> + diff --git a/libstdc++-v3/doc/html/17_intro/howto.html b/libstdc++-v3/doc/html/17_intro/howto.html new file mode 100644 index 00000000000..09f1a3c370a --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/howto.html @@ -0,0 +1,737 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> + <meta name="AUTHOR" content="pme@gcc.gnu.org (Phil Edwards), Benjamin Kosnik, Felix Natter" /> + <meta name="KEYWORDS" content="HOWTO, libstdc++, gcc, g++, libg++, STL" /> + <meta name="DESCRIPTION" content="HOWTO for libstdc++ chapter 17." /> + <meta name="GENERATOR" content="vi and eight fingers" /> + <title>libstdc++ HOWTO: Chapter 17: Library Introduction</title> +<link rel="StyleSheet" href="../lib3styles.css" type="text/css" /> +<link rel="Start" href="../documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +<link rel="Next" href="../18_support/howto.html" type="text/html" + title="Library Support" /> +<link rel="Copyright" href="license.html" type="text/html" /> +<link rel="Help" href="../faq/index.html" type="text/html" title="F.A.Q." /> +</head> +<body> + +<h1 class="centered"><a name="top">Chapter 17: Library Introduction</a></h1> + +<p>Chapter 17 is actually a list of definitions and descriptions used + in the following chapters of the Standard when describing the actual + library. Here, we use "Introduction" as an introduction + to the <em>GNU implementation of</em> the ISO Standard C++ Library. +</p> + + +<!-- ####################################################### --> +<hr /> +<h1>Contents</h1> +<ul> + <li><a href="#2.0">Header Files</a></li> + <li><a href="#3.0">Namespaces</a></li> + <li><a href="#6">Macros</a></li> + <li><a href="#5">Implementation specific behavior</a></li> + <li><a href="#7">Multithreading</a></li> +</ul> + +<hr /> + +<!-- ####################################################### --> + +<h2><a name="2.0">Header Files</a></h2> + <p>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 <code>#include</code>'s a header, the + contents of that header become + available, no matter how. + </p> + +<p>That said, in practice files are used.</p> + +<p> 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).</p> + +<p>Two dialects of standard headers are supported, corresponding to +the 1998 standard as updated for 2003, and the draft of the upcoming +200x standard. +</p> + +<p>C++98/03 include files. These are available in the default compilation mode, ie <code>-std=c++98</code> or <code>-std=gnu++98</code>. +</p> + +<center><table border="1"><caption>C++98 Library Headers</caption> +<tr><td><algorithm></td><td><iomanip></td><td><list></td><td><ostream></td><td><streambuf></td></tr> +<tr><td><bitset></td><td><ios></td><td><locale></td><td><queue></td><td><string></td></tr> +<tr><td><complex></td><td><iosfwd></td><td><map></td><td><set></td><td><typeinfo></td></tr> +<tr><td><deque></td><td><iostream></td><td><memory></td><td><sstream></td><td><utility></td></tr> +<tr><td><exception></td><td><istream></td><td><new></td><td><stack></td><td><valarray></td></tr> +<tr><td><fstream></td><td><iterator></td><td><numeric></td><td><stdexcept></td><td><vector></td></tr> +<tr><td><functional></td><td><limits></td></tr> +</table></center> + +<p></p> + +<center><table border="1"><caption>C++98 Headers for C Library Facilities</caption> +<tr><td><cassert></td><td><ciso646></td><td><csetjmp></td><td><cstdio></td><td><ctime></td></tr> +<tr><td><cctype></td><td><climits></td><td><csignal></td><td><cstdlib></td><td><cwchar></td></tr> +<tr><td><cerrno></td><td><clocale></td><td><cstdarg></td><td><cstring></td><td><cwctype></td></tr> +<tr><td><cfloat></td><td><cmath></td><td><cstddef></td></tr> +</table></center> + +<p>C++0x include files. These are only available in C++0x compilation mode, ie <code>-std=c++0x</code> or <code>-std=gnu++0x</code>. +</p> + +<center><table border="1"><caption>C++0x Library Headers</caption> +<tr><td><algorithm></td><td><iomanip></td><td><locale></td><td><regex></td><td><tuple></td></tr> +<tr><td><array></td><td><ios></td><td><map></td><td><set></td><td><typeinfo></td></tr> +<tr><td><bitset></td><td><iosfwd></td><td><memory></td><td><sstream></td><td><type_traits></td></tr> +<tr><td><complex></td><td><iostream></td><td><new></td><td><stack></td><td><unordered_map></td></tr> +<tr><td><deque></td><td><istream></td><td><numeric></td><td><stdexcept></td><td><unordered_set></td></tr> +<tr><td><exception></td><td><iterator></td><td><ostream></td><td><streambuf></td><td><utility></td></tr> +<tr><td><fstream></td><td><limits></td><td><queue></td><td><string></td><td><valarray></td></tr> +<tr><td><functional></td><td><list></td><td><random></td><td><system_error></td><td><vector></td></tr> +</table></center> + +<p></p> + +<center><table border="1"><caption>C++0x Headers for C Library Facilities</caption> +<tr><td><cassert></td><td><cfloat></td><td><cmath></td><td><cstddef></td><td><ctgmath></td></tr> +<tr><td><ccomplex></td><td><cinttypes></td><td><csetjmp></td><td><cstdint></td><td><ctime></td></tr> +<tr><td><cctype></td><td><ciso646></td><td><csignal></td><td><cstdio></td><td><cuchar></td></tr> +<tr><td><cerrno></td><td><climits></td><td><cstdarg></td><td><cstdlib></td><td><cwchar></td></tr> +<tr><td><cfenv></td><td><clocale></td><td><cstdbool></td><td><cstring></td><td><cwctype></td></tr> +</table></center> + + +<p>In addition, TR1 includes as: +</p> + +<center><table border="1"><caption>TR1 Library Headers</caption> +<tr><td><tr1/array></td><td><tr1/memory></td><td><tr1/regex></td><td><tr1/type_traits></td><td><tr1/unordered_set></td></tr> +<tr><td><tr1/complex></td><td><tr1/random></td><td><tr1/tuple></td><td><tr1/unordered_map></td><td><tr1/utility></td></tr> +<tr><td><tr1/functional></td></tr> +</table></center> + +<p></p> + +<center><table border="1"><caption>TR1 Headers for C Library Facilities</caption> +<tr><td><tr1/cmath></td><td><tr1/cfloat></td><td><tr1/cstdarg></td><td><tr1/cstdio></td><td><tr1/ctime></td></tr> +<tr><td><tr1/ccomplex></td><td><tr1/cinttypes></td><td><tr1/cstdbool></td><td><tr1/cstdlib></td><td><tr1/cwchar></td></tr> +<tr><td><tr1/cfenv></td><td><tr1/climits></td><td><tr1/cstdint></td><td><tr1/ctgmath></td><td><tr1/cwctype></td></tr> +</table></center> + +<p>Also included are files for the C++ ABI interface: +</p> +<center><table border="1"><caption>C++ ABI Headers</caption> +<tr><td><cxxabi.h></td><td><cxxabi_forced.h></td></tr> +</table></center> + +<p>And a large variety of extensions. +</p> + +<center><table border="1"><caption>Extension Headers</caption> +<tr><td><ext/algorithm></td><td><ext/debug_allocator.h></td><td><ext/mt_allocator.h></td><td><ext/pod_char_traits.h></td><td><ext/stdio_sync_filebuf.h></td></tr> +<tr><td><ext/array_allocator.h></td><td><ext/enc_filebuf.h></td><td><ext/new_allocator.h></td><td><ext/pool_allocator.h></td><td><ext/throw_allocator.h></td></tr> +<tr><td><ext/atomicity.h></td><td><ext/functional></td><td><ext/numeric></td><td><ext/rb_tree></td><td><ext/typelist.h></td></tr> +<tr><td><ext/bitmap_allocator.h></td><td><ext/iterator></td><td><ext/numeric_traits.h></td><td><ext/rope></td><td><ext/type_traits.h></td></tr> +<tr><td><ext/codecvt_specializations.h></td><td><ext/malloc_allocator.h></td><td><ext/pb_ds/assoc_container.h></td><td><ext/slist></td><td><ext/vstring.h></td></tr> +<tr><td><ext/concurrence.h></td><td><ext/memory></td><td><ext/pb_ds/priority_queue.h></td><td><ext/stdio_filebuf.h></td></tr> +</table></center> + +<p></p> + +<center><table border="1"><caption>Extension Debug Headers</caption> +<tr><td><debug/bitset></td><td><debug/list></td><td><debug/set></td><td><debug/unordered_map></td><td><debug/vector></td></tr> +<tr><td><debug/deque></td><td><debug/map></td><td><debug/string></td><td><debug/unordered_set></td></tr> +</table></center> + +<p></p> + +<center><table border="1"><caption>Extension Parallel Headers</caption> +<tr><td><parallel/algorithm></td><td><parallel/numeric></td></tr> +</table></center> + +<hr /> +<h2><a name="2.1">Recipes for mixing headers</a></h2> + +<p> A few simple rules. +</p> + +<p>First, mixing different dialects of the standard headers is not +possible. It's an all-or-nothing affair. Thus, code like +</p> + +<pre> +#include <array> +#include <functional> +</pre> + +<p>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. +</p> + +<p>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 <code>__gnu_cxx::vstring</code>, or to use the +debug-mode versions of <code>std::unordered_map</code>, one must use +the <code>std=gnu++0x</code> compiler flag. (Or <code>std=c++0x</code>, of course.) +</p> + +<p>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: +</p> + +<pre> +#include <tr1/type_traits> +#include <type_traits> +</pre> + +<p> Several parts of C++0x diverge quite substantially from TR1 predecessors. +</p> + + +<hr /> +<h2><a name="2.2">The C Headers and <code>namespace std</code></a></h2> +<p> + 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 <code>std::</code> (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. + </p> + +<p> +Usage of C++-style headers is recommended, as then +C-linkage names can be disambiguated by explicit qualification, such +as by <code>std::abort</code>. 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 <code>std::sin</code> has overloads for all the builtin +floating-point types. This means that <code>std::sin</code> can be +used uniformly, instead of a combination +of <code>std::sinf</code>, <code>std::sin</code>, +and <code>std::sinl</code>. +</p> + +<hr /> +<h2><a name="2.3">Precompiled Headers</a></h2> + +<p>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. +</p> + + +<ul> +<li>stdc++.h +<p>Includes all standard headers. Actual content varies depending on +language dialect. +</p> +</li> + +<li>stdtr1c++.h +<p>Includes all of <stdc++.h>, and adds all the TR1 headers. +</p> +</li> + +<li>extc++.h +<p>Includes all of <stdtr1c++.h>, and adds all the Extension headers. +</p></li> +</ul> + +<p>How to construct a .gch file from one of these base header files.</p> + +<p>First, find the include directory for the compiler. One way to do +this is:</p> + +<pre> +g++ -v hello.cc + +#include <...> search starts here: + /mnt/share/bld/H-x86-gcc.20071201/include/c++/4.3.0 +... +End of search list. +</pre> + + +<p>Then, create a precompiled header file with the same flags that +will be used to compile other projects.</p> + +<pre> +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 +</pre> + +<p>The resulting file will be quite large: the current size is around +thirty megabytes. </p> + +<p>How to use the resulting file.</p> + +<pre> +g++ -I. -include stdc++.h -H -g -O2 hello.cc +</pre> + +<p>Verification that the PCH file is being used is easy:</p> + +<pre> +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 +</pre> + +<p>The exclamation point to the left of the <code>stdc++.h.gch</code> listing means that the generated PCH file was used, and thus the </p> +<p></p> + +<p> Detailed information about creating precompiled header files can be found in the GCC <a href="http://gcc.gnu.org/onlinedocs/gcc/Precompiled-Headers.html">documentation</a>. +</p> + + +<hr /> +<h2><a name="3.0">Namespaces</a></h2> + + +<p> There are three main namespaces. +</p> + +<ul> +<li>std +<p>The ISO C++ standards specify that "all library entities are defined +within namespace std." This includes namepaces nested +within <code>namespace std</code>, such as <code>namespace +std::tr1</code>. +</p> +</li> +<li>abi +<p>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. +</p> +</li> + +<li>__gnu_ +<p>Indicating one of several GNU extensions. Choices +include <code>__gnu_cxx</code>, <code>__gnu_debug</code>, <code>__gnu_parallel</code>, +and <code>__gnu_pbds</code>. +</p></li> +</ul> + +<p> A complete list of implementation namespaces (including namespace contents) is available in the generated source <a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html">documentation</a>. +</p> + + +<hr /> +<h2><a name="3.1">Namespace <code>std::</code></a></h2> + +<p> + One standard requirement is that the library components are defined + in <code>namespace std::</code>. Thus, in order to use these types or + functions, one must do one of two things: +</p> + + <div class="itemizedlist"><ul type="disc"> <li><p>put a kind of +<span class="emphasis"><i>using-declaration</i></span> in your source +(either <code>using namespace std;</code> or i.e. <code>using +std::string;</code>) This approach works well for individual source files, but +should not be used in a global context, like header files. + </p></li> <li><p>use a <span class="emphasis"><i>fully +qualified name</i></span> for each library symbol +(i.e. <code>std::string</code>, <code>std::cout</code>) Always can be +used, and usually enhanced, by strategic use of typedefs. (In the +cases where the qualified verbiage becomes unwieldy.) + </p></li> +</ul></div> + +<hr /> +<h2><a name="3.2">Using namespace composition</a></h2> + +<p> +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. +</p> + +<p>For instance, consider a project that defines most of its classes in <code>namespace gtk</code>. It is possible to + adapt <code>namespace gtk</code> to <code>namespace std</code> by using a C++-feature called + <span class="emphasis"><i>namespace composition</i></span>. This is what happens if + a <span class="emphasis"><i>using</i></span>-declaration is put into a + namespace-definition: the imported symbol(s) gets imported into the + currently active namespace(s). For example: +</p> +<pre class="programlisting"> +namespace gtk +{ + using std::string; + using std::tr1::array; + + class Window { ... }; +} +</pre> +<p> + In this example, <code>std::string</code> gets imported into + <code>namespace gtk</code>. The result is that use of + <code>std::string</code> inside namespace gtk can just use <code>string</code>, without the explicit qualification. + As an added bonus, + <code>std::string</code> does not get imported into + the global namespace. Additionally, a more elaborate arrangement can be made for backwards compatibility and portability, whereby the + <code>using</code>-declarations can wrapped in macros that + are set based on autoconf-tests to either "" or i.e. <code>using + std::string;</code> (depending on whether the system has + libstdc++ in <code>std::</code> or not). (ideas from + <tt><<a href="mailto:llewelly@dbritsch.dsl.xmission.com">llewelly@dbritsch.dsl.xmission.com</a>></tt>, Karl Nelson + <tt><<a href="mailto:kenelson@ece.ucdavis.edu">kenelson@ece.ucdavis.edu</a>></tt>) +</p> + +<hr /> +<h2><a name="6">Macros for libstdc++</a></h2> + + <p>All pre-processor switches and configurations are all gathered + in the file <code>c++config.h</code>, 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. <strong>These macros cannot be + redefined</strong>. 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. + </p> + + <p>All library macros begin with <code>_GLIBCXX_</code> (except for + versions 3.1.x to 3.3.x, which use <code>_GLIBCPP_</code>). + </p> + + <p>Below is the macro which users may check for library version + information. </p> + + <dl> + <dt><code>__GLIBCXX__</code></dt> <dd>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 <a href="abi.html"> + document</a>.</dd> </dl> + + <p>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.</p> + + <p>"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 <a href="../configopts.html">here</a>), with the + various --enable/--disable choices being translated to + #define/#undef). + </p> + + <p> "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 <em>headers</em> may see different code + paths, but the <em>libraries</em> 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. + </p> + + <dl> + <dt><code>_GLIBCXX_DEPRECATED</code></dt> + <dd>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 + <code>-std=c++98</code> and <code>-std=c++0x</code>. 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. </dd> + + <dt><code>_GLIBCXX_FORCE_NEW</code></dt> <dd>Undefined by + default. When defined, memory allocation and allocators controlled + by libstdc++ call operator new/delete without caching and + pooling. Configurable via + <code>--enable-libstdcxx-allocator</code>. ABI-changing. + </dd> + + + <dt><code>_GLIBCXX_CONCEPT_CHECKS</code></dt> <dd>Undefined by + default. Configurable via <code>--enable-concept-checks</code>. + 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 <a + href="../19_diagnostics/howto.html#3">here</a>.</dd> + + <dt><code>_GLIBCXX_DEBUG</code></dt> + <dd>Undefined by default. When defined, compiles + user code using the <a href="../ext/debug.html#safe">libstdc++ debug + mode</a>. + </dd> + <dt><code>_GLIBCXX_DEBUG_PEDANTIC</code></dt> + <dd>Undefined by default. When defined while + compiling with the <a href="../ext/debug.html#safe">libstdc++ debug + mode</a>, makes the debug mode extremely picky by making the use + of libstdc++ extensions and libstdc++-specific behavior into + errors. + </dd> + <dt><code>_GLIBCXX_PARALLEL</code></dt> + <dd>Undefined by default. When defined, compiles + user code using the <a href="../ext/parallel_mode.html">libstdc++ parallel + mode</a>. + </dd> + </dl> + +<hr /> +<h2><a name="7">The Standard C++ library and multithreading</a></h2> + <p>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. + Unless explicitly prefaced, all information in this section is + relevant to the GCC 3.0 release and all later releases. + </p> + <p>Earlier GCC releases had a somewhat different approach to + threading configuration and proper compilation. Before GCC 3.0, + configuration of the threading model was dictated by compiler + command-line options and macros (both of which were somewhat + thread-implementation and port-specific). There were no + guarantees related to being able to link code compiled with one + set of options and macro setting with another set. For GCC 3.0, + configuration of the threading model used with libraries and + user-code is performed when GCC is configured and built using + the --enable-threads and --disable-threads options. The ABI is + stable for symbol name-mangling and limited functional + compatibility exists between code compiled under different + threading models. + </p> + <p>All normal disclaimers aside, multithreaded C++ application are + only supported when libstdc++ and all user code was built with + compilers which report (via <code> gcc/g++ -v </code>) the same thread + model and that model is not <em>single</em>. 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 + <em>single</em> 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.) + </p> + <p>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). + </p> + <p>See <a href="../faq/index.html#5_6">FAQ</a> (general overview), <a + href="../23_containers/howto.html#3">23</a> (containers), and <a + href="../27_io/howto.html#9">27</a> (I/O) for more information. + </p> + <p>The libstdc++ library has been designed so that it can be used in + multithreaded applications (with libstdc++-v2 this was + only true of the STL parts.) The first problem is + finding a <em>fast</em> method of implementation portable to all + platforms. Due to historical reasons, some of the library is + written against per-CPU-architecture spinlocks and other parts + against the gthr.h abstraction layer which is provided by gcc. + A minor problem that pops up every so often is different + interpretations of what "thread-safe" means for a + library (not a general program). We currently use the <a + href="http://www.sgi.com/tech/stl/thread_safety.html">same + definition that SGI</a> uses for their STL subset. However, the + exception for read-only containers only applies to the STL + components. This definition is widely-used and something similar + will be used in the next version of the C++ standard library. + </p> + <p>Here is a small link farm to threads (no pun) in the mail archives + that discuss the threading problem. Each link is to the first + relevant message in the thread; from there you can use + "Thread Next" to move down the thread. This farm is in + latest-to-oldest order. + </p> + <ul> + <li>Our threading expert Loren gives a breakdown of + <a href="http://gcc.gnu.org/ml/libstdc++/2001-10/msg00024.html">the + six situations involving threads</a> for the 3.0 release series.</li> + <li><a href="http://gcc.gnu.org/ml/libstdc++/2001-05/msg00384.html"> + This message</a> inspired a recent updating of issues with threading + and the SGI STL library. It also contains some example + POSIX-multithreaded STL code.</li> + </ul> + <p> (A large selection of links to older messages has been removed; many + of the messages from 1999 were lost in a disk crash, and the few + people with access to the backup tapes have been too swamped with work + to restore them. Many of the points have been superseded anyhow.) + </p> + <p>This section will be updated as new and interesting issues come + to light. + </p> + <p>Return <a href="#top">to top of page</a> or + <a href="../faq/index.html">to the FAQ</a>. + </p> + +<hr /> +<h2><a name="5">Behavior specific to libstdc++</a></h2> + <p>The ISO standard defines the following phrase: + </p> + <blockquote><dl> + <dt><code>[1.3.5] implementation-defined behavior</code></dt> + <dd>behavior, for a well-formed program construct and correct data, that + depends on the implementation <strong>and that each implementation + shall document</strong>. + </dd> + </dl></blockquote> + <p>We do so here, for the C++ library only. Behavior of the compiler, + linker, runtime loader, and other elements of "the + implementation" are documented elsewhere. Everything listed in + Annex B, Implementation Qualities, are also part of the compiler, not + the library. + </p> + <p>For each entry, we give the section number of the standard, when + applicable. This list is probably incomplet and inkorrekt. + </p> + <p><strong>[1.9]/11 #3</strong> If <code>isatty(3)</code> is true, then + interactive stream support is implied. + </p> + <p><strong>[17.4.4.5]</strong> Non-reentrant functions are probably best + discussed in the various sections on multithreading (see above). + </p> + <!-- [17.4.4.8]/3 says any function that doesn't have an exception-spec + can throw whatever we want; see also its footnote. Let's list those + in the sections where the function itself occurs. + --> + <p><strong>[18.1]/4</strong> The type of <code>NULL</code> is described + <a href="../18_support/howto.html#1">here</a>. + </p> + <p><strong>[18.3]/8</strong> 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. :-) + </p> + <p><strong>[18.4.2.1]/5</strong> (bad_alloc),<br /> + <strong>[18.5.2]/5</strong> (bad_cast),<br /> + <strong>[18.5.3]/5</strong> (bad_typeid),<br /> + <strong>[18.6.1]/8</strong> (exception),<br /> + <strong>[18.6.2.1]/5</strong> (bad_exception): The <code>what()</code> + member function of class <code>std::exception</code>, and these other + classes publicly derived from it, simply returns the name of the + class. But they are the <em>mangled</em> names; you will need to call + <code>c++filt</code> and pass the names as command-line parameters to + demangle them, or call a + <a href="../18_support/howto.html#5">runtime demangler function</a>. + (The classes in <code><stdexcept></code> have constructors which + require an argument to use later for <code>what()</code> calls, so the + problem of <code>what()</code>'s value does not arise in most + user-defined exceptions.) + </p> + <p><strong>[18.5.1]/7</strong> The return value of + <code>std::type_info::name()</code> is the mangled type name (see the + previous entry for more). + </p> + <p><strong>[20.1.5]/5</strong> <em>"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."</em> As yet we don't + have any allocators which compare non-equal, so we can't describe how + they behave. + </p> + <p><strong>[21.1.3.1]/3,4</strong>,<br /> + <strong>[21.1.3.2]/2</strong>,<br /> + <strong>[23.*]'s foo::iterator</strong>,<br /> + <strong>[27.*]'s foo::*_type</strong>,<br /> + <strong>others...</strong> + 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. :-) + </p> + <p><strong>[21.1.3.1]/5</strong> I don't really know about the mbstate_t + stuff... see the <a href="../22_locale/howto.html">chapter 22 notes</a> + for what does exist. + </p> + <p><strong>[22.*]</strong> Anything and everything we have on locale + implementation will be described + <a href="../22_locale/howto.html">over here</a>. + </p> + <p><strong>[26.2.8]/9</strong> I have no idea what + <code>complex<T></code>'s pow(0,0) returns. + </p> + <p><strong>[27.4.2.4]/2</strong> Calling + <code>std::ios_base::sync_with_stdio</code> after I/O has already been + performed on the standard stream objects will + flush the buffers, and <!-- this line might go away --> + 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! + </p> + <p><strong>[27.6.1.1.2]</strong>,<br /> + <strong>[27.6.2.3]</strong> The I/O sentry ctor and dtor can perform + additional work than the minimum required. We are not currently taking + advantage of this yet. + </p> + <p><strong>[27.7.1.3]/16</strong>,<br /> + <strong>[27.8.1.4]/10</strong> + The effects of <code>pubsetbuf/setbuf</code> are described + <a href="../27_io/howto.html#2">in this chapter</a>. + </p> + <p><strong>[27.8.1.4]/16</strong> Calling <code>fstream::sync</code> when + a get area exists will... whatever <code>fflush()</code> does, I think. + </p> + <p>Return <a href="#top">to top of page</a> or + <a href="../faq/index.html">to the FAQ</a>. + </p> + + <!-- + <dt><code></code></dt> + <dd> + </dd> + --> + <p>Return <a href="#top">to top of page</a> or + <a href="../faq/index.html">to the FAQ</a>. + </p> + + + +<!-- ####################################################### --> + +<hr /> +<p class="fineprint"><em> +See <a href="license.html">license.html</a> for copying conditions. +Comments and suggestions are welcome, and may be sent to +<a href="mailto:libstdc++@gcc.gnu.org">the libstdc++ mailing list</a>. +</em></p> + + +</body> +</html> + + diff --git a/libstdc++-v3/doc/html/17_intro/license.html b/libstdc++-v3/doc/html/17_intro/license.html new file mode 100644 index 00000000000..294a00892d3 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/license.html @@ -0,0 +1,119 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> + <meta name="AUTHOR" content="pme@gcc.gnu.org (Phil Edwards)" /> + <meta name="KEYWORDS" content="libstdc++, license, licence" /> + <meta name="DESCRIPTION" content="Copying restrictions for libstdc++." /> + <meta name="GENERATOR" content="vi and eight fingers" /> + <title>libstdc++ copying</title> +<link rel="StyleSheet" href="../lib3styles.css" type="text/css" /> +<link rel="Start" rev="Copyright" href="../documentation.html" type="text/html" + title="GNU C++ Standard Library" /> +</head> +<body> + +<h1 class="centered"><a name="top">Licenses for the Library</a></h1> + +<p>There are two licenses affecting GNU libstdc++: one for the code, and + one for the documentation. Here we will describe both of them, and try + to answer some of the widespread questions. If you have more questions, + ask the FSF or the + <a href="http://gcc.gnu.org/lists.html">gcc mailing list</a>; the person + writing this page is a programmer, not a lawyer. +</p> + +<hr /> + +<h2>The Code: Runtime GPL</h2> + +<p>The source code of libstdc++ is distributed under version 2 of the + <a href="COPYING" type="text/plain">GNU General Public License</a>, with the so-called + "runtime exception," as follows (or see any header or + implementation file): +</p> +<pre> + 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. +</pre> + +<p>Hopefully that text is self-explanatory. If it isn't, you need to speak + to your lawyer, or the Free Software Foundation. +</p> + +<!-- Most of the Q&A's are based on, paraphrased from, and outright stolen + from this thread: + http://gcc.gnu.org/ml/libstdc++/2000-q2/subjects.html#00050 +--> +<p><strong>Q: So any program which uses libstdc++ falls under the GPL?</strong> + <br />A: <strong>No.</strong> The special exception permits use of the + library in proprietary applications. +</p> + +<p><strong>Q: How is that different from the GNU {Lesser,Library} + GPL?</strong> + <!-- Quoting Jason Merrill from the thread above: --> + <br />A: The LGPL requires that users be able to replace the LGPL code with a + modified version; this is trivial if the library in question is a C + shared library. But there's no way to make that work with C++, where + much of the library consists of inline functions and templates, which + are expanded inside the code that uses the library. So to allow people + to replace the library code, someone using the library would have to + distribute their own source, rendering the LGPL equivalent to the GPL. +</p> + +<p><strong>Q: I see. So, what restrictions <em>are</em> there on + programs that use the library?</strong> + <br />A: None. We encourage such programs to be released as open source, + but we won't punish you or sue you if you choose otherwise. +</p> + +<hr /> + +<h2>The Docs: GPL, FDL</h2> + +<p>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 <a href="COPYING.DOC" type="text/plain">GNU Free Documentation License version 1.1</a>. + There are no Front-Cover Texts, no Back-Cover Texts, and + <!-- as far as I know --> + no Invariant Sections. +</p> + +<p> 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. +</p> + +<p>If you plan on making copies of the documentation, please let us know. + We can probably offer suggestions. +</p> + + +<!-- ####################################################### --> + +<hr /> +<p class="fineprint"><em> +Comments and suggestions about this page are welcome, and may be sent to +<a href="mailto:libstdc++@gcc.gnu.org">the libstdc++ mailing list</a>. +Comments or questions about the licenses themselves are also welcome, and +should be directed to the GCC list as descibed above. +</em></p> + + +</body> +</html> + + diff --git a/libstdc++-v3/doc/html/17_intro/porting.html b/libstdc++-v3/doc/html/17_intro/porting.html new file mode 100644 index 00000000000..2a561a9abc3 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/porting.html @@ -0,0 +1,992 @@ +<html lang="en"> +<head> +<title>Porting libstdc++</title> +<meta http-equiv="Content-Type" content="text/html"> +<meta name="description" content="Porting libstdc++"> +<meta name="generator" content="makeinfo 4.6"> +<!-- +Copyright © 2000, 2001, 2002, 2003, 2005 Free Software Foundation, Inc. + + <p>Permission is granted to copy, distribute and/or modify this document +under the terms of the GNU Free Documentation License, Version 1.2 or +any later version published by the Free Software Foundation; with the +Invariant Sections being "GNU General Public License", the Front-Cover +texts being (a) (see below), and with the Back-Cover Texts being (b) +(see below). A copy of the license is included in the section entitled +"GNU Free Documentation License". + + <p>(a) The FSF's Front-Cover Text is: + + <p>A GNU Manual + + <p>(b) The FSF's Back-Cover Text is: + + <p>You have freedom to copy and modify this GNU Manual, like GNU + software. Copies published by the Free Software Foundation raise + funds for GNU development.--> +<meta http-equiv="Content-Style-Type" content="text/css"> +<style type="text/css"><!-- + pre.display { font-family:inherit } + pre.format { font-family:inherit } + pre.smalldisplay { font-family:inherit; font-size:smaller } + pre.smallformat { font-family:inherit; font-size:smaller } + pre.smallexample { font-size:smaller } + pre.smalllisp { font-size:smaller } +--></style> +</head> +<body> +<h1 class="settitle">Porting libstdc++</h1> +<div class="node"> +<p><hr> +Node: <a name="Top">Top</a>, +Next: <a rel="next" accesskey="n" href="#Operating%20system">Operating system</a>, +Up: <a rel="up" accesskey="u" href="#dir">(dir)</a> +<br> +</div> + +<h2 class="unnumbered">Porting libstdc++</h2> + +<p>This document explains how to port libstdc++ (the GNU C++ library) to +a new target. + + <p>In order to make the GNU C++ library (libstdc++) work with a new +target, you must edit some configuration files and provide some new +header files. Unless this is done, libstdc++ will use generic +settings which may not be correct for your target; even if they are +correct, they will likely be inefficient. + + <p>Before you get started, make sure that you have a working C library on +your target. The C library need not precisely comply with any +particular standard, but should generally conform to the requirements +imposed by the ANSI/ISO standard. + + <p>In addition, you should try to verify that the C++ compiler generally +works. It is difficult to test the C++ compiler without a working +library, but you should at least try some minimal test cases. + + <p>(Note that what we think of as a "target," the library refers to as +a "host." The comment at the top of <code>configure.ac</code> explains why.) + + <p>Here are the primary steps required to port the library: + +<ul class="menu"> +<li><a accesskey="1" href="#Operating%20system">Operating system</a>: Configuring for your operating system. +<li><a accesskey="2" href="#CPU">CPU</a>: Configuring for your processor chip. +<li><a accesskey="3" href="#Character%20types">Character types</a>: Implementing character classification. +<li><a accesskey="4" href="#Thread%20safety">Thread safety</a>: Implementing atomic operations. +<li><a accesskey="5" href="#Numeric%20limits">Numeric limits</a>: Implementing numeric limits. +<li><a accesskey="6" href="#Libtool">Libtool</a>: Using libtool. +<li><a accesskey="7" href="#GNU%20Free%20Documentation%20License">GNU Free Documentation License</a>: How you can copy and share this manual. +</ul> + +<div class="node"> +<p><hr> +Node: <a name="Operating%20system">Operating system</a>, +Next: <a rel="next" accesskey="n" href="#CPU">CPU</a>, +Previous: <a rel="previous" accesskey="p" href="#Top">Top</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">Operating system</h2> + +<p>If you are porting to a new operating system (as opposed to a new chip +using an existing operating system), you will need to create a new +directory in the <code>config/os</code> hierarchy. For example, the IRIX +configuration files are all in <code>config/os/irix</code>. There is no set +way to organize the OS configuration directory. For example, +<code>config/os/solaris/solaris-2.6</code> and +<code>config/os/solaris/solaris-2.7</code> are used as configuration +directories for these two versions of Solaris. On the other hand, both +Solaris 2.7 and Solaris 2.8 use the <code>config/os/solaris/solaris-2.7</code> +directory. The important information is that there needs to be a +directory under <code>config/os</code> to store the files for your operating +system. + + <p>You might have to change the <code>configure.host</code> file to ensure that +your new directory is activated. Look for the switch statement that sets +<code>os_include_dir</code>, and add a pattern to handle your operating system +if the default will not suffice. The switch statement switches on only +the OS portion of the standard target triplet; e.g., the <code>solaris2.8</code> +in <code>sparc-sun-solaris2.8</code>. If the new directory is named after the +OS portion of the triplet (the default), then nothing needs to be changed. + + <p>The first file to create in this directory, should be called +<code>os_defines.h</code>. This file contains basic macro definitions +that are required to allow the C++ library to work with your C library. + + <p>Several libstdc++ source files unconditionally define the macro +<code>_POSIX_SOURCE</code>. On many systems, defining this macro causes +large portions of the C library header files to be eliminated +at preprocessing time. Therefore, you may have to <code>#undef</code> this +macro, or define other macros (like <code>_LARGEFILE_SOURCE</code> or +<code>__EXTENSIONS__</code>). You won't know what macros to define or +undefine at this point; you'll have to try compiling the library and +seeing what goes wrong. If you see errors about calling functions +that have not been declared, look in your C library headers to see if +the functions are declared there, and then figure out what macros you +need to define. You will need to add them to the +<code>CPLUSPLUS_CPP_SPEC</code> macro in the GCC configuration file for your +target. It will not work to simply define these macros in +<code>os_defines.h</code>. + + <p>At this time, there are a few libstdc++-specific macros which may be +defined: + + <p><code>_GLIBCXX_USE_C99_CHECK</code> may be defined to 1 to check C99 +function declarations (which are not covered by specialization below) +found in system headers against versions found in the library headers +derived from the standard. + + <p><code>_GLIBCXX_USE_C99_DYNAMIC</code> may be defined to an expression that +yields 0 if and only if the system headers are exposing proper support +for C99 functions (which are not covered by specialization below). If +defined, it must be 0 while bootstrapping the compiler/rebuilding the +library. + + <p><code>_GLIBCXX_USE_C99_LONG_LONG_CHECK</code> may be defined to 1 to check +the set of C99 long long function declarations found in system headers +against versions found in the library headers derived from the +standard. + + <p><code>_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC</code> may be defined to an +expression that yields 0 if and only if the system headers are +exposing proper support for the set of C99 long long functions. If +defined, it must be 0 while bootstrapping the compiler/rebuilding the +library. + + <p><code>_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC</code> may be defined to an +expression that yields 0 if and only if the system headers +are exposing proper support for the related set of macros. If defined, +it must be 0 while bootstrapping the compiler/rebuilding the library. + + <p><code>_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_CHECK</code> may be defined +to 1 to check the related set of function declarations found in system +headers against versions found in the library headers derived from +the standard. + + <p><code>_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC</code> may be defined +to an expression that yields 0 if and only if the system headers +are exposing proper support for the related set of functions. If defined, +it must be 0 while bootstrapping the compiler/rebuilding the library. + + <p>Finally, you should bracket the entire file in an include-guard, like +this: + +<pre class="example"> #ifndef _GLIBCXX_OS_DEFINES + #define _GLIBCXX_OS_DEFINES + ... + #endif + </pre> + + <p>We recommend copying an existing <code>os_defines.h</code> to use as a +starting point. + +<div class="node"> +<p><hr> +Node: <a name="CPU">CPU</a>, +Next: <a rel="next" accesskey="n" href="#Character%20types">Character types</a>, +Previous: <a rel="previous" accesskey="p" href="#Operating%20system">Operating system</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">CPU</h2> + +<p>If you are porting to a new chip (as opposed to a new operating system +running on an existing chip), you will need to create a new directory in the +<code>config/cpu</code> hierarchy. Much like the <a href="#Operating%20system">Operating system</a> setup, +there are no strict rules on how to organize the CPU configuration +directory, but careful naming choices will allow the configury to find your +setup files without explicit help. + + <p>We recommend that for a target triplet <code><CPU>-<vendor>-<OS></code>, you +name your configuration directory <code>config/cpu/<CPU></code>. If you do this, +the configury will find the directory by itself. Otherwise you will need to +edit the <code>configure.host</code> file and, in the switch statement that sets +<code>cpu_include_dir</code>, add a pattern to handle your chip. + + <p>Note that some chip families share a single configuration directory, for +example, <code>alpha</code>, <code>alphaev5</code>, and <code>alphaev6</code> all use the +<code>config/cpu/alpha</code> directory, and there is an entry in the +<code>configure.host</code> switch statement to handle this. + + <p>The <code>cpu_include_dir</code> sets default locations for the files controlling +<a href="#Thread%20safety">Thread safety</a> and <a href="#Numeric%20limits">Numeric limits</a>, if the defaults are not +appropriate for your chip. + +<div class="node"> +<p><hr> +Node: <a name="Character%20types">Character types</a>, +Next: <a rel="next" accesskey="n" href="#Thread%20safety">Thread safety</a>, +Previous: <a rel="previous" accesskey="p" href="#CPU">CPU</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">Character types</h2> + +<p>The library requires that you provide three header files to implement +character classification, analogous to that provided by the C libraries +<code><ctype.h></code> header. You can model these on the files provided in +<code>config/os/generic</code>. However, these files will almost +certainly need some modification. + + <p>The first file to write is <code>ctype_base.h</code>. This file provides +some very basic information about character classification. The libstdc++ +library assumes that your C library implements <code><ctype.h></code> by using +a table (indexed by character code) containing integers, where each of +these integers is a bit-mask indicating whether the character is +upper-case, lower-case, alphabetic, etc. The <code>ctype_base.h</code> +file gives the type of the integer, and the values of the various bit +masks. You will have to peer at your own <code><ctype.h></code> to figure out +how to define the values required by this file. + + <p>The <code>ctype_base.h</code> header file does not need include guards. +It should contain a single <code>struct</code> definition called +<code>ctype_base</code>. This <code>struct</code> should contain two type +declarations, and one enumeration declaration, like this example, taken +from the IRIX configuration: + +<pre class="example"> struct ctype_base + { + typedef unsigned int mask; + typedef int* __to_type; + + enum + { + space = _ISspace, + print = _ISprint, + cntrl = _IScntrl, + upper = _ISupper, + lower = _ISlower, + alpha = _ISalpha, + digit = _ISdigit, + punct = _ISpunct, + xdigit = _ISxdigit, + alnum = _ISalnum, + graph = _ISgraph + }; + }; + </pre> + +<p>The <code>mask</code> type is the type of the elements in the table. If your +C library uses a table to map lower-case numbers to upper-case numbers, +and vice versa, you should define <code>__to_type</code> to be the type of the +elements in that table. If you don't mind taking a minor performance +penalty, or if your library doesn't implement <code>toupper</code> and +<code>tolower</code> in this way, you can pick any pointer-to-integer type, +but you must still define the type. + + <p>The enumeration should give definitions for all the values in the above +example, using the values from your native <code><ctype.h></code>. They can +be given symbolically (as above), or numerically, if you prefer. You do +not have to include <code><ctype.h></code> in this header; it will always be +included before <code>ctype_base.h</code> is included. + + <p>The next file to write is <code>ctype_noninline.h</code>, which also does +not require include guards. This file defines a few member functions +that will be included in <code>include/bits/locale_facets.h</code>. The first +function that must be written is the <code>ctype<char>::ctype</code> +constructor. Here is the IRIX example: + +<pre class="example"> ctype<char>::ctype(const mask* __table = 0, bool __del = false, + size_t __refs = 0) + : _Ctype_nois<char>(__refs), _M_del(__table != 0 && __del), + _M_toupper(NULL), + _M_tolower(NULL), + _M_ctable(NULL), + _M_table(!__table + ? (const mask*) (__libc_attr._ctype_tbl->_class + 1) + : __table) + { } + </pre> + +<p>There are two parts of this that you might choose to alter. The first, +and most important, is the line involving <code>__libc_attr</code>. That is +IRIX system-dependent code that gets the base of the table mapping +character codes to attributes. You need to substitute code that obtains +the address of this table on your system. If you want to use your +operating system's tables to map upper-case letters to lower-case, and +vice versa, you should initialize <code>_M_toupper</code> and +<code>_M_tolower</code> with those tables, in similar fashion. + + <p>Now, you have to write two functions to convert from upper-case to +lower-case, and vice versa. Here are the IRIX versions: + +<pre class="example"> char + ctype<char>::do_toupper(char __c) const + { return _toupper(__c); } + + char + ctype<char>::do_tolower(char __c) const + { return _tolower(__c); } + </pre> + +<p>Your C library provides equivalents to IRIX's <code>_toupper</code> and +<code>_tolower</code>. If you initialized <code>_M_toupper</code> and +<code>_M_tolower</code> above, then you could use those tables instead. + + <p>Finally, you have to provide two utility functions that convert strings +of characters. The versions provided here will always work - but you +could use specialized routines for greater performance if you have +machinery to do that on your system: + +<pre class="example"> const char* + ctype<char>::do_toupper(char* __low, const char* __high) const + { + while (__low < __high) + { + *__low = do_toupper(*__low); + ++__low; + } + return __high; + } + + const char* + ctype<char>::do_tolower(char* __low, const char* __high) const + { + while (__low < __high) + { + *__low = do_tolower(*__low); + ++__low; + } + return __high; + } + </pre> + + <p>You must also provide the <code>ctype_inline.h</code> file, which +contains a few more functions. On most systems, you can just copy +<code>config/os/generic/ctype_inline.h</code> and use it on your system. + + <p>In detail, the functions provided test characters for particular +properties; they are analogous to the functions like <code>isalpha</code> and +<code>islower</code> provided by the C library. + + <p>The first function is implemented like this on IRIX: + +<pre class="example"> bool + ctype<char>:: + is(mask __m, char __c) const throw() + { return (_M_table)[(unsigned char)(__c)] & __m; } + </pre> + +<p>The <code>_M_table</code> is the table passed in above, in the constructor. +This is the table that contains the bitmasks for each character. The +implementation here should work on all systems. + + <p>The next function is: + +<pre class="example"> const char* + ctype<char>:: + is(const char* __low, const char* __high, mask* __vec) const throw() + { + while (__low < __high) + *__vec++ = (_M_table)[(unsigned char)(*__low++)]; + return __high; + } + </pre> + +<p>This function is similar; it copies the masks for all the characters +from <code>__low</code> up until <code>__high</code> into the vector given by +<code>__vec</code>. + + <p>The last two functions again are entirely generic: + +<pre class="example"> const char* + ctype<char>:: + scan_is(mask __m, const char* __low, const char* __high) const throw() + { + while (__low < __high && !this->is(__m, *__low)) + ++__low; + return __low; + } + + const char* + ctype<char>:: + scan_not(mask __m, const char* __low, const char* __high) const throw() + { + while (__low < __high && this->is(__m, *__low)) + ++__low; + return __low; + } + </pre> + +<div class="node"> +<p><hr> +Node: <a name="Thread%20safety">Thread safety</a>, +Next: <a rel="next" accesskey="n" href="#Numeric%20limits">Numeric limits</a>, +Previous: <a rel="previous" accesskey="p" href="#Character%20types">Character types</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">Thread safety</h2> + +<p>The C++ library string functionality requires a couple of atomic +operations to provide thread-safety. If you don't take any special +action, the library will use stub versions of these functions that are +not thread-safe. They will work fine, unless your applications are +multi-threaded. + + <p>If you want to provide custom, safe, versions of these functions, there +are two distinct approaches. One is to provide a version for your CPU, +using assembly language constructs. The other is to use the +thread-safety primitives in your operating system. In either case, you +make a file called <code>atomicity.h</code>, and the variable +<code>ATOMICITYH</code> must point to this file. + + <p>If you are using the assembly-language approach, put this code in +<code>config/cpu/<chip>/atomicity.h</code>, where chip is the name of +your processor (see <a href="#CPU">CPU</a>). No additional changes are necessary to +locate the file in this case; <code>ATOMICITYH</code> will be set by default. + + <p>If you are using the operating system thread-safety primitives approach, +you can also put this code in the same CPU directory, in which case no more +work is needed to locate the file. For examples of this approach, +see the <code>atomicity.h</code> file for IRIX or IA64. + + <p>Alternatively, if the primitives are more closely related to the OS +than they are to the CPU, you can put the <code>atomicity.h</code> file in +the <a href="#Operating%20system">Operating system</a> directory instead. In this case, you must +edit <code>configure.host</code>, and in the switch statement that handles +operating systems, override the <code>ATOMICITYH</code> variable to point to +the appropriate <code>os_include_dir</code>. For examples of this approach, +see the <code>atomicity.h</code> file for AIX. + + <p>With those bits out of the way, you have to actually write +<code>atomicity.h</code> itself. This file should be wrapped in an +include guard named <code>_GLIBCXX_ATOMICITY_H</code>. It should define one +type, and two functions. + + <p>The type is <code>_Atomic_word</code>. Here is the version used on IRIX: + +<pre class="example"> typedef long _Atomic_word; + </pre> + +<p>This type must be a signed integral type supporting atomic operations. +If you're using the OS approach, use the same type used by your system's +primitives. Otherwise, use the type for which your CPU provides atomic +primitives. + + <p>Then, you must provide two functions. The bodies of these functions +must be equivalent to those provided here, but using atomic operations: + +<pre class="example"> static inline _Atomic_word + __attribute__ ((__unused__)) + __exchange_and_add (_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + static inline void + __attribute__ ((__unused__)) + __atomic_add (_Atomic_word* __mem, int __val) + { + *__mem += __val; + } + </pre> + +<div class="node"> +<p><hr> +Node: <a name="Numeric%20limits">Numeric limits</a>, +Next: <a rel="next" accesskey="n" href="#Libtool">Libtool</a>, +Previous: <a rel="previous" accesskey="p" href="#Thread%20safety">Thread safety</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">Numeric limits</h2> + +<p>The C++ library requires information about the fundamental data types, +such as the minimum and maximum representable values of each type. +You can define each of these values individually, but it is usually +easiest just to indicate how many bits are used in each of the data +types and let the library do the rest. For information about the +macros to define, see the top of <code>include/bits/std_limits.h</code>. + + <p>If you need to define any macros, you can do so in <code>os_defines.h</code>. +However, if all operating systems for your CPU are likely to use the +same values, you can provide a CPU-specific file instead so that you +do not have to provide the same definitions for each operating system. +To take that approach, create a new file called <code>cpu_limits.h</code> in +your CPU configuration directory (see <a href="#CPU">CPU</a>). + +<div class="node"> +<p><hr> +Node: <a name="Libtool">Libtool</a>, +Next: <a rel="next" accesskey="n" href="#GNU%20Free%20Documentation%20License">GNU Free Documentation License</a>, +Previous: <a rel="previous" accesskey="p" href="#Numeric%20limits">Numeric limits</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="chapter">Libtool</h2> + +<p>The C++ library is compiled, archived and linked with libtool. +Explaining the full workings of libtool is beyond the scope of this +document, but there are a few, particular bits that are necessary for +porting. + + <p>Some parts of the libstdc++ library are compiled with the libtool +<code>--tags CXX</code> option (the C++ definitions for libtool). Therefore, +<code>ltcf-cxx.sh</code> in the top-level directory needs to have the correct +logic to compile and archive objects equivalent to the C version of libtool, +<code>ltcf-c.sh</code>. Some libtool targets have definitions for C but not +for C++, or C++ definitions which have not been kept up to date. + + <p>The C++ run-time library contains initialization code that needs to be +run as the library is loaded. Often, that requires linking in special +object files when the C++ library is built as a shared library, or +taking other system-specific actions. + + <p>The libstdc++ library is linked with the C version of libtool, even +though it is a C++ library. Therefore, the C version of libtool needs to +ensure that the run-time library initializers are run. The usual way to +do this is to build the library using <code>gcc -shared</code>. + + <p>If you need to change how the library is linked, look at +<code>ltcf-c.sh</code> in the top-level directory. Find the switch statement +that sets <code>archive_cmds</code>. Here, adjust the setting for your +operating system. + +<div class="node"> +<p><hr> +Node: <a name="GNU%20Free%20Documentation%20License">GNU Free Documentation License</a>, +Previous: <a rel="previous" accesskey="p" href="#Libtool">Libtool</a>, +Up: <a rel="up" accesskey="u" href="#Top">Top</a> +<br> +</div> + +<h2 class="unnumbered">GNU Free Documentation License</h2> + +<div align="center">Version 1.2, November 2002</div> +<pre class="display"> Copyright © 2000,2001,2002 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. + </pre> + + <ol type=1 start=0> +<li>PREAMBLE + + <p>The purpose of this License is to make a manual, textbook, or other +functional and useful document <dfn>free</dfn> in the sense of freedom: to +assure everyone the effective freedom to copy and redistribute it, +with or without modifying it, either commercially or noncommercially. +Secondarily, this License preserves for the author and publisher a way +to get credit for their work, while not being considered responsible +for modifications made by others. + + <p>This License is a kind of "copyleft", which means that derivative +works of the document must themselves be free in the same sense. It +complements the GNU General Public License, which is a copyleft +license designed for free software. + + <p>We have designed this License in order to use it for manuals for free +software, because free software needs free documentation: a free +program should come with manuals providing the same freedoms that the +software does. But this License is not limited to software manuals; +it can be used for any textual work, regardless of subject matter or +whether it is published as a printed book. We recommend this License +principally for works whose purpose is instruction or reference. + + </p><li>APPLICABILITY AND DEFINITIONS + + <p>This License applies to any manual or other work, in any medium, that +contains a notice placed by the copyright holder saying it can be +distributed under the terms of this License. Such a notice grants a +world-wide, royalty-free license, unlimited in duration, to use that +work under the conditions stated herein. The "Document", below, +refers to any such manual or work. Any member of the public is a +licensee, and is addressed as "you". You accept the license if you +copy, modify or distribute the work in a way requiring permission +under copyright law. + + <p>A "Modified Version" of the Document means any work containing the +Document or a portion of it, either copied verbatim, or with +modifications and/or translated into another language. + + <p>A "Secondary Section" is a named appendix or a front-matter section +of the Document that deals exclusively with the relationship of the +publishers or authors of the Document to the Document's overall +subject (or to related matters) and contains nothing that could fall +directly within that overall subject. (Thus, if the Document is in +part a textbook of mathematics, a Secondary Section may not explain +any mathematics.) The relationship could be a matter of historical +connection with the subject or with related matters, or of legal, +commercial, philosophical, ethical or political position regarding +them. + + <p>The "Invariant Sections" are certain Secondary Sections whose titles +are designated, as being those of Invariant Sections, in the notice +that says that the Document is released under this License. If a +section does not fit the above definition of Secondary then it is not +allowed to be designated as Invariant. The Document may contain zero +Invariant Sections. If the Document does not identify any Invariant +Sections then there are none. + + <p>The "Cover Texts" are certain short passages of text that are listed, +as Front-Cover Texts or Back-Cover Texts, in the notice that says that +the Document is released under this License. A Front-Cover Text may +be at most 5 words, and a Back-Cover Text may be at most 25 words. + + <p>A "Transparent" copy of the Document means a machine-readable copy, +represented in a format whose specification is available to the +general public, that is suitable for revising the document +straightforwardly with generic text editors or (for images composed of +pixels) generic paint programs or (for drawings) some widely available +drawing editor, and that is suitable for input to text formatters or +for automatic translation to a variety of formats suitable for input +to text formatters. A copy made in an otherwise Transparent file +format whose markup, or absence of markup, has been arranged to thwart +or discourage subsequent modification by readers is not Transparent. +An image format is not Transparent if used for any substantial amount +of text. A copy that is not "Transparent" is called "Opaque". + + <p>Examples of suitable formats for Transparent copies include plain +<small>ASCII</small> without markup, Texinfo input format, LaTeX input +format, <small>SGML</small> or <small>XML</small> using a publicly available +<small>DTD</small>, and standard-conforming simple <small>HTML</small>, +PostScript or <small>PDF</small> designed for human modification. Examples +of transparent image formats include <small>PNG</small>, <small>XCF</small> and +<small>JPG</small>. Opaque formats include proprietary formats that can be +read and edited only by proprietary word processors, <small>SGML</small> or +<small>XML</small> for which the <small>DTD</small> and/or processing tools are +not generally available, and the machine-generated <small>HTML</small>, +PostScript or <small>PDF</small> produced by some word processors for +output purposes only. + + <p>The "Title Page" means, for a printed book, the title page itself, +plus such following pages as are needed to hold, legibly, the material +this License requires to appear in the title page. For works in +formats which do not have any title page as such, "Title Page" means +the text near the most prominent appearance of the work's title, +preceding the beginning of the body of the text. + + <p>A section "Entitled XYZ" means a named subunit of the Document whose +title either is precisely XYZ or contains XYZ in parentheses following +text that translates XYZ in another language. (Here XYZ stands for a +specific section name mentioned below, such as "Acknowledgements", +"Dedications", "Endorsements", or "History".) To "Preserve the Title" +of such a section when you modify the Document means that it remains a +section "Entitled XYZ" according to this definition. + + <p>The Document may include Warranty Disclaimers next to the notice which +states that this License applies to the Document. These Warranty +Disclaimers are considered to be included by reference in this +License, but only as regards disclaiming warranties: any other +implication that these Warranty Disclaimers may have is void and has +no effect on the meaning of this License. + + </p><li>VERBATIM COPYING + + <p>You may copy and distribute the Document in any medium, either +commercially or noncommercially, provided that this License, the +copyright notices, and the license notice saying this License applies +to the Document are reproduced in all copies, and that you add no other +conditions whatsoever to those of this License. You may not use +technical measures to obstruct or control the reading or further +copying of the copies you make or distribute. However, you may accept +compensation in exchange for copies. If you distribute a large enough +number of copies you must also follow the conditions in section 3. + + <p>You may also lend copies, under the same conditions stated above, and +you may publicly display copies. + + </p><li>COPYING IN QUANTITY + + <p>If you publish printed copies (or copies in media that commonly have +printed covers) of the Document, numbering more than 100, and the +Document's license notice requires Cover Texts, you must enclose the +copies in covers that carry, clearly and legibly, all these Cover +Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on +the back cover. Both covers must also clearly and legibly identify +you as the publisher of these copies. The front cover must present +the full title with all words of the title equally prominent and +visible. You may add other material on the covers in addition. +Copying with changes limited to the covers, as long as they preserve +the title of the Document and satisfy these conditions, can be treated +as verbatim copying in other respects. + + <p>If the required texts for either cover are too voluminous to fit +legibly, you should put the first ones listed (as many as fit +reasonably) on the actual cover, and continue the rest onto adjacent +pages. + + <p>If you publish or distribute Opaque copies of the Document numbering +more than 100, you must either include a machine-readable Transparent +copy along with each Opaque copy, or state in or with each Opaque copy +a computer-network location from which the general network-using +public has access to download using public-standard network protocols +a complete Transparent copy of the Document, free of added material. +If you use the latter option, you must take reasonably prudent steps, +when you begin distribution of Opaque copies in quantity, to ensure +that this Transparent copy will remain thus accessible at the stated +location until at least one year after the last time you distribute an +Opaque copy (directly or through your agents or retailers) of that +edition to the public. + + <p>It is requested, but not required, that you contact the authors of the +Document well before redistributing any large number of copies, to give +them a chance to provide you with an updated version of the Document. + + </p><li>MODIFICATIONS + + <p>You may copy and distribute a Modified Version of the Document under +the conditions of sections 2 and 3 above, provided that you release +the Modified Version under precisely this License, with the Modified +Version filling the role of the Document, thus licensing distribution +and modification of the Modified Version to whoever possesses a copy +of it. In addition, you must do these things in the Modified Version: + + <ol type=A start=1> +<li>Use in the Title Page (and on the covers, if any) a title distinct +from that of the Document, and from those of previous versions +(which should, if there were any, be listed in the History section +of the Document). You may use the same title as a previous version +if the original publisher of that version gives permission. + + <li>List on the Title Page, as authors, one or more persons or entities +responsible for authorship of the modifications in the Modified +Version, together with at least five of the principal authors of the +Document (all of its principal authors, if it has fewer than five), +unless they release you from this requirement. + + <li>State on the Title page the name of the publisher of the +Modified Version, as the publisher. + + <li>Preserve all the copyright notices of the Document. + + <li>Add an appropriate copyright notice for your modifications +adjacent to the other copyright notices. + + <li>Include, immediately after the copyright notices, a license notice +giving the public permission to use the Modified Version under the +terms of this License, in the form shown in the Addendum below. + + <li>Preserve in that license notice the full lists of Invariant Sections +and required Cover Texts given in the Document's license notice. + + <li>Include an unaltered copy of this License. + + <li>Preserve the section Entitled "History", Preserve its Title, and add +to it an item stating at least the title, year, new authors, and +publisher of the Modified Version as given on the Title Page. If +there is no section Entitled "History" in the Document, create one +stating the title, year, authors, and publisher of the Document as +given on its Title Page, then add an item describing the Modified +Version as stated in the previous sentence. + + <li>Preserve the network location, if any, given in the Document for +public access to a Transparent copy of the Document, and likewise +the network locations given in the Document for previous versions +it was based on. These may be placed in the "History" section. +You may omit a network location for a work that was published at +least four years before the Document itself, or if the original +publisher of the version it refers to gives permission. + + <li>For any section Entitled "Acknowledgements" or "Dedications", Preserve +the Title of the section, and preserve in the section all the +substance and tone of each of the contributor acknowledgements and/or +dedications given therein. + + <li>Preserve all the Invariant Sections of the Document, +unaltered in their text and in their titles. Section numbers +or the equivalent are not considered part of the section titles. + + <li>Delete any section Entitled "Endorsements". Such a section +may not be included in the Modified Version. + + <li>Do not retitle any existing section to be Entitled "Endorsements" or +to conflict in title with any Invariant Section. + + <li>Preserve any Warranty Disclaimers. + </ol> + + <p>If the Modified Version includes new front-matter sections or +appendices that qualify as Secondary Sections and contain no material +copied from the Document, you may at your option designate some or all +of these sections as invariant. To do this, add their titles to the +list of Invariant Sections in the Modified Version's license notice. +These titles must be distinct from any other section titles. + + <p>You may add a section Entitled "Endorsements", provided it contains +nothing but endorsements of your Modified Version by various +parties--for example, statements of peer review or that the text has +been approved by an organization as the authoritative definition of a +standard. + + <p>You may add a passage of up to five words as a Front-Cover Text, and a +passage of up to 25 words as a Back-Cover Text, to the end of the list +of Cover Texts in the Modified Version. Only one passage of +Front-Cover Text and one of Back-Cover Text may be added by (or +through arrangements made by) any one entity. If the Document already +includes a cover text for the same cover, previously added by you or +by arrangement made by the same entity you are acting on behalf of, +you may not add another; but you may replace the old one, on explicit +permission from the previous publisher that added the old one. + + <p>The author(s) and publisher(s) of the Document do not by this License +give permission to use their names for publicity for or to assert or +imply endorsement of any Modified Version. + + </p><li>COMBINING DOCUMENTS + + <p>You may combine the Document with other documents released under this +License, under the terms defined in section 4 above for modified +versions, provided that you include in the combination all of the +Invariant Sections of all of the original documents, unmodified, and +list them all as Invariant Sections of your combined work in its +license notice, and that you preserve all their Warranty Disclaimers. + + <p>The combined work need only contain one copy of this License, and +multiple identical Invariant Sections may be replaced with a single +copy. If there are multiple Invariant Sections with the same name but +different contents, make the title of each such section unique by +adding at the end of it, in parentheses, the name of the original +author or publisher of that section if known, or else a unique number. +Make the same adjustment to the section titles in the list of +Invariant Sections in the license notice of the combined work. + + <p>In the combination, you must combine any sections Entitled "History" +in the various original documents, forming one section Entitled +"History"; likewise combine any sections Entitled "Acknowledgements", +and any sections Entitled "Dedications". You must delete all +sections Entitled "Endorsements." + + </p><li>COLLECTIONS OF DOCUMENTS + + <p>You may make a collection consisting of the Document and other documents +released under this License, and replace the individual copies of this +License in the various documents with a single copy that is included in +the collection, provided that you follow the rules of this License for +verbatim copying of each of the documents in all other respects. + + <p>You may extract a single document from such a collection, and distribute +it individually under this License, provided you insert a copy of this +License into the extracted document, and follow this License in all +other respects regarding verbatim copying of that document. + + </p><li>AGGREGATION WITH INDEPENDENT WORKS + + <p>A compilation of the Document or its derivatives with other separate +and independent documents or works, in or on a volume of a storage or +distribution medium, is called an "aggregate" if the copyright +resulting from the compilation is not used to limit the legal rights +of the compilation's users beyond what the individual works permit. +When the Document is included an aggregate, this License does not +apply to the other works in the aggregate which are not themselves +derivative works of the Document. + + <p>If the Cover Text requirement of section 3 is applicable to these +copies of the Document, then if the Document is less than one half of +the entire aggregate, the Document's Cover Texts may be placed on +covers that bracket the Document within the aggregate, or the +electronic equivalent of covers if the Document is in electronic form. +Otherwise they must appear on printed covers that bracket the whole +aggregate. + + </p><li>TRANSLATION + + <p>Translation is considered a kind of modification, so you may +distribute translations of the Document under the terms of section 4. +Replacing Invariant Sections with translations requires special +permission from their copyright holders, but you may include +translations of some or all Invariant Sections in addition to the +original versions of these Invariant Sections. You may include a +translation of this License, and all the license notices in the +Document, and any Warrany Disclaimers, provided that you also include +the original English version of this License and the original versions +of those notices and disclaimers. In case of a disagreement between +the translation and the original version of this License or a notice +or disclaimer, the original version will prevail. + + <p>If a section in the Document is Entitled "Acknowledgements", +"Dedications", or "History", the requirement (section 4) to Preserve +its Title (section 1) will typically require changing the actual +title. + + </p><li>TERMINATION + + <p>You may not copy, modify, sublicense, or distribute the Document except +as expressly provided for under this License. Any other attempt to +copy, modify, sublicense or distribute the Document is void, and will +automatically terminate your rights under this License. However, +parties who have received copies, or rights, from you under this +License will not have their licenses terminated so long as such +parties remain in full compliance. + + </p><li>FUTURE REVISIONS OF THIS LICENSE + + <p>The Free Software Foundation may publish new, revised versions +of the GNU Free Documentation License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. See +<a href="http://www.gnu.org/copyleft/">http://www.gnu.org/copyleft/</a>. + + <p>Each version of the License is given a distinguishing version number. +If the Document specifies that a particular numbered version of this +License "or any later version" applies to it, you have the option of +following the terms and conditions either of that specified version or +of any later version that has been published (not as a draft) by the +Free Software Foundation. If the Document does not specify a version +number of this License, you may choose any version ever published (not +as a draft) by the Free Software Foundation. + </ol> + +<h3 class="unnumberedsec">ADDENDUM: How to use this License for your documents</h3> + +<p>To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and +license notices just after the title page: + +<pre class="smallexample"> Copyright (C) <var>year</var> <var>your name</var>. + 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''. + </pre> + + <p>If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, +replace the "with...Texts." line with this: + +<pre class="smallexample"> with the Invariant Sections being <var>list their titles</var>, with + the Front-Cover Texts being <var>list</var>, and with the Back-Cover Texts + being <var>list</var>. + </pre> + + <p>If you have Invariant Sections without Cover Texts, or some other +combination of the three, merge those two alternatives to suit the +situation. + + <p>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. + + +<div class="contents"> +<h2>Table of Contents</h2> +<ul> +<li><a name="toc_Top" href="#Top">Porting libstdc++</a> +<li><a name="toc_Operating%20system" href="#Operating%20system">Operating system</a> +<li><a name="toc_CPU" href="#CPU">CPU</a> +<li><a name="toc_Character%20types" href="#Character%20types">Character types</a> +<li><a name="toc_Thread%20safety" href="#Thread%20safety">Thread safety</a> +<li><a name="toc_Numeric%20limits" href="#Numeric%20limits">Numeric limits</a> +<li><a name="toc_Libtool" href="#Libtool">Libtool</a> +<li><a name="toc_GNU%20Free%20Documentation%20License" href="#GNU%20Free%20Documentation%20License">GNU Free Documentation License</a> +<ul> +<li><a href="#GNU%20Free%20Documentation%20License">ADDENDUM: How to use this License for your documents</a> +</li></ul> +</li></ul> +</div> + + </body></html> + diff --git a/libstdc++-v3/doc/html/17_intro/porting.texi b/libstdc++-v3/doc/html/17_intro/porting.texi new file mode 100644 index 00000000000..090bdf77155 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/porting.texi @@ -0,0 +1,570 @@ +\input texinfo + +@c --------------------------------------------------------------------- +@c Prologue +@c --------------------------------------------------------------------- + +@setfilename porting.info +@settitle Porting libstdc++-v3 +@setchapternewpage odd + +@copying +Copyright @copyright{} 2000, 2001, 2002, 2003, 2005 +Free Software Foundation, Inc. + +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 the +Invariant Sections being ``GNU General Public License'', the Front-Cover +texts being (a) (see below), and with the Back-Cover Texts being (b) +(see below). A copy of the license is included in the section entitled +``GNU Free Documentation License''. + +(a) The FSF's Front-Cover Text is: + + A GNU Manual + +(b) The FSF's Back-Cover Text is: + + You have freedom to copy and modify this GNU Manual, like GNU + software. Copies published by the Free Software Foundation raise + funds for GNU development. +@end copying + +@ifinfo +This file explains how to port libstdc++-v3 (the GNU C++ library) to +a new target. + +@insertcopying +@end ifinfo + +@c --------------------------------------------------------------------- +@c Titlepage +@c --------------------------------------------------------------------- + +@titlepage +@title Porting libstdc++-v3 +@author Mark Mitchell +@page +@vskip 0pt plus 1filll +@insertcopying +@end titlepage + +@c --------------------------------------------------------------------- +@c Top +@c --------------------------------------------------------------------- + +@node Top +@top Porting libstdc++-v3 + +This document explains how to port libstdc++-v3 (the GNU C++ library) to +a new target. + +In order to make the GNU C++ library (libstdc++-v3) work with a new +target, you must edit some configuration files and provide some new +header files. Unless this is done, libstdc++-v3 will use generic +settings which may not be correct for your target; even if they are +correct, they will likely be inefficient. + +Before you get started, make sure that you have a working C library on +your target. The C library need not precisely comply with any +particular standard, but should generally conform to the requirements +imposed by the ANSI/ISO standard. + +In addition, you should try to verify that the C++ compiler generally +works. It is difficult to test the C++ compiler without a working +library, but you should at least try some minimal test cases. + +(Note that what we think of as a ``target,'' the library refers to as +a ``host.'' The comment at the top of @file{configure.ac} explains why.) + +Here are the primary steps required to port the library: + +@menu +* Operating system:: Configuring for your operating system. +* CPU:: Configuring for your processor chip. +* Character types:: Implementing character classification. +* Thread safety:: Implementing atomic operations. +* Numeric limits:: Implementing numeric limits. +* Libtool:: Using libtool. +* GNU Free Documentation License:: How you can copy and share this manual. +@end menu + +@c --------------------------------------------------------------------- +@c Operating system +@c --------------------------------------------------------------------- + +@node Operating system +@chapter Operating system + +If you are porting to a new operating system (as opposed to a new chip +using an existing operating system), you will need to create a new +directory in the @file{config/os} hierarchy. For example, the IRIX +configuration files are all in @file{config/os/irix}. There is no set +way to organize the OS configuration directory. For example, +@file{config/os/solaris/solaris-2.6} and +@file{config/os/solaris/solaris-2.7} are used as configuration +directories for these two versions of Solaris. On the other hand, both +Solaris 2.7 and Solaris 2.8 use the @file{config/os/solaris/solaris-2.7} +directory. The important information is that there needs to be a +directory under @file{config/os} to store the files for your operating +system. + +You might have to change the @file{configure.host} file to ensure that +your new directory is activated. Look for the switch statement that sets +@code{os_include_dir}, and add a pattern to handle your operating system +if the default will not suffice. The switch statement switches on only +the OS portion of the standard target triplet; e.g., the @code{solaris2.8} +in @code{sparc-sun-solaris2.8}. If the new directory is named after the +OS portion of the triplet (the default), then nothing needs to be changed. + +The first file to create in this directory, should be called +@file{os_defines.h}. This file contains basic macro definitions +that are required to allow the C++ library to work with your C library. + +Several libstdc++-v3 source files unconditionally define the macro +@code{_POSIX_SOURCE}. On many systems, defining this macro causes +large portions of the C library header files to be eliminated +at preprocessing time. Therefore, you may have to @code{#undef} this +macro, or define other macros (like @code{_LARGEFILE_SOURCE} or +@code{__EXTENSIONS__}). You won't know what macros to define or +undefine at this point; you'll have to try compiling the library and +seeing what goes wrong. If you see errors about calling functions +that have not been declared, look in your C library headers to see if +the functions are declared there, and then figure out what macros you +need to define. You will need to add them to the +@code{CPLUSPLUS_CPP_SPEC} macro in the GCC configuration file for your +target. It will not work to simply define these macros in +@file{os_defines.h}. + +At this time, there are a few libstdc++-v3-specific macros which may be +defined: + +@code{_GLIBCXX_USE_C99_CHECK} may be defined to 1 to check C99 +function declarations (which are not covered by specialization below) +found in system headers against versions found in the library headers +derived from the standard. + +@code{_GLIBCXX_USE_C99_DYNAMIC} may be defined to an expression that +yields 0 if and only if the system headers are exposing proper support +for C99 functions (which are not covered by specialization below). If +defined, it must be 0 while bootstrapping the compiler/rebuilding the +library. + +@code{_GLIBCXX_USE_C99_LONG_LONG_CHECK} may be defined to 1 to check +the set of C99 long long function declarations found in system headers +against versions found in the library headers derived from the +standard. + +@code{_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC} may be defined to an +expression that yields 0 if and only if the system headers are +exposing proper support for the set of C99 long long functions. If +defined, it must be 0 while bootstrapping the compiler/rebuilding the +library. + +@code{_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC} may be defined to an +expression that yields 0 if and only if the system headers +are exposing proper support for the related set of macros. If defined, +it must be 0 while bootstrapping the compiler/rebuilding the library. + +@code{_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_CHECK} may be defined +to 1 to check the related set of function declarations found in system +headers against versions found in the library headers derived from +the standard. + +@code{_GLIBCXX_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC} may be defined +to an expression that yields 0 if and only if the system headers +are exposing proper support for the related set of functions. If defined, +it must be 0 while bootstrapping the compiler/rebuilding the library. + +Finally, you should bracket the entire file in an include-guard, like +this: + +@example +#ifndef _GLIBCXX_OS_DEFINES +#define _GLIBCXX_OS_DEFINES +... +#endif +@end example + +We recommend copying an existing @file{os_defines.h} to use as a +starting point. + +@c --------------------------------------------------------------------- +@c CPU +@c --------------------------------------------------------------------- + +@node CPU +@chapter CPU + +If you are porting to a new chip (as opposed to a new operating system +running on an existing chip), you will need to create a new directory in the +@file{config/cpu} hierarchy. Much like the @ref{Operating system} setup, +there are no strict rules on how to organize the CPU configuration +directory, but careful naming choices will allow the configury to find your +setup files without explicit help. + +We recommend that for a target triplet @code{<CPU>-<vendor>-<OS>}, you +name your configuration directory @file{config/cpu/<CPU>}. If you do this, +the configury will find the directory by itself. Otherwise you will need to +edit the @file{configure.host} file and, in the switch statement that sets +@code{cpu_include_dir}, add a pattern to handle your chip. + +Note that some chip families share a single configuration directory, for +example, @code{alpha}, @code{alphaev5}, and @code{alphaev6} all use the +@file{config/cpu/alpha} directory, and there is an entry in the +@file{configure.host} switch statement to handle this. + +The @code{cpu_include_dir} sets default locations for the files controlling +@ref{Thread safety} and @ref{Numeric limits}, if the defaults are not +appropriate for your chip. + + +@c --------------------------------------------------------------------- +@c Character types +@c --------------------------------------------------------------------- + +@node Character types +@chapter Character types + +The library requires that you provide three header files to implement +character classification, analogous to that provided by the C libraries +@file{<ctype.h>} header. You can model these on the files provided in +@file{config/os/generic}. However, these files will almost +certainly need some modification. + +The first file to write is @file{ctype_base.h}. This file provides +some very basic information about character classification. The libstdc++-v3 +library assumes that your C library implements @file{<ctype.h>} by using +a table (indexed by character code) containing integers, where each of +these integers is a bit-mask indicating whether the character is +upper-case, lower-case, alphabetic, etc. The @file{ctype_base.h} +file gives the type of the integer, and the values of the various bit +masks. You will have to peer at your own @file{<ctype.h>} to figure out +how to define the values required by this file. + +The @file{ctype_base.h} header file does not need include guards. +It should contain a single @code{struct} definition called +@code{ctype_base}. This @code{struct} should contain two type +declarations, and one enumeration declaration, like this example, taken +from the IRIX configuration: + +@example +struct ctype_base +@{ + typedef unsigned int mask; + typedef int* __to_type; + + enum + @{ + space = _ISspace, + print = _ISprint, + cntrl = _IScntrl, + upper = _ISupper, + lower = _ISlower, + alpha = _ISalpha, + digit = _ISdigit, + punct = _ISpunct, + xdigit = _ISxdigit, + alnum = _ISalnum, + graph = _ISgraph + @}; +@}; +@end example + +@noindent +The @code{mask} type is the type of the elements in the table. If your +C library uses a table to map lower-case numbers to upper-case numbers, +and vice versa, you should define @code{__to_type} to be the type of the +elements in that table. If you don't mind taking a minor performance +penalty, or if your library doesn't implement @code{toupper} and +@code{tolower} in this way, you can pick any pointer-to-integer type, +but you must still define the type. + +The enumeration should give definitions for all the values in the above +example, using the values from your native @file{<ctype.h>}. They can +be given symbolically (as above), or numerically, if you prefer. You do +not have to include @file{<ctype.h>} in this header; it will always be +included before @file{ctype_base.h} is included. + +The next file to write is @file{ctype_noninline.h}, which also does +not require include guards. This file defines a few member functions +that will be included in @file{include/bits/locale_facets.h}. The first +function that must be written is the @code{ctype<char>::ctype} +constructor. Here is the IRIX example: + +@example +ctype<char>::ctype(const mask* __table = 0, bool __del = false, + size_t __refs = 0) + : _Ctype_nois<char>(__refs), _M_del(__table != 0 && __del), + _M_toupper(NULL), + _M_tolower(NULL), + _M_ctable(NULL), + _M_table(!__table + ? (const mask*) (__libc_attr._ctype_tbl->_class + 1) + : __table) + @{ @} +@end example + +@noindent +There are two parts of this that you might choose to alter. The first, +and most important, is the line involving @code{__libc_attr}. That is +IRIX system-dependent code that gets the base of the table mapping +character codes to attributes. You need to substitute code that obtains +the address of this table on your system. If you want to use your +operating system's tables to map upper-case letters to lower-case, and +vice versa, you should initialize @code{_M_toupper} and +@code{_M_tolower} with those tables, in similar fashion. + +Now, you have to write two functions to convert from upper-case to +lower-case, and vice versa. Here are the IRIX versions: + +@example +char +ctype<char>::do_toupper(char __c) const +@{ return _toupper(__c); @} + +char +ctype<char>::do_tolower(char __c) const +@{ return _tolower(__c); @} +@end example + +@noindent +Your C library provides equivalents to IRIX's @code{_toupper} and +@code{_tolower}. If you initialized @code{_M_toupper} and +@code{_M_tolower} above, then you could use those tables instead. + +Finally, you have to provide two utility functions that convert strings +of characters. The versions provided here will always work -- but you +could use specialized routines for greater performance if you have +machinery to do that on your system: + +@example +const char* +ctype<char>::do_toupper(char* __low, const char* __high) const +@{ + while (__low < __high) + @{ + *__low = do_toupper(*__low); + ++__low; + @} + return __high; +@} + +const char* +ctype<char>::do_tolower(char* __low, const char* __high) const +@{ + while (__low < __high) + @{ + *__low = do_tolower(*__low); + ++__low; + @} + return __high; +@} +@end example + +You must also provide the @file{ctype_inline.h} file, which +contains a few more functions. On most systems, you can just copy +@file{config/os/generic/ctype_inline.h} and use it on your system. + +In detail, the functions provided test characters for particular +properties; they are analogous to the functions like @code{isalpha} and +@code{islower} provided by the C library. + +The first function is implemented like this on IRIX: + +@example +bool +ctype<char>:: +is(mask __m, char __c) const throw() +@{ return (_M_table)[(unsigned char)(__c)] & __m; @} +@end example + +@noindent +The @code{_M_table} is the table passed in above, in the constructor. +This is the table that contains the bitmasks for each character. The +implementation here should work on all systems. + +The next function is: + +@example +const char* +ctype<char>:: +is(const char* __low, const char* __high, mask* __vec) const throw() +@{ + while (__low < __high) + *__vec++ = (_M_table)[(unsigned char)(*__low++)]; + return __high; +@} +@end example + +@noindent +This function is similar; it copies the masks for all the characters +from @code{__low} up until @code{__high} into the vector given by +@code{__vec}. + +The last two functions again are entirely generic: + +@example +const char* +ctype<char>:: +scan_is(mask __m, const char* __low, const char* __high) const throw() +@{ + while (__low < __high && !this->is(__m, *__low)) + ++__low; + return __low; +@} + +const char* +ctype<char>:: +scan_not(mask __m, const char* __low, const char* __high) const throw() +@{ + while (__low < __high && this->is(__m, *__low)) + ++__low; + return __low; +@} +@end example + +@c --------------------------------------------------------------------- +@c Thread safety +@c --------------------------------------------------------------------- + +@node Thread safety +@chapter Thread safety + +The C++ library string functionality requires a couple of atomic +operations to provide thread-safety. If you don't take any special +action, the library will use stub versions of these functions that are +not thread-safe. They will work fine, unless your applications are +multi-threaded. + +If you want to provide custom, safe, versions of these functions, there +are two distinct approaches. One is to provide a version for your CPU, +using assembly language constructs. The other is to use the +thread-safety primitives in your operating system. In either case, you +make a file called @file{atomicity.h}, and the variable +@code{ATOMICITYH} must point to this file. + +If you are using the assembly-language approach, put this code in +@file{config/cpu/<chip>/atomicity.h}, where chip is the name of +your processor (@pxref{CPU}). No additional changes are necessary to +locate the file in this case; @code{ATOMICITYH} will be set by default. + +If you are using the operating system thread-safety primitives approach, +you can also put this code in the same CPU directory, in which case no more +work is needed to locate the file. For examples of this approach, +see the @file{atomicity.h} file for IRIX or IA64. + +Alternatively, if the primitives are more closely related to the OS +than they are to the CPU, you can put the @file{atomicity.h} file in +the @ref{Operating system} directory instead. In this case, you must +edit @file{configure.host}, and in the switch statement that handles +operating systems, override the @code{ATOMICITYH} variable to point to +the appropriate @code{os_include_dir}. For examples of this approach, +see the @file{atomicity.h} file for AIX. + +With those bits out of the way, you have to actually write +@file{atomicity.h} itself. This file should be wrapped in an +include guard named @code{_GLIBCXX_ATOMICITY_H}. It should define one +type, and two functions. + +The type is @code{_Atomic_word}. Here is the version used on IRIX: + +@example +typedef long _Atomic_word; +@end example + +@noindent +This type must be a signed integral type supporting atomic operations. +If you're using the OS approach, use the same type used by your system's +primitives. Otherwise, use the type for which your CPU provides atomic +primitives. + +Then, you must provide two functions. The bodies of these functions +must be equivalent to those provided here, but using atomic operations: + +@example +static inline _Atomic_word +__attribute__ ((__unused__)) +__exchange_and_add (_Atomic_word* __mem, int __val) +@{ + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; +@} + +static inline void +__attribute__ ((__unused__)) +__atomic_add (_Atomic_word* __mem, int __val) +@{ + *__mem += __val; +@} +@end example + +@c --------------------------------------------------------------------- +@c Numeric limits +@c --------------------------------------------------------------------- + +@node Numeric limits +@chapter Numeric limits + +The C++ library requires information about the fundamental data types, +such as the minimum and maximum representable values of each type. +You can define each of these values individually, but it is usually +easiest just to indicate how many bits are used in each of the data +types and let the library do the rest. For information about the +macros to define, see the top of @file{include/bits/std_limits.h}. + +If you need to define any macros, you can do so in @file{os_defines.h}. +However, if all operating systems for your CPU are likely to use the +same values, you can provide a CPU-specific file instead so that you +do not have to provide the same definitions for each operating system. +To take that approach, create a new file called @file{cpu_limits.h} in +your CPU configuration directory (@pxref{CPU}). + +@c --------------------------------------------------------------------- +@c Libtool +@c --------------------------------------------------------------------- + +@node Libtool +@chapter Libtool + +The C++ library is compiled, archived and linked with libtool. +Explaining the full workings of libtool is beyond the scope of this +document, but there are a few, particular bits that are necessary for +porting. + +Some parts of the libstdc++-v3 library are compiled with the libtool +@code{--tags CXX} option (the C++ definitions for libtool). Therefore, +@file{ltcf-cxx.sh} in the top-level directory needs to have the correct +logic to compile and archive objects equivalent to the C version of libtool, +@file{ltcf-c.sh}. Some libtool targets have definitions for C but not +for C++, or C++ definitions which have not been kept up to date. + +The C++ run-time library contains initialization code that needs to be +run as the library is loaded. Often, that requires linking in special +object files when the C++ library is built as a shared library, or +taking other system-specific actions. + +The libstdc++-v3 library is linked with the C version of libtool, even +though it is a C++ library. Therefore, the C version of libtool needs to +ensure that the run-time library initializers are run. The usual way to +do this is to build the library using @code{gcc -shared}. + +If you need to change how the library is linked, look at +@file{ltcf-c.sh} in the top-level directory. Find the switch statement +that sets @code{archive_cmds}. Here, adjust the setting for your +operating system. + +@c --------------------------------------------------------------------- +@c GFDL +@c --------------------------------------------------------------------- + +@include fdl.texi + +@c --------------------------------------------------------------------- +@c Epilogue +@c --------------------------------------------------------------------- + +@contents +@bye diff --git a/libstdc++-v3/doc/html/17_intro/tr1_status.html b/libstdc++-v3/doc/html/17_intro/tr1_status.html new file mode 100644 index 00000000000..3d3d673cf89 --- /dev/null +++ b/libstdc++-v3/doc/html/17_intro/tr1_status.html @@ -0,0 +1,2322 @@ +<?xml version="1.0" encoding="ISO-8859-1"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> + +<head> + + <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> + <link rev="made" href="mailto:gcc@gcc.gnu.org" /> + <link rel="shortcut icon" href="http://gcc.gnu.org/favicon.ico" /> + + <title> + Status of TR1 features in GCC + - GNU Project - Free Software Foundation (FSF) + </title> + +</head> + +<body> + +<h1 align="center"> + Status of TR1 features in GCC +</h1> + +<p> +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 +</p> + +<p> +In this implementation the header names are prefixed by +<code>tr1/</code>, for instance <code><tr1/functional></code>, +<code><tr1/memory></code>, and so on. +</p> + +<p> +This page describes the TR1 support in mainline GCC SVN, not in any particular +release. +</p> + +<table border="1"> + <thead> + <tr> + <td><span style="font-weight: bold;">Section</span></td> + <td><span style="font-weight: bold;">Description</span></td> + <td><span style="font-weight: bold;">Done</span></td> + <td><span style="font-weight: bold;">Broken</span></td> + <td><span style="font-weight: bold;">Missing</span></td> + <td><span style="font-weight: bold;">Comments</span></td> + </tr> + </thead> + <tbody> + <tr> + <td><b>2</b></td> + <td colspan="5"><b>General Utilities</b></td> + </tr> + <tr> + <td>2.1</td> + <td>Reference wrappers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.1</td> + <td>Additions to header <code><functional></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2</td> + <td>Class template <code>reference_wrapper</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2.1</td> + <td><code>reference_wrapper</code> construct/copy/destroy</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2.2</td> + <td><code>reference_wrapper</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2.3</td> + <td><code>reference_wrapper</code> access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2.4</td> + <td><code>reference_wrapper</code> invocation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.1.2.5</td> + <td><code>reference_wrapper</code> helper functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2</td> + <td>Smart pointers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.1</td> + <td>Additions to header <code><memory></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.2</td> + <td>Class <code>bad_weak_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3</td> + <td>Class template <code>shared_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td><a href="tr1.html#1">1</a></td> + </tr> + <tr> + <td>2.2.3.1</td> + <td><code>shared_ptr</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.2</td> + <td><code>shared_ptr</code> destructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.3</td> + <td><code>shared_ptr</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.4</td> + <td><code>shared_ptr</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.5</td> + <td><code>shared_ptr</code> observers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.6</td> + <td><code>shared_ptr</code> comparison</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.7</td> + <td><code>shared_ptr</code> I/O</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.8</td> + <td><code>shared_ptr</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.9</td> + <td><code>shared_ptr</code> casts</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.3.10</td> + <td><code>get_deleter</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4</td> + <td>Class template <code>weak_ptr</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.1</td> + <td><code>weak_ptr</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.2</td> + <td><code>weak_ptr</code> destructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.3</td> + <td><code>weak_ptr</code> assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.4</td> + <td><code>weak_ptr</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.5</td> + <td><code>weak_ptr</code> observers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.6</td> + <td><code>weak_ptr</code> comparison</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.4.7</td> + <td><code>weak_ptr</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>2.2.5</td> + <td>Class template <code>enable_shared_from_this</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>3</b></td> + <td colspan="5"><b>Function objects</b></td> + </tr> + <tr> + <td>3.1</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.2</td> + <td>Additions to <code><functional> synopsis</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.3</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.4</td> + <td>Function return types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.5</td> + <td>Function template <code>mem_fn</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.6</td> + <td>Function object binders</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.6.1</td> + <td>Class template <code>is_bind_expression</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.6.2</td> + <td>Class template <code>is_placeholder</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.6.3</td> + <td>Function template <code>bind</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.6.4</td> + <td>Placeholders</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7</td> + <td>Polymorphic function wrappers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.1</td> + <td>Class <code>bad_function_call<code></code></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.1.1</td> + <td><code>bad_function_call</code> constructor</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2</td> + <td>Class template <code>function</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.1</td> + <td><code>function</code> construct/copy/destroy</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.2</td> + <td><code>function</code> modifiers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.3</td> + <td><code>function</code> capacity</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.4</td> + <td><code>function</code> invocation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.5</td> + <td><code>function</code> target access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.6</td> + <td>undefined operators</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.7</td> + <td>null pointer comparison operators</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>3.7.2.8</td> + <td>specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>4</b></td> + <td colspan="5"><b>Metaprogramming and type traits</b></td> + </tr> + <tr> + <td>4.1</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.2</td> + <td>Header <code><type_traits></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.3</td> + <td>Helper classes</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.4</td> + <td>General Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.5</td> + <td>Unary Type Traits</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.5.1</td> + <td>Primary Type Categories</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.5.2</td> + <td>Composite type traits</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.5.3</td> + <td>Type properties</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.6</td> + <td>Relationships between types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.7</td> + <td>Transformations between types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.7.1</td> + <td>Const-volatile modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.7.2</td> + <td>Reference modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.7.3</td> + <td>Array modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.7.4</td> + <td>Pointer modifications</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.8</td> + <td>Other transformations</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>4.9</td> + <td>Implementation requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>5</b></td> + <td colspan="5"><b>Numerical facilities</b></td> + </tr> + <tr> + <td>5.1</td> + <td>Random number generation</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.1</td> + <td>Requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.2</td> + <td>Header <code><random></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.3</td> + <td>Class template <code>variate_generator</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4</td> + <td>Random number engine class templates</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.1</td> + <td>Class template <code>linear_congruential</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.2</td> + <td>Class template <code>mersenne_twister</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.3</td> + <td>Class template <code>subtract_with_carry</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.4</td> + <td>Class template <code>subtract_with_carry_01</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.5</td> + <td>Class template <code>discard_block</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.4.6</td> + <td>Class template <code>xor_combine</code></td> + <td>done</td> + <td></td> + <td></td> + <td>operator()() per N2079</td> + </tr> + <tr> + <td>5.1.5</td> + <td>Engines with predefined parameters</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.6</td> + <td>Class <code>random_device</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7</td> + <td>Random distribution class templates</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.1</td> + <td>Class template <code>uniform_int</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.2</td> + <td>Class <code>bernoulli_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.3</td> + <td>Class template <code>geometric_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.4</td> + <td>Class template <code>poisson_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.5</td> + <td>Class template <code>binomial_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.6</td> + <td>Class template <code>uniform_real</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.7</td> + <td>Class template <code>exponential_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.8</td> + <td>Class template <code>normal_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.1.7.9</td> + <td>Class template <code>gamma_distribution</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2</td> + <td>Mathematical special functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1</td> + <td>Additions to header <code><cmath></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.1</td> + <td>associated Laguerre polynomials</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.2</td> + <td>associated Legendre functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.3</td> + <td>beta function</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.4</td> + <td>(complete) elliptic integral of the first kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.5</td> + <td>(complete) elliptic integral of the second kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.6</td> + <td>(complete) elliptic integral of the third kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.7</td> + <td>confluent hypergeometric functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.8</td> + <td>regular modified cylindrical Bessel functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.9</td> + <td>cylindrical Bessel functions (of the first kind)</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.10</td> + <td>irregular modified cylindrical Bessel functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.11</td> + <td>cylindrical Neumann functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.12</td> + <td>(incomplete) elliptic integral of the first kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.13</td> + <td>(incomplete) elliptic integral of the second kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.14</td> + <td>(incomplete) elliptic integral of the third kind</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.15</td> + <td>exponential integral</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.16</td> + <td>Hermite polynomials</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.17</td> + <td>hypergeometric functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.18</td> + <td>Laguerre polynomials</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.19</td> + <td>Legendre polynomials</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.20</td> + <td>Riemann zeta function</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.21</td> + <td>spherical Bessel functions (of the first kind)</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.22</td> + <td>spherical associated Legendre functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.1.23</td> + <td>spherical Neumann functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>5.2.2</td> + <td>Additions to header <code><math.h></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>6</b></td> + <td colspan="5"><b>Containers</b></td> + </tr> + <tr> + <td>6.1</td> + <td>Tuple types</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.1</td> + <td>Header <code><tuple></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.2</td> + <td>Additions to header <code><utility></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3</td> + <td>Class template <code>tuple</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3.1</td> + <td>Construction</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3.2</td> + <td>Tuple creation functions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3.3</td> + <td>Tuple helper classes</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3.4</td> + <td>Element access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.3.5</td> + <td>Relational operators</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.1.4</td> + <td>Pairs</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2</td> + <td>Fixed size array</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.1</td> + <td>Header <code><array></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2</td> + <td>Class template <code>array</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2.1</td> + <td><code>array</code> constructors, copy, and assignment</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2.2</td> + <td><code>array</code> specialized algorithms</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2.3</td> + <td><code>array</code> size</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2.4</td> + <td>Zero sized <code>array</code>s</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.2.2.5</td> + <td>Tuple interface to class template <code>array</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3</td> + <td>Unordered associative containers</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.1</td> + <td>Unordered associative container requirements</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.1.1</td> + <td>Exception safety guarantees</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.2</td> + <td>Additions to header <code><functional></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.3</td> + <td>Class template <code>hash</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4</td> + <td>Unordered associative container classes</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.1</td> + <td>Header <code><unordered_set></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.2</td> + <td>Header <code><unordered_map></code> synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.3</td> + <td>Class template <code>unordered_set</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.3.1</td> + <td><code>unordered_set</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.3.2</td> + <td><code>unordered_set</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.4</td> + <td>Class template <code>unordered_map</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.4.1</td> + <td><code>unordered_map</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.4.2</td> + <td><code>unordered_map</code> element access</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.4.3</td> + <td><code>unordered_map</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.5</td> + <td>Class template <code>unordered_multiset<code></code></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.5.1</td> + <td><code>unordered_multiset</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.5.2</td> + <td><code>unordered_multiset</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.6</td> + <td>Class template <code>unordered_multimap</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.6.1</td> + <td><code>unordered_multimap</code> constructors</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>6.3.4.6.2</td> + <td><code>unordered_multimap</code> swap</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><b>7</b></td> + <td colspan="5"><b>Regular expressions</b></td> + </tr> + <tr> + <td>7.1</td> + <td>Definitions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.2</td> + <td>Requirements</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.3</td> + <td>Regular expressions summary</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.4</td> + <td>Header <code><regex></code> synopsis</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.5</td> + <td>Namespace <code>tr1::regex_constants</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.5.1</td> + <td>Bitmask Type <code>syntax_option_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.5.2</td> + <td>Bitmask Type <code>regex_constants::match_flag_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.5.3</td> + <td>Implementation defined <code>error_type</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.6</td> + <td>Class <code>regex_error</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.7</td> + <td>Class template <code>regex_traits</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8</td> + <td>Class template <code>basic_regex</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.1</td> + <td><code>basic_regex</code> constants</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.2</td> + <td><code>basic_regex</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.3</td> + <td><code>basic_regex</code> assign</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.4</td> + <td><code>basic_regex</code> constant operations</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.5</td> + <td><code>basic_regex</code> locale</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.6</td> + <td><code>basic_regex</code> swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.7</td> + <td><code>basic_regex</code> non-member functions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.8.7.1</td> + <td><code>basic_regex</code> non-member swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.9</td> + <td>Class template <code>sub_match</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.9.1</td> + <td><code>sub_match</code> members</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.9.2</td> + <td><code>sub_match</code> non-member operators</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10</td> + <td>Class template <code>match_results</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.1</td> + <td><code>match_results</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.2</td> + <td><code>match_results</code> size</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.3</td> + <td><code>match_results</code> element access</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.4</td> + <td><code>match_results</code> formatting</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.5</td> + <td><code>match_results</code> allocator</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.10.6</td> + <td><code>match_results</code> swap</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.11</td> + <td>Regular expression algorithms</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.11.1</td> + <td>exceptions</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.11.2</td> + <td><code>regex_match</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.11.3</td> + <td><code>regex_search</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.11.4</td> + <td><code>regex_replace</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12</td> + <td>Regular expression Iterators</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.1</td> + <td>Class template <code>regex_iterator</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.1.1</td> + <td><code>regex_iterator</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.1.2</td> + <td><code>regex_iterator</code> comparisons</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.1.3</td> + <td><code>regex_iterator</code> dereference</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.1.4</td> + <td><code>regex_iterator</code> increment</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.2</td> + <td>Class template <code>regex_token_iterator</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.2.1</td> + <td><code>regex_token_iterator</code> constructors</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.2.2</td> + <td><code>regex_token_iterator</code> comparisons</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.2.3</td> + <td><code>regex_token_iterator</code> dereference</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.12.2.4</td> + <td><code>regex_token_iterator</code> increment</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>7.13</td> + <td>Modified ECMAScript regular expression grammar</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td><b>8</b></td> + <td colspan="5"><b>C compatibility</b></td> + </tr> + <tr> + <td>8.1</td> + <td>Additions to header <code><complex></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.2</td> + <td>Function <code>acos</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.3</td> + <td>Function <code>asin</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.4</td> + <td>Function <code>atan</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.5</td> + <td>Function <code>acosh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.6</td> + <td>Function <code>asinh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.7</td> + <td>Function <code>atanh</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.8</td> + <td>Function <code>fabs</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.1.9</td> + <td>Additional Overloads</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.2</td> + <td>Header <code><ccomplex></code></td> + <td></td> + <td></td> + <td>missing</td> + <td>DR 551</td> + </tr> + <tr> + <td>8.3</td> + <td>Header <code><complex.h></code></td> + <td></td> + <td></td> + <td>missing</td> + <td>DR 551</td> + </tr> + <tr> + <td>8.4</td> + <td>Additions to header <code><cctype></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.4.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.4.2</td> + <td>Function <code>isblank</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.5</td> + <td>Additions to header <code><ctype.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.6</td> + <td>Header <code><cfenv></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.6.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.6.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.7</td> + <td>Header <code><fenv.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.8</td> + <td>Additions to header <code><cfloat></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.9</td> + <td>Additions to header <code><float.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.10</td> + <td>Additions to header <code><ios></code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>8.10.1</td> + <td>Synopsis</td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>8.10.2</td> + <td>Function <code>hexfloat</code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>8.11</td> + <td>Header <code><cinttypes></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.11.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td>DR 557</td> + </tr> + <tr> + <td>8.11.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.12</td> + <td>Header <code><inttypes.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.13</td> + <td>Additions to header <code><climits></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.14</td> + <td>Additions to header <code><limits.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.15</td> + <td>Additions to header <code><locale></code></td> + <td></td> + <td></td> + <td>missing</td> + <td></td> + </tr> + <tr> + <td>8.16</td> + <td>Additions to header <code><cmath></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.16.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.16.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.16.3</td> + <td>Function template definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.16.4</td> + <td>Additional overloads</td> + <td>done</td> + <td></td> + <td></td> + <td>DR 568; DR 550</td> + </tr> + <tr> + <td>8.17</td> + <td>Additions to header <code><math.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.18</td> + <td>Additions to header <code><cstdarg></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.19</td> + <td>Additions to header <code><stdarg.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.20</td> + <td>The header <code><cstdbool></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.21</td> + <td>The header <code><stdbool.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.22</td> + <td>The header <code><cstdint></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.22.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.22.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.23</td> + <td>The header <code><stdint.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.24</td> + <td>Additions to header <code><cstdio></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.24.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.24.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.24.3</td> + <td>Additional format specifiers</td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>8.24.4</td> + <td>Additions to header <code><stdio.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.25</td> + <td>Additions to header <code><cstdlib></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.25.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.25.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.25.3</td> + <td>Function <code>abs</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.25.4</td> + <td>Function <code>div</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.26</td> + <td>Additions to header <code><stdlib.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.27</td> + <td>Header <code><ctgmath></code></td> + <td>done</td> + <td></td> + <td></td> + <td>DR 551</td> + </tr> + <tr> + <td>8.28</td> + <td>Header <code><tgmath.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td>DR 551</td> + </tr> + <tr> + <td>8.29</td> + <td>Additions to header <code><ctime></code></td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>8.30</td> + <td>Additions to header <code><cwchar></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.30.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.30.2</td> + <td>Definitions</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.30.3</td> + <td>Additional wide format specifiers</td> + <td>done</td> + <td></td> + <td></td> + <td>C library responsibility</td> + </tr> + <tr> + <td>8.31</td> + <td>Additions to header <code><wchar.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.32</td> + <td>Additions to header <code><cwctype></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.32.1</td> + <td>Synopsis</td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.32.2</td> + <td>Function <code>iswblank</code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td>8.33</td> + <td>Additions to header <code><wctype.h></code></td> + <td>done</td> + <td></td> + <td></td> + <td></td> + </tr> + </tbody> +</table> + +<h3>Footnotes</h3> + +<ol> + + <li> + <a name="1"/> + The shared_ptr implementation uses some code from the + <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm">Boost + shared_ptr</a> library. + </li> + +</ol> + +<p> +Please send FSF & GNU inquiries & questions to +<a href="mailto:gnu@gnu.org">gnu@gnu.org</a>. +There are also <a href="http://www.gnu.org/home.html#ContactInfo">other ways +to contact</a> the FSF. +</p> + +<p> +These pages are maintained by +<a href="http://gcc.gnu.org/about.html">the GCC team</a>. +</p> + +<address> +For questions related to the use of GCC, please consult these web +pages and the <a href="http://gcc.gnu.org/onlinedocs/">GCC manuals</a>. If +that fails, the <a href="mailto:gcc-help@gcc.gnu.org">gcc-help@gcc.gnu.org</a> +mailing list might help.<br /> +Please send comments on these web pages and the development of GCC to our +developer mailing list at <a href="mailto:gcc@gnu.org">gcc@gnu.org</a> +or <a href="mailto:gcc@gcc.gnu.org">gcc@gcc.gnu.org</a>. All of our lists +have <a href="http://gcc.gnu.org/lists.html">public archives</a>. +</address> + +<p> +Copyright (C) Free Software Foundation, Inc., +51 Franklin St, Fifth Floor, Boston, MA 02110, USA. +</p> +<p> +Verbatim copying and distribution of this entire article is +permitted in any medium, provided this notice is preserved. +</p> + +<table width="100%" border="0"> +<tr> + <td> + <!-- IGNORE DIFF -->Last modified 2006-10-01 + </td> + <td align="right" valign="bottom"> + <a href="http://validator.w3.org/check/referer"> + <img src="http://www.w3.org/Icons/valid-xhtml10" + alt="Valid XHTML 1.0" border="0" width="88" height="31" /> + </a> + </td> +</tr> +</table> + +</body> +</html> |
