Design

The following table provides the names and headers of all the parallel algorithms that can be used in a similar manner: -

Allocator (3.4)	Header (3.4)	Allocator (3.[0-3])	Header (3.[0-3])
`__gnu_cxx::new_allocator<T>`	`ext/new_allocator.h`	`std::__new_alloc`	`memory`
`__gnu_cxx::malloc_allocator<T>`	`ext/malloc_allocator.h`	`std::__malloc_alloc_template<int>`	`memory`
`__gnu_cxx::debug_allocator<T>`	`ext/debug_allocator.h`	`std::debug_alloc<T>`	`memory`
`__gnu_cxx::__pool_alloc<T>`	`ext/pool_allocator.h`	`std::__default_alloc_template<bool,int>`	`memory`
`__gnu_cxx::__mt_alloc<T>`	`ext/mt_allocator.h`
`__gnu_cxx::bitmap_allocator<T>`	`ext/bitmap_allocator.h`

Allocator (3.4)	Header (3.4)	Allocator (3.[0-3])	Header (3.[0-3])
`__gnu_cxx::new_allocator<T>`	`ext/new_allocator.h`	`std::__new_alloc`	`memory`
`__gnu_cxx::malloc_allocator<T>`	`ext/malloc_allocator.h`	`std::__malloc_alloc_template<int>`	`memory`
`__gnu_cxx::debug_allocator<T>`	`ext/debug_allocator.h`	`std::debug_alloc<T>`	`memory`
`__gnu_cxx::__pool_alloc<T>`	`ext/pool_allocator.h`	`std::__default_alloc_template<bool,int>`	`memory`
`__gnu_cxx::__mt_alloc<T>`	`ext/mt_allocator.h`
`__gnu_cxx::bitmap_allocator<T>`	`ext/bitmap_allocator.h`

Allocator	Include	Version
`__gnu_cxx::array_allocator<T>`	`ext/array_allocator.h`	4.0.0
`__gnu_cxx::throw_allocator<T>`	`ext/throw_allocator.h`	4.2.0

Allocator	Include	Version
`__gnu_cxx::array_allocator<T>`	`ext/array_allocator.h`	4.0.0
`__gnu_cxx::throw_allocator<T>`	`ext/throw_allocator.h`	4.2.0

Container	Header	Debug container	Debug header
`std::bitset`	`bitset`	`__gnu_debug::bitset`	`<debug/bitset>`
`std::deque`	`deque`	`__gnu_debug::deque`	`<debug/deque>`
`std::list`	`list`	`__gnu_debug::list`	`<debug/list>`
`std::map`	`map`	`__gnu_debug::map`	`<debug/map>`
`std::multimap`	`map`	`__gnu_debug::multimap`	`<debug/map>`
`std::multiset`	`set`	`__gnu_debug::multiset`	`<debug/set>`
`std::set`	`set`	`__gnu_debug::set`	`<debug/set>`
`std::string`	`string`	`__gnu_debug::string`	`<debug/string>`
`std::wstring`	`string`	`__gnu_debug::wstring`	`<debug/string>`
`std::basic_string`	`string`	`__gnu_debug::basic_string`	`<debug/string>`
`std::vector`	`vector`	`__gnu_debug::vector`	`<debug/vector>`

Container	Header	Debug container	Debug header
`std::bitset`	`bitset`	`__gnu_debug::bitset`	`<debug/bitset>`
`std::deque`	`deque`	`__gnu_debug::deque`	`<debug/deque>`
`std::list`	`list`	`__gnu_debug::list`	`<debug/list>`
`std::map`	`map`	`__gnu_debug::map`	`<debug/map>`
`std::multimap`	`map`	`__gnu_debug::multimap`	`<debug/map>`
`std::multiset`	`set`	`__gnu_debug::multiset`	`<debug/set>`
`std::set`	`set`	`__gnu_debug::set`	`<debug/set>`
`std::string`	`string`	`__gnu_debug::string`	`<debug/string>`
`std::wstring`	`string`	`__gnu_debug::wstring`	`<debug/string>`
`std::basic_string`	`string`	`__gnu_debug::basic_string`	`<debug/string>`
`std::vector`	`vector`	`__gnu_debug::vector`	`<debug/vector>`

Container	Header	Debug container	Debug header
`std::unordered_map`	`unordered_map`	`__gnu_debug::unordered_map`	`<debug/unordered_map>`
`std::unordered_multimap`	`unordered_map`	`__gnu_debug::unordered_multimap`	`<debug/unordered_map>`
`std::unordered_set`	`unordered_set`	`__gnu_debug::unordered_set`	`<debug/unordered_set>`
`std::unordered_multiset`	`unordered_set`	`__gnu_debug::unordered_multiset`	`<debug/unordered_set>`

Container	Header	Debug container	Debug header
`std::unordered_map`	`unordered_map`	`__gnu_debug::unordered_map`	`<debug/unordered_map>`
`std::unordered_multimap`	`unordered_map`	`__gnu_debug::unordered_multimap`	`<debug/unordered_map>`
`std::unordered_set`	`unordered_set`	`__gnu_debug::unordered_set`	`<debug/unordered_set>`
`std::unordered_multiset`	`unordered_set`	`__gnu_debug::unordered_multiset`	`<debug/unordered_set>`

Algorithm	Header	Parallel algorithm	Parallel header
`std::accumulate`	`numeric`	`__gnu_parallel::accumulate`	`parallel/numeric`
`std::adjacent_difference`	`numeric`	`__gnu_parallel::adjacent_difference`	`parallel/numeric`
`std::inner_product`	`numeric`	`__gnu_parallel::inner_product`	`parallel/numeric`
`std::partial_sum`	`numeric`	`__gnu_parallel::partial_sum`	`parallel/numeric`
`std::adjacent_find`	`algorithm`	`__gnu_parallel::adjacent_find`	`parallel/algorithm`
`std::count`	`algorithm`	`__gnu_parallel::count`	`parallel/algorithm`
`std::count_if`	`algorithm`	`__gnu_parallel::count_if`	`parallel/algorithm`
`std::equal`	`algorithm`	`__gnu_parallel::equal`	`parallel/algorithm`
`std::find`	`algorithm`	`__gnu_parallel::find`	`parallel/algorithm`
`std::find_if`	`algorithm`	`__gnu_parallel::find_if`	`parallel/algorithm`
`std::find_first_of`	`algorithm`	`__gnu_parallel::find_first_of`	`parallel/algorithm`
`std::for_each`	`algorithm`	`__gnu_parallel::for_each`	`parallel/algorithm`
`std::generate`	`algorithm`	`__gnu_parallel::generate`	`parallel/algorithm`
`std::generate_n`	`algorithm`	`__gnu_parallel::generate_n`	`parallel/algorithm`
`std::lexicographical_compare`	`algorithm`	`__gnu_parallel::lexicographical_compare`	`parallel/algorithm`
`std::mismatch`	`algorithm`	`__gnu_parallel::mismatch`	`parallel/algorithm`
`std::search`	`algorithm`	`__gnu_parallel::search`	`parallel/algorithm`
`std::search_n`	`algorithm`	`__gnu_parallel::search_n`	`parallel/algorithm`
`std::transform`	`algorithm`	`__gnu_parallel::transform`	`parallel/algorithm`
`std::replace`	`algorithm`	`__gnu_parallel::replace`	`parallel/algorithm`
`std::replace_if`	`algorithm`	`__gnu_parallel::replace_if`	`parallel/algorithm`
`std::max_element`	`algorithm`	`__gnu_parallel::max_element`	`parallel/algorithm`
`std::merge`	`algorithm`	`__gnu_parallel::merge`	`parallel/algorithm`
`std::min_element`	`algorithm`	`__gnu_parallel::min_element`	`parallel/algorithm`
`std::nth_element`	`algorithm`	`__gnu_parallel::nth_element`	`parallel/algorithm`
`std::partial_sort`	`algorithm`	`__gnu_parallel::partial_sort`	`parallel/algorithm`
`std::partition`	`algorithm`	`__gnu_parallel::partition`	`parallel/algorithm`
`std::random_shuffle`	`algorithm`	`__gnu_parallel::random_shuffle`	`parallel/algorithm`
`std::set_union`	`algorithm`	`__gnu_parallel::set_union`	`parallel/algorithm`
`std::set_intersection`	`algorithm`	`__gnu_parallel::set_intersection`	`parallel/algorithm`
`std::set_symmetric_difference`	`algorithm`	`__gnu_parallel::set_symmetric_difference`	`parallel/algorithm`
`std::set_difference`	`algorithm`	`__gnu_parallel::set_difference`	`parallel/algorithm`
`std::sort`	`algorithm`	`__gnu_parallel::sort`	`parallel/algorithm`
`std::stable_sort`	`algorithm`	`__gnu_parallel::stable_sort`	`parallel/algorithm`
`std::unique_copy`	`algorithm`	`__gnu_parallel::unique_copy`	`parallel/algorithm`

Algorithm	Header	Parallel algorithm	Parallel header
`std::accumulate`	`numeric`	`__gnu_parallel::accumulate`	`parallel/numeric`
`std::adjacent_difference`	`numeric`	`__gnu_parallel::adjacent_difference`	`parallel/numeric`
`std::inner_product`	`numeric`	`__gnu_parallel::inner_product`	`parallel/numeric`
`std::partial_sum`	`numeric`	`__gnu_parallel::partial_sum`	`parallel/numeric`
`std::adjacent_find`	`algorithm`	`__gnu_parallel::adjacent_find`	`parallel/algorithm`
`std::count`	`algorithm`	`__gnu_parallel::count`	`parallel/algorithm`
`std::count_if`	`algorithm`	`__gnu_parallel::count_if`	`parallel/algorithm`
`std::equal`	`algorithm`	`__gnu_parallel::equal`	`parallel/algorithm`
`std::find`	`algorithm`	`__gnu_parallel::find`	`parallel/algorithm`
`std::find_if`	`algorithm`	`__gnu_parallel::find_if`	`parallel/algorithm`
`std::find_first_of`	`algorithm`	`__gnu_parallel::find_first_of`	`parallel/algorithm`
`std::for_each`	`algorithm`	`__gnu_parallel::for_each`	`parallel/algorithm`
`std::generate`	`algorithm`	`__gnu_parallel::generate`	`parallel/algorithm`
`std::generate_n`	`algorithm`	`__gnu_parallel::generate_n`	`parallel/algorithm`
`std::lexicographical_compare`	`algorithm`	`__gnu_parallel::lexicographical_compare`	`parallel/algorithm`
`std::mismatch`	`algorithm`	`__gnu_parallel::mismatch`	`parallel/algorithm`
`std::search`	`algorithm`	`__gnu_parallel::search`	`parallel/algorithm`
`std::search_n`	`algorithm`	`__gnu_parallel::search_n`	`parallel/algorithm`
`std::transform`	`algorithm`	`__gnu_parallel::transform`	`parallel/algorithm`
`std::replace`	`algorithm`	`__gnu_parallel::replace`	`parallel/algorithm`
`std::replace_if`	`algorithm`	`__gnu_parallel::replace_if`	`parallel/algorithm`
`std::max_element`	`algorithm`	`__gnu_parallel::max_element`	`parallel/algorithm`
`std::merge`	`algorithm`	`__gnu_parallel::merge`	`parallel/algorithm`
`std::min_element`	`algorithm`	`__gnu_parallel::min_element`	`parallel/algorithm`
`std::nth_element`	`algorithm`	`__gnu_parallel::nth_element`	`parallel/algorithm`
`std::partial_sort`	`algorithm`	`__gnu_parallel::partial_sort`	`parallel/algorithm`
`std::partition`	`algorithm`	`__gnu_parallel::partition`	`parallel/algorithm`
`std::random_shuffle`	`algorithm`	`__gnu_parallel::random_shuffle`	`parallel/algorithm`
`std::set_union`	`algorithm`	`__gnu_parallel::set_union`	`parallel/algorithm`
`std::set_intersection`	`algorithm`	`__gnu_parallel::set_intersection`	`parallel/algorithm`
`std::set_symmetric_difference`	`algorithm`	`__gnu_parallel::set_symmetric_difference`	`parallel/algorithm`
`std::set_difference`	`algorithm`	`__gnu_parallel::set_difference`	`parallel/algorithm`
`std::sort`	`algorithm`	`__gnu_parallel::sort`	`parallel/algorithm`
`std::stable_sort`	`algorithm`	`__gnu_parallel::stable_sort`	`parallel/algorithm`
`std::unique_copy`	`algorithm`	`__gnu_parallel::unique_copy`	`parallel/algorithm`

