Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r76139 - in trunk/libs/regex/doc: . html html/boost_regex html/boost_regex/background_information html/boost_regex/format html/boost_regex/ref html/boost_regex/ref/concepts html/boost_regex/ref/deprecated_interfaces html/boost_regex/ref/internal_details html/boost_regex/ref/non_std_strings/icu html/boost_regex/ref/non_std_strings/mfc_strings html/boost_regex/syntax
From: john_at_[hidden]
Date: 2011-12-24 12:52:01

Author: johnmaddock
Date: 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
New Revision: 76139
URL: http://svn.boost.org/trac/boost/changeset/76139

Log:
Fix typo and regenerate docs.
Fixes #6154.
Text files modified:
   trunk/libs/regex/doc/html/boost_regex/background_information/examples.html | 18
   trunk/libs/regex/doc/html/boost_regex/background_information/history.html | 78 ++---
   trunk/libs/regex/doc/html/boost_regex/background_information/locale.html | 24
   trunk/libs/regex/doc/html/boost_regex/background_information/standards.html | 30 +-
   trunk/libs/regex/doc/html/boost_regex/captures.html | 25
   trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html | 24
   trunk/libs/regex/doc/html/boost_regex/install.html | 53 ++-
   trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html | 6
   trunk/libs/regex/doc/html/boost_regex/partial_matches.html | 10
   trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html | 14
   trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html | 166 +++++-----
   trunk/libs/regex/doc/html/boost_regex/ref/concepts/traits_concept.html | 12
   trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html | 80 ++--
   trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html | 8
   trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html | 278 +++++++++---------
   trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html | 12
   trunk/libs/regex/doc/html/boost_regex/ref/error_type.html | 12
   trunk/libs/regex/doc/html/boost_regex/ref/internal_details/uni_iter.html | 13
   trunk/libs/regex/doc/html/boost_regex/ref/match_flag_type.html | 8
   trunk/libs/regex/doc/html/boost_regex/ref/match_results.html | 20
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html | 18
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html | 210 +++++++-------
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html | 30 +-
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html | 42 +-
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html | 50 +-
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html | 4
   trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html | 8
   trunk/libs/regex/doc/html/boost_regex/ref/posix.html | 24
   trunk/libs/regex/doc/html/boost_regex/ref/regex_iterator.html | 80 ++--
   trunk/libs/regex/doc/html/boost_regex/ref/regex_match.html | 68 ++--
   trunk/libs/regex/doc/html/boost_regex/ref/regex_replace.html | 36 +-
   trunk/libs/regex/doc/html/boost_regex/ref/regex_search.html | 108 +++---
   trunk/libs/regex/doc/html/boost_regex/ref/regex_token_iterator.html | 182 ++++++------
   trunk/libs/regex/doc/html/boost_regex/ref/regex_traits.html | 6
   trunk/libs/regex/doc/html/boost_regex/ref/sub_match.html | 571 ++++++++++++++++++++-------------------
   trunk/libs/regex/doc/html/boost_regex/syntax/basic_extended.html | 205 +++++++-------
   trunk/libs/regex/doc/html/boost_regex/syntax/basic_syntax.html | 135 ++++----
   trunk/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html | 311 +++++++++++----------
   trunk/libs/regex/doc/html/boost_regex/unicode.html | 13
   trunk/libs/regex/doc/html/index.html | 4
   trunk/libs/regex/doc/introduction.qbk | 4
   41 files changed, 1504 insertions(+), 1496 deletions(-)

Modified: trunk/libs/regex/doc/html/boost_regex/background_information/examples.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/background_information/examples.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/background_information/examples.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,9 +27,9 @@
<a name="boost_regex.background_information.examples"></a><a class="link" href="examples.html" title="Test and Example Programs">Test and
 Example Programs</a>
</h3></div></div></div>
-<a name="boost_regex.background_information.examples.test_programs"></a><h5>
-<a name="boost_regex.background_information.examples.test_programs-heading"></a>
- <a class="link" href="examples.html#boost_regex.background_information.examples.test_programs">Test
+<h5>
+<a name="boost_regex.background_information.examples.h0"></a>
+ <a name="boost_regex.background_information.examples.test_programs"></a><a class="link" href="examples.html#boost_regex.background_information.examples.test_programs">Test
 Programs</a>
 </h5>

@@ -150,9 +150,9 @@

 Files: captures_test.cpp.
 
-<a name="boost_regex.background_information.examples.example_programs"></a><h5>
-<a name="boost_regex.background_information.examples.example_programs-heading"></a>
- <a class="link" href="examples.html#boost_regex.background_information.examples.example_programs">Example
+<h5>
+<a name="boost_regex.background_information.examples.h1"></a>
+ <a name="boost_regex.background_information.examples.example_programs"></a><a class="link" href="examples.html#boost_regex.background_information.examples.example_programs">Example
 programs</a>
 </h5>

@@ -176,9 +176,9 @@

 Files: regex_timer.cpp.
 
-<a name="boost_regex.background_information.examples.code_snippets"></a><h5>
-<a name="boost_regex.background_information.examples.code_snippets-heading"></a>
- <a class="link" href="examples.html#boost_regex.background_information.examples.code_snippets">Code
+<h5>
+<a name="boost_regex.background_information.examples.h2"></a>
+ <a name="boost_regex.background_information.examples.code_snippets"></a><a class="link" href="examples.html#boost_regex.background_information.examples.code_snippets">Code
 snippets</a>
 </h5>

Modified: trunk/libs/regex/doc/html/boost_regex/background_information/history.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/background_information/history.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/background_information/history.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -35,9 +35,9 @@

 All issues including closed ones can be viewed here.
 
-<a name="boost_regex.background_information.history.boost_1_48"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_48-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_48">Boost-1.48</a>
+<h5>
+<a name="boost_regex.background_information.history.h0"></a>
+ <a name="boost_regex.background_information.history.boost_1_48"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_48">Boost-1.48</a>
 </h5>

 Fixed issues: #698,
@@ -45,10 +45,9 @@
 <a href="https://svn.boost.org/trac/boost/ticket/5958" target="_top">#5958</a>,
 <a href="https://svn.boost.org/trac/boost/ticket/5736" target="_top">#5736</a>.
 
-<a name="boost_regex.background_information.history.boost_1_47"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_47-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_47">Boost
- 1.47</a>
+<h5>
+<a name="boost_regex.background_information.history.h1"></a>
+ <a name="boost_regex.background_information.history.boost_1_47"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_47">Boost 1.47</a>
 </h5>

 Fixed issues: #5223,
@@ -58,10 +57,9 @@
 <a href="https://svn.boost.org/trac/boost/ticket/5472" target="_top">#5472</a>,
 <a href="https://svn.boost.org/trac/boost/ticket/5504" target="_top">#5504</a>.
 
-<a name="boost_regex.background_information.history.boost_1_44"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_44-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_44">Boost
- 1.44</a>
+<h5>
+<a name="boost_regex.background_information.history.h2"></a>
+ <a name="boost_regex.background_information.history.boost_1_44"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_44">Boost 1.44</a>
 </h5>

 Fixed issues: #4309,
@@ -77,10 +75,9 @@
 <a href="https://svn.boost.org/trac/boost/ticket/3902" target="_top">#3902</a>,
 <a href="https://svn.boost.org/trac/boost/ticket/3890" target="_top">#3890</a>
 
-<a name="boost_regex.background_information.history.boost_1_42"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_42-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_42">Boost
- 1.42</a>
+<h5>
+<a name="boost_regex.background_information.history.h3"></a>
+ <a name="boost_regex.background_information.history.boost_1_42"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_42">Boost 1.42</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -106,19 +103,17 @@
 <a href="https://svn.boost.org/trac/boost/ticket/3764" target="_top">#3764</a>
 </li>
</ul></div>
-<a name="boost_regex.background_information.history.boost_1_40"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_40-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_40">Boost
- 1.40</a>
+<h5>
+<a name="boost_regex.background_information.history.h4"></a>
+ <a name="boost_regex.background_information.history.boost_1_40"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_40">Boost 1.40</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
 Added support for many Perl 5.10 syntax elements including named sub-expressions,
 branch resets and recursive regular expressions.
 </li></ul></div>
-<a name="boost_regex.background_information.history.boost_1_38"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_38-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_38">Boost
- 1.38</a>
+<h5>
+<a name="boost_regex.background_information.history.h5"></a>
+ <a name="boost_regex.background_information.history.boost_1_38"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_38">Boost 1.38</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -143,10 +138,9 @@
 and #2458.
 </li>
</ul></div>
-<a name="boost_regex.background_information.history.boost_1_34"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_34-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_34">Boost
- 1.34</a>
+<h5>
+<a name="boost_regex.background_information.history.h6"></a>
+ <a name="boost_regex.background_information.history.boost_1_34"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_34">Boost 1.34</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -166,10 +160,9 @@
 the same as |.
 </li>
</ul></div>
-<a name="boost_regex.background_information.history.boost_1_33_1"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_33_1-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_1">Boost
- 1.33.1</a>
+<h5>
+<a name="boost_regex.background_information.history.h7"></a>
+ <a name="boost_regex.background_information.history.boost_1_33_1"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_1">Boost 1.33.1</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -236,10 +229,9 @@
 Fixed bug that allowed some invalid expressions to be accepted.
 </li>
</ul></div>
-<a name="boost_regex.background_information.history.boost_1_33_0"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_33_0-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_0">Boost
- 1.33.0</a>
+<h5>
+<a name="boost_regex.background_information.history.h8"></a>
+ <a name="boost_regex.background_information.history.boost_1_33_0"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_0">Boost 1.33.0</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -288,21 +280,19 @@
 types used previously - bad_expression and bad_pattern - are now just
 typedefs for regex_error. Type regex_error has a couple of new members:
 code() to report an error code rather than a string, and position() to
- report where in the expression the error occured.
+ report where in the expression the error occurred.
 </li>
</ul></div>
-<a name="boost_regex.background_information.history.boost_1_32_1"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_32_1-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_32_1">Boost
- 1.32.1</a>
+<h5>
+<a name="boost_regex.background_information.history.h9"></a>
+ <a name="boost_regex.background_information.history.boost_1_32_1"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_32_1">Boost 1.32.1</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
 Fixed bug in partial matches of bounded repeats of '.'.
 </li></ul></div>
-<a name="boost_regex.background_information.history.boost_1_31_0"></a><h5>
-<a name="boost_regex.background_information.history.boost_1_31_0-heading"></a>
- <a class="link" href="history.html#boost_regex.background_information.history.boost_1_31_0">Boost
- 1.31.0</a>
+<h5>
+<a name="boost_regex.background_information.history.h10"></a>
+ <a name="boost_regex.background_information.history.boost_1_31_0"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_31_0">Boost 1.31.0</a>
 </h5>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">

Modified: trunk/libs/regex/doc/html/boost_regex/background_information/locale.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/background_information/locale.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/background_information/locale.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -57,9 +57,9 @@

 There are three separate localization mechanisms supported by Boost.Regex:
 
-<a name="boost_regex.background_information.locale.win32_localization_model_"></a><h5>
-<a name="boost_regex.background_information.locale.win32_localization_model_-heading"></a>
- <a class="link" href="locale.html#boost_regex.background_information.locale.win32_localization_model_">Win32
+<h5>
+<a name="boost_regex.background_information.locale.h0"></a>
+ <a name="boost_regex.background_information.locale.win32_localization_model_"></a><a class="link" href="locale.html#boost_regex.background_information.locale.win32_localization_model_">Win32
 localization model.</a>
 </h5>

@@ -89,9 +89,9 @@
 library degrades gracefully - characters 0 to 255 are supported, the remainder
 are treated as "unknown" graphic characters.
 
-<a name="boost_regex.background_information.locale.c_localization_model_"></a><h5>
-<a name="boost_regex.background_information.locale.c_localization_model_-heading"></a>
- <a class="link" href="locale.html#boost_regex.background_information.locale.c_localization_model_">C
+<h5>
+<a name="boost_regex.background_information.locale.h1"></a>
+ <a name="boost_regex.background_information.locale.c_localization_model_"></a><a class="link" href="locale.html#boost_regex.background_information.locale.c_localization_model_">C
 localization model.</a>
 </h5>

@@ -113,9 +113,9 @@
 will make this library behave equivalent to most traditional regular expression
 libraries including version 1 of this library.
 
-<a name="boost_regex.background_information.locale.c___localization_model_"></a><h5>
-<a name="boost_regex.background_information.locale.c___localization_model_-heading"></a>
- <a class="link" href="locale.html#boost_regex.background_information.locale.c___localization_model_">C++
+<h5>
+<a name="boost_regex.background_information.locale.h2"></a>
+ <a name="boost_regex.background_information.locale.c___localization_model_"></a><a class="link" href="locale.html#boost_regex.background_information.locale.c___localization_model_">C++
 localization model.</a>
 </h5>

@@ -150,9 +150,9 @@
 or <code class="computeroutput"><boost/cregex.hpp></code>
 in your code. The best way to ensure this is to add the #define to <code class="computeroutput"><boost/regex/user.hpp></code>.
 
-<a name="boost_regex.background_information.locale.providing_a_message_catalogue"></a><h5>
-<a name="boost_regex.background_information.locale.providing_a_message_catalogue-heading"></a>
- <a class="link" href="locale.html#boost_regex.background_information.locale.providing_a_message_catalogue">Providing
+<h5>
+<a name="boost_regex.background_information.locale.h3"></a>
+ <a name="boost_regex.background_information.locale.providing_a_message_catalogue"></a><a class="link" href="locale.html#boost_regex.background_information.locale.providing_a_message_catalogue">Providing
 a message catalogue</a>
 </h5>

Modified: trunk/libs/regex/doc/html/boost_regex/background_information/standards.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/background_information/standards.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/background_information/standards.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,17 +27,17 @@
<a name="boost_regex.background_information.standards"></a><a class="link" href="standards.html" title="Standards Conformance">Standards
 Conformance</a>
</h3></div></div></div>
-<a name="boost_regex.background_information.standards.c__"></a><h5>
-<a name="boost_regex.background_information.standards.c__-heading"></a>
- <a class="link" href="standards.html#boost_regex.background_information.standards.c__">C++</a>
+<h5>
+<a name="boost_regex.background_information.standards.h0"></a>
+ <a name="boost_regex.background_information.standards.c__"></a><a class="link" href="standards.html#boost_regex.background_information.standards.c__">C++</a>
 </h5>

 Boost.Regex is intended to conform to the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf" target="_top">Technical
 Report on C++ Library Extensions</a>.
 
-<a name="boost_regex.background_information.standards.ecmascript___javascript"></a><h5>
-<a name="boost_regex.background_information.standards.ecmascript___javascript-heading"></a>
- <a class="link" href="standards.html#boost_regex.background_information.standards.ecmascript___javascript">ECMAScript
+<h5>
+<a name="boost_regex.background_information.standards.h1"></a>
+ <a name="boost_regex.background_information.standards.ecmascript___javascript"></a><a class="link" href="standards.html#boost_regex.background_information.standards.ecmascript___javascript">ECMAScript
 / JavaScript</a>
 </h5>

@@ -48,9 +48,9 @@
 The escape sequence \u matches any upper case character (the same as [[:upper:]])
 rather than a Unicode escape sequence; use \x{DDDD} for Unicode escape sequences.
 
-<a name="boost_regex.background_information.standards.perl"></a><h5>
-<a name="boost_regex.background_information.standards.perl-heading"></a>
- <a class="link" href="standards.html#boost_regex.background_information.standards.perl">Perl</a>
+<h5>
+<a name="boost_regex.background_information.standards.h2"></a>
+ <a name="boost_regex.background_information.standards.perl"></a><a class="link" href="standards.html#boost_regex.background_information.standards.perl">Perl</a>
 </h5>

 Almost all Perl features are supported, except for:
@@ -72,9 +72,9 @@
 ^ $ \Z These recognise any line termination sequence, and not just \n: see
 the Unicode requirements below.
 
-<a name="boost_regex.background_information.standards.posix"></a><h5>
-<a name="boost_regex.background_information.standards.posix-heading"></a>
- <a class="link" href="standards.html#boost_regex.background_information.standards.posix">POSIX</a>
+<h5>
+<a name="boost_regex.background_information.standards.h3"></a>
+ <a name="boost_regex.background_information.standards.posix"></a><a class="link" href="standards.html#boost_regex.background_information.standards.posix">POSIX</a>
 </h5>

 All the POSIX basic and extended regular expression features are supported,
@@ -92,9 +92,9 @@
 implementation doesn't work on your platform, then you will need to supply
 a custom traits class.
 
-<a name="boost_regex.background_information.standards.unicode"></a><h5>
-<a name="boost_regex.background_information.standards.unicode-heading"></a>
- <a class="link" href="standards.html#boost_regex.background_information.standards.unicode">Unicode</a>
+<h5>
+<a name="boost_regex.background_information.standards.h4"></a>
+ <a name="boost_regex.background_information.standards.unicode"></a><a class="link" href="standards.html#boost_regex.background_information.standards.unicode">Unicode</a>
 </h5>

 The following comments refer to <a href="http://unicode.org/reports/tr18/" target="_top">Unicode

Modified: trunk/libs/regex/doc/html/boost_regex/captures.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/captures.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/captures.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -34,9 +34,10 @@
 how captures and marked sub-expressions in Boost.Regex are represented and
 accessed.
 
-<a name="boost_regex.captures.marked_sub_expressions"></a><h5>
-<a name="boost_regex.captures.marked_sub_expressions-heading"></a>
- <a class="link" href="captures.html#boost_regex.captures.marked_sub_expressions">Marked sub-expressions</a>
+<h5>
+<a name="boost_regex.captures.h0"></a>
+ <a name="boost_regex.captures.marked_sub_expressions"></a><a class="link" href="captures.html#boost_regex.captures.marked_sub_expressions">Marked
+ sub-expressions</a>
 </h5>

 Every time a Perl regular expression contains a parenthesis group <code class="computeroutput">()</code>, it spits out an extra field, known as a
@@ -217,9 +218,10 @@
 they can be compared to a string, added to a string, or streamed out to an
 output stream.
 
-<a name="boost_regex.captures.unmatched_sub_expressions"></a><h5>
-<a name="boost_regex.captures.unmatched_sub_expressions-heading"></a>
- <a class="link" href="captures.html#boost_regex.captures.unmatched_sub_expressions">Unmatched Sub-Expressions</a>
+<h5>
+<a name="boost_regex.captures.h1"></a>
+ <a name="boost_regex.captures.unmatched_sub_expressions"></a><a class="link" href="captures.html#boost_regex.captures.unmatched_sub_expressions">Unmatched
+ Sub-Expressions</a>
 </h5>

 When a regular expression match is found there is no need for all of the marked
@@ -230,9 +232,10 @@
 can match either $1 or $2, but never both at the same time. In Boost.Regex
 you can determine which sub-expressions matched by accessing the <code class="computeroutput">sub_match::matched</code> data member.
 
-<a name="boost_regex.captures.repeated_captures"></a><h5>
-<a name="boost_regex.captures.repeated_captures-heading"></a>
- <a class="link" href="captures.html#boost_regex.captures.repeated_captures">Repeated Captures</a>
+<h5>
+<a name="boost_regex.captures.h2"></a>
+ <a name="boost_regex.captures.repeated_captures"></a><a class="link" href="captures.html#boost_regex.captures.repeated_captures">Repeated
+ Captures</a>
 </h5>

 When a marked sub-expression is repeated, then the sub-expression gets "captured"
@@ -296,7 +299,7 @@
 print_captures("(([[:lower:]]+)|([[:upper:]]+))+", "aBBcccDDDDDeeeeeeee");
 print_captures("(.*)bar|(.*)bah", "abcbar");
 print_captures("(.*)bar|(.*)bah", "abcbah");
- print_captures("^(?:(\\w+)|(?>\\W+))*$",
+ print_captures("^(?:(\\w+)|(?>\\W+))*$",
 "now is the time for all good men to come to the aid of the party");
 return 0;
}
@@ -347,7 +350,7 @@
 $1 = "party"
 Captures:
 $0 = { "now is the time for all good men to come to the aid of the party" }
- $1 = { "now", "is", "the", "time", "for", "all", "good", "men", "to",
+ $1 = { "now", "is", "the", "time", "for", "all", "good", "men", "to",
 "come", "to", "the", "aid", "of", "the", "party" }
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -31,17 +31,17 @@
 Boost-Extended format strings treat all characters as literals except for
 '$', '\', '(', ')', '?', and ':'.
 
-<a name="boost_regex.format.boost_format_syntax.grouping"></a><h5>
-<a name="boost_regex.format.boost_format_syntax.grouping-heading"></a>
- <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.grouping">Grouping</a>
+<h5>
+<a name="boost_regex.format.boost_format_syntax.h0"></a>
+ <a name="boost_regex.format.boost_format_syntax.grouping"></a><a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.grouping">Grouping</a>
 </h5>

 The characters '(' and ')' perform lexical grouping, so use $ and $ if
 you want a to output literal parenthesis.
 
-<a name="boost_regex.format.boost_format_syntax.conditionals"></a><h5>
-<a name="boost_regex.format.boost_format_syntax.conditionals-heading"></a>
- <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.conditionals">Conditionals</a>
+<h5>
+<a name="boost_regex.format.boost_format_syntax.h1"></a>
+ <a name="boost_regex.format.boost_format_syntax.conditionals"></a><a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.conditionals">Conditionals</a>
 </h5>

 The character '?' begins a conditional expression, the general form is:
@@ -78,9 +78,9 @@

 ?{NAME}true-expression:false-expression
 
-<a name="boost_regex.format.boost_format_syntax.placeholder_sequences"></a><h5>
-<a name="boost_regex.format.boost_format_syntax.placeholder_sequences-heading"></a>
- <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.placeholder_sequences">Placeholder
+<h5>
+<a name="boost_regex.format.boost_format_syntax.h2"></a>
+ <a name="boost_regex.format.boost_format_syntax.placeholder_sequences"></a><a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.placeholder_sequences">Placeholder
 Sequences</a>
 </h5>

@@ -318,9 +318,9 @@
 Any $-placeholder sequence not listed above, results in '$' being treated
 as a literal.
 
-<a name="boost_regex.format.boost_format_syntax.escape_sequences"></a><h5>
-<a name="boost_regex.format.boost_format_syntax.escape_sequences-heading"></a>
- <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.escape_sequences">Escape
+<h5>
+<a name="boost_regex.format.boost_format_syntax.h3"></a>
+ <a name="boost_regex.format.boost_format_syntax.escape_sequences"></a><a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.escape_sequences">Escape
 Sequences</a>
 </h5>

Modified: trunk/libs/regex/doc/html/boost_regex/install.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/install.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/install.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -48,18 +48,19 @@
 it is necessary to build the library's support code into a library or archive
 file before you can use it, instructions for specific platforms are as follows:
 
-<a name="boost_regex.install.building_with_bjam"></a><h5>
-<a name="boost_regex.install.building_with_bjam-heading"></a>
- <a class="link" href="install.html#boost_regex.install.building_with_bjam">Building with bjam</a>
+<h5>
+<a name="boost_regex.install.h0"></a>
+ <a name="boost_regex.install.building_with_bjam"></a><a class="link" href="install.html#boost_regex.install.building_with_bjam">Building
+ with bjam</a>
 </h5>

 This is now the preferred method for building and installing this library,
 please refer to the <a href="../../../../../more/getting_started.html" target="_top">getting
 started guide</a> for more information.
 
-<a name="boost_regex.install.building_with_unicode_and_icu_support"></a><h5>
-<a name="boost_regex.install.building_with_unicode_and_icu_support-heading"></a>
- <a class="link" href="install.html#boost_regex.install.building_with_unicode_and_icu_support">Building
+<h5>
+<a name="boost_regex.install.h1"></a>
+ <a name="boost_regex.install.building_with_unicode_and_icu_support"></a><a class="link" href="install.html#boost_regex.install.building_with_unicode_and_icu_support">Building
 With Unicode and ICU Support</a>
 </h5>

@@ -156,13 +157,15 @@
 the ICU binaries use the standard names, all you have to add is the appropriate
 header-include and linker-search paths).
 
