diff options
Diffstat (limited to 'libstdc++-v3/docs/html/17_intro')
22 files changed, 0 insertions, 12281 deletions
diff --git a/libstdc++-v3/docs/html/17_intro/BADNAMES b/libstdc++-v3/docs/html/17_intro/BADNAMES deleted file mode 100644 index a904704ee39..00000000000 --- a/libstdc++-v3/docs/html/17_intro/BADNAMES +++ /dev/null @@ -1,182 +0,0 @@ - -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/docs/html/17_intro/BUGS b/libstdc++-v3/docs/html/17_intro/BUGS deleted file mode 100644 index e71304d0666..00000000000 --- a/libstdc++-v3/docs/html/17_intro/BUGS +++ /dev/null @@ -1,28 +0,0 @@ -2003-04-26 - -- _GLIBCPP_HAS_BUILTIN_SINF: We should still hold out for a cleaner solution the is currenly the case in bits/std_cmath.h. - -- there may be one set of remaining string bugs, dependent on final -clarification of the string::find technicalities when finding in an -empty string or using an empty string for an argument. At the very -least, v-3 has interpreted the standard in a way that is in opposition -to other libraries on other platforms. - -- trigraphs and keywords a la the iso646 header are not correctly -implemented. It looks like the compiler recognizes them as keywords -but then doesn't translate into the correct bit ops. It is a mystery. - -- wide strings have not been tested, and may therefore be unusable. - -- Chapter 27 io functionality is not finished. As such, there are -known bugs in: filebuf::putbackfail - -- Many facet implementations are stubs. (22) - -- Almost no optimizations for small-footprint/low-overhead. (22,27) - -- There has been some work to wrap the C headers in namespace std::, but - it may not be complete yet, and C macros are not shadowed. Please consult - the mailing list archives for more information. - - diff --git a/libstdc++-v3/docs/html/17_intro/C++STYLE b/libstdc++-v3/docs/html/17_intro/C++STYLE deleted file mode 100644 index 87f53d0ea05..00000000000 --- a/libstdc++-v3/docs/html/17_intro/C++STYLE +++ /dev/null @@ -1,386 +0,0 @@ - -C++ Standard Library Style Guidelines DRAFT 2001-01-15 -------------------------------------- - -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 here: - -http://www.gnu.org/prep/standards_toc.html - -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. - -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: - // ctor, op=, dtor - gribble() throw(); - - gribble(const gribble&); - - explicit - gribble(int __howmany); - - gribble& - operator=(const gribble&); - - virtual - ~gribble() throw (); - - // argument - 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/docs/html/17_intro/CHECKLIST b/libstdc++-v3/docs/html/17_intro/CHECKLIST deleted file mode 100644 index ad02b0d8731..00000000000 --- a/libstdc++-v3/docs/html/17_intro/CHECKLIST +++ /dev/null @@ -1,6002 +0,0 @@ - - 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(); - }; - diff --git a/libstdc++-v3/docs/html/17_intro/COPYING b/libstdc++-v3/docs/html/17_intro/COPYING deleted file mode 100644 index 623b6258a13..00000000000 --- a/libstdc++-v3/docs/html/17_intro/COPYING +++ /dev/null @@ -1,340 +0,0 @@ - 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/docs/html/17_intro/COPYING.DOC b/libstdc++-v3/docs/html/17_intro/COPYING.DOC deleted file mode 100644 index 1a864561bd4..00000000000 --- a/libstdc++-v3/docs/html/17_intro/COPYING.DOC +++ /dev/null @@ -1,355 +0,0 @@ - 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/docs/html/17_intro/DESIGN b/libstdc++-v3/docs/html/17_intro/DESIGN deleted file mode 100644 index 5af3d9aed3b..00000000000 --- a/libstdc++-v3/docs/html/17_intro/DESIGN +++ /dev/null @@ -1,859 +0,0 @@ - -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/docs/html/17_intro/HEADER_POLICY b/libstdc++-v3/docs/html/17_intro/HEADER_POLICY deleted file mode 100644 index c6fa6d38b54..00000000000 --- a/libstdc++-v3/docs/html/17_intro/HEADER_POLICY +++ /dev/null @@ -1,164 +0,0 @@ - -Header Policy -------------- - -The C++ Standard specifies many mutual dependencies among the -headers it defines. It offers no advice on how to arrange headers -to avoid problems. The worst such problem is circular references. -Most simply this is "A includes B, B includes A": - - // file <A> // file <B> - #ifndef A #ifndef B - #define A 1 #define B 1 - #include <B> #include <A> - typedef int A_type; typedef int B_type; - extern B_type g(A_type); extern A_type f(B_type); - #endif /* A */ #endif /* B */ - - // file C.cc - #include <A> - -The typical effect of such an "include loop" may be seen by tracing -the preprocessor activity: - - C // file C.cc - C #include <A> - A // file <A> - A #ifndef A - A #define A 1 - A #include <B> - B // file <B> - B #ifndef B - B #define B 1 - B #include <A> - A // file <A> - A #ifndef A <-- oops, cpp symbol A defined already - A ... <-- skip <A> contents - A #endif - B typedef int B_type; - B extern A_type f(B_type); <-- error, A_type not defined yet. - B #endif /* B */ - A typedef int A_type; - A extern B_type g(A_type); - A #endif /* A */ - -The main symptom of #include loops is that definitions from file <A> -are not available after the #include <A> for certain include orders. -The number of standard headers makes testing all permutations of -include order impractical, so a policy is needed to prevent chaos. -In any case, for some standard headers (as for the above) no ordering -can eliminate the loop. - -Other factors influence the policy. Typical implementations of -Make (unfortunately including GNU make) have bugs relating to file -names with no suffix, that lead to such problems as failure to track -dependencies on such files and an inclination to _delete_ them. -Therefore, headers used in building the library are always of the -form <bits/yyy.h> generally, or specifically <bits/std_xxx.h> for -an equivalent to the standard header <xxx>. - -Standard headers <xxx> are all placed under directory std/, and -are ignored except during installation. These headers simply -#include the corresponding header <bits/std_xxx.h>. - -Standard substitute headers <bits/std_xxx.h> that have any complexity -may sub-include other headers. When they sub-include non-standard -headers, they first include all the headers required for that -non-standard header. - -Mutual dependencies are handled by splitting up the declarations -intended for standard headers among two or more files, and then -interleaving them as needed. For example, we replace <A> and <B> -above, as follows: - - // file <bits/std_A.h> - #ifndef _CPP_A - #define _CPP_A - # include <bits/A_types.h> - # include <bits/B_types.h> - # include <bits/A_funs.h> - #endif - - // file <bits/std_B.h> - #ifndef _CPP_B - #define _CPP_B - # include <bits/A_types.h> - # include <bits/B_types.h> - # include <bits/B_funs.h> - #endif - - // file <bits/A_types.h> - #ifndef _CPP_BITS_A_TYPES_H - #define _CPP_BITS_A_TYPES_H - typedef int A_type; - #endif - - // file <bits/B_types.h> - #ifndef _CPP_BITS_B_TYPES_H - #define _CPP_BITS_B_TYPES_H - typedef int B_type; - #endif - - // file <bits/A_funs.h> - #ifndef _CPP_BITS_A_FUNS_H - #define _CPP_BITS_A_FUNS_H - extern B_type g(A_type); - #endif - - // file <bits/B_funs.h> - #ifndef _CPP_BITS_B_FUNS_H - #define _CPP_BITS_B_FUNS_H - extern A_type f(B_type); - #endif - -Of course we have the standard headers under their mandated names: - - // file <std/A> - #ifndef _CPP_A - #define _CPP_A - # include <bits/std_A.h> - #endif - - // file <std/B> - #ifndef _CPP_B - #define _CPP_B - # include <bits/std_B.h> - #endif - -Notice that the include guards are named uniformly except that -the guard for standard header <bits/std_A.h> is just _CPP_A, -identically as the header <A> in std/. - -At installation the files std/* can be replaced by symbolic links, -or simply copied into place as is. The result is: - - include/ - include/A -> bits/std_A.h - include/B -> bits/std_A.h - include/bits/ - include/bits/std_A.h - include/bits/std_B.h - include/bits/A_types.h - include/bits/B_types.h - include/bits/A_funs.h - include/bits/B_funs.h - - -Of course splitting up standard headers this way creates -complexity, so it is not done routinely, but only in response -to discovered needs. - -Another reason to split up headers is for support of separate -compilation of templates. This interacts with the foregoing -because template definitions typically have many more dependencies -on other headers than do pure declarations. Non-inline template -definitions are placed in a separate ".tcc" file that is included -by the standard header, and any other standard header that -requires definitions from it for its implementation. - -The key to preventing chaos, given the above structure, is: - - Only standard headers <bits/std_xxxx.h> should sub-include - other headers. - - diff --git a/libstdc++-v3/docs/html/17_intro/PROBLEMS b/libstdc++-v3/docs/html/17_intro/PROBLEMS deleted file mode 100644 index 52223911295..00000000000 --- a/libstdc++-v3/docs/html/17_intro/PROBLEMS +++ /dev/null @@ -1,8 +0,0 @@ -Irix 6.2: -- math.h: defines extern long double hypotl( long double ); i.e., only - one argument. They've fixed this in 6.3. - -DES OSF 3.2 & 4.0: -- libm define sincos, sincosf, and sincosl but there are no prototypes and - especially the return type is nowhere defined. The functions are - documented in the man pages, though. diff --git a/libstdc++-v3/docs/html/17_intro/RELEASE-NOTES b/libstdc++-v3/docs/html/17_intro/RELEASE-NOTES deleted file mode 100644 index 79920407c21..00000000000 --- a/libstdc++-v3/docs/html/17_intro/RELEASE-NOTES +++ /dev/null @@ -1,83 +0,0 @@ -2002-05-02 - -Release Notes -------------- -The Standard C++ Library, or libstdc++-v3, is an ongoing project -to fully implement the ISO 14882 Standard C++ library as described in -chapters 17 through 27 and annex D. - -This is the fifteenth snapshot of the libstdc++ rewrite. It still -has some incomplet and incorrekt parts, but it's a lot less incomplete -and incorrect than some of the earlier snapshots, and quite usable. - -The Standard C++ Library, follows an open development model, -attempting to be fully buzzword, bazaar, and GNU compliant. Full -details on participating, including contributor guidelines, mailing -list subscription, mailing list archives, up-to-date documentation, -and various and sundry other details can be found at the following -URL: - - http://gcc.gnu.org/libstdc++/ - - -New: ---- -- more doxygen documentation -- more named locale fixups -- stdio_filebuf that takes fd, FILE -- io performance tuning -- allocation tuning, valgrind fixups -- __cxa_demangle now supported - - -Bugs fixed: ------------ -6533, 6513, 6501, 6511, 5820, 6414, 4150, 6360, 4164, 1072, 6124, -5180, 3457, 3139, 5268, 3983, 5542, 3129, 5207, 3719, 5734 -+ others. - - -What doesn't: -------------- -- see BUGS. - - -Build and Install ------------------ -Up to date build and install directions can be found at: -http://gcc.gnu.org/libstdc++/install.html - - -Contact: --------- -Places have changed from previous snapshots. The web page, which has -information about joining the mailing list and searching its archives, -CVS access, and contribution information is now at: - - http://gcc.gnu.org/libstdc++/ - -Please note that the mailing list has moved, and is now hosted on -gcc.gnu.org. (The web site above has the most up-to-date info.) - -Obtain the library snapshot via ftp (including these release notes) from - - ftp://gcc.gnu.org/pub/libstdc++/ - -The library is maintained by Benjamin Kosnik, Gabriel -Dos Reis, Phil Edwards, Ulrich Drepper, Loren James Rittle, -and Paolo Carlini. - - -Development tools: ------------------- - -You will need a current version of gcc to compile this snapshot of -libstdc++. The use of the latest stable gcc-3.0.x release (3.0.4), CVS -gcc, or gcc-3_1-branch is strongly recommended, which may also -introduce additional dependencies for up-to-date binutils. In -particular, current binutils (2.12) is recommended so that symbol -versioning for the library is on by default. In addition, you may need -up-to-date tools for modifying Makefiles and regenerating configure -scripts: automake (version 1.4), autoconf (version 2.13 and higher), -and libtool. - diff --git a/libstdc++-v3/docs/html/17_intro/TODO b/libstdc++-v3/docs/html/17_intro/TODO deleted file mode 100644 index a0a257c4876..00000000000 --- a/libstdc++-v3/docs/html/17_intro/TODO +++ /dev/null @@ -1,164 +0,0 @@ -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/docs/html/17_intro/concept_check.diff b/libstdc++-v3/docs/html/17_intro/concept_check.diff deleted file mode 100644 index afb17f5efd6..00000000000 --- a/libstdc++-v3/docs/html/17_intro/concept_check.diff +++ /dev/null @@ -1,382 +0,0 @@ - -Changes made while bringing boost/concept_check.hpp to v3's concept_check.h: - -1) File format changed from DOS to Unix. -2) Boost config.hpp and other workaround files dropped (unneeded in g++ v3). -3) Conditionally-compiled code depending on those "breakage" macros was - removed, or not, depending on the macro, so that the macros themselves - are gone. Since the same code would always be compiled, let's make it - easier on the reader and a few milliseconds faster for cpplib. -4) Tests for NDEBUG were removed; if NDEBUG is defined, none of the checking - code will even be included. -5) BOOST_CLASS_REQUIRES* changed to accept a namespace parameter. -6) SameTypeConcept added (simple wrapper around existing code). -7) An unused variable in OutputIteratorConcept was removed. - -At checkin, this was the exact diff, modulo the end-of-line character changes: - - ---- concept_check.hpp.orig Sun Apr 1 08:59:46 2001 -+++ boost_concept_check.h Mon Apr 2 18:56:41 2001 -@@ -5,20 +5,15 @@ - // "as is" without express or implied warranty, and with no claim as - // to its suitability for any purpose. - // -+ -+// GCC Note: based on version 1.12.0 of the Boost library. - #ifndef BOOST_CONCEPT_CHECKS_HPP - #define BOOST_CONCEPT_CHECKS_HPP - --#include <boost/config.hpp> --#include <boost/iterator.hpp> --#include <boost/iterator.hpp> --#include <utility> --#include <boost/pending/limits.hpp> -- --#if (__GNUC__) || defined(__KCC) || defined(__ghs) || defined(__MWERKS__) --#define BOOST_FPTR & --#else --#define BOOST_FPTR --#endif -+#pragma GCC system_header -+#include <bits/stl_iterator_base_types.h> // for traits and tags -+#include <utility> // for pair<> -+ - - namespace boost { - -@@ -27,80 +22,64 @@ - template <class Concept> - void function_requires() - { --#if !defined(NDEBUG) -- void (Concept::*x)() = BOOST_FPTR Concept::constraints; -+ void (Concept::*x)() = &Concept::constraints; - ignore_unused_variable_warning(x); --#endif - } - --// The BOOST_CLASS_REQUIRES macros use function pointers as --// template parameters, which VC++ does not support. -- --#if defined(BOOST_NO_FUNCTION_PTR_TEMPLATE_PARAMETERS) -- --#define BOOST_CLASS_REQUIRES(type_var, concept) --#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) --#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) --#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) - --#else -- --#define BOOST_CLASS_REQUIRES(type_var, concept) \ -- typedef void (concept <type_var>::* func##type_var##concept)(); \ -+#define BOOST_CLASS_REQUIRES(type_var, ns, concept) \ -+ typedef void (ns::concept <type_var>::* func##type_var##concept)(); \ - template <func##type_var##concept _Tp1> \ - struct concept_checking_##type_var##concept { }; \ - typedef concept_checking_##type_var##concept< \ -- BOOST_FPTR concept <type_var>::constraints> \ -+ &ns::concept <type_var>::constraints> \ - concept_checking_typedef_##type_var##concept - --#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \ -- typedef void (concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \ -+#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, ns, concept) \ -+ typedef void (ns::concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \ - template <func##type_var1##type_var2##concept _Tp1> \ - struct concept_checking_##type_var1##type_var2##concept { }; \ - typedef concept_checking_##type_var1##type_var2##concept< \ -- BOOST_FPTR concept <type_var1,type_var2>::constraints> \ -+ &ns::concept <type_var1,type_var2>::constraints> \ - concept_checking_typedef_##type_var1##type_var2##concept - --#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \ -- typedef void (concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \ -+#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, ns, concept) \ -+ typedef void (ns::concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \ - template <func##type_var1##type_var2##type_var3##concept _Tp1> \ - struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \ - typedef concept_checking_##type_var1##type_var2##type_var3##concept< \ -- BOOST_FPTR concept <type_var1,type_var2,type_var3>::constraints> \ -+ &ns::concept <type_var1,type_var2,type_var3>::constraints> \ - concept_checking_typedef_##type_var1##type_var2##type_var3##concept - --#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \ -- typedef void (concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \ -+#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, ns, concept) \ -+ typedef void (ns::concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \ - template <func##type_var1##type_var2##type_var3##type_var4##concept _Tp1> \ - struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \ - typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \ -- BOOST_FPTR concept <type_var1,type_var2,type_var3,type_var4>::constraints> \ -+ &ns::concept <type_var1,type_var2,type_var3,type_var4>::constraints> \ - concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept - - --#endif -- --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <class T, class U> - struct require_same { }; - - template <class T> - struct require_same<T,T> { typedef T type; }; --#else --// This version does not perform checking, but will not do any harm. --template <class T, class U> --struct require_same { typedef T type; }; --#endif -+ -+ template <class T, class U> -+ struct SameTypeConcept -+ { -+ void constraints() { -+ typedef typename require_same<T, U>::type req; -+ } -+ }; - - template <class T> - struct IntegerConcept { - void constraints() { --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - errortype_must_be_an_integer_type(); --#endif - } - }; --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <> struct IntegerConcept<short> { void constraints() {} }; - template <> struct IntegerConcept<unsigned short> { void constraints() {} }; - template <> struct IntegerConcept<int> { void constraints() {} }; -@@ -108,32 +87,24 @@ - template <> struct IntegerConcept<long> { void constraints() {} }; - template <> struct IntegerConcept<unsigned long> { void constraints() {} }; - // etc. --#endif - - template <class T> - struct SignedIntegerConcept { - void constraints() { --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - errortype_must_be_a_signed_integer_type(); --#endif - } - }; --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <> struct SignedIntegerConcept<short> { void constraints() {} }; - template <> struct SignedIntegerConcept<int> { void constraints() {} }; - template <> struct SignedIntegerConcept<long> { void constraints() {} }; - // etc. --#endif - - template <class T> - struct UnsignedIntegerConcept { - void constraints() { --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - errortype_must_be_an_unsigned_integer_type(); --#endif - } - }; --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <> struct UnsignedIntegerConcept<unsigned short> - { void constraints() {} }; - template <> struct UnsignedIntegerConcept<unsigned int> -@@ -141,7 +112,6 @@ - template <> struct UnsignedIntegerConcept<unsigned long> - { void constraints() {} }; - // etc. --#endif - - //=========================================================================== - // Basic Concepts -@@ -159,15 +129,11 @@ - struct AssignableConcept - { - void constraints() { --#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL - a = a; // require assignment operator --#endif - const_constraints(a); - } - void const_constraints(const TT& b) { --#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL - a = b; // const required for argument to assignment --#endif - } - TT a; - }; -@@ -196,17 +162,13 @@ - { - void constraints() { - TT b(a); --#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL - a = a; // require assignment operator --#endif - const_constraints(a); - ignore_unused_variable_warning(b); - } - void const_constraints(const TT& b) { - TT c(b); --#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL - a = b; // const required for argument to assignment --#endif - ignore_unused_variable_warning(c); - } - TT a; -@@ -304,6 +266,9 @@ - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept); - -+#undef BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT -+#undef BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT -+ - //=========================================================================== - // Function Object Concepts - -@@ -318,7 +283,6 @@ - }; - - --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <class Func> - struct GeneratorConcept<Func,void> - { -@@ -327,7 +291,6 @@ - } - Func f; - }; --#endif - - template <class Func, class Return, class Arg> - struct UnaryFunctionConcept -@@ -340,7 +303,6 @@ - Return r; - }; - --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <class Func, class Arg> - struct UnaryFunctionConcept<Func, void, Arg> { - void constraints() { -@@ -348,7 +310,6 @@ - } - Func f; - }; --#endif - - template <class Func, class Return, class First, class Second> - struct BinaryFunctionConcept -@@ -362,7 +323,6 @@ - Return r; - }; - --#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template <class Func, class First, class Second> - struct BinaryFunctionConcept<Func, void, First, Second> - { -@@ -373,7 +333,6 @@ - First first; - Second second; - }; --#endif - - template <class Func, class Arg> - struct UnaryPredicateConcept -@@ -422,9 +381,7 @@ - function_requires< AssignableConcept<TT> >(); - function_requires< DefaultConstructibleConcept<TT> >(); - function_requires< EqualityComparableConcept<TT> >(); --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - typedef typename std::iterator_traits<TT>::value_type V; --#endif - (void)*i; // require dereference operator - } - TT i; -@@ -446,7 +403,6 @@ - void constraints() { - function_requires< TrivialIteratorConcept<TT> >(); - // require iterator_traits typedef's --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - typedef typename std::iterator_traits<TT>::difference_type D; - function_requires< SignedIntegerConcept<D> >(); - typedef typename std::iterator_traits<TT>::reference R; -@@ -455,7 +411,6 @@ - function_requires< ConvertibleConcept< - typename std::iterator_traits<TT>::iterator_category, - std::input_iterator_tag> >(); --#endif - ++i; // require preincrement operator - i++; // require postincrement operator - } -@@ -471,7 +426,7 @@ - i++; // require postincrement operator - *i++ = t; // require postincrement and assignment - } -- TT i, j; -+ TT i; - ValueT t; - }; - -@@ -480,14 +435,12 @@ - { - void constraints() { - function_requires< InputIteratorConcept<TT> >(); --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - function_requires< ConvertibleConcept< - typename std::iterator_traits<TT>::iterator_category, - std::forward_iterator_tag> >(); - typedef typename std::iterator_traits<TT>::reference reference; - reference r = *i; - ignore_unused_variable_warning(r); --#endif - } - TT i; - }; -@@ -507,11 +460,9 @@ - { - void constraints() { - function_requires< ForwardIteratorConcept<TT> >(); --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - function_requires< ConvertibleConcept< - typename std::iterator_traits<TT>::iterator_category, - std::bidirectional_iterator_tag> >(); --#endif - --i; // require predecrement operator - i--; // require postdecrement operator - } -@@ -536,12 +487,10 @@ - void constraints() { - function_requires< BidirectionalIteratorConcept<TT> >(); - function_requires< ComparableConcept<TT> >(); --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - function_requires< ConvertibleConcept< - typename std::iterator_traits<TT>::iterator_category, - std::random_access_iterator_tag> >(); - typedef typename std::iterator_traits<TT>::reference R; --#endif - - i += n; // require assignment addition operator - i = i + n; i = n + i; // require addition with difference type -@@ -552,11 +501,7 @@ - } - TT a, b; - TT i, j; --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - typename std::iterator_traits<TT>::difference_type n; --#else -- std::ptrdiff_t n; --#endif - }; - - template <class TT> -@@ -568,11 +513,7 @@ - i[n] = *i; // require element access and assignment - } - TT i; --#ifndef BOOST_NO_STD_ITERATOR_TRAITS - typename std::iterator_traits<TT>::difference_type n; --#else -- std::ptrdiff_t n; --#endif - }; - - //=========================================================================== - diff --git a/libstdc++-v3/docs/html/17_intro/confdeps.dot b/libstdc++-v3/docs/html/17_intro/confdeps.dot deleted file mode 100644 index a62d28ce9dd..00000000000 --- a/libstdc++-v3/docs/html/17_intro/confdeps.dot +++ /dev/null @@ -1,14 +0,0 @@ -# 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/docs/html/17_intro/confdeps.png b/libstdc++-v3/docs/html/17_intro/confdeps.png Binary files differdeleted file mode 100644 index 5075aa869b1..00000000000 --- a/libstdc++-v3/docs/html/17_intro/confdeps.png +++ /dev/null diff --git a/libstdc++-v3/docs/html/17_intro/configury.html b/libstdc++-v3/docs/html/17_intro/configury.html deleted file mode 100644 index 4b676f0405e..00000000000 --- a/libstdc++-v3/docs/html/17_intro/configury.html +++ /dev/null @@ -1,289 +0,0 @@ -<?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++-v3 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++-v3 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="#deps">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">general config notes</a></li> - <li><a href="#aclayout">acinclude.m4 layout</a></li> - <li><a href="#enable"><code>--enable</code> howto</a></li> -</ul> - -<hr /> -<h3><a name="deps">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 using a command sequence like - <code>"aclocal-1.7 && autoconf-2.59 && autoheader-2.59 - && automake-1.7"</code> as needed. And/or configure with - --enable-maintainer-mode. The version numbers will 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">general config notes</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">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"><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/docs/html/17_intro/contribute.html b/libstdc++-v3/docs/html/17_intro/contribute.html deleted file mode 100644 index 0013d604925..00000000000 --- a/libstdc++-v3/docs/html/17_intro/contribute.html +++ /dev/null @@ -1,132 +0,0 @@ -<?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 CVS 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_4.html#SEC4=> Legal Issues</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 CVS repository at - Cygnus, use "cvs update; cvs diff -c3p NEW"; else, use "diff -c3p OLD - NEW" ... If your version of diff does not support these options, then - get the latest version of GNU diff. </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/docs/html/17_intro/headers_cc.txt b/libstdc++-v3/docs/html/17_intro/headers_cc.txt deleted file mode 100644 index a0d926d71c5..00000000000 --- a/libstdc++-v3/docs/html/17_intro/headers_cc.txt +++ /dev/null @@ -1,83 +0,0 @@ -// 1999-05-12 bkoz - -// Copyright (C) 1999 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, -// USA. - -// 17.4.1.2 Headers - - -// "C++" headers -#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> - -// "C" headers -#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> - -// "C" headers that might not work if wchar_t support is disabled. -#include <bits/c++config.h> -#if _GLIBCXX_USE_WCHAR_T - #include <cwchar> - #include <cwctype> -#endif - -int main() { return 0; } diff --git a/libstdc++-v3/docs/html/17_intro/howto.html b/libstdc++-v3/docs/html/17_intro/howto.html deleted file mode 100644 index 631e58fe0b9..00000000000 --- a/libstdc++-v3/docs/html/17_intro/howto.html +++ /dev/null @@ -1,385 +0,0 @@ -<?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="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++-v3 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">The Standard C++ header files</a></li> - <li><a href="#3">The Standard C++ library and multithreading</a></li> - <li><a href="#4"><code><foo></code> vs <code><foo.h></code></a></li> - <li><a href="porting-howto.html">Porting HOWTO</a></li> - <li><a href="#5">Behavior specific to libstdc++-v3</a></li> - <li><a href="#6">Preprocessor macros controlling the library</a></li> -</ul> - -<hr /> - -<!-- ####################################################### --> - -<h2><a name="2">The Standard C++ header files</a></h2> - <p>The Standard C++ Library specifies 50 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 you <code>#include</code> a certain header, the - contents of that header, as defined by the Standard, become - available to you, no matter how. - </p> - <p>The names of the headers can be easily seen in - <a href="headers_cc.txt"><code>testsuite/17_intro/headers.cc</code></a>, - which is a small testbed we use to make certain that the headers - all compile and run. - </p> - -<hr /> -<h2><a name="3">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 - current as of the GCC 3.0 release and all later point 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#3">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++-v3 library (unlike libstdc++-v2, all of it, not - just the STL) has been designed so that multithreaded - applications using it may be written. 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. - </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="4"><code><foo></code> vs <code><foo.h></code></a></h2> - <p>The new-style headers are fully supported in libstdc++-v3. The compiler - itself fully supports namespaces, including <code>std::</code>. - </p> - <p>For those of you new to ISO C++98, no, that isn't a typo, 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>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++-v3</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++-v3 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> - -<hr /> -<h2><a name="6">Preprocessor macros controlling the library</a></h2> - <p>Some of the semantics of the libstdc++-v3 implementation are - controlled by preprocessor macros, both during build/installation and - during compilation of user code. Many of these choices are made when - the library is built and installed (actually, during - <a href="../configopts.html">the configuration step</a>, with the - various --enable/--disable choices being translated to #define/#undef). - </p> - <p>All library macros begin with <code>_GLIBCPP_</code> in earlier - versions, and <code>_GLIBCXX_</code> in later versions. The fact that - these symbols start with a leading underscore should give you a clue - that (by default) they aren't meant to be changed by the user. :-) - </p> - <p>These macros are all gathered in the file <code>c++config.h</code>, - which is generated during installation. <strong>You must assume that - these macros cannot be redefined by your own code</strong>, unless we - document otherwise here. Some of the choices control code which has - already been compiled (i.e., 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. - If you want to experiment with different values, you must change the - config headers before building/installing the library. - </p> - <p>Below are macros which, for 3.1 and later, you may change yourself, - in your own code with #define/#undef or with -D/-U compiler flags. - The default state of the symbol is listed. "Configurable" - (or "Not configurable") means that the symbol is initially - chosen (or not) based on --enable/--disable options at configure time. - For 3.1 through 3.3, the prefixes are <code>_GLIBCPP_</code>. - </p> - <dl> - <dt><code>_GLIBCXX_DEPRECATED</code></dt> - <dd>Undefined by default. Not configurable. Turning this on enables - older ARM-style iostreams code, and other anachronisms. This may be - useful in updating old C++ programs which no longer meet the - requirements of the language. - </dd> - <!-- - Can this actually be turned off and still produce a working lib? Must - check. -pme - No, it can't. Hmmm. -pme - <dt><code>_GLIBCPP_RESOLVE_LIB_DEFECTS</code></dt> - <dd>Defined by default. Not configurable. The library follows - corrections and updates from the ISO committee, see - <a href="../faq/index.html#5_2">here</a> and - <a href="../ext/howto.html#5">here</a> for more on this feature. - If you have code which depends on the first version of the standard, - you might try undefining this macro. - </dd> - --> - <dt><code>_GLIBCXX_CONCEPT_CHECKS</code></dt> - <dd>Undefined by default. Configurable. 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. Configurable. When defined, compiles - user code using the <a href="../debug.html#safe">libstdc++ debug - mode</a>. - </dd> - <dt><code>_GLIBCXX_DEBUG_PEDANTIC</code></dt> - <dd>Undefined by default. Configurable. When defined while - compiling with the <a href="../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></code></dt> - <dd> - </dd> - --> - </dl> - <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/docs/html/17_intro/license.html b/libstdc++-v3/docs/html/17_intro/license.html deleted file mode 100644 index 8dc0ebd711c..00000000000 --- a/libstdc++-v3/docs/html/17_intro/license.html +++ /dev/null @@ -1,119 +0,0 @@ -<?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">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">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/docs/html/17_intro/porting-howto.html b/libstdc++-v3/docs/html/17_intro/porting-howto.html deleted file mode 100644 index d6bedb271ed..00000000000 --- a/libstdc++-v3/docs/html/17_intro/porting-howto.html +++ /dev/null @@ -1,744 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd"> -<html> -<head> -<meta content="text/html; charset=ISO-8859-1" http-equiv="Content-Type"> -<title>Libstdc++-porting-howto</title> -<meta name="generator" content="DocBook XSL Stylesheets V1.48"> -</head> -<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article"> -<div class="titlepage"> -<div><h1 class="title"> -<a name="libstdc++-porting-howto"></a>Libstdc++-porting-howto</h1></div> -<div><h3 class="author">Felix Natter</h3></div> -<div><div class="legalnotice"> -<p class="legalnotice-title"><b>Legal Notice</b></p> -<p> - This document can be distributed under the FDL - (<a href="http://www.gnu.org" target="_top">www.gnu.org</a>) - </p> -</div></div> -<div><p class="pubdate">Tue Jun 5 20:07:49 2001</p></div> -<div><div class="revhistory"><table border="1" width="100%" summary="Revision history"> -<tr><th align="left" valign="top" colspan="3"><b>Revision History</b></th></tr> -<tr> -<td align="left">Revision 0.5</td> -<td align="left">Thu Jun 1 13:06:50 2000</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3">First docbook-version.</td></tr> -<tr> -<td align="left">Revision 0.8</td> -<td align="left">Sun Jul 30 20:28:40 2000</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3">First released version using docbook-xml - + second upload to libstdc++-page. - </td></tr> -<tr> -<td align="left">Revision 0.9</td> -<td align="left">Wed Sep 6 02:59:32 2000</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3">5 new sections.</td></tr> -<tr> -<td align="left">Revision 0.9.1</td> -<td align="left">Sat Sep 23 14:20:15 2000</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3">added information about why file-descriptors are not in the - standard</td></tr> -<tr> -<td align="left">Revision 0.9.2</td> -<td align="left">Tue Jun 5 20:07:49 2001</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3"> - a fix, added hint on increased portability of C-shadow-headers, - added autoconf-test HAVE_CONTAINER_AT - </td></tr> -<tr> -<td align="left">Revision 0.9.3</td> -<td align="left">Fri Jun 29 16:15:56 2001</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3"> - changed signature of nonstandard filebuf-constructor and - update the section on filebuf::attach to point to ../ext/howto.html, - added link to ../21/strings/howto.html - in sec-stringstream, changed <link>-tags to have content - (so that these links work), - replace "user-space" by "global namespace" - add note about gcc 3.0 and shadow-headers - add section about ostream::form and istream::scan - sec-vector-at: remove hint to modify headers - fix spelling error in sec-stringstream - </td></tr> -<tr> -<td align="left">Revision 0.9.4</td> -<td align="left">Mon Nov 5 17:01:04 2001</td> -<td align="left">fnatter</td> -</tr> -<tr><td align="left" colspan="3"> - rewrite section 1.1.3 because of gnu.gcc.help-post by - Juergen Heinzl - </td></tr> -</table></div></div> -<div><div class="abstract"> -<p><b>Abstract</b></p> -<p> - Some notes on porting applications from libstdc++-2.90 (or earlier - versions) to libstdc++-v3. Not speaking in terms of the GNU libstdc++ - implementations, this means porting from earlier versions of the - C++-Standard to ISO 14882. - </p> -</div></div> -<hr> -</div> -<div class="toc"> -<p><b>Table of Contents</b></p> -<dl> -<dt>1. <a href="#sec-nsstd">Namespace std::</a> -</dt> -<dd><dl> -<dt>1.1.1. <a href="#sec-gtkmm-hack">Using namespace - composition if the project uses a separate - namespace</a> -</dt> -<dt>1.1.2. <a href="#sec-emptyns">Defining an empty namespace std</a> -</dt> -<dt>1.1.3. <a href="#sec-avoidfqn">Avoid to use fully qualified names - (i.e. std::string)</a> -</dt> -<dt>1.1.4. <a href="#sec-osprojects">How some open-source-projects deal - with this</a> -</dt> -</dl></dd> -<dt>2. <a href="#sec-nocreate">There is no ios::nocreate/ios::noreplace - in ISO 14882</a> -</dt> -<dt>3. <a href="#sec-stream::attach">stream::attach(int - fd) is not in the standard any more</a> -</dt> -<dt>4. <a href="#sec-headers">The new headers</a> -</dt> -<dd><dl> -<dt>4.4.1. <a href="#sec-cheaders">New headers replacing C-headers</a> -</dt> -<dt>4.4.2. <a href="#sec-fstream-header"> - <fstream> does - not define std::cout, - std::cin etc.</a> -</dt> -</dl></dd> -<dt>5. <a href="#sec-iterators">Iterators</a> -</dt> -<dt>6. <a href="#sec-macros"> - Libc-macros (i.e. isspace from - <cctype>)</a> -</dt> -<dt>7. <a href="#sec-stream-state">State of streams</a> -</dt> -<dt>8. <a href="#sec-vector-at">vector::at is missing (i.e. gcc 2.95.x)</a> -</dt> -<dt>9. <a href="#sec-eof">Using std::char_traits<char>::eof()</a> -</dt> -<dt>10. <a href="#sec-string-clear">Using string::clear()/string::erase()</a> -</dt> -<dt>11. <a href="#sec-scan-form">GNU Extensions ostream::form and istream::scan</a> -</dt> -<dt>12. <a href="#sec-stringstream">Using stringstreams</a> -</dt> -<dt>13. <a href="#sec-about">About...</a> -</dt> -</dl> -</div> -<p> - In the following, when I say portable, I will refer to "portable among ISO - 14882-implementations". On the other hand, if I say "backportable" or - "conservative", I am talking about "compiles with older - libstdc++-implementations". - </p> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-nsstd"></a>Namespace std::</h2></div></div> -<p> - The latest C++-standard (ISO-14882) requires that the standard - C++-library is defined in namespace std::. Thus, in order to use - classes from the standard C++-library, you can do one of three - things: - <div class="itemizedlist"><ul type="disc"> -<li><p>wrap your code in <b>namespace std { - ... }</b> => This is not an option because only symbols - from the standard c++-library are defined in namespace std::. - </p></li> -<li><p>put a kind of - <span class="emphasis"><i>using-declaration</i></span> in your source (either - <b>using namespace std;</b> or i.e. <b>using - std::string;</b>) => works well for source-files, but - cannot be used in header-files. - </p></li> -<li><p>use a <span class="emphasis"><i>fully qualified name</i></span> for - each libstdc++-symbol (i.e. <b>std::string</b>, - <b>std::cout</b>) => can always be used - </p></li> -</ul></div> -<p> - Because there are many compilers which still use an implementation - that does not have the standard C++-library in namespace - <b>std::</b>, some care is required to support these as - well. - </p> -<p> - Namespace back-portability-issues are generally not a problem with - g++, because versions of g++ that do not have libstdc++ in - <b>std::</b> use <b>-fno-honor-std</b> - (ignore <b>std::</b>, <b>:: = std::</b>) by - default. That is, the responsibility for enabling or disabling - <b>std::</b> is on the user; the maintainer does not have - to care about it. This probably applies to some other compilers as - well. - </p> -<p> - The following sections list some possible solutions to support compilers - that cannot ignore std::. - </p> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-gtkmm-hack"></a>Using <span class="emphasis"><i>namespace - composition</i></span> if the project uses a separate - namespace</h3></div></div> -<p> - <a href="http://gtkmm.sourceforge.net" target="_top">Gtk--</a> defines - most of its classes in namespace Gtk::. Thus, it was possible to - adapt Gtk-- to namespace std:: by using a C++-feature called - <span class="emphasis"><i>namespace composition</i></span>. This is what happens if - you put a <span class="emphasis"><i>using</i></span>-declaration into a - namespace-definition: the imported symbol(s) gets imported into the - currently active namespace(s). For example: - <pre class="programlisting"> - namespace Gtk { - using std::string; - class Window { ... } - } - </pre> - In this example, <b>std::string</b> gets imported into - namespace Gtk::. The result is that you don't have to use - <b>std::string</b> in this header, but still - <b>std::string</b> does not get imported into - the global namespace (::) unless the user does - <b>using namespace Gtk;</b> (which is not recommended - practice for Gtk--, so it is not a problem). Additionally, the - <b>using</b>-declarations are wrapped in macros that - are set based on autoconf-tests to either "" or i.e. <b>using - std::string;</b> (depending on whether the system has - libstdc++ in <b>std::</b> 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>) -</div> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-emptyns"></a>Defining an empty namespace std</h3></div></div> -<p> - By defining an (empty) namespace <b>std::</b> before - using it, you avoid getting errors on systems where no part of the - library is in namespace std: - <pre class="programlisting"> - namespace std { } - using namespace std; - </pre> -</div> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-avoidfqn"></a>Avoid to use fully qualified names - (i.e. std::string)</h3></div></div> -<p> - If some compilers complain about <b>using - std::string;</b>, and if the "hack" for gtk-- mentioned above - does not work, then I see two solutions: - - <div class="itemizedlist"><ul type="disc"> -<li><p> - Define <b>std::</b> as a macro if the compiler - doesn't know about <b>std::</b>. - <pre class="programlisting"> - #ifdef OLD_COMPILER - #define std - #endif - </pre> - (thanks to Juergen Heinzl who posted this solution on - gnu.gcc.help) - </li> -<li><p> - Define a macro NS_STD, which is defined to - either "" or "std" - based on an autoconf-test. Then you should be able to use - <b>NS_STD::string</b>, which will evaluate to - <b>::string</b> ("string in the global namespace") on - systems that do not put string in std::. (This is untested) - </p></li> -</ul></div> -</div> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-osprojects"></a>How some open-source-projects deal - with this</h3></div></div> -<p> - This information was gathered around May 2000. It may not be correct - by the time you read this. - </p> -<div class="table"> -<p><b>Table 1. Namespace std:: in Open-Source programs</b></p> -<table summary="Namespace std:: in Open-Source programs" border="1"> -<colgroup> -<col> -<col> -</colgroup> -<tbody> -<tr> -<td><a href="http://www.clanlib.org" target="_top">clanlib</a></td> -<td>usual</td> -</tr> -<tr> -<td><a href="http://pingus.seul.org" target="_top">pingus</a></td> -<td>usual</td> -</tr> -<tr> -<td><a href="http://www.mozilla.org" target="_top">mozilla</a></td> -<td>usual</td> -</tr> -<tr> -<td><a href="http://libsigc.sourceforge.net" target="_top"> - libsigc++</a></td> -<td>conservative-impl</td> -</tr> -</tbody> -</table> -</div> -<div class="table"> -<p><b>Table 2. Notations for categories</b></p> -<table summary="Notations for categories" border="1"> -<colgroup> -<col> -<col> -</colgroup> -<tbody> -<tr> -<td>usual</td> -<td>mostly fully qualified names and some - using-declarations (but not in headers)</td> -</tr> -<tr> -<td>none</td> -<td>no namespace std at all</td> -</tr> -<tr> -<td>conservative-impl</td> -<td>wrap all - namespace-handling in macros to support compilers without - namespace-support (no libstdc++ used in headers)</td> -</tr> -</tbody> -</table> -</div> -<p> - As you can see, this currently lacks an example of a project - which uses libstdc++-symbols in headers in a back-portable way - (except for Gtk--: see the <a href="#sec-gtkmm-hack" title="Using namespace - composition if the project uses a separate - namespace">section on the gtkmm-hack</a>). - </p> -</div> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-nocreate"></a>There is no ios::nocreate/ios::noreplace - in ISO 14882</h2></div></div> -<p> - I have seen <b>ios::nocreate</b> being used for - input-streams, most probably because the author thought it would be - more correct to specify nocreate "explicitly". So you can simply - leave it out for input-streams. - </p> -<p> - For output streams, "nocreate" is probably the default, unless you - specify <b>std::ios::trunc</b> ? 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 <b>app</b>, - <b>ate</b> and <b>trunc</b> (except for - <b>app</b> ?). - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-stream::attach"></a><b>stream::attach(int - fd)</b> is not in the standard any more</h2></div></div> -<p> - Phil Edwards <tt><<a href="mailto:pedwards@disaster.jaj.com">pedwards@disaster.jaj.com</a>></tt> writes: - It was considered and rejected. 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 - <b>std::streambuf</b> (or - <b>std::basic_streambuf<..></b>) which opens a file - given a descriptor, and then pass an instance of this to the - stream-constructor. For an example of this, refer to - <a href="http://www.josuttis.com/cppcode/fdstream.html" target="_top">fdstream example</a> - by Nicolai Josuttis. - </p> - -<p> - An extension is also available: - <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> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-headers"></a>The new headers</h2></div></div> -<p> - All new headers can be seen in this <a href="headers_cc.txt" target="_top"> - source-code</a>. - </p> -<p> - The old C++-headers (iostream.h etc.) are available, but gcc generates - a warning that you are using deprecated headers. - </p> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-cheaders"></a>New headers replacing C-headers</h3></div></div> -<p> - You should not use the C-headers (except for system-level - headers) from C++ programs. Instead, you should use a set of - headers that are named by prepending 'c' and, as usual, - omitting the extension (.h). For example, instead of using - <tt><math.h></tt>, you - should use <tt><cmath></tt>. In some cases this has - the advantage that the C++-header is more standardized than - the C-header (i.e. <tt><ctime></tt> (almost) - corresponds to either <tt><time.h></tt> or <tt><sys/time.h></tt>). - - The standard specifies that if you include the C-style header - (<tt><math.h></tt> in - this case), the symbols will be available both in the global - namespace and in namespace <b>std::</b> (but - libstdc++ does not yet have fully compliant headers) On the - other hand, if you include only the new header (i.e. <tt><cmath></tt>), the symbols - will only be defined in namespace <b>std::</b> - (and macros will be converted to inline-functions). - </p> -<p> - For more information on this, and for information on how the - GNU C++ implementation might reuse ("shadow") the C - library-functions, have a look at <a href="http://www.cantrip.org/cheaders.html" target="_top"> - www.cantrip.org</a>. - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h3 class="title"> -<a name="sec-fstream-header"></a> - <tt><fstream></tt> does - not define <b>std::cout</b>, - <b>std::cin</b> etc.</h3></div></div> -<p> - In earlier versions of the standard, - <tt><fstream.h></tt>, - <tt><ostream.h></tt> - and <tt><istream.h></tt> - used to define - <b>cout</b>, <b>cin</b> and so on. Because - of the templatized iostreams in libstdc++-v3, you need to include - <tt><iostream></tt> - explicitly to define these. - </p> -</div> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-iterators"></a>Iterators</h2></div></div> -<p> - The following are not proper uses of iterators, but may be working - fixes for existing uses of iterators. - <div class="itemizedlist"><ul type="disc"> -<li><p>you cannot do - <b>ostream::operator<<(iterator)</b> to - print the address of the iterator => use - <b>operator<< &*iterator</b> instead ? - </p></li> -<li><p>you cannot clear an iterator's reference - (<b>iterator = 0</b>) => use - <b>iterator = iterator_type();</b> ? - </p></li> -<li><p> -<b>if (iterator)</b> won't work any - more => use <b>if (iterator != iterator_type())</b> - ?</p></li> -</ul></div> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-macros"></a> - Libc-macros (i.e. <b>isspace</b> from - <tt><cctype></tt>)</h2></div></div> -<p> - Glibc 2.0.x and 2.1.x define the - <tt><ctype.h></tt> - -functionality as macros (isspace, isalpha etc.). Libstdc++-v3 - "shadows" these macros as described in the <a href="#sec-cheaders" title="New headers replacing C-headers">section about - c-headers</a>. - </p> -<p> - Older implementations of libstdc++ (g++-2 for egcs 1.x and g++-3 - for gcc 2.95.x), however, keep these functions as macros, and so it - is not back-portable to use fully qualified names. For example: - <pre class="programlisting"> - #include <cctype> - int main() { std::isspace('X'); } - </pre> - will result in something like this (unless using g++-v3): - <pre class="programlisting"> - std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) - _ISspace ) ; - </pre> -<p> - One solution I can think of is to test for -v3 using - autoconf-macros, and define macros for each of the C-functions - (maybe that is possible with one "wrapper" macro as well ?). - </p> -<p> - Another solution which would fix g++ is to tell the user to modify a - header-file so that g++-2 (egcs 1.x) and g++-3 (gcc 2.95.x) define a - macro which tells <tt><ctype.h></tt> to define functions - instead of macros: - <pre class="programlisting"> - // This keeps isalnum, et al from being propagated as macros. - #if __linux__ - #define __NO_CTYPE 1 - #endif - - [ now include <ctype.h> ] - </pre> -<p> - Another problem arises if you put a <b>using namespace - std;</b> 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 <b>std::</b> - (<b><cctype></b>). - </p> -<p> - The solution to this problem was posted to the libstdc++-v3 - mailing-list: - Benjamin Kosnik <tt><<a href="mailto:bkoz@redhat.com">bkoz@redhat.com</a>></tt> writes: - ‘ - --enable-cshadow-headers is currently broken. As a result, shadow - headers are not being searched.... - ’ - This is now outdated, but gcc 3.0 still does not have fully - compliant "shadow headers". - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-stream-state"></a>State of streams</h2></div></div> -<p> - At least some older implementations don't have - <b>std::ios_base</b>, so you should use - <b>std::ios::badbit</b>, <b>std::ios::failbit</b> - and <b>std::ios::eofbit</b> and - <b>std::ios::goodbit</b>. - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-vector-at"></a>vector::at is missing (i.e. gcc 2.95.x)</h2></div></div> -<p> - One solution is to add an autoconf-test for this: - <pre class="programlisting"> - 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> - If you are using other (non-GNU) compilers it might be a good idea - to check for <b>string::at</b> separately. -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-eof"></a>Using std::char_traits<char>::eof()</h2></div></div> -<p> - <pre class="programlisting"> - #ifdef HAVE_CHAR_TRAITS - #define CPP_EOF std::char_traits<char>::eof() - #else - #define CPP_EOF EOF - #endif - </pre> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-string-clear"></a>Using string::clear()/string::erase()</h2></div></div> -<p> - There are two functions for deleting the contents of a string: - <b>clear</b> and <b>erase</b> (the latter - returns the string). - <pre class="programlisting"> - void - clear() { _M_mutate(0, this->size(), 0); } - </pre> - <pre class="programlisting"> - 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> - The implementation of <b>erase</b> seems to be more - complicated (from libstdc++-v3), but <b>clear</b> is not - implemented in gcc 2.95.x's libstdc++, so you should use - <b>erase</b> (which is probably faster than - <b>operator=(charT*)</b>). -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-scan-form"></a>GNU Extensions ostream::form and istream::scan</h2></div></div> -<p> - These are not supported any more - use - <a href="#sec-stringstream" title="Using stringstreams"> - stringstreams</a> instead. - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-stringstream"></a>Using stringstreams</h2></div></div> -<p> - Libstdc++-v3 provides the new - <b>i/ostringstream</b>-classes, (<tt><sstream></tt>), but for compatibility - with older implementations you still have to use - <b>i/ostrstream</b> (<tt><strstream></tt>): - <pre class="programlisting"> - #ifdef HAVE_SSTREAM - #include <sstream> - #else - #include <strstream> - #endif - </pre> - <div class="itemizedlist"><ul type="disc"> -<li><p> <b>strstream</b> is considered to be - deprecated - </p></li> -<li><p> <b>strstream</b> is limited to - <b>char</b> - </p></li> -<li><p> with <b>ostringstream</b> you don't - have to take care of terminating the string or freeing its - memory - </p></li> -<li><p> <b>istringstream</b> can be re-filled - (clear(); str(input);) - </p></li> -</ul></div> -<p> - You can then use output-stringstreams like this: - <pre class="programlisting"> - #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: - <pre class="programlisting"> - std::string input; - ... - #ifdef HAVE_SSTREAM - std::istringstream iss(input); - #else - std::istrstream iss(input.c_str()); - #endif - int i; - iss >> i; - </pre> - One (the only?) restriction is that an istrstream cannot be re-filled: - <pre class="programlisting"> - std::istringstream iss(numerator); - iss >> m_num; - // this is not possible with istrstream - iss.clear(); - iss.str(denominator); - iss >> m_den; - </pre> - If you don't care about speed, you can put these conversions in - a template-function: - <pre class="programlisting"> - 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> - Another example of using stringstreams is in <a href="../21_strings/howto.html" target="_top">this howto</a>. -<p> - I have read the Josuttis book on Standard C++, so some information - comes from there. Additionally, there is information in - "info iostream", which covers the old implementation that gcc 2.95.x - uses. - </p> -</div> -<div class="section"> -<div class="titlepage"><div><h2 class="title" style="clear: both"> -<a name="sec-about"></a>About...</h2></div></div> -<p> - Please send any experience, additions, corrections or questions to - <a href="mailto:fnatter@gmx.net" target="_top">fnatter@gmx.net</a> or for - discussion to the libstdc++-v3-mailing-list. - </p> -</div> -</div></body> -</html> diff --git a/libstdc++-v3/docs/html/17_intro/porting.html b/libstdc++-v3/docs/html/17_intro/porting.html deleted file mode 100644 index c280990c901..00000000000 --- a/libstdc++-v3/docs/html/17_intro/porting.html +++ /dev/null @@ -1,992 +0,0 @@ -<html lang="en"> -<head> -<title>Porting libstdc++-v3</title> -<meta http-equiv="Content-Type" content="text/html"> -<meta name="description" content="Porting libstdc++-v3"> -<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++-v3</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++-v3</h2> - -<p>This document explains how to port libstdc++-v3 (the GNU C++ library) to -a new target. - - <p>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. - - <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++-v3 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++-v3-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++-v3 -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++-v3 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++-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</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++-v3</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/docs/html/17_intro/porting.texi b/libstdc++-v3/docs/html/17_intro/porting.texi deleted file mode 100644 index 090bdf77155..00000000000 --- a/libstdc++-v3/docs/html/17_intro/porting.texi +++ /dev/null @@ -1,570 +0,0 @@ -\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 |