Design
PrevÂ	ChapterÂ 19.Â Profile Mode	Â Next

Design

TableÂ 19.1.Â Profile Code Location

Code Location Use

libstdc++-v3/include/std/* Preprocessor code to redirect to profile extension headers.

libstdc++-v3/include/profile/* Profile extension public headers (map, vector, ...).

libstdc++-v3/include/profile/impl/*

Profile extension internals. Implementation files are +

TableÂ 19.1.Â Profile Code Location

Code Location	Use
`libstdc++-v3/include/std/*`	Preprocessor code to redirect to profile extension headers.
`libstdc++-v3/include/profile/*`	Profile extension public headers (map, vector, ...).
`libstdc++-v3/include/profile/impl/*`	Profile extension internals. Implementation files are only included from `impl/profiler.h`, which is the only file included from the public headers.

Wrapper Model

diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html index 78d11344be00..9dc6ab9ef5a1 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html @@ -18,7 +18,7 @@ A high accuracy means that the diagnostic is unlikely to be wrong. These grades are not perfect. They are just meant to guide users with specific needs or time budgets. -

TableÂ 19.2.Â Profile Diagnostics

Group Flag Benefit Cost Freq. Implemented Â

TableÂ 19.2.Â Profile Diagnostics

Group

Flag

Benefit

Cost

Freq.

Implemented

CONTAINERS

HASHTABLE_TOO_SMALL

yes

HASHTABLE_TOO_LARGE

yes

diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html index 84309ac46ba3..5ff81e6e0652 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html @@ -76,7 +76,7 @@ else return false.

Consider a block of size 64 ints. In memory, it would look like this: (assume a 32-bit system where, size_t is a 32-bit entity). -

TableÂ 21.1.Â Bitmap Allocator Memory Map

268

4294967295

Data -> Space for 64 ints

TableÂ 21.1.Â Bitmap Allocator Memory Map

268

4294967295

Data -> Space for 64 ints

The first Column(268) represents the size of the Block in bytes as seen by the Bitmap Allocator. Internally, a global free list is used to keep track of the free blocks used and given back by the diff --git a/libstdc++-v3/doc/html/manual/bk01pt03pr01.html b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html index e496d4da1f46..ac18c2dc0440 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03pr01.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html @@ -3,7 +3,7 @@


PrevÂ	PartÂ III.Â Extensions -	Â Next

Â Next

Here we will make an attempt at describing the non-Standard extensions to the library. Some of these are from older versions of standard library components, namely SGI's STL, and some of these are diff --git a/libstdc++-v3/doc/html/manual/bk01pt04.html b/libstdc++-v3/doc/html/manual/bk01pt04.html index 47c3875cc854..c9b70a160c87 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt04.html @@ -10,7 +10,7 @@

Contributor Checklist

Reading
Assignment
Getting Sources
Submitting Patches

Directory Layout and Source Conventions

Coding Style

Bad Identifiers
By Example

Design Notes

B. Porting and Maintenance -

Configure and Build Hacking

Prerequisites
Overview: What Comes from Where
Storing Information in non-AC files (like configure.host)
Coding and Commenting Conventions
The acinclude.m4 layout
GLIBCXX_ENABLE, the --enable maker

Writing and Generating Documentation

Introduction

Generating Documentation

Doxygen

Prerequisites
Generating the Doxygen Files
Markup

Docbook

Prerequisites
Generating the DocBook Files
Editing and Validation
File Organization and Basics
Markup By Example

Porting to New Hardware or Operating Systems

Operating System
CPU
Character Types
Thread Safety
Numeric Limits
Libtool

Test

Organization

Directory Layout
Naming Conventions

Running the Testsuite

Basic
Variations
Permutations

Writing a new test case

Test Harness and Utilities

Dejagnu Harness Details
Utilities

Special Topics

+

Configure and Build Hacking

Prerequisites

Overview

General Process
What Comes from Where

Configure

Storing Information in non-AC files (like configure.host)
Coding and Commenting Conventions
The acinclude.m4 layout
GLIBCXX_ENABLE, the --enable maker

Make

Writing and Generating Documentation

Introduction

Generating Documentation

Doxygen

Prerequisites
Generating the Doxygen Files
Markup

Docbook

Prerequisites
Generating the DocBook Files
Editing and Validation
File Organization and Basics
Markup By Example

Porting to New Hardware or Operating Systems

Operating System
CPU
Character Types
Thread Safety
Numeric Limits
Libtool

Test

Organization

Directory Layout
Naming Conventions

Running the Testsuite

Basic
Variations
Permutations

Writing a new test case

Test Harness and Utilities

Dejagnu Harness Details
Utilities

Special Topics

Qualifying Exception Safety Guarantees

Overview
diff --git a/libstdc++-v3/doc/html/manual/concurrency.html b/libstdc++-v3/doc/html/manual/concurrency.html index e743d3a3dc97..94d3709e16dc 100644 --- a/libstdc++-v3/doc/html/manual/concurrency.html +++ b/libstdc++-v3/doc/html/manual/concurrency.html @@ -7,7 +7,7 @@ Standard Contents

Â Next

ChapterÂ 15.Â Concurrency - +

Table of Contents

API Reference

Facilities for concurrent operation, and control thereof.

API Reference

diff --git a/libstdc++-v3/doc/html/manual/configure.html b/libstdc++-v3/doc/html/manual/configure.html index ec4e78ba7fcb..8dc3dfdecdf0 100644 --- a/libstdc++-v3/doc/html/manual/configure.html +++ b/libstdc++-v3/doc/html/manual/configure.html @@ -223,4 +223,4 @@ facilites, which might be undesirable in a low-memory environment or when standard error is not available. This option disables those messages. This option does not change the library ABI. -

PrevÂ	Up	Â Next
ChapterÂ 2.Â SetupÂ	Home	Â Make

PrevÂ	Up	Â Next
ChapterÂ 2.Â SetupÂ	Home	Â Make

diff --git a/libstdc++-v3/doc/html/manual/containers.html b/libstdc++-v3/doc/html/manual/containers.html index 859a3562c2e9..6ce7b3aea36f 100644 --- a/libstdc++-v3/doc/html/manual/containers.html +++ b/libstdc++-v3/doc/html/manual/containers.html @@ -7,7 +7,7 @@ Standard Contents

Â Next

ChapterÂ 9.Â Containers - +

Table of Contents

Sequences

list

list::size() is O(n)

vector

Space Overhead Management

Associative

Insertion Hints

bitset

Size Variable
Type String

Interacting with C

Containers vs. Arrays

Sequences

list

list::size() is O(n)

Yes it is, and that's okay. This is a decision that we preserved when we imported SGI's STL implementation. The following is diff --git a/libstdc++-v3/doc/html/manual/diagnostics.html b/libstdc++-v3/doc/html/manual/diagnostics.html index de8905043f5f..d14c9f97efdd 100644 --- a/libstdc++-v3/doc/html/manual/diagnostics.html +++ b/libstdc++-v3/doc/html/manual/diagnostics.html @@ -7,7 +7,7 @@ Standard Contents Â Next

ChapterÂ 5.Â Diagnostics - +

Table of Contents

Exceptions

API Reference
Adding Data to exception

Concept Checking

Exceptions

API Reference

All exception objects are defined in one of the standard header files: exception, diff --git a/libstdc++-v3/doc/html/manual/documentation_hacking.html b/libstdc++-v3/doc/html/manual/documentation_hacking.html index 825caa73a60c..0a4d5e18e1b1 100644 --- a/libstdc++-v3/doc/html/manual/documentation_hacking.html +++ b/libstdc++-v3/doc/html/manual/documentation_hacking.html @@ -117,7 +117,7 @@ supported, and are always aliased to dummy rules. These unsupported formats are: info, ps, and dvi. -

Doxygen

Prerequisites

TableÂ B.1.Â Doxygen Prerequisites

Tool	Version	Required By
coreutils	8.5	all
bash	4.1	all
doxygen	1.7.6.1	all
graphviz	2.26	graphical hierarchies
pdflatex	2007-59	pdf output

Doxygen

Prerequisites

TableÂ B.1.Â Doxygen Prerequisites

Tool	Version	Required By
coreutils	8.5	all
bash	4.1	all
doxygen	1.7.6.1	all
graphviz	2.26	graphical hierarchies
pdflatex	2007-59	pdf output

Prerequisite tools are Bash 2.0 or later, Doxygen, and the GNU @@ -271,7 +271,7 @@ writing Doxygen comments. Single and double quotes, and separators in filenames are two common trouble spots. When in doubt, consult the following table. -

TableÂ B.2.Â HTML to Doxygen Markup Comparison

HTML	Doxygen
\	\\
"	\"
'	\'
<i>	@a word
<b>	@b word
<code>	@c word
<em>	@a word
<em>	<em>two words or more</em>

Docbook

Prerequisites

TableÂ B.3.Â Docbook Prerequisites

Tool	Version	Required By
docbook5-style-xsl	1.76.1	all
xsltproc	1.1.26	all
xmllint	2.7.7	validation
dblatex	0.3	pdf output
pdflatex	2007-59	pdf output
docbook2X	0.8.8	info output
epub3 stylesheets	b3	epub output

TableÂ B.2.Â HTML to Doxygen Markup Comparison

HTML	Doxygen
\	\\
"	\"
'	\'
<i>	@a word
<b>	@b word
<code>	@c word
<em>	@a word
<em>	<em>two words or more</em>

Docbook

Prerequisites

TableÂ B.3.Â Docbook Prerequisites

Tool	Version	Required By
docbook5-style-xsl	1.76.1	all
xsltproc	1.1.26	all
xmllint	2.7.7	validation
dblatex	0.3	pdf output
pdflatex	2007-59	pdf output
docbook2X	0.8.8	info output
epub3 stylesheets	b3	epub output

Editing the DocBook sources requires an XML editor. Many exist: some notable options include emacs, Kate, @@ -429,11 +429,11 @@ make XSL_STYLE_DIR="/usr/share/xml/docbook/stylesheet/nwal online. An incomplete reference for HTML to Docbook conversion is detailed in the table below. -

TableÂ B.4.Â HTML to Docbook XML Markup Comparison
HTML Docbook
<p> <para>
<pre> <computeroutput>, <programlisting>,
+      
TableÂ B.4.Â HTML to Docbook XML Markup Comparison
HTML Docbook
<p> <para>
<pre> <computeroutput>, <programlisting>,
 	<literallayout>
<ul> <itemizedlist>
<ol> <orderedlist>
<il> <listitem>
<dl> <variablelist>
<dt> <term>
<dd> <listitem>
<a href=""> <ulink url="">
<code> <literal>, <programlisting>
<strong> <emphasis>
<em> <emphasis>
" <quote>


   And examples of detailed markup for which there are no real HTML
   equivalents are listed in the table below.
-
TableÂ B.5.Â Docbook XML Element Use
Element Use
<structname> <structname>char_traits</structname>
<classname> <classname>string</classname>
<function> 
+
TableÂ B.5.Â Docbook XML Element Use
Element Use
<structname> <structname>char_traits</structname>
<classname> <classname>string</classname>
<function> 
 	<function>clear()</function>
 	<function>fs.clear()</function>
       
<type> <type>long long</type>
<varname> <varname>fs</varname>
<literal> 
diff --git a/libstdc++-v3/doc/html/manual/extensions.html b/libstdc++-v3/doc/html/manual/extensions.html
index 57358738ebd3..ea00d9470b9c 100644
--- a/libstdc++-v3/doc/html/manual/extensions.html
+++ b/libstdc++-v3/doc/html/manual/extensions.html
@@ -5,7 +5,7 @@
   
 
PrevÂ  The GNU C++ Library Manual Â Next
PartÂ III.Â 
   Extensions
-  
+  
 
Table of Contents
16. Compile Time Checks
17. Debug Mode
Intro
Semantics
Using
Using the Debug Mode
Using a Specific Debug Container
Design
Goals
Methods
The Wrapper Model
Safe Iterators
Safe Sequences (Containers)
Precondition Checking
Release- and debug-mode coexistence
Compile-time coexistence of release- and debug-mode components
Link- and run-time coexistence of release- and
     debug-mode components
Alternatives for Coexistence
Other Implementations
18. Parallel Mode
Intro
Semantics
Using
Prerequisite Compiler Flags
Using Parallel Mode
Using Specific Parallel Components
Design
Interface Basics
Configuration and Tuning
Setting up the OpenMP Environment
Compile Time Switches
Run Time Settings and Defaults
Implementation Namespaces
Testing
Bibliography
19. Profile Mode
Intro
Using the Profile Mode
Tuning the Profile Mode
Design
Wrapper Model
Instrumentation
Run Time Behavior
Analysis and Diagnostics
Cost Model
Reports
Testing
Extensions for Custom Containers
Empirical Cost Model
Implementation Issues
Stack Traces
Symbolization of Instruction Addresses
Concurrency
Using the Standard Library in the Instrumentation Implementation
Malloc Hooks
Construction and Destruction of Global Objects
Developer Information
Big Picture
How To Add A Diagnostic
Diagnostics
Diagnostic Template
Containers
Hashtable Too Small
Hashtable Too Large
Inefficient Hash
Vector Too Small
Vector Too Large
Vector to Hashtable
Hashtable to Vector
Vector to List
List to Vector
List to Forward List (Slist)
Ordered to Unordered Associative Container
Algorithms
Sort Algorithm Performance
Data Locality
Need Software Prefetch
Linked Structure Locality
Multithreaded Data Access
Data Dependence Violations at Container Level
False Sharing
Statistics
Bibliography
20. The mt_allocator
Intro
Design Issues
Overview
Implementation
Tunable Parameters
Initialization
Deallocation Notes
Single Thread Example
Multiple Thread Example
21. The bitmap_allocator
Design
Implementation
Free List Store
Super Block
Super Block Data Layout
Maximum Wasted Percentage
allocate
deallocate
Questions
1
2
3
Locality
Overhead and Grow Policy
22. Policy-Based Data Structures
Intro
Performance Issues
Associative
Priority Que
Goals
Associative
Policy Choices
Underlying Data Structures
Iterators
Functional
Priority Queues
Policy Choices
Underlying Data Structures
Binary Heaps
Using
Prerequisites
Organization
Tutorial
Basic Use

 	    Configuring via Template Parameters
diff --git a/libstdc++-v3/doc/html/manual/facets.html b/libstdc++-v3/doc/html/manual/facets.html
index acf38fc4dccb..7eae8945b074 100644
--- a/libstdc++-v3/doc/html/manual/facets.html
+++ b/libstdc++-v3/doc/html/manual/facets.html
@@ -3,7 +3,7 @@
 FacetsFacets
PrevÂ  ChapterÂ 8.Â 
   Localization
   
- Â Next
Facets
ctype
Implementation
Specializations

+ Â Next
Facets
ctype
Implementation
Specializations

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

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

+     
Bibliography

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

+    . Roland McGrath. Ulrich Drepper. Copyright Â© 2007 FSF. Chapters 6  Character Set Handling and 7 Locales and Internationalization. 

       Correspondence
-    . Ulrich Drepper. Copyright Â© 2002 . 

+    . Ulrich Drepper. Copyright Â© 2002 . 

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

+    . Copyright Â© 1998 ISO. 

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

+    . Copyright Â© 1999 ISO. 

 	
 	The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004)
 	
       . Copyright Â© 1999 
-      The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. 

+      The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. 

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

+      . 

       Standard C++ IOStreams and Locales
     . 
       Advanced Programmer's Guide and Reference
@@ -410,42 +410,42 @@ codecvt usage.
       

       wchar_t/char internal buffers and conversions between
       internal/external buffers?
-      
Bibliography

+      
Bibliography

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

+    . 

       Correspondence
-    . Ulrich Drepper. Copyright Â© 2002 . 

+    . Ulrich Drepper. Copyright Â© 2002 . 

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

+    . Copyright Â© 1998 ISO. 

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

+    . Copyright Â© 1999 ISO. 

 	
       System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008)
 	
       . Copyright Â© 2008 
 	The Open Group/The Institute of Electrical and Electronics
 	Engineers, Inc.
-      . 

+      . 

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

+      . 

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

+      . 

 	
       A brief description of Normative Addendum 1
 	
-      . Clive Feather. Extended Character Sets. 

+      . Clive Feather. Extended Character Sets. 

 	
 	  The Unicode HOWTO
 	
-      . Bruno Haible. 

+      . Bruno Haible. 

 	
       UTF-8 and Unicode FAQ for Unix/Linux
 	
@@ -691,39 +691,39 @@ void test01()
    model. As of this writing, it is unknown how to query to see
    if a specified message catalog exists using the gettext
    package.
-   
Bibliography

+   
Bibliography

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

+    . 

       Correspondence
-    . Ulrich Drepper. Copyright Â© 2002 . 

+    . Ulrich Drepper. Copyright Â© 2002 . 

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

+    . Copyright Â© 1998 ISO. 

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

+    . Copyright Â© 1999 ISO. 

 	
       System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008)
 	
       . Copyright Â© 2008 
 	The Open Group/The Institute of Electrical and Electronics
 	Engineers, Inc.
-      . 

+      . 

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

+      . 

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

+      . 

 	
 	API Specifications, Java Platform
 	
       . java.util.Properties, java.text.MessageFormat,
 java.util.Locale, java.util.ResourceBundle
-    . 

+    . 

 	
       GNU gettext tools, version 0.10.38, Native Language Support
       Library and Tools.
diff --git a/libstdc++-v3/doc/html/manual/index.html b/libstdc++-v3/doc/html/manual/index.html
index c181dde73028..4edc5498b7c7 100644
--- a/libstdc++-v3/doc/html/manual/index.html
+++ b/libstdc++-v3/doc/html/manual/index.html
@@ -16,13 +16,13 @@
 
Exceptions
API Reference
Adding Data to exception
Concept Checking
6. 
   Utilities
   
-
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. 
+
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
7. 
   Strings
   
 
String Classes
Simple Transformations
Case Sensitivity
Arbitrary Character Types
Tokenizing
Shrink to Fit
CString (MFC)
8. 
   Localization
   
-
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. 
+
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
9. 
   Containers
   
 
Sequences
list
list::size() is O(n)
vector
Space Overhead Management
Associative
Insertion Hints
bitset
Size Variable
Type String
Interacting with C
Containers vs. Arrays
10. 
@@ -119,7 +119,7 @@
 
Contributor Checklist
Reading
Assignment
Getting Sources
Submitting Patches
Directory Layout and Source Conventions
Coding Style
Bad Identifiers
By Example
Design Notes
B. 
   Porting and Maintenance
   
-
Configure and Build Hacking
Prerequisites
Overview: What Comes from Where
Storing Information in non-AC files (like configure.host)
Coding and Commenting Conventions
The acinclude.m4 layout
GLIBCXX_ENABLE, the --enable maker
Writing and Generating Documentation
Introduction
Generating Documentation
Doxygen
Prerequisites
Generating the Doxygen Files
Markup
Docbook
Prerequisites
Generating the DocBook Files
Editing and Validation
File Organization and Basics
Markup By Example
Porting to New Hardware or Operating Systems
Operating System
CPU
Character Types
Thread Safety
Numeric Limits
Libtool
Test
Organization
Directory Layout
Naming Conventions
Running the Testsuite
Basic
Variations
Permutations
Writing a new test case
Test Harness and Utilities
Dejagnu Harness Details
Utilities
Special Topics

+
Configure and Build Hacking
Prerequisites
Overview
General Process
What Comes from Where
Configure
Storing Information in non-AC files (like configure.host)
Coding and Commenting Conventions
The acinclude.m4 layout
GLIBCXX_ENABLE, the --enable maker
Make
Writing and Generating Documentation
Introduction
Generating Documentation
Doxygen
Prerequisites
Generating the Doxygen Files
Markup
Docbook
Prerequisites
Generating the DocBook Files
Editing and Validation
File Organization and Basics
Markup By Example
Porting to New Hardware or Operating Systems
Operating System
CPU
Character Types
Thread Safety
Numeric Limits
Libtool
Test
Organization
Directory Layout
Naming Conventions
Running the Testsuite
Basic
Variations
Permutations
Writing a new test case
Test Harness and Utilities
Dejagnu Harness Details
Utilities
Special Topics

   Qualifying Exception Safety Guarantees
   
 
Overview

@@ -146,19 +146,19 @@ Support for C++11 dialect.
   
 
D. 
     GNU General Public License version 3
-  
E. GNU Free Documentation License
List of Figures
22.1. Node Invariants
22.2. Underlying Associative Data Structures
22.3. Range Iteration in Different Data Structures
22.4. Point Iteration in Hash Data Structures
22.5. Effect of erase in different underlying data structures
22.6. Underlying Priority Queue Data Structures
22.7. Exception Hierarchy
22.8. Non-unique Mapping Standard Containers
22.9. 
+  
E. GNU Free Documentation License
List of Figures
22.1. Node Invariants
22.2. Underlying Associative Data Structures
22.3. Range Iteration in Different Data Structures
22.4. Point Iteration in Hash Data Structures
22.5. Effect of erase in different underlying data structures
22.6. Underlying Priority Queue Data Structures
22.7. Exception Hierarchy
22.8. Non-unique Mapping Standard Containers
22.9. 
 	    Effect of embedded lists in
 	    std::multimap
-	  
22.10. Non-unique Mapping Containers
22.11. Point Iterator Hierarchy
22.12. Invalidation Guarantee Tags Hierarchy
22.13. Container Tag Hierarchy
22.14. Hash functions, ranged-hash functions, and
-	      range-hashing functions
22.15. Insert hash sequence diagram
22.16. Insert hash sequence diagram with a null policy
22.17. Hash policy class diagram
22.18. Balls and bins
22.19. Insert resize sequence diagram
22.20. Standard resize policy trigger sequence
-		diagram
22.21. Standard resize policy size sequence
-		diagram
22.22. Tree node invariants
22.23. Tree node invalidation
22.24. A tree and its update policy
22.25. Restoring node invariants
22.26. Insert update sequence
22.27. Useless update path
22.28. A PATRICIA trie
22.29. A trie and its update policy
22.30. A simple list
22.31. The counter algorithm
22.32. Underlying Priority-Queue Data-Structures.
22.33. Priority-Queue Data-Structure Tags.
B.1. Configure and Build File Dependencies
List of Tables
1.1. C++ 1998/2003 Implementation Status
1.2. C++ 2011 Implementation Status
1.3. C++ TR1 Implementation Status
1.4. C++ TR 24733 Implementation Status
3.1. C++ Command Options
3.2. C++ 1998 Library Headers
3.3. C++ 1998 Library Headers for C Library Facilities
3.4. C++ 2011 Library Headers
3.5. C++ 2011 Library Headers for C Library Facilities
3.6. C++ TR 1 Library Headers
3.7. C++ TR 1 Library Headers for C Library Facilities
3.8. C++ TR 24733 Decimal Floating-Point Header
3.9. C++ ABI Headers
3.10. Extension Headers
3.11. Extension Debug Headers
3.12. Extension Profile Headers
3.13. Extension Parallel Headers
17.1. Debugging Containers
17.2. Debugging Containers C++11
18.1. Parallel Algorithms
19.1. Profile Code Location
19.2. Profile Diagnostics
21.1. Bitmap Allocator Memory Map
B.1. Doxygen Prerequisites
B.2. HTML to Doxygen Markup Comparison
B.3. Docbook Prerequisites
B.4. HTML to Docbook XML Markup Comparison
B.5. Docbook XML Element Use
B.6. Extension Allocators
B.7. Extension Allocators Continued
List of Equations
22.1. Ranged Hash Function
22.2. Range-Hashing, Division Method
22.3. Division via Prime Modulo
22.4. Division via Bit Mask
22.5. 
+	  
22.10. Non-unique Mapping Containers
22.11. Point Iterator Hierarchy
22.12. Invalidation Guarantee Tags Hierarchy
22.13. Container Tag Hierarchy
22.14. Hash functions, ranged-hash functions, and
+	      range-hashing functions
22.15. Insert hash sequence diagram
22.16. Insert hash sequence diagram with a null policy
22.17. Hash policy class diagram
22.18. Balls and bins
22.19. Insert resize sequence diagram
22.20. Standard resize policy trigger sequence
+		diagram
22.21. Standard resize policy size sequence
+		diagram
22.22. Tree node invariants
22.23. Tree node invalidation
22.24. A tree and its update policy
22.25. Restoring node invariants
22.26. Insert update sequence
22.27. Useless update path
22.28. A PATRICIA trie
22.29. A trie and its update policy
22.30. A simple list
22.31. The counter algorithm
22.32. Underlying Priority-Queue Data-Structures.
22.33. Priority-Queue Data-Structure Tags.
B.1. Configure and Build File Dependencies
List of Tables
1.1. C++ 1998/2003 Implementation Status
1.2. C++ 2011 Implementation Status
1.3. C++ TR1 Implementation Status
1.4. C++ TR 24733 Implementation Status
3.1. C++ Command Options
3.2. C++ 1998 Library Headers
3.3. C++ 1998 Library Headers for C Library Facilities
3.4. C++ 2011 Library Headers
3.5. C++ 2011 Library Headers for C Library Facilities
3.6. C++ TR 1 Library Headers
3.7. C++ TR 1 Library Headers for C Library Facilities
3.8. C++ TR 24733 Decimal Floating-Point Header
3.9. C++ ABI Headers
3.10. Extension Headers
3.11. Extension Debug Headers
3.12. Extension Profile Headers
3.13. Extension Parallel Headers
17.1. Debugging Containers
17.2. Debugging Containers C++11
18.1. Parallel Algorithms
19.1. Profile Code Location
19.2. Profile Diagnostics
21.1. Bitmap Allocator Memory Map
B.1. Doxygen Prerequisites
B.2. HTML to Doxygen Markup Comparison
B.3. Docbook Prerequisites
B.4. HTML to Docbook XML Markup Comparison
B.5. Docbook XML Element Use
B.6. Extension Allocators
B.7. Extension Allocators Continued
List of Equations
22.1. Ranged Hash Function
22.2. Range-Hashing, Division Method
22.3. Division via Prime Modulo
22.4. Division via Bit Mask
22.5. 
 		A Standard String Hash Function
-	      
22.6. 
+	      
22.6. 
 		Only k String DNA Hash
-	      
22.7. 
+	      
22.7. 
 		Probability of Probe Sequence of Length k
-	      
22.8. 
+	      
22.8. 
 		Probability Probe Sequence in Some Bin
 	      
PrevÂ  Â  Â Next
The GNU C++ LibraryÂ  Home Â PartÂ I.Â 
   Introduction
diff --git a/libstdc++-v3/doc/html/manual/intro.html b/libstdc++-v3/doc/html/manual/intro.html
index 9951bb47a171..45821b5c1d94 100644
--- a/libstdc++-v3/doc/html/manual/intro.html
+++ b/libstdc++-v3/doc/html/manual/intro.html
@@ -5,5 +5,5 @@
   
 
PrevÂ  The GNU C++ Library Manual Â Next
PartÂ I.Â 
   Introduction
-  
+  
 
Table of Contents
1. Status
Implementation Status
C++ 1998/2003
Implementation Status
Implementation Specific Behavior
C++ 2011
Implementation Specific Behavior
C++ TR1
Implementation Specific Behavior
C++ TR 24733
License
The Code: GPL
The Documentation: GPL, FDL
Bugs
Implementation Bugs
Standard Bugs
2. Setup
Prerequisites
Configure
Make
3. Using
Command Options
Headers
Header Files
Mixing Headers
The C Headers and namespace std
Precompiled Headers
Macros
Namespaces
Available Namespaces
namespace std
Using Namespace Composition
Linking
Almost Nothing
Finding Dynamic or Shared Libraries
Concurrency
Prerequisites
Thread Safety
Atomics
IO
Structure
Defaults
Future
Alternatives
Containers
Exceptions
Exception Safety
Exception Neutrality
Doing without
Compatibility
With C
With POSIX thread cancellation
Debugging Support
Using g++
Debug Versions of Library Binary Files
Memory Leak Hunting
Data Race Hunting
Using gdb
Tracking uncaught exceptions
Debug Mode
Compile Time Checking
Profile-based Performance Analysis
PrevÂ  Up Â Next
The GNU C++ Library ManualÂ  Home Â ChapterÂ 1.Â Status

diff --git a/libstdc++-v3/doc/html/manual/io.html b/libstdc++-v3/doc/html/manual/io.html
index f12a80077aef..2ebe126fb0c7 100644
--- a/libstdc++-v3/doc/html/manual/io.html
+++ b/libstdc++-v3/doc/html/manual/io.html
@@ -7,7 +7,7 @@
     Standard Contents
   Â Next
ChapterÂ 13.Â 
   Input and Output
-  
+  
 
Table of Contents
Iostream Objects
Stream Buffers
Derived streambuf Classes
Buffering
Memory Based Streams
Compatibility With strstream
File Based Streams
Copying a File
Binary Input and Output
Interacting with C
Using FILE* and file descriptors
Performance
Iostream Objects
To minimize the time you have to wait on the compiler, it's good to
       only include the headers you really need.  Many people simply include
       <iostream> when they don't need to -- and that can penalize
diff --git a/libstdc++-v3/doc/html/manual/iterators.html b/libstdc++-v3/doc/html/manual/iterators.html
index dcd9a92ead8a..23a899248f74 100644
--- a/libstdc++-v3/doc/html/manual/iterators.html
+++ b/libstdc++-v3/doc/html/manual/iterators.html
@@ -7,7 +7,7 @@
     Standard Contents
   Â Next
ChapterÂ 10.Â 
   Iterators
-  
+  
 
Table of Contents
Predefined
Iterators vs. Pointers
One Past the End
Predefined
Iterators vs. Pointers

      The following
 FAQ entry points out that
diff --git a/libstdc++-v3/doc/html/manual/localization.html b/libstdc++-v3/doc/html/manual/localization.html
index 8a2fa1e7dd30..1e85be7701f6 100644
--- a/libstdc++-v3/doc/html/manual/localization.html
+++ b/libstdc++-v3/doc/html/manual/localization.html
@@ -7,8 +7,8 @@
     Standard Contents
   Â Next
ChapterÂ 8.Â 
   Localization
-  
-
Table of Contents
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
Locales
locale

+  
+
Table of Contents
Locales
locale
Requirements
Design
Implementation
Interacting with "C" locales
Future
Facets
ctype
Implementation
Specializations
Future
codecvt
Requirements
Design
wchar_t Size
Support for Unicode
Other Issues
Implementation
Use
Future
messages
Requirements
Design
Implementation
Models
The GNU Model
Use
Future
Locales
locale

 Describes the basic locale object, including nested
 classes id, facet, and the reference-counted implementation object,
 class _Impl.
@@ -403,29 +403,29 @@ global locale" (emphasis Paolo), that is:
        What should non-required facet instantiations do?  If the
        generic implementation is provided, then how to end-users
        provide specializations?
-   
Bibliography

+   
Bibliography

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

+    . 

       Correspondence
-    . Ulrich Drepper. Copyright Â© 2002 . 

+    . Ulrich Drepper. Copyright Â© 2002 . 

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

+    . Copyright Â© 1998 ISO. 

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

+    . Copyright Â© 1999 ISO. 

 	
       System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008)
 	
       . Copyright Â© 2008 
 	The Open Group/The Institute of Electrical and Electronics
 	Engineers, Inc.
-      . 

+      . 

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

+      . 

       Standard C++ IOStreams and Locales
     . 
       Advanced Programmer's Guide and Reference
diff --git a/libstdc++-v3/doc/html/manual/memory.html b/libstdc++-v3/doc/html/manual/memory.html
index b097e5ff65f7..d906c212b209 100644
--- a/libstdc++-v3/doc/html/manual/memory.html
+++ b/libstdc++-v3/doc/html/manual/memory.html
@@ -93,7 +93,7 @@
     or loading and unloading shared objects in memory. As such, using
     caching allocators on systems that do not support
     abi::__cxa_atexit is not recommended.
-  
Implementation
Interface Design

+  
Implementation
Interface Design

      The only allocator interface that
      is supported is the standard C++ interface. As such, all STL
      containers have been adjusted, and all external allocators have
@@ -106,7 +106,7 @@
    

      The base class that allocator is derived from
      may not be user-configurable.
-
Selecting Default Allocation Policy

+
Selecting Default Allocation Policy

      It's difficult to pick an allocation strategy that will provide
    maximum utility, without excessively penalizing some behavior. In
    fact, it's difficult just deciding which typical actions to measure
@@ -143,7 +143,7 @@
      The current default choice for
      allocator is
      __gnu_cxx::new_allocator.
-   
Disabling Memory Caching

+   
Disabling Memory Caching

       In use, allocator may allocate and
       deallocate using implementation-specific strategies and
       heuristics. Because of this, a given call to an allocator object's
@@ -310,33 +310,33 @@
 	 of the used and unused memory locations. It has its own
 	 chapter
          in the documentation.
-       
Bibliography

+       
Bibliography

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

+    20.4 Memory. 

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

+      . 

 	
       The Hoard Memory Allocator
 	
-      . Emery Berger. 

+      . Emery Berger. 

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

+      . Emery Berger. Ben Zorn. Kathryn McKinley. Copyright Â© 2002 OOPSLA. 

 	
       Allocator Types
 	
       . Klaus Kreft. Angelika Langer. 
 	C/C++ Users Journal
-      . 
The C++ Programming Language. Bjarne Stroustrup. Copyright Â© 2000 . 19.4 Allocators. 
+      . 
The C++ Programming Language. Bjarne Stroustrup. Copyright Â© 2000 . 19.4 Allocators. 
 	Addison Wesley
-      . 
Yalloc: A Recycling C++ Allocator. Felix Yen. 
auto_ptr
Limitations
Explaining all of the fun and delicious things that can
+      . 
Yalloc: A Recycling C++ Allocator. Felix Yen. 
auto_ptr
Limitations
Explaining all of the fun and delicious things that can
    happen with misuse of the auto_ptr class
    template (called AP here) would take some
    time. Suffice it to say that the use of AP
@@ -446,7 +446,7 @@ drops to zero.
 Derived classes override those functions to destroy resources in a context
 where the correct dynamic type is known. This is an application of the
 technique known as type erasure.
-  
Implementation
Class Hierarchy

+  
Implementation
Class Hierarchy

 A shared_ptr<T> contains a pointer of
 type T* and an object of type
 __shared_count. The shared_count contains a
@@ -493,7 +493,7 @@ C++11-only features are: rvalue-ref/move support, allocator support,
 aliasing constructor, make_shared & allocate_shared. Additionally,
 the constructors taking auto_ptr parameters are
 deprecated in C++11 mode.
-    
Thread Safety

+    
Thread Safety

 The
 Thread
 Safety section of the Boost shared_ptr documentation says "shared_ptr
@@ -538,7 +538,7 @@ compiler, standard library, platform etc. For the version of
 shared_ptr in libstdc++ the compiler and library are fixed, which
 makes things much simpler: we have an atomic CAS or we don't, see Lock
 Policy below for details.
-
Selecting Lock Policy

+
Selecting Lock Policy

     

 There is a single _Sp_counted_base class,
 which is a template parameterized on the enum
@@ -579,7 +579,7 @@ used when libstdc++ is built without --enable-threadsext/atomicity.h, which detect if the program
        is multi-threaded.  If only one thread of execution exists in
        the program then less expensive non-atomic operations are used.
-     
Related functions and classes
dynamic_pointer_cast, static_pointer_cast,
+     
Related functions and classes
dynamic_pointer_cast, static_pointer_cast,
 const_pointer_cast

 As noted in N2351, these functions can be implemented non-intrusively using
 the alias constructor.  However the aliasing constructor is only available
@@ -612,13 +612,13 @@ is called.  Users should not try to use this.
 As well as the extra constructors, this implementation also needs some
 members of _Sp_counted_deleter to be protected where they could otherwise
 be private.
-    
Use
Examples

+    
Use
Examples

       Examples of use can be found in the testsuite, under
       testsuite/tr1/2_general_utilities/shared_ptr,
       testsuite/20_util/shared_ptr
       and
       testsuite/20_util/weak_ptr.
-    
Unresolved Issues

+    
Unresolved Issues

       The shared_ptr atomic access
       clause in the C++11 standard is not implemented in GCC.
     

@@ -659,25 +659,25 @@ be private.
     code to work with, Peter Dimov in particular for his help and
     invaluable advice on thread safety.  Phillip Jordan and Paolo
     Carlini for the lock policy implementation.
-  
Bibliography

+  
Bibliography

 	
       Improving shared_ptr for C++0x, Revision 2
 	
       . 
       N2351
-    . 

+    . 

 	
       C++ Standard Library Active Issues List
 	
       . 
       N2456
-    . 

+    . 

 	
       Working Draft, Standard for Programming Language C++
 	
       . 
       N2461
-    . 

+    . 

 	
       Boost C++ Libraries documentation, shared_ptr
 	
diff --git a/libstdc++-v3/doc/html/manual/numerics.html b/libstdc++-v3/doc/html/manual/numerics.html
index c7076fd05725..e0d51a621e1d 100644
--- a/libstdc++-v3/doc/html/manual/numerics.html
+++ b/libstdc++-v3/doc/html/manual/numerics.html
@@ -7,7 +7,7 @@
     Standard Contents
   Â Next
ChapterÂ 12.Â 
   Numerics
-  
+  
 
Table of Contents
Complex
complex Processing
Generalized Operations
Interacting with C
Numerics vs. Arrays
C99
Complex

   
complex Processing

     
Using complex<> becomes even more comple- er, sorry,
diff --git a/libstdc++-v3/doc/html/manual/parallel_mode.html b/libstdc++-v3/doc/html/manual/parallel_mode.html
index 65ad01ffd0a5..9f432afc13ce 100644
--- a/libstdc++-v3/doc/html/manual/parallel_mode.html
+++ b/libstdc++-v3/doc/html/manual/parallel_mode.html
@@ -13,11 +13,11 @@ explicit source declaration or by compiling existing sources with a
 specific compiler flag.
 
Intro
The following library components in the include
 numeric are included in the parallel mode:
std::accumulate
std::adjacent_difference
std::inner_product
std::partial_sum
The following library components in the include
-algorithm are included in the parallel mode:
std::adjacent_find
std::count
std::count_if
std::equal
std::find
std::find_if
std::find_first_of
std::for_each
std::generate
std::generate_n
std::lexicographical_compare
std::mismatch
std::search
std::search_n
std::transform
std::replace
std::replace_if
std::max_element
std::merge
std::min_element
std::nth_element
std::partial_sort
std::partition
std::random_shuffle
std::set_union
std::set_intersection
std::set_symmetric_difference
std::set_difference
std::sort
std::stable_sort
std::unique_copy
Bibliography

+algorithm are included in the parallel mode:
std::adjacent_find
std::count
std::count_if
std::equal
std::find
std::find_if
std::find_first_of
std::for_each
std::generate
std::generate_n
std::lexicographical_compare
std::mismatch
std::search
std::search_n
std::transform
std::replace
std::replace_if
std::max_element
std::merge
std::min_element
std::nth_element
std::partial_sort
std::partition
std::random_shuffle
std::set_union
std::set_intersection
std::set_symmetric_difference
std::set_difference
std::sort
std::stable_sort
std::unique_copy
Bibliography

       Parallelization of Bulk Operations for STL Dictionaries
     . Johannes Singler. Leonor Frias. Copyright Â© 2007 . 
 	Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS)
-      . 

+      . 

       The Multi-Core Standard Template Library
     . Johannes Singler. Peter Sanders. Felix Putze. Copyright Â© 2007 . 
 	 Euro-Par 2007: Parallel Processing. (LNCS 4641)
diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures.html b/libstdc++-v3/doc/html/manual/policy_data_structures.html
index da7cbd18e0ab..94ef9591d89b 100644
--- a/libstdc++-v3/doc/html/manual/policy_data_structures.html
+++ b/libstdc++-v3/doc/html/manual/policy_data_structures.html
@@ -251,7 +251,7 @@
 		these invariants, one must supply some policy that is aware
 		of these changes.  Without this, it would be better to use a
 		linked list (in itself very efficient for these purposes).
-	      
FigureÂ 22.1.Â Node Invariants

Underlying Data Structures

+	      
FigureÂ 22.1.Â Node Invariants

Underlying Data Structures

 	    The standard C++ library contains associative containers based on
 	    red-black trees and collision-chaining hash tables. These are
 	    very useful, but they are not ideal for all types of
@@ -259,7 +259,7 @@
 	  

 	    The figure below shows the different underlying data structures
 	    currently supported in this library.
-	  
FigureÂ 22.2.Â Underlying Associative Data Structures


+	  
FigureÂ 22.2.Â Underlying Associative Data Structures


 	    A shows a collision-chaining hash-table, B shows a probing
 	    hash-table, C shows a red-black tree, D shows a splay tree, E shows
 	    a tree based on an ordered vector(implicit in the order of the
@@ -378,7 +378,7 @@
 	      no guarantee that the elements traversed will coincide with the
 	      logical elements between 1 and 5, as in
 	      label B.
-	    
FigureÂ 22.3.Â Range Iteration in Different Data Structures


+	    
FigureÂ 22.3.Â Range Iteration in Different Data Structures


 	      In our opinion, this problem is not caused just because
 	      red-black trees are order preserving while
 	      collision-chaining hash tables are (generally) not - it
@@ -429,7 +429,7 @@
 	      list, as in the graphic below, label B.  Here the iterators are as
 	      light as can be, but the hash-table's operations are more
 	      complicated.
-	    
FigureÂ 22.4.Â Point Iteration in Hash Data Structures


+	    
FigureÂ 22.4.Â Point Iteration in Hash Data Structures


 	      It should be noted that containers based on collision-chaining
 	      hash-tables are not the only ones with this type of behavior;
 	      many other self-organizing data structures display it as well.
@@ -445,7 +445,7 @@
 	      container. The graphic below shows three cases: A1 and A2 show
 	      a red-black tree; B1 and B2 show a probing hash-table; C1 and C2
 	      show a collision-chaining hash table.
-	    
FigureÂ 22.5.Â Effect of erase in different underlying data structures


+	    
FigureÂ 22.5.Â Effect of erase in different underlying data structures


 		  Erasing 5 from A1 yields A2. Clearly, an iterator to 3 can
 		  be de-referenced and incremented. The sequence of iterators
 		  changed, but in a way that is well-defined by the interface.
@@ -681,7 +681,7 @@
 	    typically less structured than an associative container's tree;
 	    the third simply uses an associative container. These are
 	    shown in the figure below with labels A1 and A2, B, and C.
-	  
FigureÂ 22.6.Â Underlying Priority Queue Data Structures


+	  
FigureÂ 22.6.Â Underlying Priority Queue Data Structures


 	    No single implementation can completely replace any of the
 	    others. Some have better push
 	    and pop amortized performance, some have
diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html
index e711170a373f..611a58cba090 100644
--- a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html
+++ b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html
@@ -171,7 +171,7 @@
 	  naturally; collision-chaining hash tables (label B) store
 	  equivalent-key values in the same bucket, the bucket can be
 	  arranged so that equivalent-key values are consecutive.
-	
FigureÂ 22.8.Â Non-unique Mapping Standard Containers


+	
FigureÂ 22.8.Â Non-unique Mapping Standard Containers


 	  Put differently, the standards' non-unique mapping
 	  associative-containers are associative containers that map
 	  primary keys to linked lists that are embedded into the
@@ -253,7 +253,7 @@
 	  first graphic above. Labels A and B, respectively. Each shaded
 	  box represents some size-type or secondary
 	  associative-container.
-	
FigureÂ 22.10.Â Non-unique Mapping Containers


+	
FigureÂ 22.10.Â Non-unique Mapping Containers


 	  In the first example above, then, one would use an associative
 	  container mapping each user to an associative container which
 	  maps each application id to a start time (see
@@ -306,7 +306,7 @@
 	shows invariants for order-preserving containers: point-type
 	iterators are synonymous with range-type iterators.
 	Orthogonally,  Cshows invariants for "set"
-	containers: iterators are synonymous with const iterators.
FigureÂ 22.11.Â Point Iterator Hierarchy

Note that point-type iterators in self-organizing containers
+	containers: iterators are synonymous with const iterators.
FigureÂ 22.11.Â Point Iterator Hierarchy

Note that point-type iterators in self-organizing containers
 	(hash-based associative containers) lack movement
 	operators, such as operator++ - in fact, this
 	is the reason why this library differentiates from the standard C++ librarys
@@ -345,7 +345,7 @@
 	  to the question of whether point-type iterators and range-type
 	  iterators are valid. The graphic below shows tags corresponding to
 	  different types of invalidation guarantees.
-	
FigureÂ 22.12.Â Invalidation Guarantee Tags Hierarchy


+	
FigureÂ 22.12.Â Invalidation Guarantee Tags Hierarchy


 	      basic_invalidation_guarantee
 	      corresponds to a basic guarantee that a point-type iterator,
 	      a found pointer, or a found reference, remains valid as long
@@ -429,7 +429,7 @@
 	

 	  This library contains a container tag hierarchy corresponding to the
 	  diagram below.
-	
FigureÂ 22.13.Â Container Tag Hierarchy


+	
FigureÂ 22.13.Â Container Tag Hierarchy


 	  Given any container Cntnr, the tag of
 	  the underlying data structure can be found via typename
 	  Cntnr::container_category.
@@ -488,7 +488,7 @@
 	collision-chaining container, except for the following.
Comb_Probe_Fn describes how to transform a probe
 	  sequence into a sequence of positions within the table.
Probe_Fn describes a probe sequence policy.
Some of the default template values depend on the values of
 	other parameters, and are explained below.
Details
Hash Policies
General
Following is an explanation of some functions which hashing
-	    involves. The graphic below illustrates the discussion.
FigureÂ 22.14.Â Hash functions, ranged-hash functions, and
+	    involves. The graphic below illustrates the discussion.
FigureÂ 22.14.Â Hash functions, ranged-hash functions, and
 	      range-hashing functions

Let U be a domain (e.g., the integers, or the
 	    strings of 3 characters). A hash-table algorithm needs to map
 	    elements of U "uniformly" into the range [0,..., m -
@@ -505,7 +505,7 @@
 	    Z₊,
which maps a non-negative hash value, and a non-negative
 	    range upper-bound into a non-negative integral in the range
 	    between 0 (inclusive) and the range upper bound (exclusive),
-	    i.e., for any r in Z₊,
0 â¤ g(r, m) â¤ m - 1
The resulting ranged-hash function, is
EquationÂ 22.1.Â Ranged Hash Function

+	    i.e., for any r in Z₊,
0 â¤ g(r, m) â¤ m - 1
The resulting ranged-hash function, is
EquationÂ 22.1.Â Ranged Hash Function

 		f(u , m) = g(h(u), m)
 	      

From the above, it is obvious that given g and
 	    h, f can always be composed (however the converse
@@ -525,7 +525,7 @@
 	    transforming the sequence of hash values into a sequence of
 	    positions.
Range Hashing
Some common choices for range-hashing functions are the
 	    division, multiplication, and middle-square methods ([biblio.knuth98sorting]), defined
-	    as
EquationÂ 22.2.Â Range-Hashing, Division Method

+	    as
EquationÂ 22.2.Â Range-Hashing, Division Method

 		g(r, m) = r mod m
 	      

g(r, m) = â u/v ( a r mod v ) â
and
g(r, m) = â u/v ( r² mod v ) â
respectively, for some positive integrals u and
 	    v (typically powers of 2), and some a. Each of
@@ -536,9 +536,9 @@
 	    implement using the low
 	    level % (modulo) operation (for any m), or the
 	    low level & (bit-mask) operation (for the case where
-	    m is a power of 2), i.e.,
EquationÂ 22.3.Â Division via Prime Modulo

+	    m is a power of 2), i.e.,
EquationÂ 22.3.Â Division via Prime Modulo

 		g(r, m) = r % m
-	      

and
EquationÂ 22.4.Â Division via Bit Mask

+	      

and
EquationÂ 22.4.Â Division via Bit Mask

 		g(r, m) = r & m - 1, (with m =
 		2^k for some k)
 	      

respectively.
The % (modulo) implementation has the advantage that for
@@ -564,7 +564,7 @@
 	      s = [ s₀,..., s_{t - 1}]
 	    
be a string of t characters, each of which is from
 	    domain S. Consider the following ranged-hash
-	    function:
EquationÂ 22.5.Â 
+	    function:
EquationÂ 22.5.Â 
 		A Standard String Hash Function
 	      

 		f₁(s, m) = â _{i =
@@ -576,7 +576,7 @@
 	    of a long DNA sequence (and so S = {'A', 'C', 'G',
 	    'T'}). In this case, scanning the entire string might be
 	    prohibitively expensive. A possible alternative might be to use
-	    only the first k characters of the string, where
|S|^k â¥ m ,
i.e., using the hash function
EquationÂ 22.6.Â 
+	    only the first k characters of the string, where
|S|^k â¥ m ,
i.e., using the hash function
EquationÂ 22.6.Â 
 		Only k String DNA Hash
 	      

 		f₂(s, m) = â _{i
@@ -607,12 +607,12 @@
 	      the container transforms the key into a non-negative integral
 	      using the hash functor (points B and C), and transforms the
 	      result into a position using the combining functor (points D
-	      and E).
FigureÂ 22.15.Â Insert hash sequence diagram

If cc_hash_table's
+	      and E).
FigureÂ 22.15.Â Insert hash sequence diagram

If cc_hash_table's
 	      hash-functor, Hash_Fn is instantiated by null_type , then Comb_Hash_Fn is taken to be
 	      a ranged-hash function. The graphic below shows an insert sequence
 	      diagram. The user inserts an element (point A), the container
 	      transforms the key into a position using the combining functor
-	      (points B and C).
FigureÂ 22.16.Â Insert hash sequence diagram with a null policy}

+	      (points B and C).
FigureÂ 22.16.Â Insert hash sequence diagram with a null policy


 		Probing tables
 	      
gp_hash_table is parametrized by
 	      Hash_Fn, Probe_Fn,
@@ -635,7 +635,7 @@
 		a linear probe and a quadratic probe function,
 		respectively.}

 		The graphic below shows the relationships.
-	      
FigureÂ 22.17.Â Hash policy class diagram

Resize Policies
General
Hash-tables, as opposed to trees, do not naturally grow or
+	      
FigureÂ 22.17.Â Hash policy class diagram

Resize Policies
General
Hash-tables, as opposed to trees, do not naturally grow or
 	    shrink. It is necessary to specify policies to determine how
 	    and when a hash table should change its size. Usually, resize
 	    policies can be decomposed into orthogonal policies:
A size policy indicating how a hash table
@@ -668,10 +668,10 @@
 	    and some load factor be denoted by Î. We would like to
 	    calculate the minimal length of k, such that if there were Î
 	    m elements in the hash table, a probe sequence of length k would
-	    be found with probability at most 1/m.
FigureÂ 22.18.Â Balls and bins

Denote the probability that a probe sequence of length
+	    be found with probability at most 1/m.
FigureÂ 22.18.Â Balls and bins

Denote the probability that a probe sequence of length
 	    k appears in bin i by p_i, the
 	    length of the probe sequence of bin i by
-	    l_i, and assume uniform distribution. Then
EquationÂ 22.7.Â 
+	    l_i, and assume uniform distribution. Then
EquationÂ 22.7.Â 
 		Probability of Probe Sequence of Length k
 	      

 		p₁ = 
@@ -685,7 +685,7 @@
 	    l_i are negatively-dependent
 	    ([biblio.dubhashi98neg])
 	    . Let
-	    I(.) denote the indicator function. Then
EquationÂ 22.8.Â 
+	    I(.) denote the indicator function. Then
EquationÂ 22.8.Â 
 		Probability Probe Sequence in Some Bin
 	      

 		P( exists_i l_i â¥ k ) = 
@@ -724,7 +724,7 @@
 	      a resize is needed, and if so, what is the new size (points D
 	      to G); following the resize, it notifies the policy that a
 	      resize has completed (point H); finally, the element is
-	      inserted, and the policy notified (point I).
FigureÂ 22.19.Â Insert resize sequence diagram

In practice, a resize policy can be usually orthogonally
+	      inserted, and the policy notified (point I).
FigureÂ 22.19.Â Insert resize sequence diagram

In practice, a resize policy can be usually orthogonally
 	      decomposed to a size policy and a trigger policy. Consequently,
 	      the library contains a single class for instantiating a resize
 	      policy: hash_standard_resize_policy
@@ -733,8 +733,8 @@
 	      both, and acts as a standard delegate ([biblio.gof])
 	      to these policies.
The two graphics immediately below show sequence diagrams
 	      illustrating the interaction between the standard resize policy
-	      and its trigger and size policies, respectively.
FigureÂ 22.20.Â Standard resize policy trigger sequence
-		diagram

FigureÂ 22.21.Â Standard resize policy size sequence
+	      and its trigger and size policies, respectively.
FigureÂ 22.20.Â Standard resize policy trigger sequence
+		diagram

FigureÂ 22.21.Â Standard resize policy size sequence
 		diagram

Predefined Policies
The library includes the following
 	      instantiations of size and trigger policies:
hash_load_check_resize_trigger
 		implements a load check trigger policy.
cc_hash_max_collision_check_resize_trigger
@@ -877,7 +877,7 @@
 	  each node, and maintains node invariants (see [biblio.clrs2001].) The first stores in
 	  each node the size of the sub-tree rooted at the node; the
 	  second stores at each node the maximal endpoint of the
-	  intervals at the sub-tree rooted at the node.
FigureÂ 22.22.Â Tree node invariants

Supporting such trees is difficult for a number of
+	  intervals at the sub-tree rooted at the node.
FigureÂ 22.22.Â Tree node invariants

Supporting such trees is difficult for a number of
 	  reasons:
There must be a way to specify what a node's metadata
 	    should be (if any).
Various operations can invalidate node
 	    invariants.  The graphic below shows how a right rotation,
@@ -891,7 +891,7 @@
 	    metadata.
It is not feasible to know in advance which methods trees
 	    can support. Besides the usual find method, the
 	    first tree can support a find_by_order method, while
-	    the second can support an overlaps method.
FigureÂ 22.23.Â Tree node invalidation

These problems are solved by a combination of two means:
+	    the second can support an overlaps method.
FigureÂ 22.23.Â Tree node invalidation

These problems are solved by a combination of two means:
 	  node iterators, and template-template node updater
 	  parameters.
Node Iterators
Each tree-based container defines two additional iterator
 	    types, const_node_iterator
@@ -920,7 +920,7 @@
 	    node_update class, and publicly subclasses
 	    node_update. The graphic below shows this
 	    scheme, as well as some predefined policies (which are explained
-	    below).
FigureÂ 22.24.Â A tree and its update policy

node_update (an instantiation of
+	    below).
FigureÂ 22.24.Â A tree and its update policy

node_update (an instantiation of
 	    Node_Update) must define metadata_type as
 	    the type of metadata it requires. For order statistics,
 	    e.g., metadata_type might be size_t.
@@ -939,7 +939,7 @@
 	    nd_it. For example, say node x in the
 	    graphic below label A has an invalid invariant, but its' children,
 	    y and z have valid invariants. After the invocation, all three
-	    nodes should have valid invariants, as in label B.
FigureÂ 22.25.Â Restoring node invariants

When a tree operation might invalidate some node invariant,
+	    nodes should have valid invariants, as in label B.
FigureÂ 22.25.Â Restoring node invariants

When a tree operation might invalidate some node invariant,
 	    it invokes this method in its node_update base to
 	    restore the invariant. For example, the graphic below shows
 	    an insert operation (point A); the tree performs some
@@ -947,7 +947,7 @@
 	    C, and D). (It is well known that any insert,
 	    erase, split or join, can restore
 	    all node invariants by a small number of node invariant updates ([biblio.clrs2001])
-	    .
FigureÂ 22.26.Â Insert update sequence

To complete the description of the scheme, three questions
+	    .
FigureÂ 22.26.Â Insert update sequence

To complete the description of the scheme, three questions
 	    need to be answered:
How can a tree which supports order statistics define a
 	      method such as find_by_order?
How can the node updater base access methods of the
 	      tree?
How can the following cyclic dependency be resolved?
@@ -989,7 +989,7 @@
 	      node's metadata (this is halting reducible). In the graphic
 	      below, assume the shaded node is inserted. The tree would have
 	      to traverse the useless path shown to the root, applying
-	      redundant updates all the way.
FigureÂ 22.27.Â Useless update path

A null policy class, null_node_update
+	      redundant updates all the way.
FigureÂ 22.27.Â Useless update path

A null policy class, null_node_update
 	    solves both these problems. The tree detects that node
 	    invariants are irrelevant, and defines all accordingly.
Split and Join
Tree-based containers support split and join methods.
 	  It is possible to split a tree so that it passes
@@ -1072,7 +1072,7 @@
 	  sub-tree with leafs "a" and "as". The maximal common prefix is
 	  "a". The internal node contains, consequently, to const
 	  iterators, one pointing to 'a', and the other to
-	  's'.
FigureÂ 22.28.Â A PATRICIA trie

Node Invariants
Trie-based containers support node invariants, as do
+	  's'.
FigureÂ 22.28.Â A PATRICIA trie

Node Invariants
Trie-based containers support node invariants, as do
 	  tree-based containers. There are two minor
 	  differences, though, which, unfortunately, thwart sharing them
 	  sharing the same node-updating policies:
A trie's Node_Update template-template
@@ -1081,7 +1081,7 @@
 	    parametrized by Cmp_Fn.
Tree-based containers store values in all nodes, while
 	    trie-based containers (at least in this implementation) store
 	    values in leafs.
The graphic below shows the scheme, as well as some predefined
-	  policies (which are explained below).
FigureÂ 22.29.Â A trie and its update policy

This library offers the following pre-defined trie node
+	  policies (which are explained below).
FigureÂ 22.29.Â A trie and its update policy

This library offers the following pre-defined trie node
 	  updating policies:

 		trie_order_statistics_node_update
 		supports order statistics.
@@ -1129,7 +1129,7 @@
 	  simple list of integer keys. If we search for the integer 6, we
 	  are paying an overhead: the link with key 6 is only the fifth
 	  link; if it were the first link, it could be accessed
-	  faster.
FigureÂ 22.30.Â A simple list

List-update algorithms reorder lists as elements are
+	  faster.
FigureÂ 22.30.Â A simple list

List-update algorithms reorder lists as elements are
 	  accessed. They try to determine, by the access history, which
 	  keys to move to the front of the list. Some of these algorithms
 	  require adding some metadata alongside each entry.
For example, in the graphic below label A shows the counter
@@ -1139,7 +1139,7 @@
 	  predetermined value, say 10, as shown in label C, the count is set
 	  to 0 and the node is moved to the front of the list, as in label
 	  D.
-	  
FigureÂ 22.31.Â The counter algorithm

Policies
this library allows instantiating lists with policies
+	  
FigureÂ 22.31.Â The counter algorithm

Policies
this library allows instantiating lists with policies
 	  implementing any algorithm moving nodes to the front of the
 	  list (policies implementing algorithms interchanging nodes are
 	  unsupported).
Associative containers based on lists are parametrized by a
@@ -1311,7 +1311,7 @@
 	  sequence; the second uses a tree (or forest of trees), which is
 	  typically less structured than an associative container's tree;
 	  the third simply uses an associative container. These are
-	  shown in the graphic below, in labels A1 and A2, label B, and label C.
FigureÂ 22.32.Â Underlying Priority-Queue Data-Structures.

Roughly speaking, any value that is both pushed and popped
+	  shown in the graphic below, in labels A1 and A2, label B, and label C.
FigureÂ 22.32.Â Underlying Priority-Queue Data-Structures.

Roughly speaking, any value that is both pushed and popped
 	  from a priority queue must incur a logarithmic expense (in the
 	  amortized sense). Any priority queue implementation that would
 	  avoid this, would violate known bounds on comparison-based
@@ -1391,7 +1391,7 @@
 	  container Cntnr, the tag of the underlying
 	  data structure can be found via typename 
 	  Cntnr::container_category; this is one of the possible tags shown in the graphic below.
-	  
FigureÂ 22.33.Â Priority-Queue Data-Structure Tags.

Additionally, a traits mechanism can be used to query a
+	  
FigureÂ 22.33.Â Priority-Queue Data-Structure Tags.

Additionally, a traits mechanism can be used to query a
 	  container type for its attributes. Given any container
 	  Cntnr, then 
__gnu_pbds::container_traits<Cntnr>

 	  is a traits class identifying the properties of the
diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html
index 9c2d537014f7..16eca788ad5f 100644
--- a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html
+++ b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html
@@ -62,7 +62,7 @@
 	In addition, there are the following diagnostics classes,
 	used to report errors specific to this library's data
 	structures.
-      
FigureÂ 22.7.Â Exception Hierarchy

Tutorial
Basic Use

+      
FigureÂ 22.7.Â Exception Hierarchy

Tutorial
Basic Use

 	  For the most part, the policy-based containers containers in
 	  namespace __gnu_pbds have the same interface as
 	  the equivalent containers in the standard C++ library, except for
diff --git a/libstdc++-v3/doc/html/manual/profile_mode.html b/libstdc++-v3/doc/html/manual/profile_mode.html
index f47c6b7e3169..d3121a9a3a42 100644
--- a/libstdc++-v3/doc/html/manual/profile_mode.html
+++ b/libstdc++-v3/doc/html/manual/profile_mode.html
@@ -138,7 +138,7 @@ vector-size: improvement = 3: call stack = 0x804842c ...
    call context.
    (Environment variable not supported.)
    

-  
Bibliography

+  
Bibliography

       Perflint: A Context Sensitive Performance Advisor for C++ Programs
     . Lixia Liu. Silvius Rus. Copyright Â© 2009 . 
 	Proceedings of the 2009 International Symposium on Code Generation
diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html
index 4115ef417382..7ab80dcdcac7 100644
--- a/libstdc++-v3/doc/html/manual/status.html
+++ b/libstdc++-v3/doc/html/manual/status.html
@@ -8,7 +8,7 @@ This status table is based on the table of contents of ISO/IEC 14882:2003.
 

 This page describes the C++ support in mainline GCC SVN, not in any
 particular release.
-
TableÂ 1.1.Â C++ 1998/2003 Implementation Status
Section Description Status Comments

+
TableÂ 1.1.Â C++ 1998/2003 Implementation Status
Section Description Status Comments

 	18
       
 	Language support
@@ -158,7 +158,7 @@ presence of the required flag.
 

 This page describes the C++11 support in mainline GCC SVN, not in any
 particular release.
-
TableÂ 1.2.Â C++ 2011 Implementation Status
Section Description Status Comments

+
TableÂ 1.2.Â C++ 2011 Implementation Status
Section Description Status Comments

 	18
       
 	Language support
@@ -201,7 +201,11 @@ particular release.
       
 	Containers
       
23.1 General Â  Â 
23.2 Container requirements Â  Â 
23.2.1 General container requirements Partial Only vector meets the requirements
-             relating to allocator use and propagation.
23.2.2 Container data races Y Â 
23.2.3 Sequence containers Y Â 
23.2.4 Associative containers Partial Missing emplace members
23.2.5 Unordered associative containers Y Â 
23.3 Sequence containers Â  Â 
23.3.2 Class template array Y Â 
23.3.3 Class template deque Y Â 
23.3.4 Class template forward_list Y Â 
23.3.5 Class template list Y Â 
23.3.6 Class template vector Y Â 
23.3.7 Class vector<bool> Y Â 
23.4 Associative containers Â  Â 
23.4.4 Class template map Y Â 
23.4.5 Class template multimap Y Â 
23.4.6 Class template set Y Â 
23.4.7 Class template multiset Y Â 
23.5 Unordered associative containers Â  Â 
23.5.4 Class template unordered_map Y Â 
23.5.5 Class template unordered_multimap Y Â 
23.5.6 Class template unordered_set Y Â 
23.5.7 Class template unordered_multiset Y Â 
23.6 Container adaptors Â  Â 
23.6.1 Class template queue Y Â 
23.6.2 Class template priority_queue Y Â 
23.6.3 Class template stack Y Â 

+             relating to allocator use and propagation.
23.2.2 Container data races Y Â 
23.2.3 Sequence containers Y Â 
23.2.4 Associative containers Y Â 
23.2.5 Unordered associative containers Y Â 
23.3 Sequence containers Â  Â 
23.3.2 Class template array Y Â 
23.3.3 Class template deque Partial insert and erase members do not
+             take const_iterator arguments (N2350).
23.3.4 Class template forward_list Y Â 
23.3.5 Class template list Partial insert and erase members do not
+             take const_iterator arguments (N2350).
23.3.6 Class template vector Partial insert and erase members do not
+             take const_iterator arguments (N2350).
23.3.7 Class vector<bool> Partial insert and erase members do not
+             take const_iterator arguments (N2350).
23.4 Associative containers Â  Â 
23.4.4 Class template map Y Â 
23.4.5 Class template multimap Y Â 
23.4.6 Class template set Y Â 
23.4.7 Class template multiset Y Â 
23.5 Unordered associative containers Â  Â 
23.5.4 Class template unordered_map Y Â 
23.5.5 Class template unordered_multimap Y Â 
23.5.6 Class template unordered_set Y Â 
23.5.7 Class template unordered_multiset Y Â 
23.6 Container adaptors Â  Â 
23.6.1 Class template queue Y Â 
23.6.2 Class template priority_queue Y Â 
23.6.3 Class template stack Y Â 

 	24
       
 	Iterators
@@ -290,7 +294,7 @@ In this implementation the header names are prefixed by
 

 This page describes the TR1 support in mainline GCC SVN, not in any particular
 release.
-
TableÂ 1.3.Â C++ TR1 Implementation Status
Section Description Status Comments
2 General Utilities
2.1 Reference wrappers Â  Â 
2.1.1 Additions to header <functional> synopsis Y Â 
2.1.2 Class template reference_wrapper Â  Â 
2.1.2.1 reference_wrapper construct/copy/destroy Y Â 
2.1.2.2 reference_wrapper assignment Y Â 
2.1.2.3 reference_wrapper access Y Â 
2.1.2.4 reference_wrapper invocation Y Â 
2.1.2.5 reference_wrapper helper functions Y Â 
2.2 Smart pointers Â  Â 
2.2.1 Additions to header <memory> synopsis Y Â 
2.2.2 Class bad_weak_ptr Y Â 
2.2.3 Class template shared_ptr Â  
+
TableÂ 1.3.Â C++ TR1 Implementation Status
Section Description Status Comments
2 General Utilities
2.1 Reference wrappers Â  Â 
2.1.1 Additions to header <functional> synopsis Y Â 
2.1.2 Class template reference_wrapper Â  Â 
2.1.2.1 reference_wrapper construct/copy/destroy Y Â 
2.1.2.2 reference_wrapper assignment Y Â 
2.1.2.3 reference_wrapper access Y Â 
2.1.2.4 reference_wrapper invocation Y Â 
2.1.2.5 reference_wrapper helper functions Y Â 
2.2 Smart pointers Â  Â 
2.2.1 Additions to header <memory> synopsis Y Â 
2.2.2 Class bad_weak_ptr Y Â 
2.2.3 Class template shared_ptr Â  
 	
 	  Uses code from
 	  boost::shared_ptr.
@@ -311,7 +315,7 @@ decimal floating-point arithmetic
 

 This page describes the TR 24733 support in mainline GCC SVN, not in any
 particular release.
-
TableÂ 1.4.Â C++ TR 24733 Implementation Status
Section Description Status Comments

+
TableÂ 1.4.Â C++ TR 24733 Implementation Status
Section Description Status Comments

 	0
       
 	Introduction
diff --git a/libstdc++-v3/doc/html/manual/strings.html b/libstdc++-v3/doc/html/manual/strings.html
index 6e41f270b5d6..cd3ff0b1a2f7 100644
--- a/libstdc++-v3/doc/html/manual/strings.html
+++ b/libstdc++-v3/doc/html/manual/strings.html
@@ -7,7 +7,7 @@
     Standard Contents
   Â Next
ChapterÂ 7.Â 
   Strings
-  
+  
 
Table of Contents
String Classes
Simple Transformations
Case Sensitivity
Arbitrary Character Types
Tokenizing
Shrink to Fit
CString (MFC)
String Classes
Simple Transformations

       Here are Standard, simple, and portable ways to perform common
       transformations on a string instance, such as
diff --git a/libstdc++-v3/doc/html/manual/support.html b/libstdc++-v3/doc/html/manual/support.html
index 16f78d1374a6..50f6147f2004 100644
--- a/libstdc++-v3/doc/html/manual/support.html
+++ b/libstdc++-v3/doc/html/manual/support.html
@@ -7,7 +7,7 @@
     Standard Contents
   Â Next
ChapterÂ 4.Â 
   Support
-  
+  
 
Table of Contents
Types
Fundamental Types
Numeric Properties
NULL
Dynamic Memory
Termination
Termination Handlers
Verbose Terminate Handler

     This part deals with the functions called and objects created
     automatically during the course of a program's existence.
diff --git a/libstdc++-v3/doc/html/manual/test.html b/libstdc++-v3/doc/html/manual/test.html
index 16a03ca0241b..87c72e5717f4 100644
--- a/libstdc++-v3/doc/html/manual/test.html
+++ b/libstdc++-v3/doc/html/manual/test.html
@@ -493,7 +493,7 @@ only default variables.
        reporting functions including:
        
time_counter
resource_counter
report_performance
Special Topics

   Qualifying Exception Safety Guarantees
-  
+  
 
Overview

 	 Testing is composed of running a particular test sequence,
 	 and looking at what happens to the surrounding code when
diff --git a/libstdc++-v3/doc/html/manual/using.html b/libstdc++-v3/doc/html/manual/using.html
index 39faa6b7a36e..6607a0ce4522 100644
--- a/libstdc++-v3/doc/html/manual/using.html
+++ b/libstdc++-v3/doc/html/manual/using.html
@@ -11,5 +11,5 @@
       enumerated and detailed in the table below.
     

       By default, g++ is equivalent to  g++ -std=gnu++98. The standard library also defaults to this dialect.
-    
TableÂ 3.1.Â C++ Command Options
Option Flags Description
-std=c++98 Use the 1998 ISO C++ standard plus amendments.
-std=gnu++98 As directly above, with GNU extensions.
-std=c++11 Use the 2011 ISO C++ standard.
-std=gnu++11 As directly above, with GNU extensions.
-fexceptions See exception-free dialect
-frtti As above, but RTTI-free dialect.
-pthread or -pthreads For ISO C++11 <thread>, <future>,
+    
TableÂ 3.1.Â C++ Command Options
Option Flags Description
-std=c++98 Use the 1998 ISO C++ standard plus amendments.
-std=gnu++98 As directly above, with GNU extensions.
-std=c++11 Use the 2011 ISO C++ standard.
-std=gnu++11 As directly above, with GNU extensions.
-fexceptions See exception-free dialect
-frtti As above, but RTTI-free dialect.
-pthread or -pthreads For ISO C++11 <thread>, <future>,
       <mutex>, or <condition_variable>.
-fopenmp For parallel mode.

PrevÂ  Up Â Next
MakeÂ  Home Â Headers
diff --git a/libstdc++-v3/doc/html/manual/using_exceptions.html b/libstdc++-v3/doc/html/manual/using_exceptions.html
index 24014c9893ee..8a65b2163629 100644
--- a/libstdc++-v3/doc/html/manual/using_exceptions.html
+++ b/libstdc++-v3/doc/html/manual/using_exceptions.html
@@ -266,7 +266,7 @@ is called.
   }
   catch(...)
   { this->_M_setstate(ios_base::badbit); }
-Bibliography

+
Bibliography

 	
 	System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008)
 	
@@ -275,39 +275,39 @@ is called.
     . Copyright Â© 2008 
 	The Open Group/The Institute of Electrical and Electronics
 	Engineers, Inc.
-      . 

+      . 

 	
 	Error and Exception Handling
 	
       . David Abrahams . 
 	Boost
-      . 

+      . 

 	
 	Exception-Safety in Generic Components
 	
       . David Abrahams. 
 	Boost
-      . 

+      . 

 	
 	Standard Library Exception Policy
 	
       . Matt Austern. 
 	WG21 N1077
-      . 

+      . 

 	
 	ia64 c++ abi exception handling
 	
       . Richard Henderson. 
 	GNU
-      . 

+      . 

 	
 	Appendix E: Standard-Library Exception Safety
 	
-      . Bjarne Stroustrup. 

+      . Bjarne Stroustrup. 

       Exceptional C++
     . 
       Exception-Safety Issues and Techniques
-    . Herb Sutter. 

+    . Herb Sutter. 

 	
       GCC Bug 25191: exception_defines.h #defines try/catch
 	
diff --git a/libstdc++-v3/doc/html/manual/using_headers.html b/libstdc++-v3/doc/html/manual/using_headers.html
index 85b133b66ca8..423fcf765f46 100644
--- a/libstdc++-v3/doc/html/manual/using_headers.html
+++ b/libstdc++-v3/doc/html/manual/using_headers.html
@@ -19,19 +19,19 @@
      the 1998 standard as updated for 2003, and the current 2011 standard.
    

      C++98/03 include files. These are available in the default compilation mode, i.e. -std=c++98 or -std=gnu++98.
-   
TableÂ 3.2.Â C++ 1998 Library Headers
algorithm bitset complex deque exception
fstream functional iomanip ios iosfwd
iostream istream iterator limits list
locale map memory new numeric
ostream queue set sstream stack
stdexcept streambuf string utility typeinfo
valarray vector Â  Â  Â 

TableÂ 3.3.Â C++ 1998 Library Headers for C Library Facilities
cassert cerrno cctype cfloat ciso646
climits clocale cmath csetjmp csignal
cstdarg cstddef cstdio cstdlib cstring
ctime cwchar cwctype Â  Â 


+   
TableÂ 3.2.Â C++ 1998 Library Headers
algorithm bitset complex deque exception
fstream functional iomanip ios iosfwd
iostream istream iterator limits list
locale map memory new numeric
ostream queue set sstream stack
stdexcept streambuf string utility typeinfo
valarray vector Â  Â  Â 

TableÂ 3.3.Â C++ 1998 Library Headers for C Library Facilities
cassert cerrno cctype cfloat ciso646
climits clocale cmath csetjmp csignal
cstdarg cstddef cstdio cstdlib cstring
ctime cwchar cwctype Â  Â 


 C++11 include files. These are only available in C++11 compilation
 mode, i.e. -std=c++11 or -std=gnu++11.
-
TableÂ 3.4.Â C++ 2011 Library Headers
algorithm array bitset chrono complex
condition_variable deque exception forward_list fstream
functional future initalizer_list iomanip ios
iosfwd iostream istream iterator limits
list locale map memory mutex
new numeric ostream queue random
ratio regex set sstream stack
stdexcept streambuf string system_error thread
tuple type_traits typeinfo unordered_map unordered_set
utility valarray vector Â  Â 

TableÂ 3.5.Â C++ 2011 Library Headers for C Library Facilities
cassert ccomplex cctype cerrno cfenv
cfloat cinttypes ciso646 climits clocale
cmath csetjmp csignal cstdarg cstdbool
cstddef cstdint cstdlib cstdio cstring
ctgmath ctime cuchar cwchar cwctype


+
TableÂ 3.4.Â C++ 2011 Library Headers
algorithm array bitset chrono complex
condition_variable deque exception forward_list fstream
functional future initalizer_list iomanip ios
iosfwd iostream istream iterator limits
list locale map memory mutex
new numeric ostream queue random
ratio regex set sstream stack
stdexcept streambuf string system_error thread
tuple type_traits typeinfo unordered_map unordered_set
utility valarray vector Â  Â 

TableÂ 3.5.Â C++ 2011 Library Headers for C Library Facilities
cassert ccomplex cctype cerrno cfenv
cfloat cinttypes ciso646 climits clocale
cmath csetjmp csignal cstdarg cstdbool
cstddef cstdint cstdlib cstdio cstring
ctgmath ctime cuchar cwchar cwctype


   In addition, TR1 includes as:
-
TableÂ 3.6.Â C++ TR 1 Library Headers
tr1/array tr1/complex tr1/memory tr1/functional tr1/random
tr1/regex tr1/tuple tr1/type_traits tr1/unordered_map tr1/unordered_set
tr1/utility Â  Â  Â  Â 

TableÂ 3.7.Â C++ TR 1 Library Headers for C Library Facilities
tr1/ccomplex tr1/cfenv tr1/cfloat tr1/cmath tr1/cinttypes
tr1/climits tr1/cstdarg tr1/cstdbool tr1/cstdint tr1/cstdio
tr1/cstdlib tr1/ctgmath tr1/ctime tr1/cwchar tr1/cwctype

Decimal floating-point arithmetic is available if the C++
+
TableÂ 3.6.Â C++ TR 1 Library Headers
tr1/array tr1/complex tr1/memory tr1/functional tr1/random
tr1/regex tr1/tuple tr1/type_traits tr1/unordered_map tr1/unordered_set
tr1/utility Â  Â  Â  Â 

TableÂ 3.7.Â C++ TR 1 Library Headers for C Library Facilities
tr1/ccomplex tr1/cfenv tr1/cfloat tr1/cmath tr1/cinttypes
tr1/climits tr1/cstdarg tr1/cstdbool tr1/cstdint tr1/cstdio
tr1/cstdlib tr1/ctgmath tr1/ctime tr1/cwchar tr1/cwctype

Decimal floating-point arithmetic is available if the C++
 compiler supports scalar decimal floating-point types defined via
 __attribute__((mode(SD|DD|LD))).
-
TableÂ 3.8.Â C++ TR 24733 Decimal Floating-Point Header
decimal/decimal


+
TableÂ 3.8.Â C++ TR 24733 Decimal Floating-Point Header
decimal/decimal


   Also included are files for the C++ ABI interface:
-
TableÂ 3.9.Â C++ ABI Headers
cxxabi.h cxxabi_forced.h


+
TableÂ 3.9.Â C++ ABI Headers
cxxabi.h cxxabi_forced.h


   And a large variety of extensions.
-
TableÂ 3.10.Â Extension Headers
ext/algorithm ext/atomicity.h ext/array_allocator.h ext/bitmap_allocator.h ext/cast.h
ext/codecvt_specializations.h ext/concurrence.h ext/debug_allocator.h ext/enc_filebuf.h ext/extptr_allocator.h
ext/functional ext/iterator ext/malloc_allocator.h ext/memory ext/mt_allocator.h
ext/new_allocator.h ext/numeric ext/numeric_traits.h ext/pb_ds/assoc_container.h ext/pb_ds/priority_queue.h
ext/pod_char_traits.h ext/pool_allocator.h ext/rb_tree ext/rope ext/slist
ext/stdio_filebuf.h ext/stdio_sync_filebuf.h ext/throw_allocator.h ext/typelist.h ext/type_traits.h
ext/vstring.h Â  Â  Â  Â 

TableÂ 3.11.Â Extension Debug Headers
debug/bitset debug/deque debug/list debug/map debug/set
debug/string debug/unordered_map debug/unordered_set debug/vector Â 

TableÂ 3.12.Â Extension Profile Headers
profile/bitset profile/deque profile/list profile/map
profile/set profile/unordered_map profile/unordered_set profile/vector

TableÂ 3.13.Â Extension Parallel Headers
parallel/algorithm parallel/numeric

Mixing Headers
 A few simple rules.
+
TableÂ 3.10.Â Extension Headers
ext/algorithm ext/atomicity.h ext/array_allocator.h ext/bitmap_allocator.h ext/cast.h
ext/codecvt_specializations.h ext/concurrence.h ext/debug_allocator.h ext/enc_filebuf.h ext/extptr_allocator.h
ext/functional ext/iterator ext/malloc_allocator.h ext/memory ext/mt_allocator.h
ext/new_allocator.h ext/numeric ext/numeric_traits.h ext/pb_ds/assoc_container.h ext/pb_ds/priority_queue.h
ext/pod_char_traits.h ext/pool_allocator.h ext/rb_tree ext/rope ext/slist
ext/stdio_filebuf.h ext/stdio_sync_filebuf.h ext/throw_allocator.h ext/typelist.h ext/type_traits.h
ext/vstring.h Â  Â  Â  Â 

TableÂ 3.11.Â Extension Debug Headers
debug/bitset debug/deque debug/list debug/map debug/set
debug/string debug/unordered_map debug/unordered_set debug/vector Â 

TableÂ 3.12.Â Extension Profile Headers
profile/bitset profile/deque profile/list profile/map
profile/set profile/unordered_map profile/unordered_set profile/vector

TableÂ 3.13.Â Extension Parallel Headers
parallel/algorithm parallel/numeric

Mixing Headers
 A few simple rules.
 
First, mixing different dialects of the standard headers is not
 possible. It's an all-or-nothing affair. Thus, code like
 
diff --git a/libstdc++-v3/doc/html/manual/utilities.html b/libstdc++-v3/doc/html/manual/utilities.html
index e026584b34e2..a831ee1953b2 100644
--- a/libstdc++-v3/doc/html/manual/utilities.html
+++ b/libstdc++-v3/doc/html/manual/utilities.html
@@ -7,8 +7,8 @@
     Standard Contents
   Â Next
ChapterÂ 6.Â 
   Utilities
-  
-
Table of Contents
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
Functors
If you don't know what functors are, you're not alone.  Many people
+  
+
Table of Contents
Functors
Pairs
Memory
Allocators
Requirements
Design Issues
Implementation
Interface Design
Selecting Default Allocation Policy
Disabling Memory Caching
Using a Specific Allocator
Custom Allocators
Extension Allocators
auto_ptr
Limitations
Use in Containers
shared_ptr
Requirements
Design Issues
Implementation
Class Hierarchy
Thread Safety
Selecting Lock Policy
Related functions and classes
Use
Examples
Unresolved Issues
Acknowledgments
Traits
Functors
If you don't know what functors are, you're not alone.  Many people
       get slightly the wrong idea.  In the interest of not reinventing
       the wheel, we will refer you to the introduction to the functor
       concept written by SGI as part of their STL, in
diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
index 324d1e2df2ae..1e149f0318d9 100644
--- a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
+++ b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
@@ -1418,10 +1418,12 @@ particular release.
       
     
     
+      
       23.3.3
       Class template deque
-      Y
-      
+      Partial
+      insert and erase members do not
+             take const_iterator arguments (N2350).
     
     
       23.3.4
@@ -1430,22 +1432,28 @@ particular release.
       
     
     
+      
       23.3.5
       Class template list
-      Y
-      
+      Partial
+      insert and erase members do not
+             take const_iterator arguments (N2350).
     
     
+      
       23.3.6
       Class template vector
-      Y
-      
+      Partial
+      insert and erase members do not
+             take const_iterator arguments (N2350).
     
     
+      
       23.3.7
       Class vector<bool>
-      Y
-      
+      Partial
+      insert and erase members do not
+             take const_iterator arguments (N2350).
     
     
       23.4