-<a name="boost_regex.install.building_via_makefiles"></a><h5>
-<a name="boost_regex.install.building_via_makefiles-heading"></a>
- <a class="link" href="install.html#boost_regex.install.building_via_makefiles">Building via makefiles</a>
+<h5>
+<a name="boost_regex.install.h2"></a>
+ <a name="boost_regex.install.building_via_makefiles"></a><a class="link" href="install.html#boost_regex.install.building_via_makefiles">Building
+ via makefiles</a>
 </h5>
-<a name="boost_regex.install.borland_c___builder_"></a><h6>
-<a name="boost_regex.install.borland_c___builder_-heading"></a>
- <a class="link" href="install.html#boost_regex.install.borland_c___builder_">Borland C++ Builder:</a>
+<h6>
+<a name="boost_regex.install.h3"></a>
+ <a name="boost_regex.install.borland_c___builder_"></a><a class="link" href="install.html#boost_regex.install.borland_c___builder_">Borland
+ C++ Builder:</a>
 </h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
@@ -225,9 +228,9 @@
 building, this will disable some features throughout boost, but may save you
 a lot in compile times!
 
-<a name="boost_regex.install.microsoft_visual_c___6__7__7_1_and_8"></a><h5>
-<a name="boost_regex.install.microsoft_visual_c___6__7__7_1_and_8-heading"></a>
- <a class="link" href="install.html#boost_regex.install.microsoft_visual_c___6__7__7_1_and_8">Microsoft
+<h5>
+<a name="boost_regex.install.h4"></a>
+ <a name="boost_regex.install.microsoft_visual_c___6__7__7_1_and_8"></a><a class="link" href="install.html#boost_regex.install.microsoft_visual_c___6__7__7_1_and_8">Microsoft
 Visual C++ 6, 7, 7.1 and 8</a>
 </h5>

@@ -313,9 +316,10 @@
 to modify the makefile to add /Zc:wchar_t before building the library.
 </li>
</ul></div>
-<a name="boost_regex.install.gcc_2_95_and_later_"></a><h6>
-<a name="boost_regex.install.gcc_2_95_and_later_-heading"></a>
- <a class="link" href="install.html#boost_regex.install.gcc_2_95_and_later_">GCC(2.95 and later)</a>
+<h6>
+<a name="boost_regex.install.h5"></a>
+ <a name="boost_regex.install.gcc_2_95_and_later_"></a><a class="link" href="install.html#boost_regex.install.gcc_2_95_and_later_">GCC(2.95
+ and later)</a>
 </h6>

 You can build with gcc using the normal boost Jamfile in <code class="computeroutput"><boost>/libs/regex/build</code>, alternatively
@@ -362,9 +366,10 @@
 For the more adventurous there is a configure script in <code class="computeroutput"><boost>/libs/config</code>;
 see the config library documentation.
 
-<a name="boost_regex.install.sun_workshop_6_1"></a><h6>
-<a name="boost_regex.install.sun_workshop_6_1-heading"></a>
- <a class="link" href="install.html#boost_regex.install.sun_workshop_6_1">Sun Workshop 6.1</a>
+<h6>
+<a name="boost_regex.install.h6"></a>
+ <a name="boost_regex.install.sun_workshop_6_1"></a><a class="link" href="install.html#boost_regex.install.sun_workshop_6_1">Sun
+ Workshop 6.1</a>
 </h6>

 There is a makefile for the sun (6.1) compiler (C++ version 3.12). From the
@@ -407,9 +412,9 @@

 will build v9 variants of the regex library named libboost_regex_v9.a etc.
 
-<a name="boost_regex.install.makefiles_for_other_compilers"></a><h6>
-<a name="boost_regex.install.makefiles_for_other_compilers-heading"></a>
- <a class="link" href="install.html#boost_regex.install.makefiles_for_other_compilers">Makefiles
+<h6>
+<a name="boost_regex.install.h7"></a>
+ <a name="boost_regex.install.makefiles_for_other_compilers"></a><a class="link" href="install.html#boost_regex.install.makefiles_for_other_compilers">Makefiles
 for Other compilers</a>
 </h6>

Modified: trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -49,7 +49,7 @@
 
<pre class="programlisting">namespace boost{

-template <class charT,
+template <class charT,
 class traits = regex_traits<charT> >
class basic_regex;

@@ -72,7 +72,7 @@
 leaves us with the following regular expression to validate credit card number
 formats:
 
-<pre class="programlisting">(\d{4}){3}\d{4}</pre>
+<pre class="programlisting">(\d{4}[- ]){3}\d{4}</pre>

 Here the parenthesis act to group (and mark for future reference) sub-expressions,
 and the {4} means "repeat exactly 4 times". This is an example of
@@ -146,7 +146,7 @@
typedef match_results<const char*> cmatch;
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<std::string::const_iterator> smatch;
-typedef match_results<std::wstring::const_iterator> wsmatch;
+typedef match_results<std::wstring::const_iterator> wsmatch;

}
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/partial_matches.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/partial_matches.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/partial_matches.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -262,10 +262,10 @@
 next_pos = buf + sizeof(buf);
 // and then iterate:
 boost::cregex_iterator a(
- buf,
- buf + read + leftover,
- e,
- boost::match_default | boost::match_partial);
+ buf,
+ buf + read + leftover,
+ e,
+ boost::match_default | boost::match_partial);
 boost::cregex_iterator b;

 while(a != b)
@@ -281,7 +281,7 @@
 // full match:
 ++tags;
 }
-
+
 // move to next match:
 ++a;
 }

Modified: trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,9 +26,9 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.bad_expression"></a><a class="link" href="bad_expression.html" title="bad_expression">bad_expression</a>
</h3></div></div></div>
-<a name="boost_regex.ref.bad_expression.synopsis"></a><h5>
-<a name="boost_regex.ref.bad_expression.synopsis-heading"></a>
- <a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.synopsis">Synopsis</a>
+<h5>
+<a name="boost_regex.ref.bad_expression.h0"></a>
+ <a name="boost_regex.ref.bad_expression.synopsis"></a><a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.synopsis">Synopsis</a>
 </h5>
<pre class="programlisting">#include <boost/pattern_except.hpp>
</pre>
@@ -53,9 +53,9 @@

} // namespace boost
</pre>
-<a name="boost_regex.ref.bad_expression.description"></a><h5>
-<a name="boost_regex.ref.bad_expression.description-heading"></a>
- <a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.description">Description</a>
+<h5>
+<a name="boost_regex.ref.bad_expression.h1"></a>
+ <a name="boost_regex.ref.bad_expression.description"></a><a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.description">Description</a>
 </h5>
<pre class="programlisting">regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos);
regex_error(boost::regex_constants::error_type err);
@@ -69,7 +69,7 @@
 Effects: returns the error code that represents
 parsing error that occurred.
 
-<pre class="programlisting">std::ptrdiff_t position()const;
+<pre class="programlisting">std::ptrdiff_t position()const;
</pre>

 Effects: returns the location in the expression

Modified: trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,9 +26,9 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.basic_regex"></a><a class="link" href="basic_regex.html" title="basic_regex">basic_regex</a>
</h3></div></div></div>
-<a name="boost_regex.ref.basic_regex.synopsis"></a><h5>
-<a name="boost_regex.ref.basic_regex.synopsis-heading"></a>
- <a class="link" href="basic_regex.html#boost_regex.ref.basic_regex.synopsis">Synopsis</a>
+<h5>
+<a name="boost_regex.ref.basic_regex.h0"></a>
+ <a name="boost_regex.ref.basic_regex.synopsis"></a><a class="link" href="basic_regex.html#boost_regex.ref.basic_regex.synopsis">Synopsis</a>
 </h5>
<pre class="programlisting">#include <boost/regex.hpp>
</pre>
@@ -76,112 +76,112 @@

template <class charT, class traits = regex_traits<charT> >
class basic_regex {
- public:
+ public:
 // types:
 typedef charT value_type;
 typedef implementation-specific const_iterator;
- typedef const_iterator iterator;
- typedef charT& reference;
- typedef const charT& const_reference;
- typedef std::ptrdiff_t difference_type;
+ typedef const_iterator iterator;
+ typedef charT& reference;
+ typedef const charT& const_reference;
+ typedef std::ptrdiff_t difference_type;
 typedef std::size_t size_type;
 typedef regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> flag_type;
 typedef typename traits::locale_type locale_type;

 // constants:
 // main option selection:
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> normal
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> normal
 = regex_constants::normal;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> ECMAScript
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> ECMAScript
 = normal;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JavaScript
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JavaScript
 = normal;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JScript
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JScript
 = normal;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> basic
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> basic
 = regex_constants::basic;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> extended
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> extended
 = regex_constants::extended;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> awk
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> awk
 = regex_constants::awk;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> grep
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> grep
 = regex_constants::grep;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> egrep
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> egrep
 = regex_constants::egrep;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> sed
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> sed
 = basic = regex_constants::sed;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> perl
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> perl
 = regex_constants::perl;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> literal
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> literal
 = regex_constants::literal;

 // modifiers specific to perl expressions:
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_m
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_m
 = regex_constants::no_mod_m;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_s
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_s
 = regex_constants::no_mod_s;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_s
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_s
 = regex_constants::mod_s;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_x
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_x
 = regex_constants::mod_x;

 // modifiers specific to POSIX basic expressions:
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_plus_qm
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_plus_qm
 = regex_constants::bk_plus_qm;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_vbar
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_vbar
 = regex_constants::bk_vbar
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_char_classes
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_char_classes
 = regex_constants::no_char_classes
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_intervals
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_intervals
 = regex_constants::no_intervals

 // common modifiers:
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> nosubs
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> nosubs
 = regex_constants::nosubs;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> optimize
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> optimize
 = regex_constants::optimize;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> collate
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> collate
 = regex_constants::collate;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> newline_alt
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> newline_alt
 = regex_constants::newline_alt;
- static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_except
+ static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_except
 = regex_constants::newline_alt;

 // construct/copy/destroy:
 explicit <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct1">basic_regex</a> ();
 explicit <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct2">basic_regex</a>(const charT* p, flag_type f = regex_constants::normal);
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct3">basic_regex</a>(const charT* p1, const charT* p2,
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct3">basic_regex</a>(const charT* p1, const charT* p2,
 flag_type f = regex_constants::normal);
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct4">basic_regex</a>(const charT* p, size_type len, flag_type f);
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct5">basic_regex</a>(const basic_regex&);

 template <class ST, class SA>
- explicit <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct6">basic_regex</a>(const basic_string<charT, ST, SA>& p,
+ explicit <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct6">basic_regex</a>(const basic_string<charT, ST, SA>& p,
 flag_type f = regex_constants::normal);

 template <class InputIterator>
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct7">basic_regex</a>(InputIterator first, InputIterator last,
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.construct7">basic_regex</a>(InputIterator first, InputIterator last,
 flag_type f = regex_constants::normal);

 ~basic_regex();
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.opeq1">basic_regex& operator=</a>(const basic_regex&);
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.opeq2">basic_regex& operator=</a> (const charT* ptr);
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.opeq2">basic_regex& operator=</a> (const charT* ptr);

- template <class ST, class SA>
+ template <class ST, class SA>
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.opeq3">basic_regex& operator=</a> (const basic_string<charT, ST, SA>& p);
 // iterators: 
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.subexpression">std::pair<const_iterator, const_iterator> subexpression</a>(size_type n) const;
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.begin">const_iterator begin</a>() const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.subexpression">std::pair<const_iterator, const_iterator> subexpression</a>(size_type n) const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.begin">const_iterator begin</a>() const;
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.end">const_iterator end</a>() const;
 // capacity: 
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.size">size_type size</a>() const;
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.max_size">size_type max_size</a>() const;
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.empty">bool empty</a>() const;
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.mark_count">size_type mark_count</a>()const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.size">size_type size</a>() const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.max_size">size_type max_size</a>() const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.empty">bool empty</a>() const;
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.mark_count">size_type mark_count</a>()const;
 //
 // modifiers: 
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.assign1">basic_regex& assign</a>(const basic_regex& that);
- <a class="link" href="basic_regex.html#boost_regex.basic_regex.assign2">basic_regex& assign</a>(const charT* ptr,
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.assign1">basic_regex& assign</a>(const basic_regex& that);
+ <a class="link" href="basic_regex.html#boost_regex.basic_regex.assign2">basic_regex& assign</a>(const charT* ptr,
 flag_type f = regex_constants::normal);
 <a class="link" href="basic_regex.html#boost_regex.basic_regex.assign3">basic_regex& assign</a>(const charT* ptr, unsigned int len, flag_type f);

@@ -243,68 +243,68 @@

} // namespace boost
</pre>
-<a name="boost_regex.ref.basic_regex.description"></a><h5>
-<a name="boost_regex.ref.basic_regex.description-heading"></a>
- <a class="link" href="basic_regex.html#boost_regex.ref.basic_regex.description">Description</a>
+<h5>
+<a name="boost_regex.ref.basic_regex.h1"></a>
+ <a name="boost_regex.ref.basic_regex.description"></a><a class="link" href="basic_regex.html#boost_regex.ref.basic_regex.description">Description</a>
 </h5>

 Class <code class="computeroutput">basic_regex</code> has the
 following public members:
 
<pre class="programlisting">// main option selection:
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> normal
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> normal
 = regex_constants::normal;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> ECMAScript
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> ECMAScript
 = normal;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JavaScript
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JavaScript
 = normal;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JScript
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> JScript
 = normal;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> basic
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> basic
 = regex_constants::basic;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> extended
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> extended
 = regex_constants::extended;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> awk
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> awk
 = regex_constants::awk;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> grep
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> grep
 = regex_constants::grep;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> egrep
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> egrep
 = regex_constants::egrep;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> sed
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> sed
 = regex_constants::sed;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> perl
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> perl
 = regex_constants::perl;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> literal
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> literal
 = regex_constants::literal;

// modifiers specific to perl expressions:
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_m
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_m
 = regex_constants::no_mod_m;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_s
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_mod_s
 = regex_constants::no_mod_s;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_s
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_s
 = regex_constants::mod_s;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_x
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> mod_x
 = regex_constants::mod_x;

// modifiers specific to POSIX basic expressions:
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_plus_qm
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_plus_qm
 = regex_constants::bk_plus_qm;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_vbar
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> bk_vbar
 = regex_constants::bk_vbar
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_char_classes
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_char_classes
 = regex_constants::no_char_classes
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_intervals
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> no_intervals
 = regex_constants::no_intervals

// common modifiers:
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> nosubs
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> nosubs
 = regex_constants::nosubs;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> optimize
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> optimize
 = regex_constants::optimize;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> collate
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> collate
 = regex_constants::collate;
-static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> newline_alt
+static const regex_constants:: <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput">syntax_option_type</code></a> newline_alt
 = regex_constants::newline_alt;
</pre>

@@ -325,7 +325,7 @@
 <code class="computeroutput">basic_regex</code>.
 
<div class="table">
-<a name="id1070109"></a>Table 1. basic_regex default construction postconditions
+<a name="boost_regex.ref.basic_regex.t0"></a>Table 1. basic_regex default construction postconditions
<div class="table-contents"><table class="table" summary="basic_regex default construction postconditions">
<colgroup>
<col>
@@ -403,7 +403,7 @@
 flags</a> specified in f.
 
<div class="table">
-<a name="id1070408"></a>Table 2. Postconditions for basic_regex construction
+<a name="boost_regex.ref.basic_regex.t1"></a>Table 2. Postconditions for basic_regex construction
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex construction">
<colgroup>
<col>
@@ -485,7 +485,7 @@
</tbody>
</table></div>
</div>
- <a name="boost_regex.basic_regex.construct3"></a><pre class="programlisting">basic_regex(const charT* p1, const charT* p2,
+ <a name="boost_regex.basic_regex.construct3"></a><pre class="programlisting">basic_regex(const charT* p1, const charT* p2,
 flag_type f = regex_constants::normal);
</pre>

@@ -506,7 +506,7 @@
 specified in f.
 
<div class="table">
-<a name="id1070825"></a>Table 3. Postconditions for basic_regex construction
+<a name="boost_regex.ref.basic_regex.t2"></a>Table 3. Postconditions for basic_regex construction
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex construction">
<colgroup>
<col>
@@ -608,7 +608,7 @@
 according the option flags specified in f.
 
<div class="table">
-<a name="id1071233"></a>Table 4. Postconditions for basic_regex construction
+<a name="boost_regex.ref.basic_regex.t3"></a>Table 4. Postconditions for basic_regex construction
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex construction">
<colgroup>
<col>
@@ -699,7 +699,7 @@
 as a copy of the object e.
 
<a name="boost_regex.basic_regex.construct6"></a><pre class="programlisting">template <class ST, class SA>
-basic_regex(const basic_string<charT, ST, SA>& s,
+basic_regex(const basic_string<charT, ST, SA>& s,
 flag_type f = regex_constants::normal);
</pre>

@@ -716,7 +716,7 @@
 flags</a> specified in f.
 
<div class="table">
-<a name="id1071710"></a>Table 5. Postconditions for basic_regex construction
+<a name="boost_regex.ref.basic_regex.t4"></a>Table 5. Postconditions for basic_regex construction
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex construction">
<colgroup>
<col>
@@ -799,7 +799,7 @@
</table></div>
</div>
 <a name="boost_regex.basic_regex.construct7"></a><pre class="programlisting">template <class ForwardIterator>
-basic_regex(ForwardIterator first, ForwardIterator last,
+basic_regex(ForwardIterator first, ForwardIterator last,
 flag_type f = regex_constants::normal);
</pre>

@@ -816,7 +816,7 @@
 flags</a> specified in f.
 
<div class="table">
-<a name="id1072072"></a>Table 6. Postconditions for basic_regex construction
+<a name="boost_regex.ref.basic_regex.t5"></a>Table 6. Postconditions for basic_regex construction
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex construction">
<colgroup>
<col>
@@ -1002,7 +1002,7 @@
 in f.
 
<div class="table">
-<a name="id1074091"></a>Table 7. Postconditions for basic_regex::assign
+<a name="boost_regex.ref.basic_regex.t6"></a>Table 7. Postconditions for basic_regex::assign
<div class="table-contents"><table class="table" summary="Postconditions for basic_regex::assign">
<colgroup>
<col>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/concepts/traits_concept.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/concepts/traits_concept.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/concepts/traits_concept.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -33,9 +33,9 @@
 (which is part of the regex standardization proposal), and an optional
 Boost-specific enhanced interface.
 
-<a name="boost_regex.ref.concepts.traits_concept.minimal_requirements_"></a><h5>
-<a name="boost_regex.ref.concepts.traits_concept.minimal_requirements_-heading"></a>
- <a class="link" href="traits_concept.html#boost_regex.ref.concepts.traits_concept.minimal_requirements_">Minimal
+<h5>
+<a name="boost_regex.ref.concepts.traits_concept.h0"></a>
+ <a name="boost_regex.ref.concepts.traits_concept.minimal_requirements_"></a><a class="link" href="traits_concept.html#boost_regex.ref.concepts.traits_concept.minimal_requirements_">Minimal
 requirements.</a>
 </h5>

@@ -377,9 +377,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.ref.concepts.traits_concept.additional_optional_requirements"></a><h5>
-<a name="boost_regex.ref.concepts.traits_concept.additional_optional_requirements-heading"></a>
- <a class="link" href="traits_concept.html#boost_regex.ref.concepts.traits_concept.additional_optional_requirements">Additional
+<h5>
+<a name="boost_regex.ref.concepts.traits_concept.h1"></a>
+ <a name="boost_regex.ref.concepts.traits_concept.additional_optional_requirements"></a><a class="link" href="traits_concept.html#boost_regex.ref.concepts.traits_concept.additional_optional_requirements">Additional
 Optional Requirements</a>
 </h5>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -63,52 +63,52 @@
 // now matching operators: 
 // 
 bool Match(const char* p, boost::match_flag_type flags = match_default);
- bool Match(const std::string& s, boost::match_flag_type flags = match_default);
- bool Search(const char* p, boost::match_flag_type flags = match_default);
- bool Search(const std::string& s, boost::match_flag_type flags = match_default);
- unsigned int Grep(GrepCallback cb, const char* p,
- boost::match_flag_type flags = match_default);
- unsigned int Grep(GrepCallback cb, const std::string& s,
- boost::match_flag_type flags = match_default);
- unsigned int Grep(std::vector<std::string>& v, const char* p,
- boost::match_flag_type flags = match_default);
- unsigned int Grep(std::vector<std::string>& v, const std::string& s,
- boost::match_flag_type flags = match_default);
- unsigned int Grep(std::vector<unsigned int>& v, const char* p,
- boost::match_flag_type flags = match_default);
- unsigned int Grep(std::vector<unsigned int>& v, const std::string& s,
- boost::match_flag_type flags = match_default);
- unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false,
- boost::match_flag_type flags = match_default);
- unsigned int GrepFiles(GrepFileCallback cb, const std::string& files,
- bool recurse = false,
- boost::match_flag_type flags = match_default);
- unsigned int FindFiles(FindFilesCallback cb, const char* files,
- bool recurse = false,
- boost::match_flag_type flags = match_default);
- unsigned int FindFiles(FindFilesCallback cb, const std::string& files,
- bool recurse = false,
- boost::match_flag_type flags = match_default);
- std::string Merge(const std::string& in, const std::string& fmt,
- bool copy = true, boost::match_flag_type flags = match_default);
- std::string Merge(const char* in, const char* fmt, bool copy = true,
- boost::match_flag_type flags = match_default);
- unsigned Split(std::vector<std::string>& v, std::string& s,
- boost::match_flag_type flags = match_default,
- unsigned max_count = ~0);
+ bool Match(const std::string& s, boost::match_flag_type flags = match_default);
+ bool Search(const char* p, boost::match_flag_type flags = match_default);
+ bool Search(const std::string& s, boost::match_flag_type flags = match_default);
+ unsigned int Grep(GrepCallback cb, const char* p,
+ boost::match_flag_type flags = match_default);
+ unsigned int Grep(GrepCallback cb, const std::string& s,
+ boost::match_flag_type flags = match_default);
+ unsigned int Grep(std::vector<std::string>& v, const char* p,
+ boost::match_flag_type flags = match_default);
+ unsigned int Grep(std::vector<std::string>& v, const std::string& s,
+ boost::match_flag_type flags = match_default);
+ unsigned int Grep(std::vector<unsigned int>& v, const char* p,
+ boost::match_flag_type flags = match_default);
+ unsigned int Grep(std::vector<unsigned int>& v, const std::string& s,
+ boost::match_flag_type flags = match_default);
+ unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false,
+ boost::match_flag_type flags = match_default);
+ unsigned int GrepFiles(GrepFileCallback cb, const std::string& files,
+ bool recurse = false,
+ boost::match_flag_type flags = match_default);
+ unsigned int FindFiles(FindFilesCallback cb, const char* files,
+ bool recurse = false,
+ boost::match_flag_type flags = match_default);
+ unsigned int FindFiles(FindFilesCallback cb, const std::string& files,
+ bool recurse = false,
+ boost::match_flag_type flags = match_default);
+ std::string Merge(const std::string& in, const std::string& fmt,
+ bool copy = true, boost::match_flag_type flags = match_default);
+ std::string Merge(const char* in, const char* fmt, bool copy = true,
+ boost::match_flag_type flags = match_default);
+ unsigned Split(std::vector<std::string>& v, std::string& s,
+ boost::match_flag_type flags = match_default,
+ unsigned max_count = ~0);
 // 
 // now operators for returning what matched in more detail: 
 // 
- unsigned int Position(int i = 0)const;
- unsigned int Length(int i = 0)const;
+ unsigned int Position(int i = 0)const;
+ unsigned int Length(int i = 0)const;
 bool Matched(int i = 0)const;
- unsigned int Line()const;
- unsigned int Marks() const;
- std::string What(int i)const;
- std::string operator[](int i)const ;
+ unsigned int Line()const;
+ unsigned int Marks() const;
+ std::string What(int i)const;
+ std::string operator[](int i)const ;

 static const unsigned int npos;
-};
+};
</pre>

 Member functions for class RegEx are defined as follows:

Modified: trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -33,9 +33,9 @@
 will continue to compile, the following documentation is taken from the
 previous version of Boost.Regex and will not be further updated:
 
-<a name="boost_regex.ref.deprecated_interfaces.regex_format.algorithm_regex_format"></a><h5>
-<a name="boost_regex.ref.deprecated_interfaces.regex_format.algorithm_regex_format-heading"></a>
- <a class="link" href="regex_format.html#boost_regex.ref.deprecated_interfaces.regex_format.algorithm_regex_format">Algorithm
+<h5>
+<a name="boost_regex.ref.deprecated_interfaces.regex_format.h0"></a>
+ <a name="boost_regex.ref.deprecated_interfaces.regex_format.algorithm_regex_format"></a><a class="link" href="regex_format.html#boost_regex.ref.deprecated_interfaces.regex_format.algorithm_regex_format">Algorithm
 regex_format</a>
 </h5>
<pre class="programlisting">#include <boost/regex.hpp>
@@ -68,7 +68,7 @@
</table></div>
<pre class="programlisting">template <class iterator, class Allocator, class Formatter>
std::basic_string<charT> regex_format
- (const match_results<iterator, Allocator>& m,
+ (const match_results<iterator, Allocator>& m,
 Formatter fmt,
 match_flag_type flags = 0);
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -57,15 +57,15 @@
 in place of a pair of iterators.
 
<pre class="programlisting">template <class Predicate, class charT, class traits>
-unsigned int regex_grep(Predicate foo,
- const charT* str,
- const basic_regex<charT, traits>& e,
+unsigned int regex_grep(Predicate foo,
+ const charT* str,
+ const basic_regex<charT, traits>& e,
 boost::match_flag_type flags = match_default);

template <class Predicate, class ST, class SA, class charT, class traits>
-unsigned int regex_grep(Predicate foo,
- const std::basic_string<charT, ST, SA>& s,
- const basic_regex<charT, traits>& e,
+unsigned int regex_grep(Predicate foo,
+ const std::basic_string<charT, ST, SA>& s,
+ const basic_regex<charT, traits>& e,
 boost::match_flag_type flags = match_default);
</pre>

@@ -131,23 +131,23 @@

 Example: convert the example from <a class="link" href="../regex_search.html" title="regex_search"><code class="computeroutput">regex_search</code></a> to use <code class="computeroutput">regex_grep</code> instead:
 
-<pre class="programlisting">#include <string>
-#include <map>
-#include <boost/regex.hpp>
+<pre class="programlisting">#include <string>
+#include <map>
+#include <boost/regex.hpp>

// IndexClasses: 
// takes the contents of a file in the form of a string 
// and searches for all the C++ class definitions, storing 
// their locations in a map of strings/int's 
-typedef std::map<std::string, int, std::less<std::string> > map_type;
+typedef std::map<std::string, int, std::less<std::string> > map_type;

-const char* re =
+const char* re =
 // possibly leading whitespace: 
- "^[[:space:]]*"
+ "^[[:space:]]*"
 // possible template declaration:
 "(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
 // class or struct:
- "(class|struct)[[:space:]]*"
+ "(class|struct)[[:space:]]*"
 // leading declspec macros etc:
 "("
 "\\<\\w+\\>"
@@ -155,61 +155,61 @@
 "[[:blank:]]*\$[^)]*\$"
 ")?"
 "[[:space:]]*"
- ")*"
+ ")*"
 // the class name
- "(\\<\\w*\\>)[[:space:]]*"
+ "(\\<\\w*\\>)[[:space:]]*"
 // template specialisation parameters
 "(<[^;:{]+>)?[[:space:]]*"
 // terminate in { or :
 "(\\{|:[^;\\{()]*\\{)";

-boost::regex expression(re);
-class IndexClassesPred
-{
- map_type& m;
- std::string::const_iterator base;
-public:
- IndexClassesPred(map_type& a, std::string::const_iterator b) : m(a), base(b) {}
- bool operator()(const smatch& what)
- {
+boost::regex expression(re);
+class IndexClassesPred
+{
+ map_type& m;
+ std::string::const_iterator base;
+public:
+ IndexClassesPred(map_type& a, std::string::const_iterator b) : m(a), base(b) {}
+ bool operator()(const smatch& what)
+ {
 // what[0] contains the whole string 
 // what[5] contains the class name. 
 // what[6] contains the template specialisation if any. 
 // add class name and position to map: 
- m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
- what[5].first - base;
- return true;
- }
-};
-void IndexClasses(map_type& m, const std::string& file)
-{
- std::string::const_iterator start, end;
- start = file.begin();
- end = file.end();
- regex_grep(IndexClassesPred(m, start), start, end, expression);
+ m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
+ what[5].first - base;
+ return true;
+ }
+};
+void IndexClasses(map_type& m, const std::string& file)
+{
+ std::string::const_iterator start, end;
+ start = file.begin();
+ end = file.end();
+ regex_grep(IndexClassesPred(m, start), start, end, expression);
}
</pre>

 Example: Use <code class="computeroutput">regex_grep</code>
 to call a global callback function:
 
-<pre class="programlisting">#include <string>
-#include <map>
-#include <boost/regex.hpp>
+<pre class="programlisting">#include <string>
+#include <map>
+#include <boost/regex.hpp>

// purpose: 
// takes the contents of a file in the form of a string 
// and searches for all the C++ class definitions, storing 
// their locations in a map of strings/int's 
-typedef std::map<std::string, int, std::less<std::string> > map_type;
+typedef std::map<std::string, int, std::less<std::string> > map_type;

-const char* re =
+const char* re =
 // possibly leading whitespace: 
- "^[[:space:]]*"
+ "^[[:space:]]*"
 // possible template declaration:
 "(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
 // class or struct:
- "(class|struct)[[:space:]]*"
+ "(class|struct)[[:space:]]*"
 // leading declspec macros etc:
 "("
 "\\<\\w+\\>"
@@ -217,35 +217,35 @@
 "[[:blank:]]*\$[^)]*\$"
 ")?"
 "[[:space:]]*"
- ")*"
+ ")*"
 // the class name
- "(\\<\\w*\\>)[[:space:]]*"
+ "(\\<\\w*\\>)[[:space:]]*"
 // template specialisation parameters
 "(<[^;:{]+>)?[[:space:]]*"
 // terminate in { or :
 "(\\{|:[^;\\{()]*\\{)";

boost::regex expression(re);
-map_type class_index;
-std::string::const_iterator base;
+map_type class_index;
+std::string::const_iterator base;

-bool grep_callback(const boost::smatch& what)
-{
+bool grep_callback(const boost::smatch& what)
+{
 // what[0] contains the whole string 
 // what[5] contains the class name. 
 // what[6] contains the template specialisation if any. 
 // add class name and position to map: 
- class_index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[</spa
n>6].second)] =
- what[5].first - base;
- return true;
-}
-void IndexClasses(const std::string& file)
-{
- std::string::const_iterator start, end;
- start = file.begin();
- end = file.end();
- base = start;
- regex_grep(grep_callback, start, end, expression, match_default);
+ class_index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[</spa
n>6].second)] =
+ what[5].first - base;
+ return true;
+}
+void IndexClasses(const std::string& file)
+{
+ std::string::const_iterator start, end;
+ start = file.begin();
+ end = file.end();
+ base = start;
+ regex_grep(grep_callback, start, end, expression, match_default);
}
</pre>

@@ -253,110 +253,110 @@
 to call a class member function, use the standard library adapters <code class="computeroutput">std::mem_fun</code> and <code class="computeroutput">std::bind1st</code>
 to convert the member function into a predicate:
 
-<pre class="programlisting">#include <string>
-#include <map>
-#include <boost/regex.hpp>
-#include <functional>
+<pre class="programlisting">#include <string>
+#include <map>
+#include <boost/regex.hpp>
+#include <functional>
// purpose: 
// takes the contents of a file in the form of a string 
// and searches for all the C++ class definitions, storing 
// their locations in a map of strings/int's 

-typedef std::map<std::string, int, std::less<std::string> > map_type;
-class class_index
-{
- boost::regex expression;
- map_type index;
- std::string::const_iterator base;
- bool grep_callback(boost::smatch what);
-public:
- void IndexClasses(const std::string& file);
- class_index()
- : index(),
- expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
- "(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\$[^)]*\$)?"
- "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
- "(\\{|:[^;\\{()]*\\{)"
- ){}
-};
-bool class_index::grep_callback(boost::smatch what)
-{
+typedef std::map<std::string, int, std::less<std::string> > map_type;
+class class_index
+{
+ boost::regex expression;
+ map_type index;
+ std::string::const_iterator base;
+ bool grep_callback(boost::smatch what);
+public:
+ void IndexClasses(const std::string& file);
+ class_index()
+ : index(),
+ expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
+ "(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\$[^)]*\$)?"
+ "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
+ "(\\{|:[^;\\{()]*\\{)"
+ ){}
+};
+bool class_index::grep_callback(boost::smatch what)
+{
 // what[0] contains the whole string 
 // what[5] contains the class name. 
 // what[6] contains the template specialisation if any. 
 // add class name and position to map: 
- index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[<spa
n class="number">6].second)] =
- what[5].first - base;
- return true;
-}
-
-void class_index::IndexClasses(const std::string& file)
-{
- std::string::const_iterator start, end;
- start = file.begin();
- end = file.end();
- base = start;
- regex_grep(std::bind1st(std::mem_fun(&class_index::grep_callback), this),
- start,
- end,
- expression);
-}
+ index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[<spa
n class="number">6].second)] =
+ what[5].first - base;
+ return true;
+}
+
+void class_index::IndexClasses(const std::string& file)
+{
+ std::string::const_iterator start, end;
+ start = file.begin();
+ end = file.end();
+ base = start;
+ regex_grep(std::bind1st(std::mem_fun(&class_index::grep_callback), this),
+ start,
+ end,
+ expression);
+}
</pre>

 Finally, C++ Builder users can use C++ Builder's closure type as a callback
 argument:
 
-<pre class="programlisting">#include <string>
-#include <map>
-#include <boost/regex.hpp>
-#include <functional>
+<pre class="programlisting">#include <string>
+#include <map>
+#include <boost/regex.hpp>
+#include <functional>
// purpose: 
// takes the contents of a file in the form of a string 
// and searches for all the C++ class definitions, storing 
// their locations in a map of strings/int's 

-typedef std::map<std::string, int, std::less<std::string> > map_type;
-class class_index
-{
- boost::regex expression;
- map_type index;
- std::string::const_iterator base;
- typedef boost::smatch arg_type;
- bool grep_callback(const arg_type& what);
-public:
- typedef bool (__closure* grep_callback_type)(const arg_type&);
- void IndexClasses(const std::string& file);
- class_index()
- : index(),
- expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
- "(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\$[^)]*\$)?"
- "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
- "(\\{|:[^;\\{()]*\\{)"
- ){}
-};
+typedef std::map<std::string, int, std::less<std::string> > map_type;
+class class_index
+{
+ boost::regex expression;
+ map_type index;
+ std::string::const_iterator base;
+ typedef boost::smatch arg_type;
+ bool grep_callback(const arg_type& what);
+public:
+ typedef bool (__closure* grep_callback_type)(const arg_type&);
+ void IndexClasses(const std::string& file);
+ class_index()
+ : index(),
+ expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
+ "(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\$[^)]*\$)?"
+ "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
+ "(\\{|:[^;\\{()]*\\{)"
+ ){}
+};

-bool class_index::grep_callback(const arg_type& what)
-{
+bool class_index::grep_callback(const arg_type& what)
+{
 // what[0] contains the whole string 
// what[5] contains the class name. 
// what[6] contains the template specialisation if any. 
// add class name and position to map: 
-index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
- what[5].first - base;
- return true;
-}
-
-void class_index::IndexClasses(const std::string& file)
-{
- std::string::const_iterator start, end;
- start = file.begin();
- end = file.end();
- base = start;
- class_index::grep_callback_type cl = &(this->grep_callback);
- regex_grep(cl,
- start,
- end,
- expression);
+index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
+ what[5].first - base;
+ return true;
+}
+
+void class_index::IndexClasses(const std::string& file)
+{
+ std::string::const_iterator start, end;
+ start = file.begin();
+ end = file.end();
+ base = start;
+ class_index::grep_callback_type cl = &(this->grep_callback);
+ regex_grep(cl,
+ start,
+ end,
+ expression);
}
</pre>
</div>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -37,27 +37,27 @@
 Code which uses <a class="link" href="regex_split.html" title="regex_split (deprecated)"><code class="computeroutput">regex_split</code></a> will continue to compile,
 the following documentation is taken from a previous Boost.Regex version:
 
-<pre class="programlisting">#include <boost/regex.hpp>
+<pre class="programlisting">#include <boost/regex.hpp>
</pre>

 Algorithm <a class="link" href="regex_split.html" title="regex_split (deprecated)"><code class="computeroutput">regex_split</code></a> performs a similar
 operation to the perl split operation, and comes in three overloaded forms:
 
<pre class="programlisting">template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
-std::size_t regex_split(OutputIterator out,
- std::basic_string<charT, Traits1, Alloc1>& s,
+std::size_t regex_split(OutputIterator out,
+ std::basic_string<charT, Traits1, Alloc1>& s,
 const basic_regex<charT, Traits2>& e,
 boost::match_flag_type flags,
 std::size_t max_split);

template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
-std::size_t regex_split(OutputIterator out,
- std::basic_string<charT, Traits1, Alloc1>& s,
+std::size_t regex_split(OutputIterator out,
+ std::basic_string<charT, Traits1, Alloc1>& s,
 const basic_regex<charT, Traits2>& e,
 boost::match_flag_type flags = match_default);

template <class OutputIterator, class charT, class Traits1, class Alloc1>
-std::size_t regex_split(OutputIterator out,
+std::size_t regex_split(OutputIterator out,
 std::basic_string<charT, Traits1, Alloc1>& s);
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/error_type.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/error_type.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/error_type.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,9 +26,9 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.error_type"></a><a class="link" href="error_type.html" title="error_type">error_type</a>
</h3></div></div></div>
-<a name="boost_regex.ref.error_type.synopsis"></a><h5>
-<a name="boost_regex.ref.error_type.synopsis-heading"></a>
- <a class="link" href="error_type.html#boost_regex.ref.error_type.synopsis">Synopsis</a>
+<h5>
+<a name="boost_regex.ref.error_type.h0"></a>
+ <a name="boost_regex.ref.error_type.synopsis"></a><a class="link" href="error_type.html#boost_regex.ref.error_type.synopsis">Synopsis</a>
 </h5>

 Type error type represents the different types of errors that can be raised
@@ -56,9 +56,9 @@
} // namespace regex_constants
} // namespace boost
</pre>
-<a name="boost_regex.ref.error_type.description"></a><h5>
-<a name="boost_regex.ref.error_type.description-heading"></a>
- <a class="link" href="error_type.html#boost_regex.ref.error_type.description">Description</a>
+<h5>
+<a name="boost_regex.ref.error_type.h1"></a>
+ <a name="boost_regex.ref.error_type.description"></a><a class="link" href="error_type.html#boost_regex.ref.error_type.description">Description</a>
 </h5>

 The type <code class="computeroutput">error_type</code> is an

Modified: trunk/libs/regex/doc/html/boost_regex/ref/internal_details/uni_iter.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/internal_details/uni_iter.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/internal_details/uni_iter.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,12 +27,11 @@
<a name="boost_regex.ref.internal_details.uni_iter"></a><a class="link" href="uni_iter.html" title="Unicode Iterators">Unicode
 Iterators</a>
</h4></div></div></div>
-<a name="boost_regex.ref.internal_details.uni_iter.synopsis"></a><h5>
-<a name="boost_regex.ref.internal_details.uni_iter.synopsis-heading"></a>
- <a class="link" href="uni_iter.html#boost_regex.ref.internal_details.uni_iter.synopsis">Synopsis</a>
+<h5>
+<a name="boost_regex.ref.internal_details.uni_iter.h0"></a>
+ <a name="boost_regex.ref.internal_details.uni_iter.synopsis"></a><a class="link" href="uni_iter.html#boost_regex.ref.internal_details.uni_iter.synopsis">Synopsis</a>
 </h5>

-

<pre class="programlisting">#include <boost/regex/pending/unicode_iterator.hpp></pre>

@@ -55,9 +54,9 @@
template <class BaseIterator>
class utf8_output_iterator;
</pre>
-<a name="boost_regex.ref.internal_details.uni_iter.description"></a><h5>
-<a name="boost_regex.ref.internal_details.uni_iter.description-heading"></a>
- <a class="link" href="uni_iter.html#boost_regex.ref.internal_details.uni_iter.description">Description</a>
+<h5>
+<a name="boost_regex.ref.internal_details.uni_iter.h1"></a>
+ <a name="boost_regex.ref.internal_details.uni_iter.description"></a><a class="link" href="uni_iter.html#boost_regex.ref.internal_details.uni_iter.description">Description</a>
 </h5>

 This header contains a selection of iterator adaptors that make a sequence

Modified: trunk/libs/regex/doc/html/boost_regex/ref/match_flag_type.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/match_flag_type.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/match_flag_type.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -59,7 +59,7 @@
static const match_flag_type format_default = 0;
static const match_flag_type format_sed;
static const match_flag_type format_perl;
-static const match_flag_type format_literal;
+static const match_flag_type format_literal;

static const match_flag_type format_no_copy;
static const match_flag_type format_first_only;
@@ -68,9 +68,9 @@
} // namespace regex_constants
} // namespace boost
</pre>
-<a name="boost_regex.ref.match_flag_type.description"></a><h5>
-<a name="boost_regex.ref.match_flag_type.description-heading"></a>
- <a class="link" href="match_flag_type.html#boost_regex.ref.match_flag_type.description">Description</a>
+<h5>
+<a name="boost_regex.ref.match_flag_type.h0"></a>
+ <a name="boost_regex.ref.match_flag_type.description"></a><a class="link" href="match_flag_type.html#boost_regex.ref.match_flag_type.description">Description</a>
</h5>

The type <code class="computeroutput">match_flag_type</code>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/match_results.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/match_results.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/match_results.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,9 +26,9 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.match_results"></a><a class="link" href="match_results.html" title="match_results">match_results</a>
</h3></div></div></div>
-<a name="boost_regex.ref.match_results.synopsis"></a><h5>
-<a name="boost_regex.ref.match_results.synopsis-heading"></a>
- <a class="link" href="match_results.html#boost_regex.ref.match_results.synopsis">Synopsis</a>
+<h5>
+<a name="boost_regex.ref.match_results.h0"></a>
+ <a name="boost_regex.ref.match_results.synopsis"></a><a class="link" href="match_results.html#boost_regex.ref.match_results.synopsis">Synopsis</a>
 </h5>
<pre class="programlisting">#include <boost/regex.hpp>
</pre>
@@ -73,8 +73,8 @@
template <class BidirectionalIterator,
 class Allocator = std::allocator<sub_match<BidirectionalIterator> >
class match_results
-{
-public:
+{
+public:
 typedef sub_match<BidirectionalIterator> value_type;
 typedef const value_type& const_reference;
 typedef const_reference reference;
@@ -89,7 +89,7 @@
 // construct/copy/destroy:
 <a class="link" href="match_results.html#boost_regex.match_results.construct">explicit match_results</a>(const Allocator& a = Allocator());
 <a class="link" href="match_results.html#boost_regex.match_results.copy_construct">match_results</a>(const match_results& m);
- <a class="link" href="match_results.html#boost_regex.match_results.assign">match_results& operator=</a>(const match_results& m);
+ <a class="link" href="match_results.html#boost_regex.match_results.assign">match_results& operator=</a>(const match_results& m);
 ~match_results();

 // size:
@@ -166,9 +166,9 @@
void <a class="link" href="match_results.html#boost_regex.match_results.op_swap">swap</a>(match_results<BidirectionalIterator, Allocator>& m1,
 match_results<BidirectionalIterator, Allocator>& m2);
</pre>
-<a name="boost_regex.ref.match_results.description"></a><h5>
-<a name="boost_regex.ref.match_results.description-heading"></a>
- <a class="link" href="match_results.html#boost_regex.ref.match_results.description">Description</a>
+<h5>
+<a name="boost_regex.ref.match_results.h1"></a>
+ <a name="boost_regex.ref.match_results.description"></a><a class="link" href="match_results.html#boost_regex.ref.match_results.description">Description</a>
 </h5>

 In all <code class="computeroutput">match_results</code> constructors,
@@ -738,7 +738,7 @@
 whose value_type is a <code class="computeroutput">sub_match<BidirectionalIterator></code>. This type happens to be <code class="computeroutput">std::vector<sub_match<BidirectionalIterator> ></code>,
 but you shouldn't actually rely on that.
 
-<a name="boost_regex.match_results.captures"></a><pre class="programlisting">const capture_sequence_type& captures(std::size_t i)const;
+<a name="boost_regex.match_results.captures"></a><pre class="programlisting">const capture_sequence_type& captures(std::size_t i)const;
</pre>

 Requires: that the match_results object

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -42,9 +42,9 @@
 data look as though it's really a UTF-32 sequence, that can then be passed
 on to the "real" algorithm.
 
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match"></a><h5>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match-heading"></a>
- <a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match">u32regex_match</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.h0"></a>
+ <a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match"></a><a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match">u32regex_match</a>
 </h5>

 For each <a class="link" href="../../regex_match.html" title="regex_match"><code class="computeroutput">regex_match</code></a>
@@ -88,9 +88,9 @@
 }
}
</pre>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search"></a><h5>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search-heading"></a>
- <a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search">u32regex_search</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.h1"></a>
+ <a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search"></a><a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search">u32regex_search</a>
 </h5>

 For each <a class="link" href="../../regex_search.html" title="regex_search"><code class="computeroutput">regex_search</code></a>
@@ -127,9 +127,9 @@
 }
}
</pre>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace"></a><h5>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace-heading"></a>
- <a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace">u32regex_replace</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.h2"></a>
+ <a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace"></a><a class="link" href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace">u32regex_replace</a>
 </h5>

 For each <a class="link" href="../../regex_replace.html" title="regex_replace"><code class="computeroutput">regex_replace</code></a> algorithm defined

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,9 +27,9 @@
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter"></a><a class="link" href="unicode_iter.html" title="Unicode Aware Regex Iterators">Unicode
 Aware Regex Iterators</a>
</h5></div></div></div>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator"></a><h5>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator-heading"></a>
- <a class="link" href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator">u32regex_iterator</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.h0"></a>
+ <a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator"></a><a class="link" href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator">u32regex_iterator</a>
 </h5>

 Type <code class="computeroutput">u32regex_iterator</code>
@@ -54,30 +54,30 @@
 from a string, there are a series of non-member helper functions called
 make_u32regex_iterator:
 
-<pre class="programlisting">u32regex_iterator<const char*>
- make_u32regex_iterator(const char* s,
- const u32regex& e,
+<pre class="programlisting">u32regex_iterator<const char*>
+ make_u32regex_iterator(const char* s,
+ const u32regex& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_iterator<const wchar_t*>
- make_u32regex_iterator(const wchar_t* s,
- const u32regex& e,
+
+u32regex_iterator<const wchar_t*>
+ make_u32regex_iterator(const wchar_t* s,
+ const u32regex& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_iterator<const UChar*>
- make_u32regex_iterator(const UChar* s,
- const u32regex& e,
+
+u32regex_iterator<const UChar*>
+ make_u32regex_iterator(const UChar* s,
+ const u32regex& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class Traits, class Alloc>
-u32regex_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
- make_u32regex_iterator(const std::basic_string<charT, Traits, Alloc>& s,
- const u32regex& e,
+u32regex_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+ make_u32regex_iterator(const std::basic_string<charT, Traits, Alloc>& s,
+ const u32regex& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_iterator<const UChar*>
- make_u32regex_iterator(const UnicodeString& s,
- const u32regex& e,
+
+u32regex_iterator<const UChar*>
+ make_u32regex_iterator(const UnicodeString& s,
+ const u32regex& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -93,7 +93,7 @@
{
 // enumerate and print all the currency symbols, along
 // with any associated numeric values:
- const char* re =
+ const char* re =
 "([[:Sc:]][[:Cf:][:Cc:][:Z*:]]*)?"
 "([[:Nd:]]+(?:[[:Po:]][[:Nd:]]+)?)?"
 "(?(1)"
@@ -103,7 +103,7 @@
 "[[:Sc:]]"
 ")";
 boost::u32regex r = boost::make_u32regex(re);
- boost::u32regex_iterator<std::string::const_iterator>
+ boost::u32regex_iterator<std::string::const_iterator>
 i(boost::make_u32regex_iterator(text, r)), j;
 while(i != j)
 {
@@ -125,9 +125,9 @@

 Provided of course that the input is encoded as UTF-8.
 
-<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator"></a><h5>
-<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator-heading"></a>
- <a class="link" href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator">u32regex_token_iterator</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.h1"></a>
+ <a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator"></a><a class="link" href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator">u32regex_token_iterator</a>
 </h5>

 Type <code class="computeroutput">u32regex_token_iterator</code>
@@ -152,40 +152,40 @@
 from a string, there are a series of non-member helper functions called
 <code class="computeroutput">make_u32regex_token_iterator</code>:
 
-<pre class="programlisting">u32regex_token_iterator<const char*>
+<pre class="programlisting">u32regex_token_iterator<const char*>
 make_u32regex_token_iterator(
- const char* s,
- const u32regex& e,
- int sub,
+ const char* s,
+ const u32regex& e,
+ int sub,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const wchar_t*>
+
+u32regex_token_iterator<const wchar_t*>
 make_u32regex_token_iterator(
- const wchar_t* s,
- const u32regex& e,
- int sub,
+ const wchar_t* s,
+ const u32regex& e,
+ int sub,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const UChar*>
+
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const UChar* s,
- const u32regex& e,
- int sub,
+ const UChar* s,
+ const u32regex& e,
+ int sub,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class Traits, class Alloc>
-u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+ make_u32regex_token_iterator(
+ const std::basic_string<charT, Traits, Alloc>& s,
+ const u32regex& e,
+ int sub,
+ regex_constants::match_flag_type m = regex_constants::match_default);
+
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const std::basic_string<charT, Traits, Alloc>& s,
- const u32regex& e,
- int sub,
- regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const UChar*>
- make_u32regex_token_iterator(
- const UnicodeString& s,
- const u32regex& e,
- int sub,
+ const UnicodeString& s,
+ const u32regex& e,
+ int sub,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -194,43 +194,43 @@
 found in text s, using match_flags m.
 
<pre class="programlisting">template <std::size_t N>
-u32regex_token_iterator<const char*>
+u32regex_token_iterator<const char*>
 make_u32regex_token_iterator(
- const char* p,
- const u32regex& e,
- const int (&submatch)[N],
+ const char* p,
+ const u32regex& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <std::size_t N>
-u32regex_token_iterator<const wchar_t*>
+u32regex_token_iterator<const wchar_t*>
 make_u32regex_token_iterator(
- const wchar_t* p,
- const u32regex& e,
- const int (&submatch)[N],
+ const wchar_t* p,
+ const u32regex& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <std::size_t N>
-u32regex_token_iterator<const UChar*>
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const UChar* p,
- const u32regex& e,
- const int (&submatch)[N],
+ const UChar* p,
+ const u32regex& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class Traits, class Alloc, std::size_t N>
-u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
 make_u32regex_token_iterator(
- const std::basic_string<charT, Traits, Alloc>& p,
- const u32regex& e,
- const int (&submatch)[N],
+ const std::basic_string<charT, Traits, Alloc>& p,
+ const u32regex& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <std::size_t N>
-u32regex_token_iterator<const UChar*>
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const UnicodeString& s,
- const u32regex& e,
- const int (&submatch)[N],
+ const UnicodeString& s,
+ const u32regex& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -238,40 +238,40 @@
 for each submatch in regular expression e, found
 in text s, using match_flags m.
 
-<pre class="programlisting">u32regex_token_iterator<const char*>
+<pre class="programlisting">u32regex_token_iterator<const char*>
 make_u32regex_token_iterator(
- const char* p,
- const u32regex& e,
- const std::vector<int>& submatch,
+ const char* p,
+ const u32regex& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const wchar_t*>
+
+u32regex_token_iterator<const wchar_t*>
 make_u32regex_token_iterator(
- const wchar_t* p,
- const u32regex& e,
- const std::vector<int>& submatch,
+ const wchar_t* p,
+ const u32regex& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const UChar*>
+
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const UChar* p,
- const u32regex& e,
- const std::vector<int>& submatch,
+ const UChar* p,
+ const u32regex& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class Traits, class Alloc>
-u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator>
+ make_u32regex_token_iterator(
+ const std::basic_string<charT, Traits, Alloc>& p,
+ const u32regex& e,
+ const std::vector<int>& submatch,
+ regex_constants::match_flag_type m = regex_constants::match_default);
+
+u32regex_token_iterator<const UChar*>
 make_u32regex_token_iterator(
- const std::basic_string<charT, Traits, Alloc>& p,
- const u32regex& e,
- const std::vector<int>& submatch,
- regex_constants::match_flag_type m = regex_constants::match_default);
-
-u32regex_token_iterator<const UChar*>
- make_u32regex_token_iterator(
- const UnicodeString& s,
- const u32regex& e,
- const std::vector<int>& submatch,
+ const UnicodeString& s,
+ const u32regex& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -287,7 +287,7 @@
{
 // enumerate and print all the currency symbols, along
 // with any associated numeric values:
- const char* re =
+ const char* re =
 "([[:Sc:]][[:Cf:][:Cc:][:Z*:]]*)?"
 "([[:Nd:]]+(?:[[:Po:]][[:Nd:]]+)?)?"
 "(?(1)"
@@ -297,7 +297,7 @@
 "[[:Sc:]]"
 ")";
 boost::u32regex r = boost::make_u32regex(re);
- boost::u32regex_token_iterator<std::string::const_iterator>
+ boost::u32regex_token_iterator<std::string::const_iterator>
 i(boost::make_u32regex_token_iterator(text, r, 1)), j;
 while(i != j)
 {

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -51,9 +51,9 @@
 which allow regular expressions to be created from UTF-8, UTF-16, or
 UTF-32 encoded strings:
 
-<pre class="programlisting">template <class InputIterator>
-u32regex make_u32regex(InputIterator i,
- InputIterator j,
+<pre class="programlisting">template <class InputIterator>
+u32regex make_u32regex(InputIterator i,
+ InputIterator j,
 boost::regex_constants::syntax_option_type opt);
</pre>

@@ -62,24 +62,24 @@
 sequence is determined based upon sizeof(*i): 1 implies UTF-8, 2 implies
 UTF-16, and 4 implies UTF-32.
 
-<pre class="programlisting">u32regex make_u32regex(const char* p,
- boost::regex_constants::syntax_option_type opt
+<pre class="programlisting">u32regex make_u32regex(const char* p,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

 Effects: Creates a regular expression
 object from the Null-terminated UTF-8 characater sequence p.
 
-<pre class="programlisting">u32regex make_u32regex(const unsigned char* p,
- boost::regex_constants::syntax_option_type opt
+<pre class="programlisting">u32regex make_u32regex(const unsigned char* p,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

 Effects: Creates a regular expression
 object from the Null-terminated UTF-8 characater sequence p.
 
-<pre class="programlisting">u32regex make_u32regex(const wchar_t* p,
- boost::regex_constants::syntax_option_type opt
+<pre class="programlisting">u32regex make_u32regex(const wchar_t* p,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

@@ -88,8 +88,8 @@
 encoding of the sequence is determined based upon sizeof(wchar_t): 1
 implies UTF-8, 2 implies UTF-16, and 4 implies UTF-32.
 
-<pre class="programlisting">u32regex make_u32regex(const UChar* p,
- boost::regex_constants::syntax_option_type opt
+<pre class="programlisting">u32regex make_u32regex(const UChar* p,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

@@ -97,8 +97,8 @@
 object from the Null-terminated UTF-16 characater sequence p.
 
<pre class="programlisting">template<class C, class T, class A>
-u32regex make_u32regex(const std::basic_string<C, T, A>& s,
- boost::regex_constants::syntax_option_type opt
+u32regex make_u32regex(const std::basic_string<C, T, A>& s,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

@@ -107,8 +107,8 @@
 based upon sizeof(C): 1 implies UTF-8, 2 implies UTF-16, and 4 implies
 UTF-32.
 
-<pre class="programlisting">u32regex make_u32regex(const UnicodeString& s,
- boost::regex_constants::syntax_option_type opt
+<pre class="programlisting">u32regex make_u32regex(const UnicodeString& s,
+ boost::regex_constants::syntax_option_type opt
 = boost::regex_constants::perl);
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -33,9 +33,9 @@
 all look a lot more complex than they actually are, but for completeness
 here they are anyway:
 
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match-heading"></a>
- <a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match">regex_match</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.h0"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match"></a><a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match">regex_match</a>
 </h5>

 There are two overloads, the first reports what matched in a match_results
@@ -49,10 +49,10 @@
 
<pre class="programlisting">template <class charT, class T, class A>
bool regex_match(
- const ATL::CSimpleStringT<charT>& s,
- match_results<const B*, A>& what,
- const basic_regex<charT, T>& e,
- boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
+ const ATL::CSimpleStringT<charT>& s,
+ match_results<const B*, A>& what,
+ const basic_regex<charT, T>& e,
+ boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
</pre>

 Effects: returns <code class="computeroutput">::boost::regex_match(s.GetString(),
@@ -81,9 +81,9 @@
 }
}
</pre>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_-heading"></a>
- <a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_">regex_match
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.h1"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_"></a><a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_">regex_match
 (second overload)</a>
 </h5>
<pre class="programlisting">template <class charT, class T>
@@ -107,11 +107,11 @@
bool is_valid_password(const CString& password, const CString& requirements)
{
 return boost::regex_match(password, boost::make_regex(requirements));
-}
+}
</pre>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search-heading"></a>
- <a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search">regex_search</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.h2"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search"></a><a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search">regex_search</a>
 </h5>

 There are two additional overloads for <a class="link" href="../../regex_search.html" title="regex_search"><code class="computeroutput">regex_search</code></a>, the first reports
@@ -146,11 +146,11 @@
 {
 throw std::runtime_error("No postcode found");
 }
-}
+}
</pre>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_-heading"></a>
- <a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_">regex_search
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.h3"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_"></a><a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_">regex_search
 (second overload)</a>
 </h5>
<pre class="programlisting">template <class charT, class T>
@@ -163,9 +163,9 @@
 s.GetString()
 + s.GetLength(), e, f);</code>
 
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace-heading"></a>
- <a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace">regex_replace</a>
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.h4"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace"></a><a class="link" href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace">regex_replace</a>
 </h5>

 There are two additional overloads for <a class="link" href="../../regex_replace.html" title="regex_replace"><code class="computeroutput">regex_replace</code></a>, the first sends

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -31,16 +31,16 @@
 The following helper functions are provided to ease the conversion from
 an MFC/ATL string to a <a class="link" href="../../regex_iterator.html" title="regex_iterator"><code class="computeroutput">regex_iterator</code></a> or <a class="link" href="../../regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput">regex_token_iterator</code></a>:
 
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper-heading"></a>
- <a class="link" href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper">regex_iterator
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.h0"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper"></a><a class="link" href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper">regex_iterator
 creation helper</a>
 </h5>
<pre class="programlisting">template <class charT>
-regex_iterator<charT const*>
+regex_iterator<charT const*>
 make_regex_iterator(
- const ATL::CSimpleStringT<charT>& s,
- const basic_regex<charT>& e,
+ const ATL::CSimpleStringT<charT>& s,
+ const basic_regex<charT>& e,
 ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
</pre>

@@ -67,17 +67,17 @@
 }
}
</pre>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers"></a><h5>
-<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers-heading"></a>
- <a class="link" href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers">regex_token_iterator
+<h5>
+<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.h1"></a>
+ <a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers"></a><a class="link" href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers">regex_token_iterator
 creation helpers</a>
 </h5>
-<pre class="programlisting">template <class charT>
-regex_token_iterator<charT const*>
+<pre class="programlisting">template <class charT>
+regex_token_iterator<charT const*>
 make_regex_token_iterator(
- const ATL::CSimpleStringT<charT>& s,
- const basic_regex<charT>& e,
- int sub = 0,
+ const ATL::CSimpleStringT<charT>& s,
+ const basic_regex<charT>& e,
+ int sub = 0,
 ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
</pre>

@@ -86,12 +86,12 @@
 sub,
 f);</code>
 
-<pre class="programlisting">template <class charT>
-regex_token_iterator<charT const*>
+<pre class="programlisting">template <class charT>
+regex_token_iterator<charT const*>
 make_regex_token_iterator(
- const ATL::CSimpleStringT<charT>& s,
- const basic_regex<charT>& e,
- const std::vector<int>& subs,
+ const ATL::CSimpleStringT<charT>& s,
+ const basic_regex<charT>& e,
+ const std::vector<int>& subs,
 ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
</pre>

@@ -100,12 +100,12 @@
 subs,
 f);</code>
 
-<pre class="programlisting">template <class charT, std::size_t N>
-regex_token_iterator<charT const*>
+<pre class="programlisting">template <class charT, std::size_t N>
+regex_token_iterator<charT const*>
 make_regex_token_iterator(
- const ATL::CSimpleStringT<charT>& s,
- const basic_regex<charT>& e,
- const int (& subs)[N],
+ const ATL::CSimpleStringT<charT>& s,
+ const basic_regex<charT>& e,
+ const int (& subs)[N],
 ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default);
</pre>

@@ -131,7 +131,7 @@
 std::cout << *i << std::endl;
 ++i;
 }
-}
+}
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -32,8 +32,8 @@
 of a regular expression from an MFC/ATL string type:
 
<pre class="programlisting">template <class charT>
-basic_regex<charT>
- make_regex(const ATL::CSimpleStringT<charT>& s,
+basic_regex<charT>
+ make_regex(const ATL::CSimpleStringT<charT>& s,
 ::boost::regex_constants::syntax_option_type f = boost::regex_constants::normal);
</pre>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -31,10 +31,10 @@
 The following typedefs are provided for the convenience of those working
 with TCHAR's:
 
-<pre class="programlisting">typedef basic_regex<TCHAR> tregex;
-typedef match_results<TCHAR const*> tmatch;
-typedef regex_iterator<TCHAR const*> tregex_iterator;
-typedef regex_token_iterator<TCHAR const*> tregex_token_iterator;
+<pre class="programlisting">typedef basic_regex<TCHAR> tregex;
+typedef match_results<TCHAR const*> tmatch;
+typedef regex_iterator<TCHAR const*> tregex_iterator;
+typedef regex_token_iterator<TCHAR const*> tregex_token_iterator;
</pre>

 If you are working with explicitly narrow or wide characters rather than

Modified: trunk/libs/regex/doc/html/boost_regex/ref/posix.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/posix.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/posix.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -162,9 +162,9 @@
 upon the macro <code class="computeroutput">UNICODE</code>.
 </td></tr>
</table></div>
-<a name="regcomp"></a><a name="boost_regex.ref.posix.regcomp"></a><h5>
-<a name="boost_regex.ref.posix.regcomp-heading"></a>
- <a class="link" href="posix.html#boost_regex.ref.posix.regcomp">regcomp</a>
+<a name="regcomp"></a><h5>
+<a name="boost_regex.ref.posix.h0"></a>
+ <a name="boost_regex.ref.posix.regcomp"></a><a class="link" href="posix.html#boost_regex.ref.posix.regcomp">regcomp</a>
 </h5>

 <code class="computeroutput">regcomp</code> takes a pointer to
@@ -374,9 +374,9 @@
</tr>
</tbody>
</table></div>
-<a name="regerror"></a><a name="boost_regex.ref.posix.regerror"></a><h5>
-<a name="boost_regex.ref.posix.regerror-heading"></a>
- <a class="link" href="posix.html#boost_regex.ref.posix.regerror">regerror</a>
+<a name="regerror"></a><h5>
+<a name="boost_regex.ref.posix.h1"></a>
+ <a name="boost_regex.ref.posix.regerror"></a><a class="link" href="posix.html#boost_regex.ref.posix.regerror">regerror</a>
 </h5>

 regerror takes the following parameters, it maps an error code to a human
@@ -460,9 +460,9 @@
 equal to buf_size then regerror will have to be called again with a larger
 buffer.
 
-<a name="regexec"></a><a name="boost_regex.ref.posix.regexec"></a><h5>
-<a name="boost_regex.ref.posix.regexec-heading"></a>
- <a class="link" href="posix.html#boost_regex.ref.posix.regexec">regexec</a>
+<a name="regexec"></a><h5>
+<a name="boost_regex.ref.posix.h2"></a>
+ <a name="boost_regex.ref.posix.regexec"></a><a class="link" href="posix.html#boost_regex.ref.posix.regexec">regexec</a>
 </h5>

 regexec finds the first occurrence of expression e within string buf. If
@@ -528,9 +528,9 @@
</tr>
</tbody>
</table></div>
-<a name="regfree"></a><a name="boost_regex.ref.posix.regfree"></a><h5>
-<a name="boost_regex.ref.posix.regfree-heading"></a>
- <a class="link" href="posix.html#boost_regex.ref.posix.regfree">regfree</a>
+<a name="regfree"></a><h5>
+<a name="boost_regex.ref.posix.h3"></a>
+ <a name="boost_regex.ref.posix.regfree"></a><a class="link" href="posix.html#boost_regex.ref.posix.regfree">regfree</a>
 </h5>

 <code class="computeroutput">regfree</code> frees all the memory

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_iterator.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_iterator.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_iterator.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -32,10 +32,10 @@
 <a class="link" href="regex_iterator.html" title="regex_iterator"><code class="computeroutput">regex_iterator</code></a>
 yields a reference to a <a class="link" href="match_results.html" title="match_results"><code class="computeroutput">match_results</code></a> object.
 
-<pre class="programlisting">template <class BidirectionalIterator,
+<pre class="programlisting">template <class BidirectionalIterator,
 class charT = iterator_traits<BidirectionalIterator>::value_type,
 class traits = regex_traits<charT> >
-class regex_iterator
+class regex_iterator
{
public:
 typedef basic_regex<charT, traits> regex_type;
@@ -44,10 +44,10 @@
 typedef const value_type* pointer;
 typedef const value_type& reference;
 typedef std::forward_iterator_tag iterator_category;
-
+
 <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.construct1">regex_iterator</a>();
- <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.construct2">regex_iterator</a>(BidirectionalIterator a, BidirectionalIterator b,
- const regex_type& re,
+ <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.construct2">regex_iterator</a>(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type& re,
 match_flag_type m = match_default);
 <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.construct3">regex_iterator</a>(const regex_iterator&);
 regex_iterator& <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.assign">operator=(</a>const regex_iterator&);
@@ -59,27 +59,27 @@
 regex_iterator <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.op_inc2">operator++</a>(int);
};

-typedef regex_iterator<const char*> cregex_iterator;
-typedef regex_iterator<std::string::const_iterator> sregex_iterator;
+typedef regex_iterator<const char*> cregex_iterator;
+typedef regex_iterator<std::string::const_iterator> sregex_iterator;

#ifndef BOOST_NO_WREGEX
-typedef regex_iterator<const wchar_t*> wcregex_iterator;
-typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
-#endif
-
-template <class charT, class traits> regex_iterator<const charT*, charT, traits>
- <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.make">make_regex_iterator</a>(const charT* p, const basic_regex<charT, traits>& e,
- regex_constants::match_flag_type m = regex_constants::match_default);
-
-template <class charT, class traits, class ST, class SA>
- regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
- <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.make">make_regex_iterator</a>(const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
+typedef regex_iterator<const wchar_t*> wcregex_iterator;
+typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
+#endif
+
+template <class charT, class traits> regex_iterator<const charT*, charT, traits>
+ <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.make">make_regex_iterator</a>(const charT* p, const basic_regex<charT, traits>& e,
+ regex_constants::match_flag_type m = regex_constants::match_default);
+
+template <class charT, class traits, class ST, class SA>
+ regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+ <a class="link" href="regex_iterator.html#boost_regex.regex_iterator.make">make_regex_iterator</a>(const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>
-<a name="boost_regex.ref.regex_iterator.description"></a><h5>
-<a name="boost_regex.ref.regex_iterator.description-heading"></a>
- <a class="link" href="regex_iterator.html#boost_regex.ref.regex_iterator.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_iterator.h0"></a>
+ <a name="boost_regex.ref.regex_iterator.description"></a><a class="link" href="regex_iterator.html#boost_regex.ref.regex_iterator.description">Description</a>
 </h5>

 A <a class="link" href="regex_iterator.html" title="regex_iterator"><code class="computeroutput">regex_iterator</code></a>
@@ -92,8 +92,8 @@
 Effects: constructs an end of sequence
 <a class="link" href="regex_iterator.html" title="regex_iterator"><code class="computeroutput">regex_iterator</code></a>.
 
-<a name="boost_regex.regex_iterator.construct2"></a><pre class="programlisting">regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
- const regex_type& re,
+<a name="boost_regex.regex_iterator.construct2"></a><pre class="programlisting">regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type& re,
 match_flag_type m = match_default);
</pre>

@@ -397,15 +397,15 @@

 Returns: result.
 
-<a name="boost_regex.regex_iterator.make"></a><pre class="programlisting">template <class charT, class traits>
+<a name="boost_regex.regex_iterator.make"></a><pre class="programlisting">template <class charT, class traits>
regex_iterator<const charT*, charT, traits>
- make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e,
- regex_constants::match_flag_type m = regex_constants::match_default);
-
-template <class charT, class traits, class ST, class SA>
-regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
- make_regex_iterator(const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
+ make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e,
+ regex_constants::match_flag_type m = regex_constants::match_default);
+
+template <class charT, class traits, class ST, class SA>
+regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+ make_regex_iterator(const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -414,9 +414,9 @@
 using <a class="link" href="match_flag_type.html" title="match_flag_type"><code class="computeroutput">match_flag_type</code></a>
 m.
 
-<a name="boost_regex.ref.regex_iterator.examples"></a><h5>
-<a name="boost_regex.ref.regex_iterator.examples-heading"></a>
- <a class="link" href="regex_iterator.html#boost_regex.ref.regex_iterator.examples">Examples</a>
+<h5>
+<a name="boost_regex.ref.regex_iterator.h1"></a>
+ <a name="boost_regex.ref.regex_iterator.examples"></a><a class="link" href="regex_iterator.html#boost_regex.ref.regex_iterator.examples">Examples</a>
 </h5>

 The following example takes a C++ source file and builds up an index of class
@@ -437,13 +437,13 @@

typedef std::map<std::string, std::string::difference_type, std::less<std::string> > map_type;

-const char* re =
+const char* re =
 // possibly leading whitespace: 
- "^[[:space:]]*"
+ "^[[:space:]]*"
 // possible template declaration:
 "(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
 // class or struct:
- "(class|struct)[[:space:]]*"
+ "(class|struct)[[:space:]]*"
 // leading declspec macros etc:
 "("
 "\\<\\w+\\>"
@@ -451,9 +451,9 @@
 "[[:blank:]]*\$[^)]*\$"
 ")?"
 "[[:space:]]*"
- ")*"
+ ")*"
 // the class name
- "(\\<\\w*\\>)[[:space:]]*"
+ "(\\<\\w*\\>)[[:space:]]*"
 // template specialisation parameters
 "(<[^;:{]+>)?[[:space:]]*"
 // terminate in { or :

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_match.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_match.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_match.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,7 +26,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.regex_match"></a><a class="link" href="regex_match.html" title="regex_match">regex_match</a>
</h3></div></div></div>
-<pre class="programlisting">#include <boost/regex.hpp>
+<pre class="programlisting">#include <boost/regex.hpp>
</pre>

 The algorithm <a class="link" href="regex_match.html" title="regex_match"><code class="computeroutput">regex_match</code></a>
@@ -51,37 +51,37 @@
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
 match_results<BidirectionalIterator, Allocator>& m,
 const basic_regex <charT, traits>& e,
- match_flag_type flags = match_default);
+ match_flag_type flags = match_default);

template <class BidirectionalIterator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
 const basic_regex <charT, traits>& e,
- match_flag_type flags = match_default);
+ match_flag_type flags = match_default);

template <class charT, class Allocator, class traits>
bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
 const basic_regex <charT, traits>& e,
- match_flag_type flags = match_default);
+ match_flag_type flags = match_default);

template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_match(const basic_string<charT, ST, SA>& s,
- match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
- const basic_regex <charT, traits>& e,
- match_flag_type flags = match_default);
+ match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
+ const basic_regex <charT, traits>& e,
+ match_flag_type flags = match_default);

template <class charT, class traits>
bool regex_match(const charT* str,
 const basic_regex <charT, traits>& e,
- match_flag_type flags = match_default);
+ match_flag_type flags = match_default);

template <class ST, class SA, class charT, class traits>
bool regex_match(const basic_string<charT, ST, SA>& s,
 const basic_regex <charT, traits>& e,
 match_flag_type flags = match_default);
</pre>
-<a name="boost_regex.ref.regex_match.description"></a><h5>
-<a name="boost_regex.ref.regex_match.description-heading"></a>
- <a class="link" href="regex_match.html#boost_regex.ref.regex_match.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_match.h0"></a>
+ <a name="boost_regex.ref.regex_match.description"></a><a class="link" href="regex_match.html#boost_regex.ref.regex_match.description">Description</a>
 </h5>
<pre class="programlisting">template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
@@ -335,8 +335,8 @@
<pre class="programlisting">template <class ST, class SA, class Allocator,
 class charT, class traits>
bool regex_match(const basic_string<charT, ST, SA>& s,
- match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
- const basic_regex <charT, traits>& e,
+ match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
+ const basic_regex <charT, traits>& e,
 match_flag_type flags = match_default);
</pre>

@@ -360,42 +360,42 @@

 Effects: Returns the result of <code class="computeroutput">regex_match(s.begin(), s.end(), e, flags)</code>.
 
-<a name="boost_regex.ref.regex_match.examples"></a><h5>
-<a name="boost_regex.ref.regex_match.examples-heading"></a>
- <a class="link" href="regex_match.html#boost_regex.ref.regex_match.examples">Examples</a>
+<h5>
+<a name="boost_regex.ref.regex_match.h1"></a>
+ <a name="boost_regex.ref.regex_match.examples"></a><a class="link" href="regex_match.html#boost_regex.ref.regex_match.examples">Examples</a>
 </h5>

 The following example processes an ftp response:
 
-<pre class="programlisting">#include <stdlib.h>
-#include <boost/regex.hpp>
-#include <string>
-#include <iostream>
+<pre class="programlisting">#include <stdlib.h>
+#include <boost/regex.hpp>
+#include <string>
+#include <iostream>

-using namespace boost;
+using namespace boost;

-regex expression("([0-9]+)(\\-| |$)(.*)");
+regex expression("([0-9]+)(\\-| |$)(.*)");

// process_ftp: 
// on success returns the ftp response code, and fills 
// msg with the ftp response message. 
-int process_ftp(const char* response, std::string* msg)
-{
- cmatch what;
- if(regex_match(response, what, expression))
- {
+int process_ftp(const char* response, std::string* msg)
+{
+ cmatch what;
+ if(regex_match(response, what, expression))
+ {
 // what[0] contains the whole string 
 // what[1] contains the response code 
 // what[2] contains the separator character 
 // what[3] contains the text message. 
- if(msg)
- msg->assign(what[3].first, what[3].second);
- return std::atoi(what[1].first);
- }
+ if(msg)
+ msg->assign(what[3].first, what[3].second);
+ return std::atoi(what[1].first);
+ }
 // failure did not match 
- if(msg)
- msg->erase();
- return -1;
+ if(msg)
+ msg->erase();
+ return -1;
}
</pre>
</div>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_replace.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_replace.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_replace.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,7 +26,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.regex_replace"></a><a class="link" href="regex_replace.html" title="regex_replace">regex_replace</a>
</h3></div></div></div>
-<pre class="programlisting">#include <boost/regex.hpp>
+<pre class="programlisting">#include <boost/regex.hpp>
</pre>

 The algorithm <a class="link" href="regex_replace.html" title="regex_replace"><code class="computeroutput">regex_replace</code></a> searches through a
@@ -52,9 +52,9 @@
 Formatter fmt,
 match_flag_type flags = match_default);
</pre>
-<a name="boost_regex.ref.regex_replace.description"></a><h5>
-<a name="boost_regex.ref.regex_replace.description-heading"></a>
- <a class="link" href="regex_replace.html#boost_regex.ref.regex_replace.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_replace.h0"></a>
+ <a name="boost_regex.ref.regex_replace.description"></a><a class="link" href="regex_replace.html#boost_regex.ref.regex_replace.description">Description</a>
 </h5>
<pre class="programlisting">template <class OutputIterator, class BidirectionalIterator, class traits, class Formatter>
OutputIterator regex_replace(OutputIterator out,
@@ -109,8 +109,8 @@

 Effects: Constructs an <a class="link" href="regex_iterator.html" title="regex_iterator"><code class="computeroutput">regex_iterator</code></a> object:
 
-<pre class="programlisting">regex_iterator<BidirectionalIterator, charT, traits, Allocator>
- i(first, last, e, flags),
+<pre class="programlisting">regex_iterator<BidirectionalIterator, charT, traits, Allocator>
+ i(first, last, e, flags),
</pre>

 and uses i to enumerate through all of the matches
@@ -120,37 +120,37 @@

 If no such matches are found and
 
-<pre class="programlisting">!(flags & format_no_copy)
+<pre class="programlisting">!(flags & format_no_copy)
</pre>

 then calls
 
-<pre class="programlisting">std::copy(first, last, out).
+<pre class="programlisting">std::copy(first, last, out).
</pre>

 Otherwise, for each match found, if
 
-<pre class="programlisting">!(flags & format_no_copy)
+<pre class="programlisting">!(flags & format_no_copy)
</pre>

 calls
 
-<pre class="programlisting">std::copy(m.prefix().first, m.prefix().last, out),
+<pre class="programlisting">std::copy(m.prefix().first, m.prefix().last, out),
</pre>

 and then calls
 
-<pre class="programlisting">m.format(out, fmt, flags).
+<pre class="programlisting">m.format(out, fmt, flags).
</pre>

 Finally if
 
-<pre class="programlisting">!(flags & format_no_copy)
+<pre class="programlisting">!(flags & format_no_copy)
</pre>

 calls
 
-<pre class="programlisting">std::copy(last_m.suffix().first, last_m,suffix().last, out)
+<pre class="programlisting">std::copy(last_m.suffix().first, last_m,suffix().last, out)
</pre>

 where last_m is a copy of the last match found.
@@ -198,9 +198,9 @@
 flags)</code>,
 and then returns <code class="computeroutput">result</code>.
 
-<a name="boost_regex.ref.regex_replace.examples"></a><h5>
-<a name="boost_regex.ref.regex_replace.examples-heading"></a>
- <a class="link" href="regex_replace.html#boost_regex.ref.regex_replace.examples">Examples</a>
+<h5>
+<a name="boost_regex.ref.regex_replace.h1"></a>
+ <a name="boost_regex.ref.regex_replace.examples"></a><a class="link" href="regex_replace.html#boost_regex.ref.regex_replace.examples">Examples</a>
 </h5>

 The following example takes C/C++ source code as input, and outputs syntax
@@ -277,7 +277,7 @@
extern const char* pre_format = "(?1&lt;)(?2&gt;)(?3&amp;)";

-const char* expression_text =
+const char* expression_text =
 // preprocessor directives: index 1
 "(^[[:blank:]]*#(?:[^\\\\\\n]|\\\\[^\\n[:punct:][:word:]]*[\\n[:punct:][:word:]])*)|"
 // comment: index 2
@@ -305,7 +305,7 @@
 "(?4$&)"
 "(?5$&)";

-const char* header_text =
+const char* header_text =
 "<HTML>\n<HEAD>\n"
 "<TITLE>Auto-generated html formated source</TITLE>\n"
 "<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=windows-1252\">\n"

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_search.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_search.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_search.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -26,7 +26,7 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_regex.ref.regex_search"></a><a class="link" href="regex_search.html" title="regex_search">regex_search</a>
</h3></div></div></div>
-<pre class="programlisting">#include <boost/regex.hpp>
+<pre class="programlisting">#include <boost/regex.hpp>
</pre>

 The algorithm <a class="link" href="regex_search.html" title="regex_search"><code class="computeroutput">regex_search</code></a> will search a range
@@ -35,46 +35,46 @@
 for a match if a match could conceivably start at that position. The algorithm
 is defined as follows:
 
-<pre class="programlisting">template <class BidirectionalIterator,
+<pre class="programlisting">template <class BidirectionalIterator,
 class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
 match_results<BidirectionalIterator, Allocator>& m,
 const basic_regex<charT, traits>& e,
 match_flag_type flags = match_default);
-
-template <class ST, class SA,
- class Allocator, class charT, class traits>
-bool regex_search(const basic_string<charT, ST, SA>& s,
+
+template <class ST, class SA,
+ class Allocator, class charT, class traits>
+bool regex_search(const basic_string<charT, ST, SA>& s,
 match_results<
- typename basic_string<charT, ST,SA>::const_iterator,
- Allocator>& m,
- const basic_regex<charT, traits>& e,
- match_flag_type flags = match_default);
-
-template<class charT, class Allocator, class traits>
-bool regex_search(const charT* str,
- match_results<const charT*, Allocator>& m,
- const basic_regex<charT, traits>& e,
- match_flag_type flags = match_default);
-
-template <class BidirectionalIterator, class charT, class traits>
-bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
- const basic_regex<charT, traits>& e,
- match_flag_type flags = match_default);
-
-template <class charT, class traits>
-bool regex_search(const charT* str,
- const basic_regex<charT, traits>& e,
- match_flag_type flags = match_default);
-
+ typename basic_string<charT, ST,SA>::const_iterator,
+ Allocator>& m,
+ const basic_regex<charT, traits>& e,
+ match_flag_type flags = match_default);
+
+template<class charT, class Allocator, class traits>
+bool regex_search(const charT* str,
+ match_results<const charT*, Allocator>& m,
+ const basic_regex<charT, traits>& e,
+ match_flag_type flags = match_default);
+
+template <class BidirectionalIterator, class charT, class traits>
+bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
+ const basic_regex<charT, traits>& e,
+ match_flag_type flags = match_default);
+
+template <class charT, class traits>
+bool regex_search(const charT* str,
+ const basic_regex<charT, traits>& e,
+ match_flag_type flags = match_default);
+
template<class ST, class SA, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
 const basic_regex<charT, traits>& e,
 match_flag_type flags = match_default);
</pre>
-<a name="boost_regex.ref.regex_search.description"></a><h5>
-<a name="boost_regex.ref.regex_search.description-heading"></a>
- <a class="link" href="regex_search.html#boost_regex.ref.regex_search.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_search.h0"></a>
+ <a name="boost_regex.ref.regex_search.description"></a><a class="link" href="regex_search.html#boost_regex.ref.regex_search.description">Description</a>
 </h5>
<pre class="programlisting">template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
@@ -356,9 +356,9 @@

 Effects: Returns the result of <code class="computeroutput">regex_search(s.begin(), s.end(), e, flags)</code>.
 
-<a name="boost_regex.ref.regex_search.examples"></a><h5>
-<a name="boost_regex.ref.regex_search.examples-heading"></a>
- <a class="link" href="regex_search.html#boost_regex.ref.regex_search.examples">Examples</a>
+<h5>
+<a name="boost_regex.ref.regex_search.h1"></a>
+ <a name="boost_regex.ref.regex_search.examples"></a><a class="link" href="regex_search.html#boost_regex.ref.regex_search.examples">Examples</a>
 </h5>

 The following example, takes the contents of a file in the form of a string,
@@ -367,45 +367,45 @@
 is implemented, for example it could easily be modified to work with the
 SGI rope class, which uses a non-contiguous storage strategy.
 
-<pre class="programlisting">#include <string>
-#include <map>
-#include <boost/regex.hpp>
+<pre class="programlisting">#include <string>
+#include <map>
+#include <boost/regex.hpp>

// purpose: 
// takes the contents of a file in the form of a string 
// and searches for all the C++ class definitions, storing 
// their locations in a map of strings/int's 
-typedef std::map<std::string, int, std::less<std::string> > map_type;
+typedef std::map<std::string, int, std::less<std::string> > map_type;

boost::regex expression(
 "^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
 "(class|struct)[[:space:]]*"
 "(\\<\\w+\\>([[:blank:]]*\$[^)]*\$)?"
 "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*"
- "(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");
+ "(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");

-void IndexClasses(map_type& m, const std::string& file)
-{
- std::string::const_iterator start, end;
- start = file.begin();
- end = file.end();
- boost::match_results<std::string::const_iterator> what;
- boost::match_flag_type flags = boost::match_default;
- while(regex_search(start, end, what, expression, flags))
- {
+void IndexClasses(map_type& m, const std::string& file)
+{
+ std::string::const_iterator start, end;
+ start = file.begin();
+ end = file.end();
+ boost::match_results<std::string::const_iterator> what;
+ boost::match_flag_type flags = boost::match_default;
+ while(regex_search(start, end, what, expression, flags))
+ {
 // what[0] contains the whole string 
 // what[5] contains the class name. 
 // what[6] contains the template specialisation if any. 
 // add class name and position to map: 
- m[std::string(what[5].first, what[5].second)
- + std::string(what[6].first, what[6].second)]
- = what[5].first - file.begin();
+ m[std::string(what[5].first, what[5].second)
+ + std::string(what[6].first, what[6].second)]
+ = what[5].first - file.begin();
 // update search position: 
- start = what[0].second;
+ start = what[0].second;
 // update flags: 
- flags |= boost::match_prev_avail;
- flags |= boost::match_not_bob;
- }
+ flags |= boost::match_prev_avail;
+ flags |= boost::match_not_bob;
+ }
}
</pre>
</div>

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_token_iterator.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_token_iterator.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_token_iterator.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -39,10 +39,10 @@
 each section of the character container sequence that does not match the
 regular expression specified.
 
-<pre class="programlisting">template <class BidirectionalIterator,
+<pre class="programlisting">template <class BidirectionalIterator,
 class charT = iterator_traits<BidirectionalIterator>::value_type,
 class traits = regex_traits<charT> >
-class regex_token_iterator
+class regex_token_iterator
{
public:
 typedef basic_regex<charT, traits> regex_type;
@@ -51,23 +51,23 @@
 typedef const value_type* pointer;
 typedef const value_type& reference;
 typedef std::forward_iterator_tag iterator_category;
-
+
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct1">regex_token_iterator</a>();
- <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct2">regex_token_iterator</a>(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- int submatch = 0,
+ <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct2">regex_token_iterator</a>(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ int submatch = 0,
 match_flag_type m = match_default);
- <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct3">regex_token_iterator</a>(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- const std::vector<int>& submatches,
+ <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct3">regex_token_iterator</a>(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ const std::vector<int>& submatches,
 match_flag_type m = match_default);
 template <std::size_t N>
- <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct4">regex_token_iterator</a>(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- const int (&submatches)[N],
+ <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct4">regex_token_iterator</a>(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ const int (&submatches)[N],
 match_flag_type m = match_default);
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.construct5">regex_token_iterator</a>(const regex_token_iterator&);
 regex_token_iterator& <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.assign">operator=</a>(const regex_token_iterator&);
@@ -87,67 +87,67 @@
#endif

template <class charT, class traits>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const charT* p,
- const basic_regex<charT, traits>& e,
- int submatch = 0,
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ int submatch = 0,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA>
-regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- int submatch = 0,
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ int submatch = 0,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, std::size_t N>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
<a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const charT* p,
- const basic_regex<charT, traits>& e,
- const int (&submatch)[N],
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA, std::size_t N>
-regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- const int (&submatch)[N],
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const charT* p,
- const basic_regex<charT, traits>& e,
- const std::vector<int>& submatch,
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA>
regex_token_iterator<
- typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+ typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 <a class="link" href="regex_token_iterator.html#boost_regex.regex_token_iterator.make">make_regex_token_iterator</a>(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- const std::vector<int>& submatch,
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>
-<a name="boost_regex.ref.regex_token_iterator.description"></a><h5>
-<a name="boost_regex.ref.regex_token_iterator.description-heading"></a>
- <a class="link" href="regex_token_iterator.html#boost_regex.ref.regex_token_iterator.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_token_iterator.h0"></a>
+ <a name="boost_regex.ref.regex_token_iterator.description"></a><a class="link" href="regex_token_iterator.html#boost_regex.ref.regex_token_iterator.description">Description</a>
 </h5>
<a name="boost_regex.regex_token_iterator.construct1"></a><pre class="programlisting">regex_token_iterator();
</pre>

 Effects: constructs an end of sequence iterator.
 
-<a name="boost_regex.regex_token_iterator.construct2"></a><pre class="programlisting">regex_token_iterator(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- int submatch = 0,
+<a name="boost_regex.regex_token_iterator.construct2"></a><pre class="programlisting">regex_token_iterator(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ int submatch = 0,
 match_flag_type m = match_default);
</pre>

@@ -172,10 +172,10 @@
 matcher exhausts its permitted memory allocation (if Boost.Regex is configured
 in non-recursive mode).
 
-<a name="boost_regex.regex_token_iterator.construct3"></a><pre class="programlisting">regex_token_iterator(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- const std::vector<int>& submatches,
+<a name="boost_regex.regex_token_iterator.construct3"></a><pre class="programlisting">regex_token_iterator(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ const std::vector<int>& submatches,
 match_flag_type m = match_default);
</pre>

@@ -205,10 +205,10 @@
 in non-recursive mode).
 
<a name="boost_regex.regex_token_iterator.construct4"></a><pre class="programlisting">template <std::size_t N>
-regex_token_iterator(BidirectionalIterator a,
- BidirectionalIterator b,
- const regex_type& re,
- const int (&submatches)[R],
+regex_token_iterator(BidirectionalIterator a,
+ BidirectionalIterator b,
+ const regex_type& re,
+ const int (&submatches)[R],
 match_flag_type m = match_default);
</pre>

@@ -299,53 +299,53 @@
 Returns: result.
 
<a name="boost_regex.regex_token_iterator.make"></a><pre class="programlisting">template <class charT, class traits>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
 make_regex_token_iterator(
- const charT* p,
- const basic_regex<charT, traits>& e,
- int submatch = 0,
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ int submatch = 0,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA>
-regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 make_regex_token_iterator(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- int submatch = 0,
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ int submatch = 0,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, std::size_t N>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
make_regex_token_iterator(
- const charT* p,
- const basic_regex<charT, traits>& e,
- const int (&submatch)[N],
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA, std::size_t N>
regex_token_iterator<
- typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+ typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 make_regex_token_iterator(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- const int (&submatch)[N],
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ const int (&submatch)[N],
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits>
-regex_token_iterator<const charT*, charT, traits>
+regex_token_iterator<const charT*, charT, traits>
 make_regex_token_iterator(
- const charT* p,
- const basic_regex<charT, traits>& e,
- const std::vector<int>& submatch,
+ const charT* p,
+ const basic_regex<charT, traits>& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
-
+
template <class charT, class traits, class ST, class SA>
regex_token_iterator<
- typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
+ typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
 make_regex_token_iterator(
- const std::basic_string<charT, ST, SA>& p,
- const basic_regex<charT, traits>& e,
- const std::vector<int>& submatch,
+ const std::basic_string<charT, ST, SA>& p,
+ const basic_regex<charT, traits>& e,
+ const std::vector<int>& submatch,
 regex_constants::match_flag_type m = regex_constants::match_default);
</pre>

@@ -356,9 +356,9 @@
 using <a class="link" href="match_flag_type.html" title="match_flag_type"><code class="computeroutput">match_flag_type</code></a>
 m.
 
-<a name="boost_regex.ref.regex_token_iterator.examples"></a><h5>
-<a name="boost_regex.ref.regex_token_iterator.examples-heading"></a>
- <a class="link" href="regex_token_iterator.html#boost_regex.ref.regex_token_iterator.examples">Examples</a>
+<h5>
+<a name="boost_regex.ref.regex_token_iterator.h1"></a>
+ <a name="boost_regex.ref.regex_token_iterator.examples"></a><a class="link" href="regex_token_iterator.html#boost_regex.ref.regex_token_iterator.examples">Examples</a>
 </h5>

 The following example takes a string and splits it into a series of tokens:

Modified: trunk/libs/regex/doc/html/boost_regex/ref/regex_traits.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/regex_traits.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/regex_traits.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -45,9 +45,9 @@

} // namespace boost
</pre>
-<a name="boost_regex.ref.regex_traits.description"></a><h5>
-<a name="boost_regex.ref.regex_traits.description-heading"></a>
- <a class="link" href="regex_traits.html#boost_regex.ref.regex_traits.description">Description</a>
+<h5>
+<a name="boost_regex.ref.regex_traits.h0"></a>
+ <a name="boost_regex.ref.regex_traits.description"></a><a class="link" href="regex_traits.html#boost_regex.ref.regex_traits.description">Description</a>
</h5>

The class <code class="computeroutput">regex_traits</code> is

Modified: trunk/libs/regex/doc/html/boost_regex/ref/sub_match.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/ref/sub_match.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/ref/sub_match.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -139,182 +139,182 @@
//
// comparisons to a basic_string:
//
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare7">operator ==</a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare7">operator ==</a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare8">operator != </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare8">operator != </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare9">operator <</a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare9">operator <</a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare10">operator ></a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare10">operator ></a> (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare11">operator >= </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare11">operator >= </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare12">operator <= </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+template <class BidirectionalIterator, class traits, class Allocator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare12">operator <= </a>(const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);

-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare13">operator == </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare14">operator != </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare15">operator < </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare16">operator > </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare17">operator >= </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare18">operator <= </a>(const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);

//
// comparisons to a pointer to a character array:
//
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare19">operator == </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare20">operator != </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare21">operator < </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare22">operator > </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare23">operator >= </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare24">operator <= </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare19">operator == </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare20">operator != </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare21">operator < </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare22">operator > </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare23">operator >= </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare24">operator <= </a>(typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);

-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare25">operator == </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare26">operator != </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare27">operator < </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare28">operator > </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare29">operator >= </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare30">operator <= </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare25">operator == </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare26">operator != </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare27">operator < </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare28">operator > </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare29">operator >= </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare30">operator <= </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

//
// comparisons to a single character:
//
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare31">operator == </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare32">operator != </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare33">operator < </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare34">operator > </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare35">operator >= </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare36">operator <= </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare31">operator == </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare32">operator != </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare33">operator < </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare34">operator > </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare35">operator >= </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare36">operator <= </a>(typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);

-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare37">operator == </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare38">operator != </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare39">operator < </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare40">operator > </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare41">operator >= </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
-template <class BidirectionalIterator>
-bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare42">operator <= </a>(const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare37">operator == </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare38">operator != </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare39">operator < </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare40">operator > </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare41">operator >= </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+template <class BidirectionalIterator>
+bool <a class="link" href="sub_match.html#boost_regex.sub_match.op_compare42">operator <= </a>(const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
// 
// addition operators: 
//
-template <class BidirectionalIterator, class traits, class Allocator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add1">operator + </a>(const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
- traits,
- Allocator>& s,
- const sub_match<BidirectionalIterator>& m);
-template <class BidirectionalIterator, class traits, class Allocator>
+template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add2">operator + </a>(const sub_match<BidirectionalIterator>& m,
- const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
- traits,
- Allocator>& s);
-template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add3">operator + </a>(typename iterator_traits<BidirectionalIterator>::value_type const* s,
- const sub_match<BidirectionalIterator>& m);
-template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add4">operator + </a>(const sub_match<BidirectionalIterator>& m,
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add1">operator + </a>(const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
+ traits,
+ Allocator>& s,
+ const sub_match<BidirectionalIterator>& m);
+template <class BidirectionalIterator, class traits, class Allocator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add2">operator + </a>(const sub_match<BidirectionalIterator>& m,
+ const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
+ traits,
+ Allocator>& s);
+template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add3">operator + </a>(typename iterator_traits<BidirectionalIterator>::value_type const* s,
+ const sub_match<BidirectionalIterator>& m);
+template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add4">operator + </a>(const sub_match<BidirectionalIterator>& m,
 typename iterator_traits<BidirectionalIterator>::value_type const * s);
-template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add5">operator + </a>(typename iterator_traits<BidirectionalIterator>::value_type const& s,
- const sub_match<BidirectionalIterator>& m);
-template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- <a class="link" href="sub_match.html#boost_regex.sub_match.op_add6">operator + </a>(const sub_match<BidirectionalIterator>& m,
- typename iterator_traits<BidirectionalIterator>::value_type const& s);
-template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add5">operator + </a>(typename iterator_traits<BidirectionalIterator>::value_type const& s,
+ const sub_match<BidirectionalIterator>& m);
+template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ <a class="link" href="sub_match.html#boost_regex.sub_match.op_add6">operator + </a>(const sub_match<BidirectionalIterator>& m,
+ typename iterator_traits<BidirectionalIterator>::value_type const& s);
+template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
 <a class="link" href="sub_match.html#boost_regex.sub_match.op_add7">operator + </a>(const sub_match<BidirectionalIterator>& m1,
 const sub_match<BidirectionalIterator>& m2);

@@ -328,13 +328,13 @@

} // namespace boost
</pre>
-<a name="boost_regex.ref.sub_match.description"></a><h5>
-<a name="boost_regex.ref.sub_match.description-heading"></a>
- <a class="link" href="sub_match.html#boost_regex.ref.sub_match.description">Description</a>
+<h5>
+<a name="boost_regex.ref.sub_match.h0"></a>
+ <a name="boost_regex.ref.sub_match.description"></a><a class="link" href="sub_match.html#boost_regex.ref.sub_match.description">Description</a>
 </h5>
-<a name="boost_regex.ref.sub_match.members"></a><h6>
-<a name="boost_regex.ref.sub_match.members-heading"></a>
- <a class="link" href="sub_match.html#boost_regex.ref.sub_match.members">Members</a>
+<h6>
+<a name="boost_regex.ref.sub_match.h1"></a>
+ <a name="boost_regex.ref.sub_match.members"></a><a class="link" href="sub_match.html#boost_regex.ref.sub_match.members">Members</a>
 </h6>
<a name="boost_regex.sub_match.value_type"></a><pre class="programlisting">typedef typename std::iterator_traits<iterator>::value_type value_type;
</pre>
@@ -412,7 +412,7 @@
 whose value_type is a <code class="computeroutput">sub_match<BidirectionalIterator></code>. This type happens to be <code class="computeroutput">std::vector<sub_match<BidirectionalIterator> ></code>,
 but you shouldn't actually rely on that.
 
-<a name="boost_regex.sub_match.captures"></a><pre class="programlisting">const capture_sequence_type& captures()const;
+<a name="boost_regex.sub_match.captures"></a><pre class="programlisting">const capture_sequence_type& captures()const;
</pre>

 Effects: returns a sequence containing all
@@ -445,9 +445,9 @@
 to take place.
 </li>
</ul></div>
-<a name="boost_regex.ref.sub_match.sub_match_non_member_operators"></a><h6>
-<a name="boost_regex.ref.sub_match.sub_match_non_member_operators-heading"></a>
- <a class="link" href="sub_match.html#boost_regex.ref.sub_match.sub_match_non_member_operators">sub_match
+<h6>
+<a name="boost_regex.ref.sub_match.h2"></a>
+ <a name="boost_regex.ref.sub_match.sub_match_non_member_operators"></a><a class="link" href="sub_match.html#boost_regex.ref.sub_match.sub_match_non_member_operators">sub_match
 non-member operators</a>
 </h6>
<a name="boost_regex.sub_match.op_compare1"></a><pre class="programlisting">template <class BidirectionalIterator>
@@ -498,19 +498,19 @@
 Effects: returns <code class="computeroutput">lhs.compare(rhs)
 > 0</code>.
 
-<a name="boost_regex.sub_match.op_compare7"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+<a name="boost_regex.sub_match.op_compare7"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
 traits,
- Allocator>& lhs,
+ Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 == rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare8"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+<a name="boost_regex.sub_match.op_compare8"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>
@@ -518,9 +518,9 @@
 Effects: returns <code class="computeroutput">lhs
 != rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare9"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+<a name="boost_regex.sub_match.op_compare9"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>
@@ -528,9 +528,9 @@
 Effects: returns <code class="computeroutput">lhs
 < rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare10"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+<a name="boost_regex.sub_match.op_compare10"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>
@@ -538,9 +538,9 @@
 Effects: returns <code class="computeroutput">lhs
 > rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare11"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+<a name="boost_regex.sub_match.op_compare11"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>
@@ -548,9 +548,9 @@
 Effects: returns <code class="computeroutput">lhs
 >= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare12"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+<a name="boost_regex.sub_match.op_compare12"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& lhs,
 const sub_match<BidirectionalIterator>& rhs);
</pre>
@@ -558,253 +558,253 @@
 Effects: returns <code class="computeroutput">lhs
 <= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare13"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare13"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 == rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare14"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare14"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 != rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare15"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare15"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 < rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare16"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare16"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 > rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare17"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare17"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 >= rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare18"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_compare18"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
- const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
- traits,
+ const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
+ traits,
 Allocator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 <= rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare19"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare19"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 == rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare20"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare20"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 != rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare21"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare21"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 < rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare22"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare22"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 > rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare23"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare23"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 >= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare24"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare24"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 <= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare25"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator == (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare25"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator == (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 == rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare26"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator != (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare26"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator != (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 != rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare27"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator < (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare27"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator < (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 < rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare28"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator > (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare28"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator > (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 > rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare29"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator >= (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare29"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator >= (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 >= rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare30"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator <= (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
+<a name="boost_regex.sub_match.op_compare30"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator <= (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 <= rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare31"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare31"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 == rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare32"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare32"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 != rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare33"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare33"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 < rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare34"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare34"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 > rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare35"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare35"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 >= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare36"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
- const sub_match<BidirectionalIterator>& rhs);
+<a name="boost_regex.sub_match.op_compare36"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
+ const sub_match<BidirectionalIterator>& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs
 <= rhs.str()</code>.
 
-<a name="boost_regex.sub_match.op_compare37"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator == (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare37"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator == (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 == rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare38"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator != (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare38"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator != (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 != rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare39"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator < (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare39"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator < (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 < rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare40"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator > (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare40"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator > (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 > rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare41"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator >= (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare41"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator >= (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
 >= rhs</code>.
 
-<a name="boost_regex.sub_match.op_compare42"></a><pre class="programlisting">template <class BidirectionalIterator>
-bool operator <= (const sub_match<BidirectionalIterator>& lhs,
- typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
+<a name="boost_regex.sub_match.op_compare42"></a><pre class="programlisting">template <class BidirectionalIterator>
+bool operator <= (const sub_match<BidirectionalIterator>& lhs,
+ typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
</pre>

 Effects: returns <code class="computeroutput">lhs.str()
@@ -815,66 +815,66 @@
 to any type to which you can add a <code class="computeroutput">std::string</code>
 and obtain a new string as the result.
 
-<a name="boost_regex.sub_match.op_add1"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
- operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
- traits,
- Allocator>& s,
- const sub_match<BidirectionalIterator>& m);
+<a name="boost_regex.sub_match.op_add1"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
+ operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
+ traits,
+ Allocator>& s,
+ const sub_match<BidirectionalIterator>& m);
</pre>

 Effects: returns <code class="computeroutput">s
 + m.str()</code>.
 
-<a name="boost_regex.sub_match.op_add2"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
+<a name="boost_regex.sub_match.op_add2"></a><pre class="programlisting">template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
- operator + (const sub_match<BidirectionalIterator>& m,
- const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
- traits,
- Allocator>& s);
+ operator + (const sub_match<BidirectionalIterator>& m,
+ const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
+ traits,
+ Allocator>& s);
</pre>

 Effects: returns <code class="computeroutput">m.str()
 + s</code>.
 
-<a name="boost_regex.sub_match.op_add3"></a><pre class="programlisting">template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
- const sub_match<BidirectionalIterator>& m);
+<a name="boost_regex.sub_match.op_add3"></a><pre class="programlisting">template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
+ const sub_match<BidirectionalIterator>& m);
</pre>

 Effects: returns <code class="computeroutput">s
 + m.str()</code>.
 
-<a name="boost_regex.sub_match.op_add4"></a><pre class="programlisting">template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- operator + (const sub_match<BidirectionalIterator>& m,
+<a name="boost_regex.sub_match.op_add4"></a><pre class="programlisting">template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ operator + (const sub_match<BidirectionalIterator>& m,
 typename iterator_traits<BidirectionalIterator>::value_type const * s);
</pre>

 Effects: returns <code class="computeroutput">m.str()
 + s</code>.
 
-<a name="boost_regex.sub_match.op_add5"></a><pre class="programlisting">template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
- const sub_match<BidirectionalIterator>& m);
+<a name="boost_regex.sub_match.op_add5"></a><pre class="programlisting">template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
+ const sub_match<BidirectionalIterator>& m);
</pre>

 Effects: returns <code class="computeroutput">s
 + m.str()</code>.
 
-<a name="boost_regex.sub_match.op_add6"></a><pre class="programlisting">template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
- operator + (const sub_match<BidirectionalIterator>& m,
- typename iterator_traits<BidirectionalIterator>::value_type const& s);
+<a name="boost_regex.sub_match.op_add6"></a><pre class="programlisting">template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+ operator + (const sub_match<BidirectionalIterator>& m,
+ typename iterator_traits<BidirectionalIterator>::value_type const& s);
</pre>

 Effects: returns <code class="computeroutput">m.str()
 + s</code>.
 
-<a name="boost_regex.sub_match.op_add7"></a><pre class="programlisting">template <class BidirectionalIterator>
-std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
+<a name="boost_regex.sub_match.op_add7"></a><pre class="programlisting">template <class BidirectionalIterator>
+std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
 operator + (const sub_match<BidirectionalIterator>& m1,
 const sub_match<BidirectionalIterator>& m2);
</pre>
@@ -882,9 +882,10 @@
 Effects: returns <code class="computeroutput">m1.str()
 + m2.str()</code>.
 
-<a name="boost_regex.ref.sub_match.stream_inserter"></a><h6>
-<a name="boost_regex.ref.sub_match.stream_inserter-heading"></a>
- <a class="link" href="sub_match.html#boost_regex.ref.sub_match.stream_inserter">Stream inserter</a>
+<h6>
+<a name="boost_regex.ref.sub_match.h3"></a>
+ <a name="boost_regex.ref.sub_match.stream_inserter"></a><a class="link" href="sub_match.html#boost_regex.ref.sub_match.stream_inserter">Stream
+ inserter</a>
 </h6>
<a name="boost_regex.sub_match.op_stream"></a><pre class="programlisting">template <class charT, class traits, class BidirectionalIterator>
basic_ostream<charT, traits>&

Modified: trunk/libs/regex/doc/html/boost_regex/syntax/basic_extended.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/syntax/basic_extended.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/syntax/basic_extended.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,9 +27,9 @@
<a name="boost_regex.syntax.basic_extended"></a><a class="link" href="basic_extended.html" title="POSIX Extended Regular Expression Syntax">POSIX Extended Regular
 Expression Syntax</a>
</h3></div></div></div>
-<a name="boost_regex.syntax.basic_extended.synopsis"></a><h4>
-<a name="boost_regex.syntax.basic_extended.synopsis-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.synopsis">Synopsis</a>
+<h4>
+<a name="boost_regex.syntax.basic_extended.h0"></a>
+ <a name="boost_regex.syntax.basic_extended.synopsis"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.synopsis">Synopsis</a>
 </h4>

 The POSIX-Extended regular expression syntax is supported by the POSIX C
@@ -43,19 +43,19 @@
// e2 a case insensitive POSIX-Extended expression:
boost::regex e2(my_expression, boost::regex::extended|boost::regex::icase);
</pre>
-<a name="boost_regex.posix_extended_syntax"></a><a name="boost_regex.syntax.basic_extended.posix_extended_syntax"></a><h4>
-<a name="boost_regex.syntax.basic_extended.posix_extended_syntax-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.posix_extended_syntax">POSIX
- Extended Syntax</a>
+<a name="boost_regex.posix_extended_syntax"></a><h4>
+<a name="boost_regex.syntax.basic_extended.h1"></a>
+ <a name="boost_regex.syntax.basic_extended.posix_extended_syntax"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.posix_extended_syntax">POSIX Extended
+ Syntax</a>
 </h4>

 In POSIX-Extended regular expressions, all characters match themselves except
 for the following special characters:
 
<pre class="programlisting">.[{}()\*+?|^$</pre>
-<a name="boost_regex.syntax.basic_extended.wildcard_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.wildcard_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.wildcard_">Wildcard:</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h2"></a>
+ <a name="boost_regex.syntax.basic_extended.wildcard_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.wildcard_">Wildcard:</a>
 </h5>

 The single character '.' when used outside of a character set will match
@@ -71,9 +71,9 @@
 is passed to the matching algorithms.
 </li>
</ul></div>
-<a name="boost_regex.syntax.basic_extended.anchors_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.anchors_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.anchors_">Anchors:</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h3"></a>
+ <a name="boost_regex.syntax.basic_extended.anchors_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.anchors_">Anchors:</a>
 </h5>

 A '^' character shall match the start of a line when used as the first character
@@ -83,9 +83,9 @@
 A '$' character shall match the end of a line when used as the last character
 of an expression, or the last character of a sub-expression.
 
-<a name="boost_regex.syntax.basic_extended.marked_sub_expressions_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.marked_sub_expressions_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.marked_sub_expressions_">Marked
+<h5>
+<a name="boost_regex.syntax.basic_extended.h4"></a>
+ <a name="boost_regex.syntax.basic_extended.marked_sub_expressions_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.marked_sub_expressions_">Marked
 sub-expressions:</a>
 </h5>

@@ -95,9 +95,9 @@
 matching algorithms. Marked sub-expressions can also repeated, or referred
 to by a back-reference.
 
-<a name="boost_regex.syntax.basic_extended.repeats_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.repeats_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.repeats_">Repeats:</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h5"></a>
+ <a name="boost_regex.syntax.basic_extended.repeats_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.repeats_">Repeats:</a>
 </h5>

 Any atom (a single character, a marked sub-expression, or a character class)
@@ -181,9 +181,10 @@
 Will raise an error, as there is nothing for the <code class="computeroutput">*</code>
 operator to be applied to.
 
-<a name="boost_regex.syntax.basic_extended.back_references_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.back_references_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.back_references_">Back references:</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h6"></a>
+ <a name="boost_regex.syntax.basic_extended.back_references_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.back_references_">Back
+ references:</a>
 </h5>

 An escape character followed by a digit n, where n
@@ -211,9 +212,9 @@
 regular expressions, this is a compatible extension to that standard.
 </td></tr>
</table></div>
-<a name="boost_regex.syntax.basic_extended.alternation"></a><h5>
-<a name="boost_regex.syntax.basic_extended.alternation-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.alternation">Alternation</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h7"></a>
+ <a name="boost_regex.syntax.basic_extended.alternation"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.alternation">Alternation</a>
 </h5>

 The <code class="computeroutput">|</code> operator will match either
@@ -224,9 +225,9 @@
 Parenthesis can be used to group alternations, for example: <code class="computeroutput">ab(d|ef)</code>
 will match either of "abd" or "abef".
 
-<a name="boost_regex.syntax.basic_extended.character_sets_"></a><h5>
-<a name="boost_regex.syntax.basic_extended.character_sets_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_sets_">Character
+<h5>
+<a name="boost_regex.syntax.basic_extended.h8"></a>
+ <a name="boost_regex.syntax.basic_extended.character_sets_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_sets_">Character
 sets:</a>
 </h5>

@@ -237,18 +238,17 @@

 A bracket expression may contain any combination of the following:
 
-<a name="boost_regex.syntax.basic_extended.single_characters_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.single_characters_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.single_characters_">Single
- characters:</a>
+<h6>
+<a name="boost_regex.syntax.basic_extended.h9"></a>
+ <a name="boost_regex.syntax.basic_extended.single_characters_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.single_characters_">Single characters:</a>
 </h6>

 For example <code class="computeroutput">[abc]</code>, will match any of the characters 'a', 'b',
 or 'c'.
 
-<a name="boost_regex.syntax.basic_extended.character_ranges_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.character_ranges_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_ranges_">Character
+<h6>
+<a name="boost_regex.syntax.basic_extended.h10"></a>
+ <a name="boost_regex.syntax.basic_extended.character_ranges_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_ranges_">Character
 ranges:</a>
 </h6>

@@ -262,18 +262,18 @@
 which case whether a character appears within a range is determined by comparing
 the code points of the characters only.
 
-<a name="boost_regex.syntax.basic_extended.negation_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.negation_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.negation_">Negation:</a>
+<h6>
+<a name="boost_regex.syntax.basic_extended.h11"></a>
+ <a name="boost_regex.syntax.basic_extended.negation_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.negation_">Negation:</a>
 </h6>

 If the bracket-expression begins with the ^ character, then it matches the
 complement of the characters it contains, for example <code class="computeroutput">[^a-c]</code> matches any character that is not in the
 range <code class="computeroutput">a-c</code>.
 
-<a name="boost_regex.syntax.basic_extended.character_classes_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.character_classes_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_classes_">Character
+<h6>
+<a name="boost_regex.syntax.basic_extended.h12"></a>
+ <a name="boost_regex.syntax.basic_extended.character_classes_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_classes_">Character
 classes:</a>
 </h6>

@@ -281,9 +281,9 @@
 matches the named character class "name", for example <code class="computeroutput">[[:lower:]]</code> matches any lower case character. See
 <a class="link" href="character_classes.html" title="Character Class Names">character class names</a>.
 
-<a name="boost_regex.syntax.basic_extended.collating_elements_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.collating_elements_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.collating_elements_">Collating
+<h6>
+<a name="boost_regex.syntax.basic_extended.h13"></a>
+ <a name="boost_regex.syntax.basic_extended.collating_elements_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.collating_elements_">Collating
 Elements:</a>
 </h6>

@@ -309,9 +309,9 @@

 matches a NUL character.
 
-<a name="boost_regex.syntax.basic_extended.equivalence_classes_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.equivalence_classes_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.equivalence_classes_">Equivalence
+<h6>
+<a name="boost_regex.syntax.basic_extended.h14"></a>
+ <a name="boost_regex.syntax.basic_extended.equivalence_classes_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.equivalence_classes_">Equivalence
 classes:</a>
 </h6>

@@ -326,17 +326,17 @@
 this feature can not be relied upon to work portably across all platforms,
 or even all locales on one platform.
 
-<a name="boost_regex.syntax.basic_extended.combinations_"></a><h6>
-<a name="boost_regex.syntax.basic_extended.combinations_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.combinations_">Combinations:</a>
+<h6>
+<a name="boost_regex.syntax.basic_extended.h15"></a>
+ <a name="boost_regex.syntax.basic_extended.combinations_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.combinations_">Combinations:</a>
 </h6>

 All of the above can be combined in one character set declaration, for example:
 <code class="computeroutput">[[:digit:]a-c[.NUL.]]</code>.
 
-<a name="boost_regex.syntax.basic_extended.escapes"></a><h5>
-<a name="boost_regex.syntax.basic_extended.escapes-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.escapes">Escapes</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h16"></a>
+ <a name="boost_regex.syntax.basic_extended.escapes"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.escapes">Escapes</a>
 </h5>

 The POSIX standard defines no escape sequences for POSIX-Extended regular
@@ -360,9 +360,9 @@
 However, that's rather restrictive, so the following standard-compatible
 extensions are also supported by Boost.Regex:
 
-<a name="boost_regex.syntax.basic_extended.escapes_matching_a_specific_character"></a><h6>
-<a name="boost_regex.syntax.basic_extended.escapes_matching_a_specific_character-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.escapes_matching_a_specific_character">Escapes
+<h6>
+<a name="boost_regex.syntax.basic_extended.h17"></a>
+ <a name="boost_regex.syntax.basic_extended.escapes_matching_a_specific_character"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.escapes_matching_a_specific_character">Escapes
 matching a specific character</a>
 </h6>

@@ -549,9 +549,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.basic_extended._quot_single_character_quot__character_classes_"></a><h6>
-<a name="boost_regex.syntax.basic_extended._quot_single_character_quot__character_classes_-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended._quot_single_character_quot__character_classes_">"Single
+<h6>
+<a name="boost_regex.syntax.basic_extended.h18"></a>
+ <a name="boost_regex.syntax.basic_extended._quot_single_character_quot__character_classes_"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended._quot_single_character_quot__character_classes_">"Single
 character" character classes:</a>
 </h6>

@@ -703,9 +703,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.basic_extended.character_properties"></a><h6>
-<a name="boost_regex.syntax.basic_extended.character_properties-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_properties">Character
+<h6>
+<a name="boost_regex.syntax.basic_extended.h19"></a>
+ <a name="boost_regex.syntax.basic_extended.character_properties"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.character_properties">Character
 Properties</a>
 </h6>

@@ -810,9 +810,10 @@
 For example <code class="computeroutput">\pd</code>
 matches any "digit" character, as does <code class="computeroutput">\p{digit}</code>.
 
-<a name="boost_regex.syntax.basic_extended.word_boundaries"></a><h6>
-<a name="boost_regex.syntax.basic_extended.word_boundaries-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.word_boundaries">Word Boundaries</a>
+<h6>
+<a name="boost_regex.syntax.basic_extended.h20"></a>
+ <a name="boost_regex.syntax.basic_extended.word_boundaries"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.word_boundaries">Word
+ Boundaries</a>
 </h6>

 The following escape sequences match the boundaries of words:
@@ -885,9 +886,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.basic_extended.buffer_boundaries"></a><h6>
-<a name="boost_regex.syntax.basic_extended.buffer_boundaries-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.buffer_boundaries">Buffer
+<h6>
+<a name="boost_regex.syntax.basic_extended.h21"></a>
+ <a name="boost_regex.syntax.basic_extended.buffer_boundaries"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.buffer_boundaries">Buffer
 boundaries</a>
 </h6>

@@ -976,9 +977,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.basic_extended.continuation_escape"></a><h6>
-<a name="boost_regex.syntax.basic_extended.continuation_escape-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.continuation_escape">Continuation
+<h6>
+<a name="boost_regex.syntax.basic_extended.h22"></a>
+ <a name="boost_regex.syntax.basic_extended.continuation_escape"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.continuation_escape">Continuation
 Escape</a>
 </h6>

@@ -988,9 +989,9 @@
 iterating over the matches contained within a text, and you want each subsequence
 match to start where the last one ended.
 
-<a name="boost_regex.syntax.basic_extended.quoting_escape"></a><h6>
-<a name="boost_regex.syntax.basic_extended.quoting_escape-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.quoting_escape">Quoting
+<h6>
+<a name="boost_regex.syntax.basic_extended.h23"></a>
+ <a name="boost_regex.syntax.basic_extended.quoting_escape"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.quoting_escape">Quoting
 escape</a>
 </h6>

@@ -1002,9 +1003,9 @@
<pre class="programlisting">\*+a
\*+aaa
</pre>
-<a name="boost_regex.syntax.basic_extended.unicode_escapes"></a><h6>
-<a name="boost_regex.syntax.basic_extended.unicode_escapes-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.unicode_escapes">Unicode
+<h6>
+<a name="boost_regex.syntax.basic_extended.h24"></a>
+ <a name="boost_regex.syntax.basic_extended.unicode_escapes"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.unicode_escapes">Unicode
 escapes</a>
 </h6>
<div class="informaltable"><table class="table">
@@ -1053,18 +1054,18 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.basic_extended.any_other_escape"></a><h6>
-<a name="boost_regex.syntax.basic_extended.any_other_escape-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.any_other_escape">Any other
- escape</a>
+<h6>
+<a name="boost_regex.syntax.basic_extended.h25"></a>
+ <a name="boost_regex.syntax.basic_extended.any_other_escape"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.any_other_escape">Any
+ other escape</a>
 </h6>

 Any other escape sequence matches the character that is escaped, for example
 \@ matches a literal '@'.
 
-<a name="boost_regex.syntax.basic_extended.operator_precedence"></a><h5>
-<a name="boost_regex.syntax.basic_extended.operator_precedence-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.operator_precedence">Operator
+<h5>
+<a name="boost_regex.syntax.basic_extended.h26"></a>
+ <a name="boost_regex.syntax.basic_extended.operator_precedence"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.operator_precedence">Operator
 precedence</a>
 </h5>

@@ -1099,9 +1100,9 @@
 Alternation <code class="computeroutput">|</code>
 </li>
</ol></div>
-<a name="boost_regex.syntax.basic_extended.what_gets_matched"></a><h5>
-<a name="boost_regex.syntax.basic_extended.what_gets_matched-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.what_gets_matched">What
+<h5>
+<a name="boost_regex.syntax.basic_extended.h27"></a>
+ <a name="boost_regex.syntax.basic_extended.what_gets_matched"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.what_gets_matched">What
 Gets Matched</a>
 </h5>

@@ -1109,13 +1110,13 @@
 possible match is obtained using the <a class="link" href="leftmost_longest_rule.html" title="The Leftmost Longest Rule">leftmost-longest
 rule</a>.
 
-<a name="boost_regex.syntax.basic_extended.variations"></a><h4>
-<a name="boost_regex.syntax.basic_extended.variations-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.variations">Variations</a>
+<h4>
+<a name="boost_regex.syntax.basic_extended.h28"></a>
+ <a name="boost_regex.syntax.basic_extended.variations"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.variations">Variations</a>
 </h4>
-<a name="boost_regex.syntax.basic_extended.egrep"></a><h5>
-<a name="boost_regex.syntax.basic_extended.egrep-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.egrep">Egrep</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h29"></a>
+ <a name="boost_regex.syntax.basic_extended.egrep"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.egrep">Egrep</a>
 </h5>

 When an expression is compiled with the <a class="link" href="../ref/syntax_option_type.html" title="syntax_option_type">flag
@@ -1134,9 +1135,9 @@
 <code class="computeroutput">egrep</code>, and with grep when
 used with the -E option.
 
-<a name="boost_regex.syntax.basic_extended.awk"></a><h5>
-<a name="boost_regex.syntax.basic_extended.awk-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.awk">awk</a>
+<h5>
+<a name="boost_regex.syntax.basic_extended.h30"></a>
+ <a name="boost_regex.syntax.basic_extended.awk"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.awk">awk</a>
 </h5>

 In addition to the <a class="link" href="basic_extended.html#boost_regex.posix_extended_syntax">POSIX-Extended
@@ -1148,9 +1149,9 @@
 specification are required to be supported - however Boost.Regex supports
 these by default anyway.
 
-<a name="boost_regex.syntax.basic_extended.options"></a><h4>
-<a name="boost_regex.syntax.basic_extended.options-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.options">Options</a>
+<h4>
+<a name="boost_regex.syntax.basic_extended.h31"></a>
+ <a name="boost_regex.syntax.basic_extended.options"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.options">Options</a>
 </h4>

 There are a <a class="link" href="../ref/syntax_option_type/syntax_option_type_extended.html" title="Options for POSIX Extended Regular Expressions">variety
@@ -1161,9 +1162,9 @@
 and <code class="computeroutput">icase</code> options</a>
 modify how the case and locale sensitivity are to be applied.
 
-<a name="boost_regex.syntax.basic_extended.references"></a><h4>
-<a name="boost_regex.syntax.basic_extended.references-heading"></a>
- <a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.references">References</a>
+<h4>
+<a name="boost_regex.syntax.basic_extended.h32"></a>
+ <a name="boost_regex.syntax.basic_extended.references"></a><a class="link" href="basic_extended.html#boost_regex.syntax.basic_extended.references">References</a>
 </h4>

 <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap09.html" target="_top">IEEE

Modified: trunk/libs/regex/doc/html/boost_regex/syntax/basic_syntax.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/syntax/basic_syntax.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/syntax/basic_syntax.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,9 +27,9 @@
<a name="boost_regex.syntax.basic_syntax"></a><a class="link" href="basic_syntax.html" title="POSIX Basic Regular Expression Syntax">POSIX Basic Regular
 Expression Syntax</a>
</h3></div></div></div>
-<a name="boost_regex.syntax.basic_syntax.synopsis"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.synopsis-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.synopsis">Synopsis</a>
+<h4>
+<a name="boost_regex.syntax.basic_syntax.h0"></a>
+ <a name="boost_regex.syntax.basic_syntax.synopsis"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.synopsis">Synopsis</a>
 </h4>

 The POSIX-Basic regular expression syntax is used by the Unix utility <code class="computeroutput">sed</code>, and variations are used by <code class="computeroutput">grep</code> and <code class="computeroutput">emacs</code>.
@@ -42,9 +42,9 @@
// e2 a case insensitive POSIX-Basic expression:
boost::regex e2(my_expression, boost::regex::basic|boost::regex::icase);
</pre>
-<a name="boost_regex.posix_basic"></a><a name="boost_regex.syntax.basic_syntax.posix_basic_syntax"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.posix_basic_syntax-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.posix_basic_syntax">POSIX
+<a name="boost_regex.posix_basic"></a><h4>
+<a name="boost_regex.syntax.basic_syntax.h1"></a>
+ <a name="boost_regex.syntax.basic_syntax.posix_basic_syntax"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.posix_basic_syntax">POSIX
 Basic Syntax</a>
 </h4>

@@ -52,9 +52,9 @@
 for the following special characters:
 
<pre class="programlisting">.[\*^$</pre>
-<a name="boost_regex.syntax.basic_syntax.wildcard_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.wildcard_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.wildcard_">Wildcard:</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h2"></a>
+ <a name="boost_regex.syntax.basic_syntax.wildcard_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.wildcard_">Wildcard:</a>
 </h5>

 The single character '.' when used outside of a character set will match
@@ -70,9 +70,9 @@
 is passed to the matching algorithms.
 </li>
</ul></div>
-<a name="boost_regex.syntax.basic_syntax.anchors_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.anchors_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.anchors_">Anchors:</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h3"></a>
+ <a name="boost_regex.syntax.basic_syntax.anchors_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.anchors_">Anchors:</a>
 </h5>

 A '^' character shall match the start of a line when used as the first character
@@ -82,9 +82,9 @@
 A '$' character shall match the end of a line when used as the last character
 of an expression, or the last character of a sub-expression.
 
-<a name="boost_regex.syntax.basic_syntax.marked_sub_expressions_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.marked_sub_expressions_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.marked_sub_expressions_">Marked
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h4"></a>
+ <a name="boost_regex.syntax.basic_syntax.marked_sub_expressions_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.marked_sub_expressions_">Marked
 sub-expressions:</a>
 </h5>

@@ -94,9 +94,9 @@
 matching algorithms. Marked sub-expressions can also repeated, or referred-to
 by a back-reference.
 
-<a name="boost_regex.syntax.basic_syntax.repeats_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.repeats_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.repeats_">Repeats:</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h5"></a>
+ <a name="boost_regex.syntax.basic_syntax.repeats_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.repeats_">Repeats:</a>
 </h5>

 Any atom (a single character, a marked sub-expression, or a character class)
@@ -152,9 +152,10 @@
 Will raise an error, as there is nothing for the * operator to be applied
 to.
 
-<a name="boost_regex.syntax.basic_syntax.back_references_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.back_references_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.back_references_">Back references:</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h6"></a>
+ <a name="boost_regex.syntax.basic_syntax.back_references_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.back_references_">Back
+ references:</a>
 </h5>

 An escape character followed by a digit n, where n
@@ -170,9 +171,9 @@
 But not the string:
 
<pre class="programlisting">aaabba</pre>
-<a name="boost_regex.syntax.basic_syntax.character_sets_"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.character_sets_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_sets_">Character
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h7"></a>
+ <a name="boost_regex.syntax.basic_syntax.character_sets_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_sets_">Character
 sets:</a>
 </h5>

@@ -183,18 +184,18 @@

 A bracket expression may contain any combination of the following:
 
-<a name="boost_regex.syntax.basic_syntax.single_characters_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.single_characters_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.single_characters_">Single
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h8"></a>
+ <a name="boost_regex.syntax.basic_syntax.single_characters_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.single_characters_">Single
 characters:</a>
 </h6>

 For example <code class="computeroutput">[abc]</code>, will match any of the characters 'a', 'b',
 or 'c'.
 
-<a name="boost_regex.syntax.basic_syntax.character_ranges_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.character_ranges_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_ranges_">Character
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h9"></a>
+ <a name="boost_regex.syntax.basic_syntax.character_ranges_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_ranges_">Character
 ranges:</a>
 </h6>

@@ -208,18 +209,18 @@
 a character appears within a range is determined by comparing the code points
 of the characters only.
 
-<a name="boost_regex.syntax.basic_syntax.negation_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.negation_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.negation_">Negation:</a>
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h10"></a>
+ <a name="boost_regex.syntax.basic_syntax.negation_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.negation_">Negation:</a>
 </h6>

 If the bracket-expression begins with the ^ character, then it matches the
 complement of the characters it contains, for example <code class="computeroutput">[^a-c]</code> matches any character that is not in the
 range a-c.
 
-<a name="boost_regex.syntax.basic_syntax.character_classes_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.character_classes_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_classes_">Character
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h11"></a>
+ <a name="boost_regex.syntax.basic_syntax.character_classes_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.character_classes_">Character
 classes:</a>
 </h6>

@@ -227,9 +228,9 @@
 matches the named character class "name", for example <code class="computeroutput">[[:lower:]]</code> matches any lower case character. See
 <a class="link" href="character_classes.html" title="Character Class Names">character class names</a>.
 
-<a name="boost_regex.syntax.basic_syntax.collating_elements_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.collating_elements_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.collating_elements_">Collating
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h12"></a>
+ <a name="boost_regex.syntax.basic_syntax.collating_elements_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.collating_elements_">Collating
 Elements:</a>
 </h6>

@@ -256,9 +257,9 @@
 matches a 'NUL' character. See <a class="link" href="collating_names.html" title="Collating Names">collating
 element names</a>.
 
-<a name="boost_regex.syntax.basic_syntax.equivalence_classes_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.equivalence_classes_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.equivalence_classes_">Equivalence
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h13"></a>
+ <a name="boost_regex.syntax.basic_syntax.equivalence_classes_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.equivalence_classes_">Equivalence
 classes:</a>
 </h6>

@@ -273,17 +274,17 @@
 this feature can not be relied upon to work portably across all platforms,
 or even all locales on one platform.
 
-<a name="boost_regex.syntax.basic_syntax.combinations_"></a><h6>
-<a name="boost_regex.syntax.basic_syntax.combinations_-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.combinations_">Combinations:</a>
+<h6>
+<a name="boost_regex.syntax.basic_syntax.h14"></a>
+ <a name="boost_regex.syntax.basic_syntax.combinations_"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.combinations_">Combinations:</a>
 </h6>

 All of the above can be combined in one character set declaration, for example:
 <code class="computeroutput">[[:digit:]a-c[.NUL.]].</code>
 
-<a name="boost_regex.syntax.basic_syntax.escapes"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.escapes-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.escapes">Escapes</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h15"></a>
+ <a name="boost_regex.syntax.basic_syntax.escapes"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.escapes">Escapes</a>
 </h5>

 With the exception of the escape sequences \{, \}, $, and $, which are
@@ -296,23 +297,23 @@
 inside a character set, so <code class="computeroutput">[\^]</code>
 will match either a literal '\' or a '^'.
 
-<a name="boost_regex.syntax.basic_syntax.what_gets_matched"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.what_gets_matched-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.what_gets_matched">What Gets
- Matched</a>
+<h4>
+<a name="boost_regex.syntax.basic_syntax.h16"></a>
+ <a name="boost_regex.syntax.basic_syntax.what_gets_matched"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.what_gets_matched">What
+ Gets Matched</a>
 </h4>

 When there is more that one way to match a regular expression, the "best"
 possible match is obtained using the <a class="link" href="leftmost_longest_rule.html" title="The Leftmost Longest Rule">leftmost-longest
 rule</a>.
 
-<a name="boost_regex.syntax.basic_syntax.variations"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.variations-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.variations">Variations</a>
+<h4>
+<a name="boost_regex.syntax.basic_syntax.h17"></a>
+ <a name="boost_regex.syntax.basic_syntax.variations"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.variations">Variations</a>
 </h4>
-<a name="boost_regex.grep_syntax"></a><a name="boost_regex.syntax.basic_syntax.grep"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.grep-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.grep">Grep</a>
+<a name="boost_regex.grep_syntax"></a><h5>
+<a name="boost_regex.syntax.basic_syntax.h18"></a>
+ <a name="boost_regex.syntax.basic_syntax.grep"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.grep">Grep</a>
 </h5>

 When an expression is compiled with the flag <code class="computeroutput">grep</code>
@@ -328,9 +329,9 @@

 As its name suggests, this behavior is consistent with the Unix utility grep.
 
-<a name="boost_regex.syntax.basic_syntax.emacs"></a><h5>
-<a name="boost_regex.syntax.basic_syntax.emacs-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.emacs">emacs</a>
+<h5>
+<a name="boost_regex.syntax.basic_syntax.h19"></a>
+ <a name="boost_regex.syntax.basic_syntax.emacs"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.emacs">emacs</a>
 </h5>

 In addition to the <a class="link" href="basic_syntax.html#boost_regex.posix_basic">POSIX-Basic features</a>
@@ -608,9 +609,9 @@
 well with the <a class="link" href="leftmost_longest_rule.html" title="The Leftmost Longest Rule">POSIX-style
 leftmost-longest rule</a>.
 
-<a name="boost_regex.syntax.basic_syntax.options"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.options-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.options">Options</a>
+<h4>
+<a name="boost_regex.syntax.basic_syntax.h20"></a>
+ <a name="boost_regex.syntax.basic_syntax.options"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.options">Options</a>
 </h4>

 There are a <a class="link" href="../ref/syntax_option_type/syntax_option_type_basic.html" title="Options for POSIX Basic Regular Expressions">variety
@@ -622,9 +623,9 @@
 all alter the syntax, while the <a class="link" href="../ref/syntax_option_type/syntax_option_type_basic.html" title="Options for POSIX Basic Regular Expressions"><code class="computeroutput">collate</code> and <code class="computeroutput">icase</code>
 options</a> modify how the case and locale sensitivity are to be applied.
 
-<a name="boost_regex.syntax.basic_syntax.references"></a><h4>
-<a name="boost_regex.syntax.basic_syntax.references-heading"></a>
- <a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.references">References</a>
+<h4>
+<a name="boost_regex.syntax.basic_syntax.h21"></a>
+ <a name="boost_regex.syntax.basic_syntax.references"></a><a class="link" href="basic_syntax.html#boost_regex.syntax.basic_syntax.references">References</a>
 </h4>

 <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap09.html" target="_top">IEEE

Modified: trunk/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -27,9 +27,9 @@
<a name="boost_regex.syntax.perl_syntax"></a><a class="link" href="perl_syntax.html" title="Perl Regular Expression Syntax">Perl Regular Expression
 Syntax</a>
</h3></div></div></div>
-<a name="boost_regex.syntax.perl_syntax.synopsis"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.synopsis-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.synopsis">Synopsis</a>
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h0"></a>
+ <a name="boost_regex.syntax.perl_syntax.synopsis"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.synopsis">Synopsis</a>
 </h4>

 The Perl regular expression syntax is based on that used by the programming
@@ -42,9 +42,9 @@
// e2 a case insensitive Perl regular expression:
boost::regex e2(my_expression, boost::regex::perl|boost::regex::icase);
</pre>
-<a name="boost_regex.syntax.perl_syntax.perl_regular_expression_syntax"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.perl_regular_expression_syntax-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.perl_regular_expression_syntax">Perl
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h1"></a>
+ <a name="boost_regex.syntax.perl_syntax.perl_regular_expression_syntax"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.perl_regular_expression_syntax">Perl
 Regular Expression Syntax</a>
 </h4>

@@ -52,9 +52,9 @@
 following special characters:
 
<pre class="programlisting">.[{}()\*+?|^$</pre>
-<a name="boost_regex.syntax.perl_syntax.wildcard"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.wildcard-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.wildcard">Wildcard</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h2"></a>
+ <a name="boost_regex.syntax.perl_syntax.wildcard"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.wildcard">Wildcard</a>
 </h5>

 The single character '.' when used outside of a character set will match
@@ -72,9 +72,9 @@
 algorithms.
 </li>
</ul></div>
-<a name="boost_regex.syntax.perl_syntax.anchors"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.anchors-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.anchors">Anchors</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h3"></a>
+ <a name="boost_regex.syntax.perl_syntax.anchors"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.anchors">Anchors</a>
 </h5>

 A '^' character shall match the start of a line.
@@ -82,10 +82,9 @@

 A '$' character shall match the end of a line.
 
-<a name="boost_regex.syntax.perl_syntax.marked_sub_expressions"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.marked_sub_expressions-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.marked_sub_expressions">Marked
- sub-expressions</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h4"></a>
+ <a name="boost_regex.syntax.perl_syntax.marked_sub_expressions"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.marked_sub_expressions">Marked sub-expressions</a>
 </h5>

 A section beginning <code class="literal">(</code> and ending <code class="literal">)</code>
@@ -93,9 +92,9 @@
 out in a separate field by the matching algorithms. Marked sub-expressions
 can also repeated, or referred to by a back-reference.
 
-<a name="boost_regex.syntax.perl_syntax.non_marking_grouping"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.non_marking_grouping-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_marking_grouping">Non-marking
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h5"></a>
+ <a name="boost_regex.syntax.perl_syntax.non_marking_grouping"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_marking_grouping">Non-marking
 grouping</a>
 </h5>

@@ -106,9 +105,9 @@
 , for example <code class="literal">(?:ab)+</code> will repeat <code class="literal">ab</code>
 without splitting out any separate sub-expressions.
 
-<a name="boost_regex.syntax.perl_syntax.repeats"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.repeats-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.repeats">Repeats</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h6"></a>
+ <a name="boost_regex.syntax.perl_syntax.repeats"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.repeats">Repeats</a>
 </h5>

 Any atom (a single character, a marked sub-expression, or a character class)
@@ -187,10 +186,10 @@
 Will raise an error, as there is nothing for the <code class="literal">*</code> operator
 to be applied to.
 
-<a name="boost_regex.syntax.perl_syntax.non_greedy_repeats"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.non_greedy_repeats-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_greedy_repeats">Non greedy
- repeats</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h7"></a>
+ <a name="boost_regex.syntax.perl_syntax.non_greedy_repeats"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_greedy_repeats">Non
+ greedy repeats</a>
 </h5>

 The normal repeat operators are "greedy", that is to say they will
@@ -217,9 +216,9 @@
 <code class="literal">{n,m}?</code> Matches the previous atom between n and m times,
 while consuming as little input as possible.
 
-<a name="boost_regex.syntax.perl_syntax.possessive_repeats"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.possessive_repeats-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.possessive_repeats">Possessive
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h8"></a>
+ <a name="boost_regex.syntax.perl_syntax.possessive_repeats"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.possessive_repeats">Possessive
 repeats</a>
 </h5>

@@ -249,9 +248,10 @@
 <code class="literal">{n,m}+</code> Matches the previous atom between n and m times,
 while giving nothing back.
 
-<a name="boost_regex.syntax.perl_syntax.back_references"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.back_references-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.back_references">Back references</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h9"></a>
+ <a name="boost_regex.syntax.perl_syntax.back_references"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.back_references">Back
+ references</a>
 </h5>

 An escape character followed by a digit n, where n
@@ -359,9 +359,9 @@
 <code class="literal">\k<two></code> will match whatever matched the subexpression
 named "two".
 
-<a name="boost_regex.syntax.perl_syntax.alternation"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.alternation-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.alternation">Alternation</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h10"></a>
+ <a name="boost_regex.syntax.perl_syntax.alternation"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.alternation">Alternation</a>
 </h5>

 The <code class="literal">|</code> operator will match either of its arguments, so
@@ -386,9 +386,10 @@

 <code class="literal">(?:abc)??</code> has exactly the same effect.
 
-<a name="boost_regex.syntax.perl_syntax.character_sets"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.character_sets-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_sets">Character sets</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h11"></a>
+ <a name="boost_regex.syntax.perl_syntax.character_sets"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_sets">Character
+ sets</a>
 </h5>

 A character set is a bracket-expression starting with <code class="literal">[</code>
@@ -398,16 +399,17 @@

 A bracket expression may contain any combination of the following:
 
-<a name="boost_regex.syntax.perl_syntax.single_characters"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.single_characters-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.single_characters">Single characters</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h12"></a>
+ <a name="boost_regex.syntax.perl_syntax.single_characters"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.single_characters">Single
+ characters</a>
 </h6>

 For example =[abc]=, will match any of the characters 'a', 'b', or 'c'.
 
-<a name="boost_regex.syntax.perl_syntax.character_ranges"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.character_ranges-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_ranges">Character
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h13"></a>
+ <a name="boost_regex.syntax.perl_syntax.character_ranges"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_ranges">Character
 ranges</a>
 </h6>

@@ -418,18 +420,18 @@
 flag</a> when constructing the regular expression, then ranges are locale
 sensitive.
 
-<a name="boost_regex.syntax.perl_syntax.negation"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.negation-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.negation">Negation</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h14"></a>
+ <a name="boost_regex.syntax.perl_syntax.negation"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.negation">Negation</a>
 </h6>

 If the bracket-expression begins with the ^ character, then it matches the
 complement of the characters it contains, for example =<code class="literal">a-c</code>=
 matches any character that is not in the range <code class="literal">a-c</code>.
 
-<a name="boost_regex.syntax.perl_syntax.character_classes"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.character_classes-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_classes">Character
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h15"></a>
+ <a name="boost_regex.syntax.perl_syntax.character_classes"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_classes">Character
 classes</a>
 </h6>

@@ -438,9 +440,9 @@
 matches any lower case character. See <a class="link" href="character_classes.html" title="Character Class Names">character
 class names</a>.
 
-<a name="boost_regex.syntax.perl_syntax.collating_elements"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.collating_elements-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.collating_elements">Collating
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h16"></a>
+ <a name="boost_regex.syntax.perl_syntax.collating_elements"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.collating_elements">Collating
 Elements</a>
 </h6>

@@ -460,9 +462,9 @@

 matches a <code class="literal">\0</code> character.
 
-<a name="boost_regex.syntax.perl_syntax.equivalence_classes"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.equivalence_classes-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.equivalence_classes">Equivalence
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h17"></a>
+ <a name="boost_regex.syntax.perl_syntax.equivalence_classes"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.equivalence_classes">Equivalence
 classes</a>
 </h6>

@@ -477,9 +479,9 @@
 this feature can not be relied upon to work portably across all platforms,
 or even all locales on one platform.
 
-<a name="boost_regex.syntax.perl_syntax.escaped_characters"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.escaped_characters-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.escaped_characters">Escaped
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h18"></a>
+ <a name="boost_regex.syntax.perl_syntax.escaped_characters"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.escaped_characters">Escaped
 Characters</a>
 </h6>

@@ -489,17 +491,17 @@
 would match any character that is either a "digit", or
 is not a "word" character.
 
-<a name="boost_regex.syntax.perl_syntax.combinations"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.combinations-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.combinations">Combinations</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h19"></a>
+ <a name="boost_regex.syntax.perl_syntax.combinations"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.combinations">Combinations</a>
 </h6>

 All of the above can be combined in one character set declaration, for example:
 <code class="literal">[[:digit:]a-c[.NUL.]]</code>.
 
-<a name="boost_regex.syntax.perl_syntax.escapes"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.escapes-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.escapes">Escapes</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h20"></a>
+ <a name="boost_regex.syntax.perl_syntax.escapes"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.escapes">Escapes</a>
 </h5>

 Any special character preceded by an escape shall match itself.
@@ -689,9 +691,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.perl_syntax._quot_single_character_quot__character_classes_"></a><h6>
-<a name="boost_regex.syntax.perl_syntax._quot_single_character_quot__character_classes_-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax._quot_single_character_quot__character_classes_">"Single
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h21"></a>
+ <a name="boost_regex.syntax.perl_syntax._quot_single_character_quot__character_classes_"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax._quot_single_character_quot__character_classes_">"Single
 character" character classes:</a>
 </h6>

@@ -891,9 +893,9 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.perl_syntax.character_properties"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.character_properties-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_properties">Character
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h22"></a>
+ <a name="boost_regex.syntax.perl_syntax.character_properties"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.character_properties">Character
 Properties</a>
 </h6>

@@ -999,9 +1001,10 @@
 For example <code class="literal">\pd</code> matches any "digit" character,
 as does <code class="literal">\p{digit}</code>.
 
-<a name="boost_regex.syntax.perl_syntax.word_boundaries"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.word_boundaries-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.word_boundaries">Word Boundaries</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h23"></a>
+ <a name="boost_regex.syntax.perl_syntax.word_boundaries"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.word_boundaries">Word
+ Boundaries</a>
 </h6>

 The following escape sequences match the boundaries of words:
@@ -1018,9 +1021,10 @@

 <code class="literal">\B</code> Matches only when not at a word boundary.
 
-<a name="boost_regex.syntax.perl_syntax.buffer_boundaries"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.buffer_boundaries-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.buffer_boundaries">Buffer boundaries</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h24"></a>
+ <a name="boost_regex.syntax.perl_syntax.buffer_boundaries"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.buffer_boundaries">Buffer
+ boundaries</a>
 </h6>

 The following match only at buffer boundaries: a "buffer" in this
@@ -1045,9 +1049,9 @@
 Note that this is subtly different from Perl which behaves as if matching
 <code class="literal">(?=\n?\z)</code>.
 
-<a name="boost_regex.syntax.perl_syntax.continuation_escape"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.continuation_escape-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.continuation_escape">Continuation
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h25"></a>
+ <a name="boost_regex.syntax.perl_syntax.continuation_escape"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.continuation_escape">Continuation
 Escape</a>
 </h6>

@@ -1057,9 +1061,10 @@
 within a text, and you want each subsequence match to start where the last
 one ended.
 
-<a name="boost_regex.syntax.perl_syntax.quoting_escape"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.quoting_escape-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.quoting_escape">Quoting escape</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h26"></a>
+ <a name="boost_regex.syntax.perl_syntax.quoting_escape"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.quoting_escape">Quoting
+ escape</a>
 </h6>

 The escape sequence <code class="literal">\Q</code> begins a "quoted sequence":
@@ -1070,9 +1075,10 @@
<pre class="programlisting">\*+a
\*+aaa
</pre>
-<a name="boost_regex.syntax.perl_syntax.unicode_escapes"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.unicode_escapes-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.unicode_escapes">Unicode escapes</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h27"></a>
+ <a name="boost_regex.syntax.perl_syntax.unicode_escapes"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.unicode_escapes">Unicode
+ escapes</a>
 </h6>

 <code class="literal">\C</code> Matches a single code point: in Boost regex this has
@@ -1080,19 +1086,19 @@
 Matches a combining character sequence: that is any non-combining character
 followed by a sequence of zero or more combining characters.
 
-<a name="boost_regex.syntax.perl_syntax.matching_line_endings"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.matching_line_endings-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.matching_line_endings">Matching
- Line Endings</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h28"></a>
+ <a name="boost_regex.syntax.perl_syntax.matching_line_endings"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.matching_line_endings">Matching Line
+ Endings</a>
 </h6>

 The escape sequence <code class="literal">\R</code> matches any line ending character
 sequence, specifically it is identical to the expression <code class="literal">(?>\x0D\x0A?|[\x0A-\x0C\x85\x{2028}\x{2029}])</code>.
 
-<a name="boost_regex.syntax.perl_syntax.keeping_back_some_text"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.keeping_back_some_text-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.keeping_back_some_text">Keeping
- back some text</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h29"></a>
+ <a name="boost_regex.syntax.perl_syntax.keeping_back_some_text"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.keeping_back_some_text">Keeping back
+ some text</a>
 </h6>

 <code class="literal">\K</code> Resets the start location of $0 to the current text
@@ -1104,27 +1110,27 @@
 would return the match "bar" for $0 and "foo" for $`.
 This can be used to simulate variable width lookbehind assertions.
 
-<a name="boost_regex.syntax.perl_syntax.any_other_escape"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.any_other_escape-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.any_other_escape">Any other
- escape</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h30"></a>
+ <a name="boost_regex.syntax.perl_syntax.any_other_escape"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.any_other_escape">Any
+ other escape</a>
 </h6>

 Any other escape sequence matches the character that is escaped, for example
 \@ matches a literal '@'.
 
-<a name="boost_regex.syntax.perl_syntax.perl_extended_patterns"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.perl_extended_patterns-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.perl_extended_patterns">Perl
- Extended Patterns</a>
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h31"></a>
+ <a name="boost_regex.syntax.perl_syntax.perl_extended_patterns"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.perl_extended_patterns">Perl Extended
+ Patterns</a>
 </h5>

 Perl-specific extensions to the regular expression syntax all start with
 <code class="literal">(?</code>.
 
-<a name="boost_regex.syntax.perl_syntax.named_subexpressions"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.named_subexpressions-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.named_subexpressions">Named
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h32"></a>
+ <a name="boost_regex.syntax.perl_syntax.named_subexpressions"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.named_subexpressions">Named
 Subexpressions</a>
 </h6>

@@ -1144,16 +1150,16 @@
 also be refered to by name in a <a class="link" href="../format/perl_format.html" title="Perl Format String Syntax">Perl</a>
 format string for search and replace operations, or in the <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput">match_results</code></a> member functions.
 
-<a name="boost_regex.syntax.perl_syntax.comments"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.comments-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.comments">Comments</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h33"></a>
+ <a name="boost_regex.syntax.perl_syntax.comments"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.comments">Comments</a>
 </h6>

 <code class="literal">(?# ... )</code> is treated as a comment, it's contents are ignored.
 
-<a name="boost_regex.syntax.perl_syntax.modifiers"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.modifiers-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.modifiers">Modifiers</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h34"></a>
+ <a name="boost_regex.syntax.perl_syntax.modifiers"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.modifiers">Modifiers</a>
 </h6>

 <code class="literal">(?imsx-imsx ... )</code> alters which of the perl modifiers are
@@ -1165,18 +1171,19 @@
 <code class="literal">(?imsx-imsx:pattern)</code> applies the specified modifiers to
 pattern only.
 
-<a name="boost_regex.syntax.perl_syntax.non_marking_groups"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.non_marking_groups-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_marking_groups">Non-marking
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h35"></a>
+ <a name="boost_regex.syntax.perl_syntax.non_marking_groups"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.non_marking_groups">Non-marking
 groups</a>
 </h6>

 <code class="literal">(?:pattern)</code> lexically groups pattern, without generating
 an additional sub-expression.
 
-<a name="boost_regex.syntax.perl_syntax.branch_reset"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.branch_reset-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.branch_reset">Branch reset</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h36"></a>
+ <a name="boost_regex.syntax.perl_syntax.branch_reset"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.branch_reset">Branch
+ reset</a>
 </h6>

 <code class="literal">(?|pattern)</code> resets the subexpression count at the start
@@ -1192,13 +1199,13 @@
 In the following example the index of each sub-expression is shown below
 the expression:
 
-<pre class="programlisting"># before ---------------branch-reset----------- after
+<pre class="programlisting"># before ---------------branch-reset----------- after
/ ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
# 1 2 2 3 2 3 4
</pre>
-<a name="boost_regex.syntax.perl_syntax.lookahead"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.lookahead-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.lookahead">Lookahead</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h37"></a>
+ <a name="boost_regex.syntax.perl_syntax.lookahead"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.lookahead">Lookahead</a>
 </h6>

 <code class="literal">(?=pattern)</code> consumes zero characters, only if pattern
@@ -1219,9 +1226,9 @@

 could be used to validate the password.
 
-<a name="boost_regex.syntax.perl_syntax.lookbehind"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.lookbehind-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.lookbehind">Lookbehind</a>
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h38"></a>
+ <a name="boost_regex.syntax.perl_syntax.lookbehind"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.lookbehind">Lookbehind</a>
 </h6>

 <code class="literal">(?<=pattern)</code> consumes zero characters, only if pattern
@@ -1233,9 +1240,9 @@
 could not be matched against the characters preceding the current position
 (pattern must be of fixed length).
 
-<a name="boost_regex.syntax.perl_syntax.independent_sub_expressions"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.independent_sub_expressions-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.independent_sub_expressions">Independent
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h39"></a>
+ <a name="boost_regex.syntax.perl_syntax.independent_sub_expressions"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.independent_sub_expressions">Independent
 sub-expressions</a>
 </h6>

@@ -1246,9 +1253,9 @@
 be considered, if this doesn't allow the expression as a whole to match then
 no match is found at all.
 
-<a name="boost_regex.syntax.perl_syntax.recursive_expressions"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.recursive_expressions-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.recursive_expressions">Recursive
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h40"></a>
+ <a name="boost_regex.syntax.perl_syntax.recursive_expressions"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.recursive_expressions">Recursive
 Expressions</a>
 </h6>

@@ -1273,9 +1280,9 @@

 <code class="literal">(?&NAME)</code> recurses to named sub-expression NAME.
 
-<a name="boost_regex.syntax.perl_syntax.conditional_expressions"></a><h6>
-<a name="boost_regex.syntax.perl_syntax.conditional_expressions-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.conditional_expressions">Conditional
+<h6>
+<a name="boost_regex.syntax.perl_syntax.h41"></a>
+ <a name="boost_regex.syntax.perl_syntax.conditional_expressions"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.conditional_expressions">Conditional
 Expressions</a>
 </h6>

@@ -1323,9 +1330,9 @@
 from elsewhere in the pattern.
 </li>
</ul></div>
-<a name="boost_regex.syntax.perl_syntax.operator_precedence"></a><h5>
-<a name="boost_regex.syntax.perl_syntax.operator_precedence-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.operator_precedence">Operator
+<h5>
+<a name="boost_regex.syntax.perl_syntax.h42"></a>
+ <a name="boost_regex.syntax.perl_syntax.operator_precedence"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.operator_precedence">Operator
 precedence</a>
 </h5>

@@ -1358,10 +1365,10 @@
 Alternation |
 </li>
</ol></div>
-<a name="boost_regex.syntax.perl_syntax.what_gets_matched"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.what_gets_matched-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.what_gets_matched">What gets
- matched</a>
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h43"></a>
+ <a name="boost_regex.syntax.perl_syntax.what_gets_matched"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.what_gets_matched">What
+ gets matched</a>
 </h4>

 If you view the regular expression as a directed (possibly cyclic) graph,
@@ -1534,18 +1541,18 @@
</tr>
</tbody>
</table></div>
-<a name="boost_regex.syntax.perl_syntax.variations"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.variations-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.variations">Variations</a>
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h44"></a>
+ <a name="boost_regex.syntax.perl_syntax.variations"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.variations">Variations</a>
 </h4>

 The <a class="link" href="../ref/syntax_option_type/syntax_option_type_perl.html" title="Options for Perl Regular Expressions">options
 <code class="literal">normal</code>, <code class="literal">ECMAScript</code>, <code class="literal">JavaScript</code>
 and <code class="literal">JScript</code></a> are all synonyms for <code class="literal">perl</code>.
 
-<a name="boost_regex.syntax.perl_syntax.options"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.options-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.options">Options</a>
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h45"></a>
+ <a name="boost_regex.syntax.perl_syntax.options"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.options">Options</a>
 </h4>

 There are a <a class="link" href="../ref/syntax_option_type/syntax_option_type_perl.html" title="Options for Perl Regular Expressions">variety
@@ -1555,9 +1562,9 @@
 and <code class="literal">icase</code> options modify how the case and locale sensitivity
 are to be applied.
 
-<a name="boost_regex.syntax.perl_syntax.pattern_modifiers"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.pattern_modifiers-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.pattern_modifiers">Pattern
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h46"></a>
+ <a name="boost_regex.syntax.perl_syntax.pattern_modifiers"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.pattern_modifiers">Pattern
 Modifiers</a>
 </h4>

@@ -1567,9 +1574,9 @@
 time flags <code class="literal">no_mod_m</code>, <code class="literal">mod_x</code>, <code class="literal">mod_s</code>,
 and <code class="literal">no_mod_s</code></a>.
 
-<a name="boost_regex.syntax.perl_syntax.references"></a><h4>
-<a name="boost_regex.syntax.perl_syntax.references-heading"></a>
- <a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.references">References</a>
+<h4>
+<a name="boost_regex.syntax.perl_syntax.h47"></a>
+ <a name="boost_regex.syntax.perl_syntax.references"></a><a class="link" href="perl_syntax.html#boost_regex.syntax.perl_syntax.references">References</a>
 </h4>

 <a href="http://perldoc.perl.org/perlre.html" target="_top">Perl 5.8</a>.

Modified: trunk/libs/regex/doc/html/boost_regex/unicode.html
==============================================================================
--- trunk/libs/regex/doc/html/boost_regex/unicode.html (original)
+++ trunk/libs/regex/doc/html/boost_regex/unicode.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -29,9 +29,10 @@

 There are two ways to use Boost.Regex with Unicode strings:
 
-<a name="boost_regex.unicode.rely_on_wchar_t"></a><h5>
-<a name="boost_regex.unicode.rely_on_wchar_t-heading"></a>
- <a class="link" href="unicode.html#boost_regex.unicode.rely_on_wchar_t">Rely on wchar_t</a>
+<h5>
+<a name="boost_regex.unicode.h0"></a>
+ <a name="boost_regex.unicode.rely_on_wchar_t"></a><a class="link" href="unicode.html#boost_regex.unicode.rely_on_wchar_t">Rely
+ on wchar_t</a>
 </h5>

 If your platform's <code class="computeroutput">wchar_t</code> type
@@ -55,9 +56,9 @@
 it is not possible to search UTF-8, or even UTF-16 on many platforms.
 </li>
</ul></div>
-<a name="boost_regex.unicode.use_a_unicode_aware_regular_expression_type_"></a><h5>
-<a name="boost_regex.unicode.use_a_unicode_aware_regular_expression_type_-heading"></a>
- <a class="link" href="unicode.html#boost_regex.unicode.use_a_unicode_aware_regular_expression_type_">Use
+<h5>
+<a name="boost_regex.unicode.h1"></a>
+ <a name="boost_regex.unicode.use_a_unicode_aware_regular_expression_type_"></a><a class="link" href="unicode.html#boost_regex.unicode.use_a_unicode_aware_regular_expression_type_">Use
 a Unicode Aware Regular Expression Type.</a>
 </h5>

Modified: trunk/libs/regex/doc/html/index.html
==============================================================================
--- trunk/libs/regex/doc/html/index.html (original)
+++ trunk/libs/regex/doc/html/index.html 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -28,7 +28,7 @@
</h3></div></div></div>
<div>Copyright © 1998-2010 John Maddock</div>
<div><div class="legalnotice">
-<a name="id1026993"></a>
+<a name="boost_regex.legal"></a>
 Distributed under the Boost Software License, Version 1.0. (See accompanying
 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -198,7 +198,7 @@
 
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: October 16, 2011 at 12:24:31 GMT</td>
+<td align="left">Last revised: December 24, 2011 at 17:50:34 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: trunk/libs/regex/doc/introduction.qbk
==============================================================================
--- trunk/libs/regex/doc/introduction.qbk (original)
+++ trunk/libs/regex/doc/introduction.qbk 2011-12-24 12:51:57 EST (Sat, 24 Dec 2011)
@@ -40,14 +40,14 @@
space or a hyphen. Before storing a credit card number in a database
(not necessarily something your customers will appreciate!), we may want to
verify that the number is in the correct format. To match any digit we could
-use the regular expression [0-9], however ranges of characters like this are
+use the regular expression \[0-9\], however ranges of characters like this are
actually locale dependent. Instead we should use the POSIX standard
form \[\[:digit:\]\], or the Boost.Regex and Perl shorthand for this \\d (note
that many older libraries tended to be hard-coded to the C-locale,
consequently this was not an issue for them). That leaves us with the
following regular expression to validate credit card number formats:

-[pre (\d{4}[- ]){3}\d{4}]
+[pre (\d{4}\[- \]){3}\d{4}]

Here the parenthesis act to group (and mark for future reference)
sub-expressions, and the {4} means "repeat exactly 4 times". This is an

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk