From a08e8b5c85d1617894904b34b3b677735b05a051 Mon Sep 17 00:00:00 2001 From: John Maddock Date: Fri, 11 Jul 2008 11:49:03 +0000 Subject: [PATCH] Merge changes from Trunk. [SVN r47307] --- .../boost_regex/background_information.html | 4 +- .../acknowledgements.html | 4 +- .../background_information/examples.html | 16 +- .../background_information/faq.html | 8 +- .../background_information/futher.html | 4 +- .../background_information/headers.html | 6 +- .../background_information/history.html | 24 +- .../background_information/locale.html | 40 +- .../background_information/performance.html | 4 +- .../background_information/redist.html | 4 +- .../background_information/standards.html | 24 +- .../background_information/thread_safety.html | 22 +- doc/html/boost_regex/captures.html | 30 +- doc/html/boost_regex/configuration.html | 4 +- .../boost_regex/configuration/algorithm.html | 4 +- .../boost_regex/configuration/compiler.html | 4 +- .../boost_regex/configuration/linkage.html | 4 +- .../boost_regex/configuration/locale.html | 4 +- .../boost_regex/configuration/tuning.html | 4 +- doc/html/boost_regex/format.html | 10 +- .../format/boost_format_syntax.html | 20 +- doc/html/boost_regex/format/perl_format.html | 4 +- doc/html/boost_regex/format/sed_format.html | 4 +- doc/html/boost_regex/install.html | 36 +- .../introduction_and_overview.html | 48 ++- doc/html/boost_regex/partial_matches.html | 22 +- doc/html/boost_regex/ref.html | 4 +- doc/html/boost_regex/ref/bad_expression.html | 27 +- doc/html/boost_regex/ref/basic_regex.html | 374 ++++++++---------- doc/html/boost_regex/ref/concepts.html | 4 +- .../ref/concepts/charT_concept.html | 6 +- .../ref/concepts/iterator_concepts.html | 4 +- .../ref/concepts/traits_concept.html | 18 +- .../ref/deprecated_interfaces.html | 4 +- .../ref/deprecated_interfaces/old_regex.html | 58 ++- .../deprecated_interfaces/regex_format.html | 25 +- .../ref/deprecated_interfaces/regex_grep.html | 32 +- .../deprecated_interfaces/regex_split.html | 24 +- doc/html/boost_regex/ref/error_type.html | 15 +- doc/html/boost_regex/ref/match_flag_type.html | 27 +- doc/html/boost_regex/ref/match_results.html | 162 ++++---- doc/html/boost_regex/ref/non_std_strings.html | 4 +- .../boost_regex/ref/non_std_strings/icu.html | 4 +- .../ref/non_std_strings/icu/intro.html | 9 +- .../ref/non_std_strings/icu/unicode_algo.html | 36 +- .../ref/non_std_strings/icu/unicode_iter.html | 40 +- .../non_std_strings/icu/unicode_types.html | 31 +- .../ref/non_std_strings/mfc_strings.html | 4 +- .../non_std_strings/mfc_strings/mfc_algo.html | 64 ++- .../mfc_strings/mfc_intro.html | 7 +- .../non_std_strings/mfc_strings/mfc_iter.html | 32 +- .../mfc_strings/mfc_regex_create.html | 7 +- .../mfc_strings/mfc_regex_types.html | 7 +- doc/html/boost_regex/ref/posix.html | 29 +- doc/html/boost_regex/ref/regex_iterator.html | 99 ++--- doc/html/boost_regex/ref/regex_match.html | 47 +-- doc/html/boost_regex/ref/regex_replace.html | 61 ++- doc/html/boost_regex/ref/regex_search.html | 41 +- .../boost_regex/ref/regex_token_iterator.html | 120 +++--- doc/html/boost_regex/ref/regex_traits.html | 13 +- doc/html/boost_regex/ref/sub_match.html | 368 +++++++---------- .../boost_regex/ref/syntax_option_type.html | 4 +- .../syntax_option_type_basic.html | 18 +- .../syntax_option_type_extended.html | 16 +- .../syntax_option_type_literal.html | 4 +- .../syntax_option_type_overview.html | 19 +- .../syntax_option_type_perl.html | 10 +- .../syntax_option_type_synopsis.html | 11 +- doc/html/boost_regex/syntax.html | 10 +- .../boost_regex/syntax/basic_extended.html | 185 +++++---- doc/html/boost_regex/syntax/basic_syntax.html | 124 +++--- .../boost_regex/syntax/character_classes.html | 4 +- .../optional_char_class_names.html | 4 +- .../character_classes/std_char_clases.html | 4 +- .../boost_regex/syntax/collating_names.html | 4 +- .../syntax/collating_names/digraphs.html | 4 +- .../syntax/collating_names/named_unicode.html | 6 +- .../collating_names/posix_symbolic_names.html | 4 +- .../syntax/leftmost_longest_rule.html | 4 +- doc/html/boost_regex/syntax/perl_syntax.html | 242 ++++++------ doc/html/boost_regex/unicode.html | 16 +- doc/html/index.html | 6 +- doc/syntax_perl.qbk | 2 +- example/snippets/icu_example.cpp | 2 +- include/boost/regex/concepts.hpp | 6 +- include/boost/regex/pending/object_cache.hpp | 2 +- .../boost/regex/pending/unicode_iterator.hpp | 1 + .../boost/regex/v4/basic_regex_creator.hpp | 13 + include/boost/regex/v4/instances.hpp | 19 +- .../boost/regex/v4/perl_matcher_common.hpp | 4 +- .../regex/v4/perl_matcher_non_recursive.hpp | 9 + src/posix_api.cpp | 16 +- src/usinstances.cpp | 5 + src/wc_regex_traits.cpp | 35 +- src/wide_posix_api.cpp | 16 +- test/regress/test_escapes.cpp | 3 + 96 files changed, 1386 insertions(+), 1611 deletions(-) diff --git a/doc/html/boost_regex/background_information.html b/doc/html/boost_regex/background_information.html index 9cf4e305..d0c12bab 100644 --- a/doc/html/boost_regex/background_information.html +++ b/doc/html/boost_regex/background_information.html @@ -3,7 +3,7 @@ Background Information - + @@ -24,7 +24,7 @@

-Background Information +Background Information

Headers
diff --git a/doc/html/boost_regex/background_information/acknowledgements.html b/doc/html/boost_regex/background_information/acknowledgements.html index a71d745e..38965407 100644 --- a/doc/html/boost_regex/background_information/acknowledgements.html +++ b/doc/html/boost_regex/background_information/acknowledgements.html @@ -3,7 +3,7 @@ Acknowledgements - + @@ -24,7 +24,7 @@

diff --git a/doc/html/boost_regex/background_information/examples.html b/doc/html/boost_regex/background_information/examples.html index ccd06873..403074ea 100644 --- a/doc/html/boost_regex/background_information/examples.html +++ b/doc/html/boost_regex/background_information/examples.html @@ -3,7 +3,7 @@ Test and Example Programs - + @@ -24,12 +24,12 @@

- - Test + + Test Programs

@@ -98,8 +98,8 @@ Files: captures_test.cpp.

- - Example + + Example programs

@@ -124,8 +124,8 @@ Files: regex_timer.cpp.

- - Code + + Code snippets

diff --git a/doc/html/boost_regex/background_information/faq.html b/doc/html/boost_regex/background_information/faq.html index ae33ffba..d3f8900b 100644 --- a/doc/html/boost_regex/background_information/faq.html +++ b/doc/html/boost_regex/background_information/faq.html @@ -3,7 +3,7 @@ FAQ - + @@ -24,7 +24,7 @@

Q. I can't get regex++ to work with escape @@ -115,10 +115,10 @@ throw specifications, others support them but with reduced efficiency. Throw specifications may be added at a later date as compilers begin to handle this better. The library should throw only three types of exception: [boost::regex_error] - can be thrown by basic_regex when compiling a regular + can be thrown by basic_regex when compiling a regular expression, std::runtime_error can be thrown when a call to basic_regex::imbue tries to open a message catalogue - that doesn't exist, or when a call to regex_search or regex_match results in an "everlasting" + that doesn't exist, or when a call to regex_search or regex_match results in an "everlasting" search, or when a call to RegEx::GrepFiles or RegEx::FindFiles tries to open a file that cannot be opened, finally std::bad_alloc can be thrown by just about any diff --git a/doc/html/boost_regex/background_information/futher.html b/doc/html/boost_regex/background_information/futher.html index 8ce07356..6573efe2 100644 --- a/doc/html/boost_regex/background_information/futher.html +++ b/doc/html/boost_regex/background_information/futher.html @@ -3,7 +3,7 @@ References and Further Information - + @@ -24,7 +24,7 @@

diff --git a/doc/html/boost_regex/background_information/headers.html b/doc/html/boost_regex/background_information/headers.html index b832e977..82dfc5c1 100644 --- a/doc/html/boost_regex/background_information/headers.html +++ b/doc/html/boost_regex/background_information/headers.html @@ -3,7 +3,7 @@ Headers - + @@ -24,7 +24,7 @@

There are two main headers used by this library: <boost/regex.hpp> @@ -34,7 +34,7 @@

There is also a header containing only forward declarations <boost/regex_fwd.hpp> - for use when an interface is dependent upon basic_regex, but otherwise does + for use when an interface is dependent upon basic_regex, but otherwise does not need the full definitions.

diff --git a/doc/html/boost_regex/background_information/history.html b/doc/html/boost_regex/background_information/history.html index ae8ac58d..76d39eea 100644 --- a/doc/html/boost_regex/background_information/history.html +++ b/doc/html/boost_regex/background_information/history.html @@ -3,7 +3,7 @@ History - + @@ -23,11 +23,11 @@

- History + History

- - Boost + + Boost 1.34
    @@ -49,8 +49,8 @@
- - Boost + + Boost 1.33.1
    @@ -119,8 +119,8 @@
- - Boost + + Boost 1.33.0
    @@ -174,16 +174,16 @@
- - Boost + + Boost 1.32.1
  • Fixed bug in partial matches of bounded repeats of '.'.
- - Boost + + Boost 1.31.0
    diff --git a/doc/html/boost_regex/background_information/locale.html b/doc/html/boost_regex/background_information/locale.html index ef9e836c..6d5e99d5 100644 --- a/doc/html/boost_regex/background_information/locale.html +++ b/doc/html/boost_regex/background_information/locale.html @@ -3,7 +3,7 @@ Localization - + @@ -24,7 +24,7 @@

Boost.Regex provides extensive support for run-time localization, the localization @@ -58,14 +58,14 @@ There are three separate localization mechanisms supported by Boost.Regex:

- - Win32 + + Win32 localization model.

This is the default model when the library is compiled under Win32, and is encapsulated by the traits class w32_regex_traits. - When this model is in effect each basic_regex object gets it's own + When this model is in effect each basic_regex object gets it's own LCID, by default this is the users default setting as returned by GetUserDefaultLCID, but you can call imbue on the basic_regex object to set it's locale to some other LCID if you wish. All the settings @@ -74,8 +74,7 @@ a string table with the user-defined strings. The traits class exports the function:

-
-static std::string set_message_catalogue(const std::string& s);
+
static std::string set_message_catalogue(const std::string& s);
 

 

         which needs to be called with a string identifying the name of the resource
@@ -83,8 +82,7 @@
         before you construct any basic_regex
         instances):
       

-
-boost::w32_regex_traits<char>::set_message_catalogue("mydll.dll");
+
boost::w32_regex_traits<char>::set_message_catalogue("mydll.dll");
 

 

         The library provides full Unicode support under NT, under Windows 9x the
@@ -92,8 +90,8 @@
         are treated as "unknown" graphic characters.
       

 

-
-        C
+
+        C
         localization model.
       

 

@@ -116,35 +114,33 @@
         libraries including version 1 of this library.
       

 

-
-        C++
+
+        C++
         localization model.
       

 

         This model is the default for non-Windows compilers.
       

 

-        When this model is in effect each instance of basic_regex has its own instance
-        of std::locale, class basic_regex also has a member function
+        When this model is in effect each instance of basic_regex has its own instance
+        of std::locale, class basic_regex also has a member function
         imbue which allows the locale
         for the expression to be set on a per-instance basis. Front end localization
         requires a POSIX message catalogue, which will be loaded via the std::messages
         facet of the expression's locale, the traits class exports the symbol:
       

-
-static std::string set_message_catalogue(const std::string& s);
+
static std::string set_message_catalogue(const std::string& s);
 

 

         which needs to be called with a string identifying the name of the message
         catalogue, before your code compiles any regular expressions (but not necessarily
         before you construct any basic_regex instances):
       

-
-boost::cpp_regex_traits<char>::set_message_catalogue("mycatalogue");
+
boost::cpp_regex_traits<char>::set_message_catalogue("mycatalogue");
 

 

         Note that calling basic_regex<>::imbue
-        will invalidate any expression currently compiled in that instance of basic_regex.
+        will invalidate any expression currently compiled in that instance of basic_regex.
       

 

         Finally note that if you build the library with a non-default localization
@@ -155,8 +151,8 @@
         in your code. The best way to ensure this is to add the #define to <boost/regex/user.hpp>.
       

 

-
-        Providing
+
+        Providing
         a message catalogue
       

 

diff --git a/doc/html/boost_regex/background_information/performance.html b/doc/html/boost_regex/background_information/performance.html
index 4be98bb6..b26c1139 100644
--- a/doc/html/boost_regex/background_information/performance.html
+++ b/doc/html/boost_regex/background_information/performance.html
@@ -3,7 +3,7 @@
 
 Performance
 
-
+
 
 
 
@@ -24,7 +24,7 @@

The performance of Boost.Regex in both recursive and non-recursive modes diff --git a/doc/html/boost_regex/background_information/redist.html b/doc/html/boost_regex/background_information/redist.html index 4de0859a..a4c2158a 100644 --- a/doc/html/boost_regex/background_information/redist.html +++ b/doc/html/boost_regex/background_information/redist.html @@ -3,7 +3,7 @@ Redistributables - + @@ -24,7 +24,7 @@

If you are using Microsoft or Borland C++ and link to a dll version of the diff --git a/doc/html/boost_regex/background_information/standards.html b/doc/html/boost_regex/background_information/standards.html index e680d1c1..db70edb4 100644 --- a/doc/html/boost_regex/background_information/standards.html +++ b/doc/html/boost_regex/background_information/standards.html @@ -3,7 +3,7 @@ Standards Conformance - + @@ -24,20 +24,20 @@

- - C++ + + C++

Boost.Regex is intended to conform to the Technical Report on C++ Library Extensions.

- - ECMAScript + + ECMAScript / JavaScript

@@ -49,8 +49,8 @@ rather than a Unicode escape sequence; use \x{DDDD} for Unicode escape sequences.

- - Perl + + Perl

Almost all Perl features are supported, except for: @@ -62,8 +62,8 @@ (??{code}) Not implementable in a compiled strongly typed language.

- - POSIX + + POSIX

All the POSIX basic and extended regular expression features are supported, @@ -82,8 +82,8 @@ a custom traits class.

- - Unicode + + Unicode

The following comments refer to Unicode diff --git a/doc/html/boost_regex/background_information/thread_safety.html b/doc/html/boost_regex/background_information/thread_safety.html index 291bd6f8..7b88363c 100644 --- a/doc/html/boost_regex/background_information/thread_safety.html +++ b/doc/html/boost_regex/background_information/thread_safety.html @@ -3,7 +3,7 @@ Thread Safety - + @@ -24,7 +24,7 @@

@@ -34,26 +34,26 @@ support is turned on in your compiler.

- Class basic_regex + Class basic_regex and its typedefs regex and wregex are thread safe, in that compiled regular expressions can safely be shared between threads. The matching algorithms - regex_match, - regex_search, - and regex_replace - are all re-entrant and thread safe. Class match_results is now thread safe, + regex_match, + regex_search, + and regex_replace + are all re-entrant and thread safe. Class match_results is now thread safe, in that the results of a match can be safely copied from one thread to another - (for example one thread may find matches and push match_results instances onto a queue, + (for example one thread may find matches and push match_results instances onto a queue, while another thread pops them off the other end), otherwise use a separate - instance of match_results + instance of match_results per thread.

- The POSIX API functions are + The POSIX API functions are all re-entrant and thread safe, regular expressions compiled with regcomp can also be shared between threads.

- The class + The class RegEx is only thread safe if each thread gets its own RegEx instance (apartment threading) - this is a consequence of RegEx handling both compiling and matching regular expressions. diff --git a/doc/html/boost_regex/captures.html b/doc/html/boost_regex/captures.html index 5c4ecb1d..9d48399d 100644 --- a/doc/html/boost_regex/captures.html +++ b/doc/html/boost_regex/captures.html @@ -3,7 +3,7 @@ Understanding Marked Sub-Expressions and Captures - + @@ -24,7 +24,7 @@

@@ -35,8 +35,8 @@ accessed.

- - Marked sub-expressions + + Marked sub-expressions

Every time a Perl regular expression contains a parenthesis group (), it spits out an extra field, known as a @@ -131,11 +131,10 @@

- In Boost.Regex all these are accessible via the match_results class that gets filled - in when calling one of the regular expression matching algorithms ( regex_search, regex_match, or regex_iterator). So given: + In Boost.Regex all these are accessible via the match_results class that gets filled + in when calling one of the regular expression matching algorithms ( regex_search, regex_match, or regex_iterator). So given:

-
-boost::match_results<IteratorType> m;
+
boost::match_results<IteratorType> m;
 

 

       The Perl and Boost.Regex equivalents are as follows:
@@ -209,18 +208,18 @@

- In Boost.Regex each sub-expression match is represented by a sub_match object, this is basically + In Boost.Regex each sub-expression match is represented by a sub_match object, this is basically just a pair of iterators denoting the start and end position of the sub-expression match, but there are some additional operators provided so that objects of - type sub_match + type sub_match behave a lot like a std::basic_string: for example they are implicitly convertible to a basic_string, they can be compared to a string, added to a string, or streamed out to an output stream.

- - Unmatched Sub-Expressions + + Unmatched Sub-Expressions

When a regular expression match is found there is no need for all of the marked @@ -232,8 +231,8 @@ you can determine which sub-expressions matched by accessing the sub_match::matched data member.

- - Repeated Captures + + Repeated Captures

When a marked sub-expression is repeated, then the sub-expression gets "captured" @@ -256,8 +255,7 @@ the regular expression matching. The following example program shows how this information may be used:

-
-#include <boost/regex.hpp>
+
#include <boost/regex.hpp>
 #include <iostream>
 
 void print_captures(const std::string& regx, const std::string& text)
diff --git a/doc/html/boost_regex/configuration.html b/doc/html/boost_regex/configuration.html
index 3754e54d..b8de398d 100644
--- a/doc/html/boost_regex/configuration.html
+++ b/doc/html/boost_regex/configuration.html
@@ -3,7 +3,7 @@
 
 Configuration
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
 

 

 

 
 Compiler Setup

diff --git a/doc/html/boost_regex/configuration/algorithm.html b/doc/html/boost_regex/configuration/algorithm.html
index 040a50bb..479bacc9 100644
--- a/doc/html/boost_regex/configuration/algorithm.html
+++ b/doc/html/boost_regex/configuration/algorithm.html
@@ -3,7 +3,7 @@
 
 Algorithm Selection
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

 
diff --git a/doc/html/boost_regex/configuration/compiler.html b/doc/html/boost_regex/configuration/compiler.html
index c1e8729e..4e6a85d1 100644
--- a/doc/html/boost_regex/configuration/compiler.html
+++ b/doc/html/boost_regex/configuration/compiler.html
@@ -3,7 +3,7 @@
 Compiler Setup
-
+
@@ -24,7 +24,7 @@
 

 

 

         You shouldn't need to do anything special to configure Boost.Regex for use
diff --git a/doc/html/boost_regex/configuration/linkage.html b/doc/html/boost_regex/configuration/linkage.html
index f773537b..511dc37c 100644
--- a/doc/html/boost_regex/configuration/linkage.html
+++ b/doc/html/boost_regex/configuration/linkage.html
@@ -3,7 +3,7 @@
 
 Linkage Options
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

 

 
 
 
 
 
 
 
diff --git a/doc/html/boost_regex/configuration/locale.html b/doc/html/boost_regex/configuration/locale.html
index 7df3417e..7cca75d2 100644
--- a/doc/html/boost_regex/configuration/locale.html
+++ b/doc/html/boost_regex/configuration/locale.html
@@ -3,7 +3,7 @@
 Locale and traits class selection
-
+
@@ -24,7 +24,7 @@
 

 

 

diff --git a/doc/html/boost_regex/configuration/tuning.html b/doc/html/boost_regex/configuration/tuning.html
index 0069eaac..d0921904 100644
--- a/doc/html/boost_regex/configuration/tuning.html
+++ b/doc/html/boost_regex/configuration/tuning.html
@@ -3,7 +3,7 @@
 
 Algorithm Tuning
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

         The following option applies only if BOOST_REGEX_RECURSIVE is set.
diff --git a/doc/html/boost_regex/format.html b/doc/html/boost_regex/format.html
index 6aefc96e..22d67e10 100644
--- a/doc/html/boost_regex/format.html
+++ b/doc/html/boost_regex/format.html
@@ -3,7 +3,7 @@
 
 Search and Replace Format String Syntax
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

 
 Sed Format String Syntax

@@ -33,12 +33,12 @@
       Format String Syntax
 

 

-      Format strings are used by the algorithm regex_replace and by match_results<>::format, and are used to transform
+      Format strings are used by the algorithm regex_replace and by match_results<>::format, and are used to transform
       one string into another.
     

 

-      There are three kind of format string: Sed,
-      Perl and Boost-Extended.
+      There are three kind of format string: Sed,
+      Perl and Boost-Extended.
     

 

       Alternatively, when the flag format_literal
diff --git a/doc/html/boost_regex/format/boost_format_syntax.html b/doc/html/boost_regex/format/boost_format_syntax.html
index 842bb55f..cb22bcda 100644
--- a/doc/html/boost_regex/format/boost_format_syntax.html
+++ b/doc/html/boost_regex/format/boost_format_syntax.html
@@ -3,7 +3,7 @@
 
 Boost-Extended Format String Syntax
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

@@ -32,16 +32,16 @@
         '$', '\', '(', ')', '?', and ':'.
       

 

-
-        Grouping
+
+        Grouping
       

 

         The characters '(' and ')' perform lexical grouping, so use \( and \) if
         you want a to output literal parenthesis.
       

 

-
-        Conditionals
+
+        Conditionals
       

 

         The character '?' begins a conditional expression, the general form is:
@@ -66,8 +66,8 @@
         with "bar" otherwise.
       

 

-
-        Placeholder
+
+        Placeholder
         Sequences
       

 

@@ -161,8 +161,8 @@
         as a literal.
       

 

-
-        Escape
+
+        Escape
         Sequences
       

 

diff --git a/doc/html/boost_regex/format/perl_format.html b/doc/html/boost_regex/format/perl_format.html
index a3ba53b0..5488c5f8 100644
--- a/doc/html/boost_regex/format/perl_format.html
+++ b/doc/html/boost_regex/format/perl_format.html
@@ -3,7 +3,7 @@
 
 Perl Format String Syntax
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

         Perl-style format strings treat all characters as literals except '$' and
diff --git a/doc/html/boost_regex/format/sed_format.html b/doc/html/boost_regex/format/sed_format.html
index d3b8fae5..ff55b8dc 100644
--- a/doc/html/boost_regex/format/sed_format.html
+++ b/doc/html/boost_regex/format/sed_format.html
@@ -3,7 +3,7 @@
 
 Sed Format String Syntax
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

         Sed-style format strings treat all characters as literals except:
diff --git a/doc/html/boost_regex/install.html b/doc/html/boost_regex/install.html
index 1cb2f0c3..6d7308cc 100644
--- a/doc/html/boost_regex/install.html
+++ b/doc/html/boost_regex/install.html
@@ -3,7 +3,7 @@
 
 Building and Installing the Library
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

       When you extract the library from its zip file, you must preserve its internal
@@ -49,8 +49,8 @@
       file before you can use it, instructions for specific platforms are as follows:
     

 

-
-      Building with bjam
+
+      Building with bjam
     

 

       This is now the preferred method for building and installing this library,
@@ -58,8 +58,8 @@
       started guide for more information.
     

 

-
-      Building
+
+      Building
       With Unicode and ICU Support
     

 

@@ -96,12 +96,12 @@
       ICU you are using is binary compatible with the toolset you use to build Boost.
     

 

-
-      Building via makefiles
+
+      Building via makefiles
     

 

-
-      Borland C++ Builder:
+
+      Borland C++ Builder:
     

 

 

-
-      GCC(2.95 and later)
+
+      GCC(2.95 and later)
     

 

       You can build with gcc using the normal boost Jamfile in <boost>/libs/regex/build, alternatively
@@ -302,8 +302,8 @@
       see the config library documentation.
     

 

-
-      Sun Workshop 6.1
+
+      Sun Workshop 6.1
     

 

       There is a makefile for the sun (6.1) compiler (C++ version 3.12). From the
@@ -347,8 +347,8 @@
       will build v9 variants of the regex library named libboost_regex_v9.a etc.
     

 

-
-      Makefiles
+
+      Makefiles
       for Other compilers
     

 

diff --git a/doc/html/boost_regex/introduction_and_overview.html b/doc/html/boost_regex/introduction_and_overview.html
index b5702281..68adc16d 100644
--- a/doc/html/boost_regex/introduction_and_overview.html
+++ b/doc/html/boost_regex/introduction_and_overview.html
@@ -3,7 +3,7 @@
 
 Introduction and Overview
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 

 

 

@@ -39,7 +39,7 @@
       libraries can not do.
     

 

-      The class basic_regex
+      The class basic_regex
       is the key class in this library; it represents a "machine readable"
       regular expression, and is very closely modeled on std::basic_string,
       think of it as a string plus the actual state-machine required by the regular
@@ -47,8 +47,7 @@
       there are two typedefs that are almost always the means by which this class
       is referenced:
     

-
-namespace boost{
+
namespace boost{
 
 template <class charT, 
          class traits = regex_traits<charT> >
@@ -86,8 +85,7 @@
       Now let's take that expression and place it in some C++ code to validate the
       format of a credit card number:
     

-
-bool validate_card_format(const std::string& s)
+
bool validate_card_format(const std::string& s)
 {
    static const boost::regex e("(\\d{4}[- ]){3}\\d{4}");
    return regex_match(s, e);
@@ -112,11 +110,10 @@
       the utilities sed and Perl will already be ahead here; we need two strings
       - one a regular expression - the other a "format string" that provides
       a description of the text to replace the match with. In Boost.Regex this search
-      and replace operation is performed with the algorithm regex_replace, for our credit card
+      and replace operation is performed with the algorithm regex_replace, for our credit card
       example we can write two algorithms like this to provide the format conversions:
     

-
-// match any format with the regular expression:
+
// match any format with the regular expression:
 const boost::regex e("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z");
 const std::string machine_format("\\1\\2\\3\\4");
 const std::string human_format("\\1-\\2-\\3-\\4");
@@ -141,11 +138,10 @@
       expression match, however in general the result of a match contains a number
       of sub-expression matches in addition to the overall match. When the library
       needs to report a regular expression match it does so using an instance of
-      the class match_results,
+      the class match_results,
       as before there are typedefs of this class for the most common cases:
     

-
-namespace boost{
+
namespace boost{
 
 typedef match_results<const char*>                  cmatch;
 typedef match_results<const wchar_t*>               wcmatch;
@@ -155,12 +151,12 @@
 }
 

 

-      The algorithms regex_search
-      and regex_match
-      make use of match_results
-      to report what matched; the difference between these algorithms is that regex_match
+      The algorithms regex_search
+      and regex_match
+      make use of match_results
+      to report what matched; the difference between these algorithms is that regex_match
       will only find matches that consume all of the input text,
-      where as regex_search
+      where as regex_search
       will search for a match anywhere within the text being matched.
     

 

@@ -169,21 +165,21 @@
       of seamlessly searching almost any kind of data.
     

 

-      For search and replace operations, in addition to the algorithm regex_replace that we have already
-      seen, the match_results
+      For search and replace operations, in addition to the algorithm regex_replace that we have already
+      seen, the match_results
       class has a format member that
       takes the result of a match and a format string, and produces a new string
       by merging the two.
     

 

       For iterating through all occurences of an expression within a text, there
-      are two iterator types: regex_iterator will enumerate over
-      the match_results
-      objects found, while regex_token_iterator will enumerate
+      are two iterator types: regex_iterator will enumerate over
+      the match_results
+      objects found, while regex_token_iterator will enumerate
       a series of strings (similar to perl style split operations).
     

 

-      For those that dislike templates, there is a high level wrapper class RegEx
+      For those that dislike templates, there is a high level wrapper class RegEx
       that is an encapsulation of the lower level template code - it provides a simplified
       interface for those that don't need the full power of the library, and supports
       only narrow characters, and the "extended" regular expression syntax.
@@ -191,12 +187,12 @@
       C++ standard library proposal.
     

 

-      The POSIX API functions: regcomp, regexec, regfree and [regerr], are available
+      The POSIX API functions: regcomp, regexec, regfree and [regerr], are available
       in both narrow character and Unicode versions, and are provided for those who
       need compatibility with these API's.
     

 

-      Finally, note that the library now has run-time
+      Finally, note that the library now has run-time
       localization support, and recognizes the full POSIX regular expression
       syntax - including advanced features like multi-character collating elements
       and equivalence classes - as well as providing compatibility with other regular
diff --git a/doc/html/boost_regex/partial_matches.html b/doc/html/boost_regex/partial_matches.html
index 20cce870..0543b089 100644
--- a/doc/html/boost_regex/partial_matches.html
+++ b/doc/html/boost_regex/partial_matches.html
@@ -3,7 +3,7 @@
 
 Partial Matches
 
-
+
 
 
 
@@ -24,13 +24,13 @@
 

 

 

-      The match_flag_type
+      The match_flag_type
       match_partial can be passed
-      to the following algorithms: regex_match, regex_search, and regex_grep, and used with the iterator
-      regex_iterator.
+      to the following algorithms: regex_match, regex_search, and regex_grep, and used with the iterator
+      regex_iterator.
       When used it indicates that partial as well as full matches should be found.
       A partial match is one that matched one or more characters at the end of the
       text input, but did not match all of the regular expression (although it may
@@ -40,9 +40,9 @@
       into memory (or even into a memory mapped file), or are of indeterminate length
       (for example the source may be a socket or similar). Partial and full matches
       can be differentiated as shown in the following table (the variable M represents
-      an instance of match_results as filled in by regex_match,
-      regex_search
-      or regex_grep):
+      an instance of match_results as filled in by regex_match,
+      regex_search
+      or regex_grep):
     

 

 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
@@ -192,8 +192,7 @@
       the input could never become a valid number, and the inputted character must
       be discarded, and a suitable error indication displayed to the user.
     

-
-#include <string>
+
#include <string>
 #include <iostream>
 #include <boost/regex.hpp>
 
@@ -228,8 +227,7 @@
       if a partial match was encountered, then the partial match gets searched a
       second time as the start of the next batch of text:
     

-
-#include <iostream>
+
#include <iostream>
 #include <fstream>
 #include <sstream>
 #include <string>
diff --git a/doc/html/boost_regex/ref.html b/doc/html/boost_regex/ref.html
index 1322fd43..b4562707 100644
--- a/doc/html/boost_regex/ref.html
+++ b/doc/html/boost_regex/ref.html
@@ -3,7 +3,7 @@
 
 Reference
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
 

 

 

 
 basic_regex

diff --git a/doc/html/boost_regex/ref/bad_expression.html b/doc/html/boost_regex/ref/bad_expression.html
index 8073355e..84cace8c 100644
--- a/doc/html/boost_regex/ref/bad_expression.html
+++ b/doc/html/boost_regex/ref/bad_expression.html
@@ -3,7 +3,7 @@
 
 bad_expression
 
-
+
 
 
 
@@ -24,22 +24,20 @@
 

 

 

 

-
-        Synopsis
+
+        Synopsis
       

-
-#include <boost/pattern_except.hpp>
+
#include <boost/pattern_except.hpp>
 

 

         The class regex_error defines
         the type of objects thrown as exceptions to report errors during the conversion
         from a string representing a regular expression to a finite state machine.
       

-
-namespace boost{
+
namespace boost{
 
 class regex_error : public std::runtime_error
 {
@@ -56,25 +54,22 @@
 } // namespace boost
 

 

-
-        Description
+
+        Description
       

-
-regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos);
+
regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos);
 regex_error(boost::regex_constants::error_type err);
 

 

         Effects: Constructs an object of class regex_error.
       

-
-boost::regex_constants::error_type code()const;
+
boost::regex_constants::error_type code()const;
 

 

         Effects: returns the error code that represents
         parsing error that occurred.
       

-
-std::ptrdiff_t position()const; 
+
std::ptrdiff_t position()const; 
 

 

         Effects: returns the location in the expression
diff --git a/doc/html/boost_regex/ref/basic_regex.html b/doc/html/boost_regex/ref/basic_regex.html
index d420b044..9203286c 100644
--- a/doc/html/boost_regex/ref/basic_regex.html
+++ b/doc/html/boost_regex/ref/basic_regex.html
@@ -3,7 +3,7 @@
 
 basic_regex
 
-
+
 
 
 
@@ -24,14 +24,13 @@
 

 

 

 

-
-        Synopsis
+
+        Synopsis
       

-
-#include <boost/regex.hpp>
+
#include <boost/regex.hpp>
 

 

         The template class basic_regex
@@ -42,24 +41,23 @@
 
  • 
 charT: determines the character
           type, i.e. either char or
-          wchar_t; see charT
+          wchar_t; see charT
           concept.
         
    • 
 
  • 
 traits: determines the
           behavior of the character type, for example which character class names
-          are recognized. A default traits class is provided: regex_traits<charT>. See also traits
+          are recognized. A default traits class is provided: regex_traits<charT>. See also traits
           concept.
         
    • 
 
    
 
    
         For ease of use there are two typedefs that define the two standard basic_regex instances, unless you want
         to use custom traits classes or non-standard character types (for example
-        see unicode support),
+        see unicode support),
         you won't need to use anything other than these:
       
    
-
    -namespace boost{
+
    namespace boost{
 
 template <class charT, class traits = regex_traits<charT>  >
 class basic_regex;
@@ -74,8 +72,7 @@
         follows: it is based very closely on class basic_string,
         and fulfils the requirements for a constant-container of charT.
       
    
-
    -namespace boost{
+
    namespace boost{
 
 template <class  charT, class traits = regex_traits<charT> >
 class basic_regex {
@@ -88,156 +85,156 @@
    typedef          const charT&                         const_reference;           
    typedef          std::ptrdiff_t                       difference_type;                 
    typedef          std::size_t                          size_type;
-   typedef          regex_constants:: syntax_option_type  flag_type;
+   typedef          regex_constants:: syntax_option_type  flag_type;
    typedef typename traits::locale_type                  locale_type;
 
    // constants:
    // main option selection:
-   static const regex_constants:: syntax_option_type normal          
+   static const regex_constants:: syntax_option_type normal          
                                                 = regex_constants::normal;
-   static const regex_constants:: syntax_option_type ECMAScript      
+   static const regex_constants:: syntax_option_type ECMAScript      
                                                 = normal;
-   static const regex_constants:: syntax_option_type JavaScript      
+   static const regex_constants:: syntax_option_type JavaScript      
                                                 = normal;
-   static const regex_constants:: syntax_option_type JScript         
+   static const regex_constants:: syntax_option_type JScript         
                                                 = normal;
-   static const regex_constants:: syntax_option_type basic           
+   static const regex_constants:: syntax_option_type basic           
                                                 = regex_constants::basic;
-   static const regex_constants:: syntax_option_type extended        
+   static const regex_constants:: syntax_option_type extended        
                                                 = regex_constants::extended;
-   static const regex_constants:: syntax_option_type awk             
+   static const regex_constants:: syntax_option_type awk             
                                                 = regex_constants::awk;
-   static const regex_constants:: syntax_option_type grep            
+   static const regex_constants:: syntax_option_type grep            
                                                 = regex_constants::grep;
-   static const regex_constants:: syntax_option_type egrep           
+   static const regex_constants:: syntax_option_type egrep           
                                                 = regex_constants::egrep;
-   static const regex_constants:: syntax_option_type sed             
+   static const regex_constants:: syntax_option_type sed             
                                                 = basic = regex_constants::sed;
-   static const regex_constants:: syntax_option_type perl            
+   static const regex_constants:: syntax_option_type perl            
                                                 = regex_constants::perl;
-   static const regex_constants:: syntax_option_type literal         
+   static const regex_constants:: syntax_option_type literal         
                                                 = regex_constants::literal;
 
    // modifiers specific to perl expressions:
-   static const regex_constants:: syntax_option_type no_mod_m        
+   static const regex_constants:: syntax_option_type no_mod_m        
                                                 = regex_constants::no_mod_m;
-   static const regex_constants:: syntax_option_type no_mod_s        
+   static const regex_constants:: syntax_option_type no_mod_s        
                                                 = regex_constants::no_mod_s;
-   static const regex_constants:: syntax_option_type mod_s           
+   static const regex_constants:: syntax_option_type mod_s           
                                                 = regex_constants::mod_s;
-   static const regex_constants:: syntax_option_type mod_x           
+   static const regex_constants:: syntax_option_type mod_x           
                                                 = regex_constants::mod_x;
 
    // modifiers specific to POSIX basic expressions:
-   static const regex_constants:: syntax_option_type bk_plus_qm      
+   static const regex_constants:: syntax_option_type bk_plus_qm      
                                                 = regex_constants::bk_plus_qm;
-   static const regex_constants:: syntax_option_type bk_vbar         
+   static const regex_constants:: syntax_option_type bk_vbar         
                                                 = regex_constants::bk_vbar
-   static const regex_constants:: syntax_option_type no_char_classes 
+   static const regex_constants:: syntax_option_type no_char_classes 
                                                 = regex_constants::no_char_classes
-   static const regex_constants:: syntax_option_type no_intervals    
+   static const regex_constants:: syntax_option_type no_intervals    
                                                 = regex_constants::no_intervals
 
    // common modifiers:
-   static const regex_constants:: syntax_option_type nosubs          
+   static const regex_constants:: syntax_option_type nosubs          
                                                 = regex_constants::nosubs;
-   static const regex_constants:: syntax_option_type optimize        
+   static const regex_constants:: syntax_option_type optimize        
                                                 = regex_constants::optimize;
-   static const regex_constants:: syntax_option_type collate         
+   static const regex_constants:: syntax_option_type collate         
                                                 = regex_constants::collate;
-   static const regex_constants:: syntax_option_type newline_alt     
+   static const regex_constants:: syntax_option_type newline_alt     
                                                 = regex_constants::newline_alt;
-   static const regex_constants:: syntax_option_type no_except       
+   static const regex_constants:: syntax_option_type no_except       
                                                 = regex_constants::newline_alt;
 
    // construct/copy/destroy:
-   explicit basic_regex ();
-   explicit basic_regex(const  charT* p, flag_type f = regex_constants::normal);
-   basic_regex(const charT* p1, const  charT* p2, 
+   explicit basic_regex ();
+   explicit basic_regex(const  charT* p, flag_type f = regex_constants::normal);
+   basic_regex(const charT* p1, const  charT* p2, 
                flag_type f = regex_constants::normal);
-   basic_regex(const charT* p, size_type len, flag_type  f);
-   basic_regex(const basic_regex&);
+   basic_regex(const charT* p, size_type len, flag_type  f);
+   basic_regex(const basic_regex&);
 
    template <class ST, class SA>
-   explicit basic_regex(const basic_string<charT, ST,  SA>& p, 
+   explicit basic_regex(const basic_string<charT, ST,  SA>& p, 
                         flag_type f = regex_constants::normal);
 
    template <class InputIterator>
-   basic_regex(InputIterator first,  InputIterator last, 
+   basic_regex(InputIterator first,  InputIterator last, 
                flag_type f = regex_constants::normal);
 
    ~basic_regex();
-   basic_regex& operator=(const basic_regex&);
-   basic_regex& operator= (const charT* ptr); 
+   basic_regex& operator=(const basic_regex&);
+   basic_regex& operator= (const charT* ptr); 
 
    template <class ST, class SA> 
-   basic_regex& operator= (const basic_string<charT, ST, SA>& p);
+   basic_regex& operator= (const basic_string<charT, ST, SA>& p);
    // iterators: 
-   const_iterator begin() const; 
-   const_iterator end() const;
+   const_iterator begin() const; 
+   const_iterator end() const;
    // capacity: 
-   size_type size() const; 
-   size_type max_size() const; 
-   bool empty() const; 
-   unsigned mark_count()const; 
+   size_type size() const; 
+   size_type max_size() const; 
+   bool empty() const; 
+   unsigned mark_count()const; 
    //
    // modifiers: 
-   basic_regex& assign(const basic_regex& that); 
-   basic_regex& assign(const charT* ptr, 
+   basic_regex& assign(const basic_regex& that); 
+   basic_regex& assign(const charT* ptr, 
                        flag_type f = regex_constants::normal);
-   basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
+   basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
 
    template <class string_traits, class A>
-   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
+   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                        flag_type f = regex_constants::normal);
 
    template <class InputIterator>
-   basic_regex& assign(InputIterator first, InputIterator last,
+   basic_regex& assign(InputIterator first, InputIterator last,
                        flag_type f = regex_constants::normal);
 
    // const operations:
-   flag_type flags() const;
-   int status()const;
-   basic_string<charT> str() const;
-   int compare(basic_regex&) const;
+   flag_type flags() const;
+   int status()const;
+   basic_string<charT> str() const;
+   int compare(basic_regex&) const;
    // locale:
-   locale_type imbue(locale_type loc);
-   locale_type getloc() const;
+   locale_type imbue(locale_type loc);
+   locale_type getloc() const;
    // swap
-   void swap(basic_regex&) throw();
+   void swap(basic_regex&) throw();
 };
 
 template <class charT, class traits>
-bool operator == (const basic_regex<charT, traits>& lhs,
+bool operator == (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
 template <class charT, class traits>
-bool operator != (const basic_regex<charT, traits>& lhs,
+bool operator != (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
 template <class charT, class traits>
-bool operator < (const basic_regex<charT, traits>& lhs,
+bool operator < (const basic_regex<charT, traits>& lhs,
                const basic_regex<charT, traits>& rhs);
 
 template <class charT, class traits>
-bool operator <= (const basic_regex<charT, traits>& lhs,
+bool operator <= (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
 template <class charT, class traits>
-bool operator >= (const basic_regex<charT, traits>& lhs,
+bool operator >= (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
 template <class charT, class traits>
-bool operator > (const basic_regex<charT, traits>& lhs,
+bool operator > (const basic_regex<charT, traits>& lhs,
                const basic_regex<charT, traits>& rhs);
 
 template <class charT, class io_traits, class re_traits>
 basic_ostream<charT, io_traits>&
-   operator << (basic_ostream<charT, io_traits>& os,
+   operator << (basic_ostream<charT, io_traits>& os,
                const basic_regex<charT, re_traits>& e);
 
 template <class charT, class traits>
-void swap(basic_regex<charT, traits>& e1,
+void swap(basic_regex<charT, traits>& e1,
          basic_regex<charT, traits>& e2);
 
 typedef basic_regex<char> regex;
@@ -246,92 +243,90 @@
 } // namespace boost
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
         Class basic_regex has the
         following public members:
       
    
-
    -// main option selection:
-static const regex_constants:: syntax_option_type normal           
+
    // main option selection:
+static const regex_constants:: syntax_option_type normal           
                                           = regex_constants::normal;
-static const regex_constants:: syntax_option_type ECMAScript       
+static const regex_constants:: syntax_option_type ECMAScript       
                                           = normal;
-static const regex_constants:: syntax_option_type JavaScript       
+static const regex_constants:: syntax_option_type JavaScript       
                                           = normal;
-static const regex_constants:: syntax_option_type JScript          
+static const regex_constants:: syntax_option_type JScript          
                                           = normal;
-static const regex_constants:: syntax_option_type basic            
+static const regex_constants:: syntax_option_type basic            
                                           = regex_constants::basic;
-static const regex_constants:: syntax_option_type extended         
+static const regex_constants:: syntax_option_type extended         
                                           = regex_constants::extended;
-static const regex_constants:: syntax_option_type awk              
+static const regex_constants:: syntax_option_type awk              
                                           = regex_constants::awk;
-static const regex_constants:: syntax_option_type grep             
+static const regex_constants:: syntax_option_type grep             
                                           = regex_constants::grep;
-static const regex_constants:: syntax_option_type egrep            
+static const regex_constants:: syntax_option_type egrep            
                                           = regex_constants::egrep;
-static const regex_constants:: syntax_option_type sed              
+static const regex_constants:: syntax_option_type sed              
                                           = regex_constants::sed;
-static const regex_constants:: syntax_option_type perl             
+static const regex_constants:: syntax_option_type perl             
                                           = regex_constants::perl;
-static const regex_constants:: syntax_option_type literal          
+static const regex_constants:: syntax_option_type literal          
                                           = regex_constants::literal;
 
 // modifiers specific to perl expressions:
-static const regex_constants:: syntax_option_type no_mod_m         
+static const regex_constants:: syntax_option_type no_mod_m         
                                           = regex_constants::no_mod_m;
-static const regex_constants:: syntax_option_type no_mod_s         
+static const regex_constants:: syntax_option_type no_mod_s         
                                           = regex_constants::no_mod_s;
-static const regex_constants:: syntax_option_type mod_s            
+static const regex_constants:: syntax_option_type mod_s            
                                           = regex_constants::mod_s;
-static const regex_constants:: syntax_option_type mod_x            
+static const regex_constants:: syntax_option_type mod_x            
                                           = regex_constants::mod_x;
 
 // modifiers specific to POSIX basic expressions:
-static const regex_constants:: syntax_option_type bk_plus_qm       
+static const regex_constants:: syntax_option_type bk_plus_qm       
                                           = regex_constants::bk_plus_qm;
-static const regex_constants:: syntax_option_type bk_vbar          
+static const regex_constants:: syntax_option_type bk_vbar          
                                           = regex_constants::bk_vbar
-static const regex_constants:: syntax_option_type no_char_classes  
+static const regex_constants:: syntax_option_type no_char_classes  
                                           = regex_constants::no_char_classes
-static const regex_constants:: syntax_option_type no_intervals     
+static const regex_constants:: syntax_option_type no_intervals     
                                           = regex_constants::no_intervals
 
 // common modifiers:
-static const regex_constants:: syntax_option_type nosubs           
+static const regex_constants:: syntax_option_type nosubs           
                                           = regex_constants::nosubs;
-static const regex_constants:: syntax_option_type optimize         
+static const regex_constants:: syntax_option_type optimize         
                                           = regex_constants::optimize;
-static const regex_constants:: syntax_option_type collate          
+static const regex_constants:: syntax_option_type collate          
                                           = regex_constants::collate;
-static const regex_constants:: syntax_option_type newline_alt      
+static const regex_constants:: syntax_option_type newline_alt      
                                           = regex_constants::newline_alt;
 
    
 
    
-        The meaning of these options is documented in the syntax_option_type section.
+        The meaning of these options is documented in the syntax_option_type section.
       
    
 
    
         The static constant members are provided as synonyms for the constants declared
         in namespace boost::regex_constants; for each constant of type
-        syntax_option_type
+        syntax_option_type
         declared in namespace boost::regex_constants
         then a constant with the same name, type and value is declared within the
         scope of basic_regex.
       
    
 
    
       
    
-
    -basic_regex();
+
    basic_regex();
 
    
 
    
         Effects: Constructs an object of class
         basic_regex.
       
    
 
    
-
    Table 1. basic_regex default construction postconditions
    
+
    Table 1. basic_regex default construction postconditions
    
 
    
 

    @@ -391,28 +386,27 @@
 
    
       
    
-
    -basic_regex(const charT* p, flag_type f = regex_constants::normal);
+
    basic_regex(const charT* p, flag_type f = regex_constants::normal);
 
    
 
    
         Requires: p shall not
         be a null pointer.
       
    
 
    
-        Throws: bad_expression if p
+        Throws: bad_expression if p
         is not a valid regular expression, unless the flag no_except
         is set in f.
       
    
 
    
         Effects: Constructs an object of class
-        basic_regex;
+        basic_regex;
         the object's internal finite state machine is constructed from the regular
         expression contained in the null-terminated string p,
-        and interpreted according to the option
+        and interpreted according to the option
         flags specified in f.
       
    
 
    
-
    Table 2. Postconditions for basic_regex construction
    
+
    Table 2. Postconditions for basic_regex construction
    
 
    
 
 

 
    @@ -496,8 +490,7 @@
 
    
       
    
-
    -basic_regex(const charT* p1, const charT* p2, 
+
    basic_regex(const charT* p1, const charT* p2, 
             flag_type f = regex_constants::normal);
 
    
 
    
@@ -511,14 +504,14 @@
       
    
 
    
         Effects: Constructs an object of class
-        basic_regex;
+        basic_regex;
         the object's internal finite state machine is constructed from the regular
         expression contained in the sequence of characters [p1,p2), and interpreted
-        according the option flags
+        according the option flags
         specified in f.
       
    
 
    
-
    Table 3. Postconditions for basic_regex construction
    
+
    Table 3. Postconditions for basic_regex construction
    
 
    
 
 

 
    @@ -602,8 +595,7 @@
 
    
       
    
-
    -basic_regex(const charT* p, size_type len, flag_type f);
+
    basic_regex(const charT* p, size_type len, flag_type f);
 
    
 
    
         Requires: p shall not
@@ -611,19 +603,19 @@
         max_size().
       
    
 
    
-        Throws: bad_expression if p
+        Throws: bad_expression if p
         is not a valid regular expression, unless the flag no_except
         is set in f.
       
    
 
    
         Effects: Constructs an object of class
-        basic_regex;
+        basic_regex;
         the object's internal finite state machine is constructed from the regular
         expression contained in the sequence of characters [p, p+len), and interpreted
         according the option flags specified in f.
       
    
 
    
-
    Table 4. Postconditions for basic_regex construction
    
+
    Table 4. Postconditions for basic_regex construction
    
 
    
 
 

 
    @@ -707,36 +699,34 @@
 
    
       
    
-
    -basic_regex(const basic_regex& e);
+
    basic_regex(const basic_regex& e);
 
    
 
    
         Effects: Constructs an object of class
-        basic_regex
+        basic_regex
         as a copy of the object e.
       
    
 
    
       
    
-
    -template <class ST, class SA>
+
    template <class ST, class SA>
 basic_regex(const basic_string<charT, ST, SA>& s, 
             flag_type f = regex_constants::normal);
 
    
 
    
-        Throws: bad_expression if s
+        Throws: bad_expression if s
         is not a valid regular expression, unless the flag no_except
         is set in f.
       
    
 
    
         Effects: Constructs an object of class
-        basic_regex;
+        basic_regex;
         the object's internal finite state machine is constructed from the regular
         expression contained in the string s, and interpreted
-        according to the option
+        according to the option
         flags specified in f.
       
    
 
    
-
    Table 5. Postconditions for basic_regex construction
    
+
    Table 5. Postconditions for basic_regex construction
    
 
    
 
 

 
    @@ -820,26 +810,25 @@
 
    
       
    
-
    -template <class ForwardIterator>
+
    template <class ForwardIterator>
 basic_regex(ForwardIterator first, ForwardIterator last, 
             flag_type f = regex_constants::normal);
 
    
 
    
-        Throws: bad_expression if the sequence [first,
+        Throws: bad_expression if the sequence [first,
         last) is not a valid regular expression, unless the flag no_except
         is set in f.
       
    
 
    
         Effects: Constructs an object of class
-        basic_regex;
+        basic_regex;
         the object's internal finite state machine is constructed from the regular
         expression contained in the sequence of characters [first, last), and interpreted
-        according to the option
+        according to the option
         flags specified in f.
       
    
 
    
-
    Table 6. Postconditions for basic_regex construction
    
+
    Table 6. Postconditions for basic_regex construction
    
 
    
 
 

 
    @@ -923,16 +912,14 @@
 
    
       
    
-
    -basic_regex& operator=(const basic_regex& e);
+
    basic_regex& operator=(const basic_regex& e);
 
    
 
    
         Effects: Returns the result of assign(e.str(), e.flags()).
       
    
 
    
       
    
-
    -basic_regex& operator=(const charT* ptr);
+
    basic_regex& operator=(const charT* ptr);
 
    
 
    
         Requires: p shall not
@@ -943,8 +930,7 @@
       
    
 
    
       
    
-
    -template <class ST, class SA>
+
    template <class ST, class SA>
 basic_regex& operator=(const basic_string<charT, ST, SA>& p);
 
    
 
    
@@ -952,8 +938,7 @@
       
    
 
    
       
    
-
    -const_iterator begin() const;
+
    const_iterator begin() const;
 
    
 
    
         Effects: Returns a starting iterator to
@@ -961,8 +946,7 @@
       
    
 
    
       
    
-
    -const_iterator end() const;
+
    const_iterator end() const;
 
    
 
    
         Effects: Returns termination iterator to
@@ -970,8 +954,7 @@
       
    
 
    
       
    
-
    -size_type size() const;
+
    size_type size() const;
 
    
 
    
         Effects: Returns the length of the sequence
@@ -979,8 +962,7 @@
       
    
 
    
       
    
-
    -size_type max_size() const;
+
    size_type max_size() const;
 
    
 
    
         Effects: Returns the maximum length of the
@@ -988,8 +970,7 @@
       
    
 
    
       
    
-
    -bool empty() const;
+
    bool empty() const;
 
    
 
    
         Effects: Returns true if the object does
@@ -997,8 +978,7 @@
       
    
 
    
       
    
-
    -unsigned mark_count() const;
+
    unsigned mark_count() const;
 
    
 
    
         Effects: Returns the number of marked sub-expressions
@@ -1006,37 +986,33 @@
       
    
 
    
       
    
-
    -basic_regex& assign(const basic_regex& that);
+
    basic_regex& assign(const basic_regex& that);
 
    
 
    
-        Effects: Returns assign(that.str(), that.flags()).
+        Effects: Returns assign(that.str(), that.flags()).
       
    
 
    
       
    
-
    -basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);
+
    basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);
 
    
 
    
-        Effects: Returns assign(string_type(ptr), f).
+        Effects: Returns assign(string_type(ptr), f).
       
    
 
    
       
    
-
    -basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
+
    basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
 
    
 
    
-        Effects: Returns assign(string_type(ptr, len), f).
+        Effects: Returns assign(string_type(ptr, len), f).
       
    
 
    
       
    
-
    -template <class string_traits, class A>
+
    template <class string_traits, class A>
 basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                   flag_type f = regex_constants::normal);
 
    
 
    
-        Throws: bad_expression if s
+        Throws: bad_expression if s
         is not a valid regular expression, unless the flag no_except
         is set in f.
       
    
@@ -1046,11 +1022,11 @@
 
    
         Effects: Assigns the regular expression
         contained in the string s, interpreted according the
-        option flags specified
+        option flags specified
         in f.
       
    
 
    
-
    Table 7. Postconditions for basic_regex::assign
    
+
    Table 7. Postconditions for basic_regex::assign
    
 
    
 
 

 
    @@ -1134,8 +1110,7 @@
 
    
       
    
-
    -template <class InputIterator>
+
    template <class InputIterator>
 basic_regex& assign(InputIterator first, InputIterator last,
                     flag_type f = regex_constants::normal);
 
    
@@ -1145,22 +1120,20 @@
         (24.1.1).
       
    
 
    
-        Effects: Returns assign(string_type(first, last), f).
+        Effects: Returns assign(string_type(first, last), f).
       
    
 
    
       
    
-
    -flag_type flags() const;
+
    flag_type flags() const;
 
    
 
    
-        Effects: Returns a copy of the regular
+        Effects: Returns a copy of the regular
         expression syntax flags that were passed to the object's constructor,
         or the last call to assign.
       
    
 
    
       
    
-
    -int status() const;
+
    int status() const;
 
    
 
    
         Effects: Returns zero if the expression
@@ -1169,8 +1142,7 @@
       
    
 
    
       
    
-
    -basic_string<charT> str() const;
+
    basic_string<charT> str() const;
 
    
 
    
         Effects: Returns a copy of the character
@@ -1178,8 +1150,7 @@
       
    
 
    
       
    
-
    -int compare(basic_regex& e)const;
+
    int compare(basic_regex& e)const;
 
    
 
    
         Effects: If flags() == e.flags() then returns str().compare(e.str()),
@@ -1188,8 +1159,7 @@
       
    
 
    
       
    
-
    -locale_type imbue(locale_type l);
+
    locale_type imbue(locale_type l);
 
    
 
    
         Effects: Returns the result of traits_inst.imbue(l) where
@@ -1203,8 +1173,7 @@
       
    
 
    
       
    
-
    -locale_type getloc() const;
+
    locale_type getloc() const;
 
    
 
    
         Effects: Returns the result of traits_inst.getloc()
@@ -1214,8 +1183,7 @@
       
    
 
    
       
    
-
    -void swap(basic_regex& e) throw();
+
    void swap(basic_regex& e) throw();
 
    
 
    
         Effects: Swaps the contents of the two regular
@@ -1235,17 +1203,16 @@
 
    
 
 

 
    Note
 
    
 
    
-          Comparisons between basic_regex objects are provided
+          Comparisons between basic_regex objects are provided
           on an experimental basis: please note that these are not present in the
           Technical
           Report on C++ Library Extensions, so use with care if you are writing
-          code that may need to be ported to other implementations of basic_regex.
+          code that may need to be ported to other implementations of basic_regex.
         
    
 
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator == (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
    
@@ -1255,8 +1222,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator != (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
    
@@ -1266,8 +1232,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator < (const basic_regex<charT, traits>& lhs,
                const basic_regex<charT, traits>& rhs);
 
    
@@ -1277,8 +1242,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator <= (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
    
@@ -1288,8 +1252,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator >= (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);
 
    
@@ -1299,8 +1262,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool operator > (const basic_regex<charT, traits>& lhs,
                const basic_regex<charT, traits>& rhs);
 
    
@@ -1320,8 +1282,7 @@
 
    
 
    
       
    
-
    -template <class charT, class io_traits, class re_traits>
+
    template <class charT, class io_traits, class re_traits>
 basic_ostream<charT, io_traits>&
    operator << (basic_ostream<charT, io_traits>& os
                const basic_regex<charT, re_traits>& e);
@@ -1331,8 +1292,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 void swap(basic_regex<charT, traits>& lhs,
          basic_regex<charT, traits>& rhs);
 
    
diff --git a/doc/html/boost_regex/ref/concepts.html b/doc/html/boost_regex/ref/concepts.html
index 9e56ceb4..6a632460 100644
--- a/doc/html/boost_regex/ref/concepts.html
+++ b/doc/html/boost_regex/ref/concepts.html
@@ -3,7 +3,7 @@
 
 Concepts
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
 
     charT Requirements
    
diff --git a/doc/html/boost_regex/ref/concepts/charT_concept.html b/doc/html/boost_regex/ref/concepts/charT_concept.html
index e0eed8dd..d7934898 100644
--- a/doc/html/boost_regex/ref/concepts/charT_concept.html
+++ b/doc/html/boost_regex/ref/concepts/charT_concept.html
@@ -3,7 +3,7 @@
 
 charT Requirements
 
-
+
 
 
 
@@ -24,11 +24,11 @@
 
    
 
    
 
    
 
    
           Type charT used a template
-          argument to class template basic_regex, must have a trivial
+          argument to class template basic_regex, must have a trivial
           default constructor, copy constructor, assignment operator, and destructor.
           In addition the following requirements must be met for objects; c
           of type charT, c1
diff --git a/doc/html/boost_regex/ref/concepts/iterator_concepts.html b/doc/html/boost_regex/ref/concepts/iterator_concepts.html
index 3ff649cf..c6b6d4c7 100644
--- a/doc/html/boost_regex/ref/concepts/iterator_concepts.html
+++ b/doc/html/boost_regex/ref/concepts/iterator_concepts.html
@@ -3,7 +3,7 @@
 
 Iterator Requirements
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/concepts/traits_concept.html b/doc/html/boost_regex/ref/concepts/traits_concept.html
index 2f911ca1..147a93c3 100644
--- a/doc/html/boost_regex/ref/concepts/traits_concept.html
+++ b/doc/html/boost_regex/ref/concepts/traits_concept.html
@@ -3,7 +3,7 @@
 
 Traits Class Requirements
 
-
+
 
 
 
@@ -24,18 +24,18 @@
 
    
 
    
 
    
 
    
           There are two sets of requirements for the traits
-          template argument to basic_regex: a mininal interface
+          template argument to basic_regex: a mininal interface
           (which is part of the regex standardization proposal), and an optional
           Boost-specific enhanced interface.
         
    
 
    
-
-          Minimal
+
+          Minimal
           requirements.
         
    
 
    
@@ -381,15 +381,15 @@
 
 
    
 
    
-
-          Additional
+
+          Additional
           Optional Requirements
         
    
 
    
           The following additional requirements are strictly optional, however in
-          order for basic_regex
+          order for basic_regex
           to take advantage of these additional interfaces, all of the following
-          requirements must be met; basic_regex will detect the presence
+          requirements must be met; basic_regex will detect the presence
           or absense of the member boost_extensions_tag
           and configure itself appropriately.
         
    
diff --git a/doc/html/boost_regex/ref/deprecated_interfaces.html b/doc/html/boost_regex/ref/deprecated_interfaces.html
index 7f782c4d..b7724524 100644
--- a/doc/html/boost_regex/ref/deprecated_interfaces.html
+++ b/doc/html/boost_regex/ref/deprecated_interfaces.html
@@ -3,7 +3,7 @@
 
 Deprecated Interfaces
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html b/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html
index c2963703..68656cb4 100644
--- a/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html
+++ b/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html
@@ -3,7 +3,7 @@
 
 High Level Class RegEx (Deprecated)
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
@@ -33,8 +33,7 @@
           exists, and existing code will continue to compile, however the following
           documentation is unlikely to be further updated.
         
    
-
    -#include <boost/cregex.hpp>
+
    #include <boost/cregex.hpp>
 
    
 
    
           The class RegEx provides a high level simplified interface to the regular
@@ -42,8 +41,7 @@
           regular expressions always follow the "normal" syntax - that
           is the same as the perl / ECMAScript synatx.
         
    
-
    -typedef bool (*GrepCallback)(const RegEx& expression);
+
    typedef bool (*GrepCallback)(const RegEx& expression);
 typedef bool (*GrepFileCallback)(const char* file, const RegEx& expression);
 typedef bool (*FindFilesCallback)(const char* file);
 
@@ -171,7 +169,7 @@
                 
    
                   Constructs an instance of RegEx, setting the expression to c,
                   if icase is true then matching is insensitive
-                  to case, otherwise it is sensitive to case. Throws bad_expression on failure.
+                  to case, otherwise it is sensitive to case. Throws bad_expression on failure.
                 
    
                 
 
@@ -187,7 +185,7 @@
                 
    
                   Constructs an instance of RegEx, setting the expression to s,
                   if icase is true then matching is insensitive
-                  to case, otherwise it is sensitive to case. Throws bad_expression on failure.
+                  to case, otherwise it is sensitive to case. Throws bad_expression on failure.
                 
    
                 
 
@@ -213,7 +211,7 @@
                 
 
                 
    
-                  Assignment operator, equivalent to calling SetExpression(p, false). Throws bad_expression on failure.
+                  Assignment operator, equivalent to calling SetExpression(p, false). Throws bad_expression on failure.
                 
    
                 
 
@@ -226,7 +224,7 @@
                 
 
                 
    
-                  Assignment operator, equivalent to calling SetExpression(s, false). Throws bad_expression on failure.
+                  Assignment operator, equivalent to calling SetExpression(s, false). Throws bad_expression on failure.
                 
    
                 
 
@@ -244,7 +242,7 @@
                 
    
                   Sets the current expression to p, if icase
                   is true then matching is insensitive to case, otherwise it is sensitive
-                  to case. Throws bad_expression on failure.
+                  to case. Throws bad_expression on failure.
                 
    
                 
 
@@ -261,7 +259,7 @@
                 
    
                   Sets the current expression to s, if icase
                   is true then matching is insensitive to case, otherwise it is sensitive
-                  to case. Throws bad_expression on failure.
+                  to case. Throws bad_expression on failure.
                 
    
                 
 
@@ -290,7 +288,7 @@
 
                 
    
                   Attempts to match the current expression against the text p
-                  using the match flags flags - see match_flag_type. Returns
+                  using the match flags flags - see match_flag_type. Returns
                   true if the expression matches the whole of
                   the input string.
                 
    
@@ -309,7 +307,7 @@
 
                 
    
                   Attempts to match the current expression against the text s
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   Returns true if the expression matches the
                   whole of the input string.
                 
    
@@ -328,7 +326,7 @@
 
                 
    
                   Attempts to find a match for the current expression somewhere in
-                  the text p using the match_flag_type flags.
+                  the text p using the match_flag_type flags.
                   Returns true if the match succeeds.
                 
    
                 
@@ -346,7 +344,7 @@
 
                 
    
                   Attempts to find a match for the current expression somewhere in
-                  the text s using the match_flag_type flags.
+                  the text s using the match_flag_type flags.
                   Returns true if the match succeeds.
                 
    
                 
@@ -365,7 +363,7 @@
 
                 
    
                   Finds all matches of the current expression in the text p
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match found calls the call-back function cb as: cb(*this);
                   If at any stage the call-back function returns false
                   then the grep operation terminates, otherwise continues until no
@@ -387,7 +385,7 @@
 
                 
    
                   Finds all matches of the current expression in the text s
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match found calls the call-back function cb as: cb(*this);
                   If at any stage the call-back function returns false then the grep
                   operation terminates, otherwise continues until no further matches
@@ -409,7 +407,7 @@
 
                 
    
                   Finds all matches of the current expression in the text p
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match pushes a copy of what matched onto v.
                   Returns the number of matches found.
                 
    
@@ -429,7 +427,7 @@
 
                 
    
                   Finds all matches of the current expression in the text s
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match pushes a copy of what matched onto v.
                   Returns the number of matches found.
                 
    
@@ -449,7 +447,7 @@
 
                 
    
                   Finds all matches of the current expression in the text p
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match pushes the starting index of what matched onto
                   v. Returns the number of matches found.
                 
    
@@ -469,7 +467,7 @@
 
                 
    
                   Finds all matches of the current expression in the text s
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match pushes the starting index of what matched onto
                   v. Returns the number of matches found.
                 
    
@@ -491,7 +489,7 @@
 
                 
    
                   Finds all matches of the current expression in the files files
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match calls the call-back function cb. If the call-back
                   returns false then the algorithm returns without considering further
                   matches in the current file, or any further files.
@@ -526,7 +524,7 @@
 
                 
    
                   Finds all matches of the current expression in the files files
-                  using the match_flag_type flags.
+                  using the match_flag_type flags.
                   For each match calls the call-back function cb.
                 
    
                 
    
@@ -564,7 +562,7 @@
 
                 
    
                   Searches files to find all those which contain at least one match
-                  of the current expression using the match_flag_type flags.
+                  of the current expression using the match_flag_type flags.
                   For each matching file calls the call-back function cb. If the
                   call-back returns false then the algorithm returns without considering
                   any further files.
@@ -599,7 +597,7 @@
 
                 
    
                   Searches files to find all those which contain at least one match
-                  of the current expression using the match_flag_type flags.
+                  of the current expression using the match_flag_type flags.
                   For each matching file calls the call-back function cb.
                 
    
                 
    
@@ -643,8 +641,8 @@
                   If copy is true then all unmatched sections
                   of input are copied unchanged to output, if the flag format_first_only
                   is set then only the first occurance of the pattern found is replaced.
-                  Returns the new string. See also format
-                  string syntax, and match_flag_type.
+                  Returns the new string. See also format
+                  string syntax, and match_flag_type.
                 
    
                 
 
@@ -671,8 +669,8 @@
                   If copy is true then all unmatched sections
                   of input are copied unchanged to output, if the flag format_first_only
                   is set then only the first occurance of the pattern found is replaced.
-                  Returns the new string. See also format
-                  string syntax, and match_flag_type.
+                  Returns the new string. See also format
+                  string syntax, and match_flag_type.
                 
    
                 
 
diff --git a/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html b/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html
index 792d6411..0163436f 100644
--- a/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html
+++ b/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html
@@ -3,7 +3,7 @@
 
 regex_format (Deprecated)
 
-
+
 
 
 
@@ -24,22 +24,21 @@
 
    
 
    
 
    
 
    
           The algorithm regex_format
-          is deprecated; new code should use match_results<>::format instead. Existing code
+          is deprecated; new code should use match_results<>::format instead. Existing code
           will continue to compile, the following documentation is taken from the
           previous version of Boost.Regex and will not be further updated:
         
    
 
    
-
-          Algorithm
+
+          Algorithm
           regex_format
         
    
-
    -#include <boost/regex.hpp>
+
    #include <boost/regex.hpp>
 
    
 
    
           The algorithm regex_format
@@ -47,8 +46,7 @@
           string, regex_format can
           be used for search and replace operations:
         
    
-
    -template <class OutputIterator, class iterator, class Allocator, class charT>
+
    template <class OutputIterator, class iterator, class Allocator, class charT>
 OutputIterator regex_format(OutputIterator out,
                            const match_results<iterator, Allocator>& m,
                            const charT* fmt,
@@ -73,8 +71,7 @@
             form, depending upon your compilers capabilities
           
    
 
    
-
    -template <class iterator, class Allocator, class charT>
+
    template <class iterator, class Allocator, class charT>
 std::basic_string<charT> regex_format
                                  (const match_results<iterator, Allocator>& m, 
                                  const charT* fmt,
@@ -128,7 +125,7 @@
                 
 
                 
    
-                  An instance of match_results obtained
+                  An instance of match_results obtained
                   from one of the matching algorithms above, and denoting what matched.
                 
    
                 
@@ -161,11 +158,11 @@
 
 
    
 
    
-          Format flags are described under match_flag_type.
+          Format flags are described under match_flag_type.
         
    
 
    
           The format string syntax (and available options) is described more fully
-          under format strings.
+          under format strings.
         
    
 
 
diff --git a/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html b/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html
index ecdc6b4c..d293e650 100644
--- a/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html
+++ b/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html
@@ -3,7 +3,7 @@
 regex_grep (Deprecated)
-
+
@@ -24,28 +24,26 @@
 
    
 
    
 
    
           The algorithm regex_grep
-          is deprecated in favor of regex_iterator which provides
+          is deprecated in favor of regex_iterator which provides
           a more convenient and standard library friendly interface.
         
    
 
    
           The following documentation is taken unchanged from the previous boost
           release, and will not be updated in future.
         
    
-
    -#include <boost/regex.hpp>
+
    #include <boost/regex.hpp>
 
    
 
    
           regex_grep allows you to
           search through a bidirectional-iterator range and locate all the (non-overlapping)
           matches with a given regular expression. The function is declared as:
         
    
-
    -template <class Predicate, class iterator, class charT, class traits>
+
    template <class Predicate, class iterator, class charT, class traits>
 unsigned int regex_grep(Predicate foo,
                         iterator first,
                         iterator last,
@@ -58,8 +56,7 @@
           std::basic_string<>&
           in place of a pair of iterators.
         
    
-
    -template <class Predicate, class charT, class traits>
+
    template <class Predicate, class charT, class traits>
 unsigned int regex_grep(Predicate foo, 
             const charT* str, 
             const basic_regex<charT, traits>& e, 
@@ -104,8 +101,7 @@
 
    
           The general form of the predicate is:
         
    
-
    -struct grep_predicate
+
    struct grep_predicate
 {
    bool operator()(const match_results<iterator_type>& m);
 };
@@ -133,10 +129,9 @@
           (if Boost.Regex is configured in non-recursive mode).
         
    
 
    
-          Example: convert the example from regex_search to use regex_grep instead:
+          Example: convert the example from regex_search to use regex_grep instead:
         
    
-
    -#include <string> 
+
    #include <string> 
 #include <map> 
 #include <boost/regex.hpp> 
 
@@ -198,8 +193,7 @@
           Example: Use regex_grep
           to call a global callback function:
         
    
-
    -#include <string> 
+
    #include <string> 
 #include <map> 
 #include <boost/regex.hpp> 
 
@@ -259,8 +253,7 @@
           to call a class member function, use the standard library adapters std::mem_fun and std::bind1st
           to convert the member function into a predicate:
         
    
-
    -#include <string> 
+
    #include <string> 
 #include <map> 
 #include <boost/regex.hpp> 
 #include <functional> 
@@ -313,8 +306,7 @@
           Finally, C++ Builder users can use C++ Builder's closure type as a callback
           argument:
         
    
-
    -#include <string> 
+
    #include <string> 
 #include <map> 
 #include <boost/regex.hpp> 
 #include <functional> 
diff --git a/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html b/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html
index 0e6b2d23..d5b43e87 100644
--- a/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html
+++ b/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html
@@ -3,7 +3,7 @@
 
 regex_split (deprecated)
 
-
+
 
 
 
@@ -24,28 +24,26 @@
 
    
 
    
 
    
-          The algorithm regex_split has been deprecated
-          in favor of the iterator regex_token_iterator which has
+          The algorithm regex_split has been deprecated
+          in favor of the iterator regex_token_iterator which has
           a more flexible and powerful interface, as well as following the more usual
           standard library "pull" rather than "push" semantics.
         
    
 
    
-          Code which uses regex_split will continue to compile,
+          Code which uses regex_split will continue to compile,
           the following documentation is taken from a previous Boost.Regex version:
         
    
-
    -#include <boost/regex.hpp> 
+
    #include <boost/regex.hpp> 
 
    
 
    
-          Algorithm regex_split performs a similar
+          Algorithm regex_split performs a similar
           operation to the perl split operation, and comes in three overloaded forms:
         
    
-
    -template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
+
    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, 
                         const basic_regex<charT, Traits2>& e,
@@ -90,8 +88,7 @@
           the input string into a series of tokens, and remove each token from the
           string s:
         
    
-
    -unsigned tokenise(std::list<std::string>& l, std::string& s)
+
    unsigned tokenise(std::list<std::string>& l, std::string& s)
 {
    return boost::regex_split(std::back_inserter(l), s);
 }
@@ -100,8 +97,7 @@
           Example: the following short program will extract all of the URL's from
           a html file, and print them out to cout:
         
    
-
    -#include <list>
+
    #include <list>
 #include <fstream>
 #include <iostream>
 #include <boost/regex.hpp>
diff --git a/doc/html/boost_regex/ref/error_type.html b/doc/html/boost_regex/ref/error_type.html
index 7365074f..0b3fdf2c 100644
--- a/doc/html/boost_regex/ref/error_type.html
+++ b/doc/html/boost_regex/ref/error_type.html
@@ -3,7 +3,7 @@
 
 error_type
 
-
+
 
 
 
@@ -24,18 +24,17 @@
 
    
 
    
 
    
-
-        Synopsis
+
+        Synopsis
       
    
 
    
         Type error type represents the different types of errors that can be raised
         by the library when parsing a regular expression.
       
    
-
    -namespace boost{ namespace regex_constants{
+
    namespace boost{ namespace regex_constants{
 
 typedef implementation-specific-type error_type;
 
@@ -58,8 +57,8 @@
 } // namespace boost
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
         The type error_type is an
diff --git a/doc/html/boost_regex/ref/match_flag_type.html b/doc/html/boost_regex/ref/match_flag_type.html
index 4d57b228..9bcc0dac 100644
--- a/doc/html/boost_regex/ref/match_flag_type.html
+++ b/doc/html/boost_regex/ref/match_flag_type.html
@@ -3,7 +3,7 @@
 
 match_flag_type
 
-
+
 
 
 
@@ -24,16 +24,15 @@
 
    
 
    
 
    
         The type match_flag_type
         is an implementation specific bitmask type (see C++ std 17.3.2.1.2) that
         controls how a regular expression is matched against a character sequence.
-        The behavior of the format flags is described in more detail in the format syntax guide.
+        The behavior of the format flags is described in more detail in the format syntax guide.
       
    
-
    -namespace boost{ namespace regex_constants{
+
    namespace boost{ namespace regex_constants{
 
 typedef implemenation-specific-bitmask-type match_flag_type;
 
@@ -70,8 +69,8 @@
 } // namespace boost
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
         The type match_flag_type
@@ -328,7 +327,7 @@
 
    
@@ -414,7 +413,7 @@
 
@@ -442,7 +441,7 @@
 
diff --git a/doc/html/boost_regex/ref/match_results.html b/doc/html/boost_regex/ref/match_results.html
index 41dee670..9a08c670 100644
--- a/doc/html/boost_regex/ref/match_results.html
+++ b/doc/html/boost_regex/ref/match_results.html
@@ -3,7 +3,7 @@
 match_results
-
+
@@ -24,14 +24,13 @@
 
    
 
    
 
    
-
-        Synopsis
+
+        Synopsis
       
    
-
    -#include <boost/regex.hpp>
+
    #include <boost/regex.hpp>
 
    
 
    
         Regular expressions are different from many simple pattern-matching algorithms
@@ -40,14 +39,14 @@
         parenthesis (...). There has to be some method for reporting sub-expression
         matches back to the user: this is achieved this by defining a class match_results that acts as an indexed collection
         of sub-expression matches, each sub-expression match being contained in an
-        object of type sub_match.
+        object of type sub_match.
       
    
 
    
         Template class match_results
         denotes a collection of character sequences representing the result of a
         regular expression match. Objects of type match_results
-        are passed to the algorithms regex_match and regex_search, and are returned by
-        the iterator regex_iterator. Storage for the
+        are passed to the algorithms regex_match and regex_search, and are returned by
+        the iterator regex_iterator. Storage for the
         collection is allocated and freed as necessary by the member functions of
         class match_results.
       
    
@@ -62,8 +61,7 @@
         wcmatch, smatch,
         or wsmatch:
       
    
-
    -template <class BidirectionalIterator,
+
    template <class BidirectionalIterator,
          class Allocator = std::allocator<sub_match<BidirectionalIterator> >
 class match_results;
 
@@ -89,63 +87,63 @@
    typedef          basic_string<char_type>                                 string_type;
 
    // construct/copy/destroy:
-   explicit match_results(const Allocator& a = Allocator());
-   match_results(const match_results& m);
-   match_results& operator=(const match_results& m); 
+   explicit match_results(const Allocator& a = Allocator());
+   match_results(const match_results& m);
+   match_results& operator=(const match_results& m); 
    ~match_results();
 
    // size:
-   size_type size() const;
-   size_type max_size() const;
-   bool empty() const;
+   size_type size() const;
+   size_type max_size() const;
+   bool empty() const;
    // element access:
-   difference_type length(int sub = 0) const;
-   difference_type position(unsigned int sub = 0) const;
-   string_type str(int sub = 0) const;
-   const_reference operator[](int n) const;
+   difference_type length(int sub = 0) const;
+   difference_type position(unsigned int sub = 0) const;
+   string_type str(int sub = 0) const;
+   const_reference operator[](int n) const;
 
-   const_reference prefix() const;
+   const_reference prefix() const;
 
-   const_reference suffix() const;
-   const_iterator begin() const;
-   const_iterator end() const;
+   const_reference suffix() const;
+   const_iterator begin() const;
+   const_iterator end() const;
    // format:
    template <class OutputIterator>
-   OutputIterator format(OutputIterator out,
+   OutputIterator format(OutputIterator out,
                         const string_type& fmt,
                         match_flag_type flags = format_default) const;
-   string_type format(const string_type& fmt,
+   string_type format(const string_type& fmt,
                      match_flag_type flags = format_default) const;
 
-   allocator_type get_allocator() const;
-   void swap(match_results& that);
+   allocator_type get_allocator() const;
+   void swap(match_results& that);
 
 #ifdef BOOST_REGEX_MATCH_EXTRA
    typedef typename value_type::capture_sequence_type capture_sequence_type;
-   const capture_sequence_type& captures(std::size_t i)const;
+   const capture_sequence_type& captures(std::size_t i)const;
 #endif
 
 };
 
 template <class BidirectionalIterator, class Allocator>
-bool operator == (const match_results<BidirectionalIterator, Allocator>& m1,
+bool operator == (const match_results<BidirectionalIterator, Allocator>& m1,
                   const match_results<BidirectionalIterator, Allocator>& m2);
 template <class BidirectionalIterator, class Allocator>
-bool operator != (const match_results<BidirectionalIterator, Allocator>& m1,
+bool operator != (const match_results<BidirectionalIterator, Allocator>& m1,
                   const match_results<BidirectionalIterator, Allocator>& m2);
 
 template <class charT, class traits, class BidirectionalIterator, class Allocator>
 basic_ostream<charT, traits>&
-   operator << (basic_ostream<charT, traits>& os,
+   operator << (basic_ostream<charT, traits>& os,
                const match_results<BidirectionalIterator, Allocator>& m);
 
 template <class BidirectionalIterator, class Allocator>
-void swap(match_results<BidirectionalIterator, Allocator>& m1,
+void swap(match_results<BidirectionalIterator, Allocator>& m1,
          match_results<BidirectionalIterator, Allocator>& m2);
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
         In all match_results constructors,
@@ -154,8 +152,7 @@
       
    
 
    
       
    
-
    -match_results(const Allocator& a = Allocator());
+
    match_results(const Allocator& a = Allocator());
 
    
 
    
         Effects: Constructs an object of class
@@ -220,8 +217,7 @@
 
    
 
 
 
 
 
 
 
 
 
               
    
                 Specifies that the expression should be matched according to the
-                POSIX leftmost-longest
+                POSIX leftmost-longest
                 rule, regardless of what kind of expression was compiled.
                 Be warned that these rules do not work well with many Perl-specific
                 features such as non-greedy repeats.
@@ -344,7 +343,7 @@
 
    		
               
    
                 Specifies that the expression should be matched according to the
-                Perl
+                Perl
                 matching rules, irrespective of what kind of expression was
                 compiled.
               
    
@@ -359,7 +358,7 @@
     		
               
    
                 Makes the expression behave as if it had no marked subexpressions,
-                no matter how many capturing groups are actually present. The match_results
+                no matter how many capturing groups are actually present. The match_results
                 class will only contain information about the overall match, and
                 not any sub-expressions.
               
    
@@ -379,7 +378,7 @@
                 Specification, Chapter 15 part 5.4.11 String.prototype.replace. (FWD.1).
               
    
               
    
-                This is functionally identical to the Perl
+                This is functionally identical to the Perl
                 format string rules.
               
    
               
    
@@ -401,7 +400,7 @@
                 Specifies that when a regular expression match is to be replaced
                 by a new string, that the new string is constructed using the rules
                 used by the Unix sed utility in IEEE Std 1003.1-2001, Portable Operating
-                SystemInterface (POSIX ), Shells and Utilities. See also the Sed Format string reference.
+                SystemInterface (POSIX ), Shells and Utilities. See also the Sed Format string reference.
               
    
                   		
 
    
               
    
                 Specifies that when a regular expression match is to be replaced
-                by a new string, that the new string is constructed using the
+                by a new string, that the new string is constructed using the
                 same rules as Perl 5.
               
    
                   		
               
    
                 Specifies that all syntax extensions are enabled, including conditional
-                (?ddexpression1:expression2) replacements: see the format
+                (?ddexpression1:expression2) replacements: see the format
                 string guide for more details.
               
    
                   		
 
 
 
 
 
 
    
 
    
       
    
-
    -match_results(const match_results& m);
+
    match_results(const match_results& m);
 
    
 
    
         Effects: Constructs an object of class match_results,
@@ -229,8 +225,7 @@
       
    
 
    
       
    
-
    -match_results& operator=(const match_results& m);
+
    match_results& operator=(const match_results& m);
 
    
 
    
         Effects: Assigns m to *this. The postconditions
@@ -354,36 +349,32 @@
 
 
    
       
    
-
    -size_type size()const;
+
    size_type size()const;
 
    
 
    
-        Effects: Returns the number of sub_match elements stored in *this;
+        Effects: Returns the number of sub_match elements stored in *this;
         that is the number of marked sub-expressions in the regular expression that
         was matched plus one.
       
    
 
    
       
    
-
    -size_type max_size()const;
+
    size_type max_size()const;
 
    
 
    
         Effects: Returns the maximum number of
-        sub_match
+        sub_match
         elements that can be stored in *this.
       
    
 
    
       
    
-
    -bool empty()const;
+
    bool empty()const;
 
    
 
    
         Effects: Returns size() == 0.
       
    
 
    
       
    
-
    -difference_type length(int sub = 0)const;
+
    difference_type length(int sub = 0)const;
 
    
 
    
         Effects: Returns the length of sub-expression
@@ -391,8 +382,7 @@
       
    
 
    
       
    
-
    -difference_type position(unsigned int sub = 0)const;
+
    difference_type position(unsigned int sub = 0)const;
 
    
 
    
         Effects: Returns the starting location of
@@ -403,8 +393,7 @@
       
    
 
    
       
    
-
    -string_type str(int sub = 0)const;
+
    string_type str(int sub = 0)const;
 
    
 
    
         Effects: Returns sub-expression sub
@@ -412,43 +401,39 @@
       
    
 
    
       
    
-
    -const_reference operator[](int n) const;
+
    const_reference operator[](int n) const;
 
    
 
    
-        Effects: Returns a reference to the sub_match
+        Effects: Returns a reference to the sub_match
         object representing the character sequence that matched marked sub-expression
         n. If n == 0 then returns
-        a reference to a sub_match object representing the
+        a reference to a sub_match object representing the
         character sequence that matched the whole regular expression. If n
         is out of range, or if n is an unmatched sub-expression,
-        then returns a sub_match
+        then returns a sub_match
         object whose matched member is false.
       
    
 
    
       
    
-
    -const_reference prefix()const;
+
    const_reference prefix()const;
 
    
 
    
-        Effects: Returns a reference to the sub_match
+        Effects: Returns a reference to the sub_match
         object representing the character sequence from the start of the string being
         matched or searched, to the start of the match found.
       
    
 
    
       
    
-
    -const_reference suffix()const;
+
    const_reference suffix()const;
 
    
 
    
-        Effects: Returns a reference to the sub_match
+        Effects: Returns a reference to the sub_match
         object representing the character sequence from the end of the match found
         to the end of the string being matched or searched.
       
    
 
    
       
    
-
    -const_iterator begin()const;
+
    const_iterator begin()const;
 
    
 
    
         Effects: Returns a starting iterator that
@@ -456,8 +441,7 @@
       
    
 
    
       
    
-
    -const_iterator end()const;
+
    const_iterator end()const;
 
    
 
    
         Effects: Returns a terminating iterator
@@ -465,8 +449,7 @@
       
    
 
    
       
    
-
    -template <class OutputIterator>
+
    template <class OutputIterator>
 OutputIterator format(OutputIterator out,
                      const string_type& fmt,
                      match_flag_type flags = format_default);
@@ -487,15 +470,14 @@
         Chapter 15 part 5.4.11 String.prototype.replace.
       
    
 
    
-        See the format syntax guide for more information.
+        See the format syntax guide for more information.
       
    
 
    
         Returns: out.
       
    
 
    
       
    
-
    -string_type format(const string_type& fmt,
+
    string_type format(const string_type& fmt,
                   match_flag_type flags = format_default);
 
    
 
    
@@ -508,12 +490,11 @@
         Chapter 15 part 5.4.11 String.prototype.replace.
       
    
 
    
-        See the format syntax guide for more information.
+        See the format syntax guide for more information.
       
    
 
    
       
    
-
    -allocator_type get_allocator()const;
+
    allocator_type get_allocator()const;
 
    
 
    
         Effects: Returns a copy of the Allocator
@@ -521,8 +502,7 @@
       
    
 
    
       
    
-
    -void swap(match_results& that);
+
    void swap(match_results& that);
 
    
 
    
         Effects: Swaps the contents of the two sequences.
@@ -537,8 +517,7 @@
       
    
 
    
       
    
-
    -typedef typename value_type::capture_sequence_type capture_sequence_type;
+
    typedef typename value_type::capture_sequence_type capture_sequence_type;
 
    
 
    
         Defines an implementation-specific type that satisfies the requirements of
@@ -548,8 +527,7 @@
       
    
 
    
       
    
-
    -const capture_sequence_type& captures(std::size_t i)const; 
+
    const capture_sequence_type& captures(std::size_t i)const; 
 
    
 
    
         Effects: returns a sequence containing all
@@ -561,7 +539,7 @@
 
    
         Preconditions: the library must be built
         and used with BOOST_REGEX_MATCH_EXTRA defined, and you must pass the flag
-        match_extra to the regex matching functions ( regex_match, regex_search, regex_iterator or regex_token_iterator) in order for
+        match_extra to the regex matching functions ( regex_match, regex_search, regex_iterator or regex_token_iterator) in order for
         this member function to be defined and return useful information.
       
    
 
    
@@ -585,8 +563,7 @@
 
 
    
       
    
-
    -template <class BidirectionalIterator, class Allocator>
+
    template <class BidirectionalIterator, class Allocator>
 bool operator == (const match_results<BidirectionalIterator, Allocator>& m1,
                   const match_results<BidirectionalIterator, Allocator>& m2);
 
    
@@ -596,8 +573,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class Allocator>
+
    template <class BidirectionalIterator, class Allocator>
 bool operator != (const match_results<BidirectionalIterator, Allocator>& m1,
                   const match_results<BidirectionalIterator, Allocator>& m2);
 
    
@@ -607,8 +583,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits, class BidirectionalIterator, class Allocator>
+
    template <class charT, class traits, class BidirectionalIterator, class Allocator>
 basic_ostream<charT, traits>&
    operator << (basic_ostream<charT, traits>& os,
                const match_results<BidirectionalIterator, Allocator>& m);
@@ -621,8 +596,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class Allocator>
+
    template <class BidirectionalIterator, class Allocator>
 void swap(match_results<BidirectionalIterator, Allocator>& m1,
          match_results<BidirectionalIterator, Allocator>& m2);
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings.html b/doc/html/boost_regex/ref/non_std_strings.html
index 3bbbcef4..64578031 100644
--- a/doc/html/boost_regex/ref/non_std_strings.html
+++ b/doc/html/boost_regex/ref/non_std_strings.html
@@ -3,7 +3,7 @@
 
 Interfacing With Non-Standard String Types
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings/icu.html b/doc/html/boost_regex/ref/non_std_strings/icu.html
index 133d2f4f..d051e5fc 100644
--- a/doc/html/boost_regex/ref/non_std_strings/icu.html
+++ b/doc/html/boost_regex/ref/non_std_strings/icu.html
@@ -3,7 +3,7 @@
 
 Working With Unicode and ICU String Types
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings/icu/intro.html b/doc/html/boost_regex/ref/non_std_strings/icu/intro.html
index 6be681d2..59cbc25d 100644
--- a/doc/html/boost_regex/ref/non_std_strings/icu/intro.html
+++ b/doc/html/boost_regex/ref/non_std_strings/icu/intro.html
@@ -3,7 +3,7 @@
 
 Introduction to using Regex with ICU
 
-
+
 
 
 
@@ -24,14 +24,13 @@
 
    
 
    
 
    
 
    
             The header:
           
    
-
    -<boost/regex/icu.hpp>
+
    <boost/regex/icu.hpp>
 
    
 
    
             contains the data types and algorithms necessary for working with regular
@@ -40,7 +39,7 @@
 
    
             In order to use this header you will need the ICU
             library, and you will need to have built the Boost.Regex library
-            with ICU
+            with ICU
             support enabled.
           
    
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html
index 199e941a..9000f383 100644
--- a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html
+++ b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html
@@ -3,7 +3,7 @@
 
 Unicode Regular Expression Algorithms
 
-
+
 
 
 
@@ -24,11 +24,11 @@
 
    
 
    
 
    
 
    
-            The regular expression algorithms regex_match, regex_search and regex_replace all expect that
+            The regular expression algorithms regex_match, regex_search and regex_replace all expect that
             the character sequence upon which they operate, is encoded in the same
             character encoding as the regular expression object with which they are
             used. For Unicode regular expressions that behavior is undesirable: while
@@ -43,11 +43,11 @@
             on to the "real" algorithm.
           
    
 
    
-
-            u32regex_match
+
+            u32regex_match
           
    
 
    
-            For each regex_match
+            For each regex_match
             algorithm defined by <boost/regex.hpp>,
             then <boost/regex/icu.hpp> defines an overloaded algorithm that
             takes the same arguments, but which is called u32regex_match,
@@ -57,8 +57,7 @@
 
    
             Example: match a password, encoded in a UTF-16 UnicodeString:
           
    
-
    -//
+
    //
 // Find out if *password* meets our password requirements,
 // as defined by the regular expression *requirements*.
 //
@@ -70,8 +69,7 @@
 
    
             Example: match a UTF-8 encoded filename:
           
    
-
    -//
+
    //
 // Extract filename part of a path from a UTF-8 encoded std::string and return the result
 // as another std::string:
 //
@@ -91,11 +89,11 @@
 }
 
    
 
    
-
-            u32regex_search
+
+            u32regex_search
           
    
 
    
-            For each regex_search
+            For each regex_search
             algorithm defined by <boost/regex.hpp>,
             then <boost/regex/icu.hpp> defines an overloaded algorithm that
             takes the same arguments, but which is called u32regex_search,
@@ -105,8 +103,7 @@
 
    
             Example: search for a character sequence in a specific language block:
           
    
-
    -UnicodeString extract_greek(const UnicodeString& text)
+
    UnicodeString extract_greek(const UnicodeString& text)
 {
    // searches through some UTF-16 encoded text for a block encoded in Greek,
    // this expression is imperfect, but the best we can do for now - searching
@@ -131,11 +128,11 @@
 }
 
    
 
    
-
-            u32regex_replace
+
+            u32regex_replace
           
    
 
    
-            For each regex_replace algorithm defined
+            For each regex_replace algorithm defined
             by <boost/regex.hpp>, then <boost/regex/icu.hpp>
             defines an overloaded algorithm that takes the same arguments, but which
             is called u32regex_replace,
@@ -149,8 +146,7 @@
 
    
             Example: Credit card number reformatting:
           
    
-
    -//
+
    //
 // Take a credit card number as a string of digits, 
 // and reformat it as a human readable string with "-"
 // separating each group of four digit;, 
diff --git a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html
index f188b7e5..debc21d2 100644
--- a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html
+++ b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html
@@ -3,7 +3,7 @@
 
 Unicode Aware Regex Iterators
 
-
+
 
 
 
@@ -24,23 +24,22 @@
 
    
 
    
 
    
 
    
-
-            u32regex_iterator
+
+            u32regex_iterator
           
    
 
    
             Type u32regex_iterator
-            is in all respects the same as regex_iterator except that since
+            is in all respects the same as regex_iterator except that since
             the regular expression type is always u32regex
             it only takes one template parameter (the iterator type). It also calls
             u32regex_search internally,
             allowing it to interface correctly with UTF-8, UTF-16, and UTF-32 data:
           
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 class u32regex_iterator
 {
    // for members see regex_iterator
@@ -55,8 +54,7 @@
             from a string, there are a series of non-member helper functions called
             make_u32regex_iterator:
           
    
-
    -u32regex_iterator<const char*> 
+
    u32regex_iterator<const char*> 
    make_u32regex_iterator(const char* s, 
                           const u32regex& e, 
                           regex_constants::match_flag_type m = regex_constants::match_default);
@@ -91,8 +89,7 @@
             Example: search for international currency symbols, along with their
             associated numeric value:
           
    
-
    -void enumerate_currencies(const std::string& text)
+
    void enumerate_currencies(const std::string& text)
 {
    // enumerate and print all the currency symbols, along
    // with any associated numeric values:
@@ -129,19 +126,18 @@
             Provided of course that the input is encoded as UTF-8.
           
    
 
    
-
-            u32regex_token_iterator
+
+            u32regex_token_iterator
           
    
 
    
             Type u32regex_token_iterator
-            is in all respects the same as regex_token_iterator except
+            is in all respects the same as regex_token_iterator except
             that since the regular expression type is always u32regex
             it only takes one template parameter (the iterator type). It also calls
             u32regex_search internally,
             allowing it to interface correctly with UTF-8, UTF-16, and UTF-32 data:
           
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 class u32regex_token_iterator
 {
    // for members see regex_token_iterator
@@ -156,8 +152,7 @@
             from a string, there are a series of non-member helper functions called
             make_u32regex_token_iterator:
           
    
-
    -u32regex_token_iterator<const char*> 
+
    u32regex_token_iterator<const char*> 
    make_u32regex_token_iterator(
          const char* s, 
          const u32regex& e, 
@@ -198,8 +193,7 @@
             of marked sub-expression sub in regular expression e,
             found in text s, using match_flags m.
           
    
-
    -template <std::size_t N>
+
    template <std::size_t N>
 u32regex_token_iterator<const char*> 
    make_u32regex_token_iterator(
          const char* p, 
@@ -244,8 +238,7 @@
             for each submatch in regular expression e, found
             in text s, using match_flags m.
           
    
-
    -u32regex_token_iterator<const char*> 
+
    u32regex_token_iterator<const char*> 
    make_u32regex_token_iterator(
          const char* p, 
          const u32regex& e, 
@@ -290,8 +283,7 @@
             Example: search for international currency symbols, along with their
             associated numeric value:
           
    
-
    -void enumerate_currencies2(const std::string& text)
+
    void enumerate_currencies2(const std::string& text)
 {
    // enumerate and print all the currency symbols, along
    // with any associated numeric values:
diff --git a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
index 43e73751..cc35964f 100644
--- a/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
+++ b/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
@@ -3,7 +3,7 @@
 
 Unicode regular expression types
 
-
+
 
 
 
@@ -24,21 +24,19 @@
 
    
 
    
 
    
 
    
             Header <boost/regex/icu.hpp> provides a regular expression traits
             class that handles UTF-32 characters:
           
    
-
    -class icu_regex_traits;
+
    class icu_regex_traits;
 
    
 
    
             and a regular expression type based upon that:
           
    
-
    -typedef basic_regex<UChar32,icu_regex_traits> u32regex;
+
    typedef basic_regex<UChar32,icu_regex_traits> u32regex;
 
    
 
    
             The type u32regex is
@@ -53,8 +51,7 @@
             which allow regular expressions to be created from UTF-8, UTF-16, or
             UTF-32 encoded strings:
           
    
-
    -template <class InputIterator> 
+
    template <class InputIterator> 
 u32regex make_u32regex(InputIterator i, 
                        InputIterator j, 
                        boost::regex_constants::syntax_option_type opt);
@@ -65,8 +62,7 @@
             sequence is determined based upon sizeof(*i): 1 implies UTF-8, 2 implies
             UTF-16, and 4 implies UTF-32.
           
    
-
    -u32regex make_u32regex(const char* p, 
+
    u32regex make_u32regex(const char* p, 
                        boost::regex_constants::syntax_option_type opt 
                            = boost::regex_constants::perl);
 
    
@@ -74,8 +70,7 @@
             Effects: Creates a regular expression
             object from the Null-terminated UTF-8 characater sequence p.
           
    
-
    -u32regex make_u32regex(const unsigned char* p, 
+
    u32regex make_u32regex(const unsigned char* p, 
                        boost::regex_constants::syntax_option_type opt 
                            = boost::regex_constants::perl);
 
    
@@ -83,8 +78,7 @@
             Effects: Creates a regular expression
             object from the Null-terminated UTF-8 characater sequence p.
           
    
-
    -u32regex make_u32regex(const wchar_t* p, 
+
    u32regex make_u32regex(const wchar_t* p, 
                        boost::regex_constants::syntax_option_type opt 
                            = boost::regex_constants::perl);
 
    
@@ -94,8 +88,7 @@
             encoding of the sequence is determined based upon sizeof(wchar_t): 1
             implies UTF-8, 2 implies UTF-16, and 4 implies UTF-32.
           
    
-
    -u32regex make_u32regex(const UChar* p, 
+
    u32regex make_u32regex(const UChar* p, 
                        boost::regex_constants::syntax_option_type opt 
                            = boost::regex_constants::perl);
 
    
@@ -103,8 +96,7 @@
             Effects: Creates a regular expression
             object from the Null-terminated UTF-16 characater sequence p.
           
    
-
    -template<class C, class T, class A>
+
    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 
                            = boost::regex_constants::perl);
@@ -115,8 +107,7 @@
             based upon sizeof(C): 1 implies UTF-8, 2 implies UTF-16, and 4 implies
             UTF-32.
           
    
-
    -u32regex make_u32regex(const UnicodeString& s, 
+
    u32regex make_u32regex(const UnicodeString& s, 
                        boost::regex_constants::syntax_option_type opt 
                            = boost::regex_constants::perl);
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings.html
index 3712ad40..e58958d2 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings.html
@@ -3,7 +3,7 @@
 
 Using Boost Regex With MFC Strings
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html
index 00e8775f..60541b54 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html
@@ -3,7 +3,7 @@
 
 Overloaded Algorithms For MFC String Types
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
@@ -34,21 +34,20 @@
             here they are anyway:
           
    
 
    
-
-            regex_match
+
+            regex_match
           
    
 
    
             There are two overloads, the first reports what matched in a match_results
             structure, the second does not.
           
    
 
    
-            All the usual caveats for regex_match apply, in particular
+            All the usual caveats for regex_match apply, in particular
             the algorithm will only report a successful match if all of the input
-            text matches the expression, if this isn't what you want then use regex_search
+            text matches the expression, if this isn't what you want then use regex_search
             instead.
           
    
-
    -template <class charT, class T, class A>
+
    template <class charT, class T, class A>
 bool regex_match(
    const ATL::CSimpleStringT<charT>& s, 
    match_results<const B*, A>& what, 
@@ -63,8 +62,7 @@
 
    
             Example:
           
    
-
    -//
+
    //
 // Extract filename part of a path from a CString and return the result
 // as another CString:
 //
@@ -84,12 +82,11 @@
 }
 
    
 
    
-
-            regex_match
+
+            regex_match
             (second overload)
           
    
-
    -template <class charT, class T>
+
    template <class charT, class T>
 bool regex_match(
    const ATL::CSimpleStringT<charT>& s,
    const basic_regex<B, T>& e,
@@ -103,8 +100,7 @@
 
    
             Example:
           
    
-
    -//
+
    //
 // Find out if *password* meets our password requirements,
 // as defined by the regular expression *requirements*.
 //
@@ -114,15 +110,14 @@
 }      
 
    
 
    
-
-            regex_search
+
+            regex_search
           
    
 
    
-            There are two additional overloads for regex_search, the first reports
+            There are two additional overloads for regex_search, the first reports
             what matched the second does not:
           
    
-
    -template <class charT, class A, class T>
+
    template <class charT, class A, class T>
 bool regex_search(const ATL::CSimpleStringT<charT>& s,
                   match_results<const charT*, A>& what,
                   const basic_regex<charT, T>& e,
@@ -136,8 +131,7 @@
             Example: Postcode extraction from an
             address string.
           
    
-
    -CString extract_postcode(const CString& address)
+
    CString extract_postcode(const CString& address)
 {
    // searches throw address for a UK postcode and returns the result,
    // the expression used is by Phil A. on www.regxlib.com:
@@ -155,12 +149,11 @@
 }      
 
    
 
    
-
-            regex_search
+
+            regex_search
             (second overload)
           
    
-
    -template <class charT, class T>
+
    template <class charT, class T>
 inline bool regex_search(const ATL::CSimpleStringT<charT>& s,
                const basic_regex<charT, T>& e,
                boost::regex_constants::match_flag_type f = boost::regex_constants::match_default)
@@ -171,15 +164,14 @@
             + s.GetLength(), e, f);
           
    
 
    
-
-            regex_replace
+
+            regex_replace
           
    
 
    
-            There are two additional overloads for regex_replace, the first sends
+            There are two additional overloads for regex_replace, the first sends
             output to an output iterator, while the second creates a new string
           
    
-
    -template <class OutputIterator, class BidirectionalIterator, class traits, class
+
    template <class OutputIterator, class BidirectionalIterator, class traits, class
          charT>
 OutputIterator regex_replace(OutputIterator out,
                            BidirectionalIterator first,
@@ -192,8 +184,7 @@
             Effects: returns ::boost::regex_replace(out, first, last, e, fmt.GetString(),
             flags);
           
    
-
    -template <class traits, charT>
+
    template <class traits, charT>
 ATL::CSimpleStringT<charT> regex_replace(const ATL::CSimpleStringT<charT>& s,
                            const basic_regex<charT, traits>& e,
                            const ATL::CSimpleStringT<charT>& fmt,
@@ -201,14 +192,13 @@
 
    
 
    
             Effects: returns a new string created
-            using regex_replace,
+            using regex_replace,
             and the same memory manager as string s.
           
    
 
    
             Example:
           
    
-
    -//
+
    //
 // Take a credit card number as a string of digits, 
 // and reformat it as a human readable string with "-"
 // separating each group of four digits:
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html
index 2633b62c..0c3c45d8 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html
@@ -3,7 +3,7 @@
 
 Introduction to Boost.Regex and MFC Strings
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
@@ -38,8 +38,7 @@
             then you can substitute any of the following MFC/ATL types (all of which
             inherit from CSimpleStringT):
           
    
-
    -CString
+
    CString
 CStringA
 CStringW
 CAtlString
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html
index 208faa71..41b53be5 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html
@@ -3,7 +3,7 @@
 
 Iterating Over the Matches Within An MFC String
 
-
+
 
 
 
@@ -24,20 +24,19 @@
 
    
 
    
 
    
 
    
             The following helper functions are provided to ease the conversion from
-            an MFC/ATL string to a regex_iterator or regex_token_iterator:
+            an MFC/ATL string to a regex_iterator or regex_token_iterator:
           
    
 
    
-
-            regex_iterator
+
+            regex_iterator
             creation helper
           
    
-
    -template <class charT>
+
    template <class charT>
 regex_iterator<charT const*> 
    make_regex_iterator(
       const ATL::CSimpleStringT<charT>& s, 
@@ -52,8 +51,7 @@
 
    
             Example:
           
    
-
    -void enumerate_links(const CString& html)
+
    void enumerate_links(const CString& html)
 {
    // enumerate and print all the  links in some HTML text,
    // the expression used is by Andew Lee on www.regxlib.com:
@@ -70,12 +68,11 @@
 }
 
    
 
    
-
-            regex_token_iterator
+
+            regex_token_iterator
             creation helpers
           
    
-
    -template <class charT> 
+
    template <class charT> 
 regex_token_iterator<charT const*> 
    make_regex_token_iterator(
       const ATL::CSimpleStringT<charT>& s, 
@@ -89,8 +86,7 @@
             sub,
             f);
           
    
-
    -template <class charT> 
+
    template <class charT> 
 regex_token_iterator<charT const*> 
    make_regex_token_iterator(
       const ATL::CSimpleStringT<charT>& s, 
@@ -104,8 +100,7 @@
             subs,
             f);
           
    
-
    -template <class charT, std::size_t N> 
+
    template <class charT, std::size_t N> 
 regex_token_iterator<charT const*> 
    make_regex_token_iterator(
       const ATL::CSimpleStringT<charT>& s, 
@@ -122,8 +117,7 @@
 
    
             Example:
           
    
-
    -void enumerate_links2(const CString& html)
+
    void enumerate_links2(const CString& html)
 {
    // enumerate and print all the  links in some HTML text,
    // the expression used is by Andew Lee on www.regxlib.com:
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html
index 6d10879b..cda7adca 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html
@@ -3,7 +3,7 @@
 
 Regular Expression Creation From an MFC String
 
-
+
 
 
 
@@ -24,15 +24,14 @@
 
    
 
    
 
    
 
    
             The following helper function is available to assist in the creation
             of a regular expression from an MFC/ATL string type:
           
    
-
    -template <class charT>
+
    template <class charT>
 basic_regex<charT> 
    make_regex(const ATL::CSimpleStringT<charT>& s, 
             ::boost::regex_constants::syntax_option_type f = boost::regex_constants::normal);
diff --git a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
index f820f9b2..ea09c6a5 100644
--- a/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
+++ b/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
@@ -3,7 +3,7 @@
 
 Regex Types Used With MFC Strings
 
-
+
 
 
 
@@ -24,15 +24,14 @@
 
    
 
    
 
    
 
    
             The following typedefs are provided for the convenience of those working
             with TCHAR's:
           
    
-
    -typedef basic_regex<TCHAR>                  tregex; 
+
    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; 
diff --git a/doc/html/boost_regex/ref/posix.html b/doc/html/boost_regex/ref/posix.html
index 503ef254..780e8201 100644
--- a/doc/html/boost_regex/ref/posix.html
+++ b/doc/html/boost_regex/ref/posix.html
@@ -3,7 +3,7 @@
 
 POSIX Compatible C API's
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
@@ -39,14 +39,12 @@
           as the names used are macros that expand to the actual function names.
         
    
 
    
 
    
-
    -#include <boost/cregex.hpp>
+
    #include <boost/cregex.hpp>
 
    
 
    
         or:
       
    
-
    -#include <boost/regex.h>
+
    #include <boost/regex.h>
 
    
 
    
         The following functions are available for users who need a POSIX compatible
@@ -69,8 +67,7 @@
 
    
         The functions are defined as:
       
    
-
    -extern "C" {
+
    extern "C" {
 
 struct regex_tA;
 struct regex_tW;
@@ -168,8 +165,8 @@
 
    
       
    
 
    
-
-        regcomp
+
+        regcomp
       
    
 
    
         regcomp takes a pointer to
@@ -382,8 +379,8 @@
 
    
       
    
 
    
-
-        regerror
+
+        regerror
       
    
 
    
         regerror takes the following parameters, it maps an error code to a human
@@ -470,8 +467,8 @@
 
    
       
    
 
    
-
-        regexec
+
+        regexec
       
    
 
    
         regexec finds the first occurrence of expression e within string buf. If
@@ -540,8 +537,8 @@
 
    
       
    
 
    
-
-        regfree
+
+        regfree
       
    
 
    
         regfree frees all the memory
diff --git a/doc/html/boost_regex/ref/regex_iterator.html b/doc/html/boost_regex/ref/regex_iterator.html
index 0ca6733e..173e5ec1 100644
--- a/doc/html/boost_regex/ref/regex_iterator.html
+++ b/doc/html/boost_regex/ref/regex_iterator.html
@@ -3,7 +3,7 @@
 
 regex_iterator
 
-
+
 
 
 
@@ -24,16 +24,15 @@
 
    
 
    
 
    
 
    
-        The iterator type regex_iterator will enumerate all
+        The iterator type regex_iterator will enumerate all
         of the regular expression matches found in some sequence: dereferencing a
-        regex_iterator
-        yields a reference to a match_results object.
+        regex_iterator
+        yields a reference to a match_results object.
       
    
-
    -template <class BidirectionalIterator, 
+
    template <class BidirectionalIterator, 
          class charT = iterator_traits<BidirectionalIterator>::value_type,
          class traits = regex_traits<charT> >
 class regex_iterator 
@@ -46,18 +45,18 @@
    typedef          const value_type&                                       reference;
    typedef          std::forward_iterator_tag                               iterator_category;
    
-   regex_iterator();
-   regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 
+   regex_iterator();
+   regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 
                   const regex_type& re, 
                   match_flag_type m = match_default);
-   regex_iterator(const regex_iterator&);
-   regex_iterator& operator=(const regex_iterator&);
-   bool operator==(const regex_iterator&)const;
-   bool operator!=(const regex_iterator&)const;
-   const value_type& operator*()const;
-   const value_type* operator->()const;
-   regex_iterator& operator++();
-   regex_iterator operator++(int);
+   regex_iterator(const regex_iterator&);
+   regex_iterator& operator=(const regex_iterator&);
+   bool operator==(const regex_iterator&)const;
+   bool operator!=(const regex_iterator&)const;
+   const value_type& operator*()const;
+   const value_type* operator->()const;
+   regex_iterator& operator++();
+   regex_iterator operator++(int);
 };
 
 typedef regex_iterator<const char*>                  cregex_iterator; 
@@ -69,45 +68,43 @@
 #endif 
 
 template <class charT, class traits> regex_iterator<const charT*, charT, traits> 
-   make_regex_iterator(const charT* 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, 
+      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);
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
-        A regex_iterator
+        A regex_iterator
         is constructed from a pair of iterators, and enumerates all occurrences of
         a regular expression within that iterator range.
       
    
 
    
       
    
-
    -regex_iterator();
+
    regex_iterator();
 
    
 
    
         Effects: constructs an end of sequence
-        regex_iterator.
+        regex_iterator.
       
    
 
    
       
    
-
    -regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 
+
    regex_iterator(BidirectionalIterator a, BidirectionalIterator b, 
                const regex_type& re, 
                match_flag_type m = match_default);
 
    
 
    
-        Effects: constructs a regex_iterator that will enumerate
+        Effects: constructs a regex_iterator that will enumerate
         all occurrences of the expression re, within the sequence
-        [a,b), and found using match_flag_type m.
-        The object re must exist for the lifetime of the regex_iterator.
+        [a,b), and found using match_flag_type m.
+        The object re must exist for the lifetime of the regex_iterator.
       
    
 
    
         Throws: std::runtime_error
@@ -119,8 +116,7 @@
       
    
 
    
       
    
-
    -regex_iterator(const regex_iterator& that);
+
    regex_iterator(const regex_iterator& that);
 
    
 
    
         Effects: constructs a copy of that.
@@ -130,8 +126,7 @@
       
    
 
    
       
    
-
    -regex_iterator& operator=(const regex_iterator&);
+
    regex_iterator& operator=(const regex_iterator&);
 
    
 
    
         Effects: sets *this equal to those in that.
@@ -141,8 +136,7 @@
       
    
 
    
       
    
-
    -bool operator==(const regex_iterator& that)const;
+
    bool operator==(const regex_iterator& that)const;
 
    
 
    
         Effects: returns true if *this is equal
@@ -150,20 +144,18 @@
       
    
 
    
       
    
-
    -bool operator!=(const regex_iterator&)const;
+
    bool operator!=(const regex_iterator&)const;
 
    
 
    
         Effects: returns !(*this == that).
       
    
 
    
       
    
-
    -const value_type& operator*()const;
+
    const value_type& operator*()const;
 
    
 
    
-        Effects: dereferencing a regex_iterator object it yields
-        a const reference to a match_results object, whose members
+        Effects: dereferencing a regex_iterator object it yields
+        a const reference to a match_results object, whose members
         are set as follows:
       
    
 
    
@@ -383,22 +375,20 @@
 
    
 
    
       
    
-
    -const value_type* operator->()const;
+
    const value_type* operator->()const;
 
    
 
    
         Effects: returns &(*this).
       
    
 
    
       
    
-
    -regex_iterator& operator++();
+
    regex_iterator& operator++();
 
    
 
    
         Effects: moves the iterator to the next
         match in the underlying sequence, or the end of sequence iterator if none
         if found. When the last match found matched a zero length string, then the
-        regex_iterator
+        regex_iterator
         will find the next match as follows: if there exists a non-zero length match
         that starts at the same location as the last one, then returns it, otherwise
         starts looking for the next (possibly zero length) match from one position
@@ -417,8 +407,7 @@
       
    
 
    
       
    
-
    -regex_iterator operator++(int);
+
    regex_iterator operator++(int);
 
    
 
    
         Effects: constructs a copy result of *this, then
@@ -429,8 +418,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits> 
+
    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); 
@@ -444,19 +432,18 @@
 
    
         Effects: returns an iterator that enumerates
         all occurences of expression e in text p
-        using match_flag_type
+        using match_flag_type
         m.
       
    
 
    
-
-        Examples
+
+        Examples
       
    
 
    
         The following example takes a C++ source file and builds up an index of class
         names, and the location of that class in the file.
       
    
-
    -#include <string>
+
    #include <string>
 #include <map>
 #include <fstream>
 #include <iostream>
diff --git a/doc/html/boost_regex/ref/regex_match.html b/doc/html/boost_regex/ref/regex_match.html
index d7fbf58d..059d6c5d 100644
--- a/doc/html/boost_regex/ref/regex_match.html
+++ b/doc/html/boost_regex/ref/regex_match.html
@@ -3,7 +3,7 @@
 
 regex_match
 
-
+
 
 
 
@@ -24,13 +24,12 @@
 
    
 
    
 
    
-
    -#include <boost/regex.hpp> 
+
    #include <boost/regex.hpp> 
 
    
 
    
-        The algorithm regex_match
+        The algorithm regex_match
         determines whether a given regular expression matches all
         of a given character sequence denoted by a pair of bidirectional-iterators,
         the algorithm is defined as follows, the main use of this function is data
@@ -43,13 +42,12 @@
 
 
    
           Note that the result is true only if the expression matches the whole of the input sequence. If you want to search
-          for an expression somewhere within the sequence then use regex_search. If you want to match
-          a prefix of the character string then use regex_search with the flag match_continuous
+          for an expression somewhere within the sequence then use regex_search. If you want to match
+          a prefix of the character string then use regex_search with the flag match_continuous
           set.
         
    
 
    
-
    -template <class BidirectionalIterator, class Allocator, class charT, class traits>
+
    template <class BidirectionalIterator, class Allocator, class charT, class traits>
 bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
                  match_results<BidirectionalIterator, Allocator>& m,
                  const basic_regex <charT, traits>& e,
@@ -82,11 +80,10 @@
                  match_flag_type flags = match_default);
 
    
 
    
-
-        Description
+
+        Description
       
    
-
    -template <class BidirectionalIterator, class Allocator, class charT, class traits>
+
    template <class BidirectionalIterator, class Allocator, class charT, class traits>
 bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
                  match_results<BidirectionalIterator, Allocator>& m,
                  const basic_regex <charT, traits>& e,
@@ -100,7 +97,7 @@
         Effects: Determines whether there is an
         exact match between the regular expression e, and all
         of the character sequence [first, last), parameter flags
-        (see match_flag_type)
+        (see match_flag_type)
         is used to control how the expression is matched against the character sequence.
         Returns true if such a match exists, false otherwise.
       
    
@@ -313,8 +310,7 @@
 
 
 
    
-
    -template <class BidirectionalIterator, class charT, class traits>
+
    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);
@@ -325,8 +321,7 @@
         and then returning the result of regex_match(first, last, what, e,
         flags).
       
    
-
    -template <class charT, class Allocator, class traits>
+
    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);
@@ -336,8 +331,7 @@
         + char_traits<charT>::length(str),
         m, e, flags).
       
    
-
    -template <class ST, class SA, class Allocator,
+
    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, 
@@ -347,8 +341,7 @@
 
    
         Effects: Returns the result of regex_match(s.begin(), s.end(), m, e, flags).
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool regex_match(const charT* str,
                const basic_regex <charT, traits>& e,
                match_flag_type flags = match_default);
@@ -358,8 +351,7 @@
         + char_traits<charT>::length(str),
         e, flags).
       
    
-
    -template <class ST, class SA, class charT, class traits>
+
    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);
@@ -368,14 +360,13 @@
         Effects: Returns the result of regex_match(s.begin(), s.end(), e, flags).
       
    
 
    
-
-        Examples
+
+        Examples
       
    
 
    
         The following example processes an ftp response:
       
    
-
    -#include <stdlib.h> 
+
    #include <stdlib.h> 
 #include <boost/regex.hpp> 
 #include <string> 
 #include <iostream> 
diff --git a/doc/html/boost_regex/ref/regex_replace.html b/doc/html/boost_regex/ref/regex_replace.html
index 01d2f538..d4df057f 100644
--- a/doc/html/boost_regex/ref/regex_replace.html
+++ b/doc/html/boost_regex/ref/regex_replace.html
@@ -3,7 +3,7 @@
 
 regex_replace
 
-
+
 
 
 
@@ -24,23 +24,21 @@
 
    
 
    
 
    
-
    -#include <boost/regex.hpp> 
+
    #include <boost/regex.hpp> 
 
    
 
    
-        The algorithm regex_replace searches through a
+        The algorithm regex_replace searches through a
         string finding all the matches to the regular expression: for each match
-        it then calls match_results<>::format to format the string and
+        it then calls match_results<>::format to format the string and
         sends the result to the output iterator. Sections of text that do not match
         are copied to the output unchanged only if the flags
         parameter does not have the flag format_no_copy
         set. If the flag format_first_only
         is set then only the first occurrence is replaced rather than all occurrences.
       
    
-
    -template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
+
    template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
 OutputIterator regex_replace(OutputIterator out,
                              BidirectionalIterator first,
                              BidirectionalIterator last,
@@ -55,11 +53,10 @@
                                   match_flag_type flags = match_default);
 
    
 
    
-
-        Description
+
+        Description
       
    
-
    -template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
+
    template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
 OutputIterator regex_replace(OutputIterator out,
                              BidirectionalIterator first,
                              BidirectionalIterator last,
@@ -86,61 +83,53 @@
 
    
         The manner in which the format string fmt is interpretted,
         along with the rules used for finding matches, are determined by the flags
-        set in flags: see match_flag_type.
+        set in flags: see match_flag_type.
       
    
 
    
-        Effects: Constructs an regex_iterator object:
+        Effects: Constructs an regex_iterator object:
       
    
-
    -regex_iterator<BidirectionalIterator, charT, traits, Allocator> 
+
    regex_iterator<BidirectionalIterator, charT, traits, Allocator> 
                                           i(first, last, e, flags), 
 
    
 
    
         and uses i to enumerate through all of the matches
-        m of type match_results <BidirectionalIterator>
+        m of type match_results <BidirectionalIterator>
         that occur within the sequence [first, last).
       
    
 
    
         If no such matches are found and
       
    
-
    -!(flags & format_no_copy) 
+
    !(flags & format_no_copy) 
 
    
 
    
         then calls
       
    
-
    -std::copy(first, last, out). 
+
    std::copy(first, last, out). 
 
    
 
    
         Otherwise, for each match found, if
       
    
-
    -!(flags & format_no_copy) 
+
    !(flags & format_no_copy) 
 
    
 
    
         calls
       
    
-
    -std::copy(m.prefix().first, m.prefix().last, out), 
+
    std::copy(m.prefix().first, m.prefix().last, out), 
 
    
 
    
         and then calls
       
    
-
    -m.format(out, fmt, flags). 
+
    m.format(out, fmt, flags). 
 
    
 
    
         Finally if
       
    
-
    -!(flags & format_no_copy) 
+
    !(flags & format_no_copy) 
 
    
 
    
         calls
       
    
-
    -std::copy(last_m.suffix().first, last_m,suffix().last, out) 
+
    std::copy(last_m.suffix().first, last_m,suffix().last, out) 
 
    
 
    
         where last_m is a copy of the last match found.
@@ -161,8 +150,7 @@
 
    
         Returns: out.
       
    
-
    -template <class traits, class charT>
+
    template <class traits, class charT>
 basic_string<charT> regex_replace(const basic_string<charT>& s,
                                   const basic_regex<charT, traits>& e,
                                   const basic_string<charT>& fmt,
@@ -175,15 +163,14 @@
         and then returns result.
       
    
 
    
-
-        Examples
+
+        Examples
       
    
 
    
         The following example takes C/C++ source code as input, and outputs syntax
         highlighted HTML code.
       
    
-
    -#include <fstream>
+
    #include <fstream>
 #include <sstream>
 #include <string>
 #include <iterator>
diff --git a/doc/html/boost_regex/ref/regex_search.html b/doc/html/boost_regex/ref/regex_search.html
index 0ff4e507..f04b1d9f 100644
--- a/doc/html/boost_regex/ref/regex_search.html
+++ b/doc/html/boost_regex/ref/regex_search.html
@@ -3,7 +3,7 @@
 
 regex_search
 
-
+
 
 
 
@@ -24,20 +24,18 @@
 
    
 
    
 
    
-
    -#include <boost/regex.hpp> 
+
    #include <boost/regex.hpp> 
 
    
 
    
-        The algorithm regex_search will search a range
+        The algorithm regex_search will search a range
         denoted by a pair of bidirectional-iterators for a given regular expression.
         The algorithm uses various heuristics to reduce the search time by only checking
         for a match if a match could conceivably start at that position. The algorithm
         is defined as follows:
       
    
-
    -template <class BidirectionalIterator, 
+
    template <class BidirectionalIterator, 
          class Allocator, class charT, class traits>
 bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                   match_results<BidirectionalIterator, Allocator>& m,
@@ -75,11 +73,10 @@
                   match_flag_type flags = match_default);
 
    
 
    
-
-        Description
+
+        Description
       
    
-
    -template <class BidirectionalIterator, class Allocator, class charT, class traits>
+
    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,
@@ -308,8 +305,7 @@
 
 
 
    
-
    -template <class charT, class Allocator, class traits>
+
    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);
@@ -319,8 +315,7 @@
         + char_traits<charT>::length(str),
         m, e, flags).
       
    
-
    -template <class ST, class SA, class Allocator, class charT,
+
    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,
@@ -330,8 +325,7 @@
 
    
         Effects: Returns the result of regex_search(s.begin(), s.end(), m, e, flags).
       
    
-
    -template <class iterator, class charT, class traits>
+
    template <class iterator, class charT, class traits>
 bool regex_search(iterator first, iterator last,
                   const basic_regex<charT, traits>& e,
                   match_flag_type flags = match_default);
@@ -342,8 +336,7 @@
         and then returning the result of regex_search(first, last, what, e,
         flags).
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 bool regex_search(const charT* str
                   const basic_regex<charT, traits>& e,
                   match_flag_type flags = match_default);
@@ -353,8 +346,7 @@
         + char_traits<charT>::length(str),
         e, flags).
       
    
-
    -template <class ST, class SA, class charT, class traits>
+
    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);
@@ -363,8 +355,8 @@
         Effects: Returns the result of regex_search(s.begin(), s.end(), e, flags).
       
    
 
    
-
-        Examples
+
+        Examples
       
    
 
    
         The following example, takes the contents of a file in the form of a string,
@@ -373,8 +365,7 @@
         is implemented, for example it could easily be modified to work with the
         SGI rope class, which uses a non-contiguous storage strategy.
       
    
-
    -#include <string> 
+
    #include <string> 
 #include <map> 
 #include <boost/regex.hpp> 
 
diff --git a/doc/html/boost_regex/ref/regex_token_iterator.html b/doc/html/boost_regex/ref/regex_token_iterator.html
index d90c9fc0..a0c19431 100644
--- a/doc/html/boost_regex/ref/regex_token_iterator.html
+++ b/doc/html/boost_regex/ref/regex_token_iterator.html
@@ -3,7 +3,7 @@
 
 regex_token_iterator
 
-
+
 
 
 
@@ -24,23 +24,22 @@
 
    
 
    
 
    
 
    
-        The template class regex_token_iterator is an iterator
+        The template class regex_token_iterator is an iterator
         adapter; that is to say it represents a new view of an existing iterator
         sequence, by enumerating all the occurrences of a regular expression within
         that sequence, and presenting one or more character sequence for each match
-        found. Each position enumerated by the iterator is a sub_match object that represents
+        found. Each position enumerated by the iterator is a sub_match object that represents
         what matched a particular sub-expression within the regular expression. When
-        class regex_token_iterator is used to
+        class regex_token_iterator is used to
         enumerate a single sub-expression with index -1, then the iterator performs
         field splitting: that is to say it enumerates one character sequence for
         each section of the character container sequence that does not match the
         regular expression specified.
       
    
-
    -template <class BidirectionalIterator, 
+
    template <class BidirectionalIterator, 
          class charT = iterator_traits<BidirectionalIterator>::value_type,
          class traits = regex_traits<charT> >
 class regex_token_iterator 
@@ -53,31 +52,31 @@
    typedef          const value_type&                                       reference;
    typedef          std::forward_iterator_tag                               iterator_category;
    
-   regex_token_iterator();
-   regex_token_iterator(BidirectionalIterator a, 
+   regex_token_iterator();
+   regex_token_iterator(BidirectionalIterator a, 
                         BidirectionalIterator b, 
                         const regex_type& re, 
                         int submatch = 0, 
                         match_flag_type m = match_default);
-   regex_token_iterator(BidirectionalIterator a, 
+   regex_token_iterator(BidirectionalIterator a, 
                         BidirectionalIterator b, 
                         const regex_type& re, 
                         const std::vector<int>& submatches, 
                         match_flag_type m = match_default);
    template <std::size_t N>
-   regex_token_iterator(BidirectionalIterator a, 
+   regex_token_iterator(BidirectionalIterator a, 
                         BidirectionalIterator b, 
                         const regex_type& re, 
                         const int (&submatches)[N], 
                         match_flag_type m = match_default);
-   regex_token_iterator(const regex_token_iterator&);
-   regex_token_iterator& operator=(const regex_token_iterator&);
-   bool operator==(const regex_token_iterator&)const;
-   bool operator!=(const regex_token_iterator&)const;
-   const value_type& operator*()const;
-   const value_type* operator->()const;
-   regex_token_iterator& operator++();
-   regex_token_iterator operator++(int);
+   regex_token_iterator(const regex_token_iterator&);
+   regex_token_iterator& operator=(const regex_token_iterator&);
+   bool operator==(const regex_token_iterator&)const;
+   bool operator!=(const regex_token_iterator&)const;
+   const value_type& operator*()const;
+   const value_type* operator->()const;
+   regex_token_iterator& operator++();
+   regex_token_iterator operator++(int);
 };
 
 typedef regex_token_iterator<const char*>                   cregex_token_iterator;
@@ -89,7 +88,7 @@
 
 template <class charT, class traits>
 regex_token_iterator<const charT*, charT, traits> 
-   make_regex_token_iterator(
+   make_regex_token_iterator(
          const charT* p, 
          const basic_regex<charT, traits>& e, 
          int submatch = 0, 
@@ -97,7 +96,7 @@
                              
 template <class charT, class traits, class ST, class SA>
 regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> 
-   make_regex_token_iterator(
+   make_regex_token_iterator(
          const std::basic_string<charT, ST, SA>& p, 
          const basic_regex<charT, traits>& e, 
          int submatch = 0, 
@@ -105,7 +104,7 @@
                              
 template <class charT, class traits, std::size_t N>
 regex_token_iterator<const charT*, charT, traits> 
-make_regex_token_iterator(
+make_regex_token_iterator(
          const charT* p, 
          const basic_regex<charT, traits>& e, 
          const int (&submatch)[N], 
@@ -113,7 +112,7 @@
                             
 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> 
-   make_regex_token_iterator(
+   make_regex_token_iterator(
          const std::basic_string<charT, ST, SA>& p, 
          const basic_regex<charT, traits>& e, 
          const int (&submatch)[N], 
@@ -121,7 +120,7 @@
                              
 template <class charT, class traits>
 regex_token_iterator<const charT*, charT, traits> 
-   make_regex_token_iterator(
+   make_regex_token_iterator(
          const charT* p, 
          const basic_regex<charT, traits>& e, 
          const std::vector<int>& submatch, 
@@ -130,28 +129,26 @@
 template <class charT, class traits, class ST, class SA>
 regex_token_iterator<
       typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> 
-   make_regex_token_iterator(
+   make_regex_token_iterator(
          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);
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
       
    
-
    -regex_token_iterator();
+
    regex_token_iterator();
 
    
 
    
         Effects: constructs an end of sequence iterator.
       
    
 
    
       
    
-
    -regex_token_iterator(BidirectionalIterator a, 
+
    regex_token_iterator(BidirectionalIterator a, 
                      BidirectionalIterator b, 
                      const regex_type& re, 
                      int submatch = 0, 
@@ -162,10 +159,10 @@
         for the lifetime of the iterator constructed from it.
       
    
 
    
-        Effects: constructs a regex_token_iterator that will enumerate
+        Effects: constructs a regex_token_iterator that will enumerate
         one string for each regular expression match of the expression re
         found within the sequence [a,b), using match flags m
-        (see match_flag_type).
+        (see match_flag_type).
         The string enumerated is the sub-expression submatch
         for each match found; if submatch is -1, then enumerates
         all the text sequences that did not match the expression re
@@ -181,8 +178,7 @@
       
    
 
    
       
    
-
    -regex_token_iterator(BidirectionalIterator a, 
+
    regex_token_iterator(BidirectionalIterator a, 
                      BidirectionalIterator b, 
                      const regex_type& re, 
                      const std::vector<int>& submatches, 
@@ -194,11 +190,11 @@
         for the lifetime of the iterator constructed from it.
       
    
 
    
-        Effects: constructs a regex_token_iterator that will enumerate
+        Effects: constructs a regex_token_iterator that will enumerate
         submatches.size()
         strings for each regular expression match of the expression re
         found within the sequence [a,b), using match flags m
-        (see match_flag_type).
+        (see match_flag_type).
         For each match found one string will be enumerated for each sub-expression
         index contained within submatches vector; if submatches[0]
         is -1, then the first string enumerated for each match will be all of the
@@ -216,8 +212,7 @@
       
    
 
    
       
    
-
    -template <std::size_t N>
+
    template <std::size_t N>
 regex_token_iterator(BidirectionalIterator a, 
                      BidirectionalIterator b, 
                      const regex_type& re, 
@@ -229,10 +224,10 @@
         for the lifetime of the iterator constructed from it.
       
    
 
    
-        Effects: constructs a regex_token_iterator that will enumerate
+        Effects: constructs a regex_token_iterator that will enumerate
         R strings for each regular expression match of the expression
         re found within the sequence [a,b), using match flags
-        m (see match_flag_type). For each match
+        m (see match_flag_type). For each match
         found one string will be enumerated for each sub-expression index contained
         within the submatches array; if submatches[0]
         is -1, then the first string enumerated for each match will be all of the
@@ -250,8 +245,7 @@
       
    
 
    
       
    
-
    -regex_token_iterator(const regex_token_iterator& that);
+
    regex_token_iterator(const regex_token_iterator& that);
 
    
 
    
         Effects: constructs a copy of that.
@@ -261,8 +255,7 @@
       
    
 
    
       
    
-
    -regex_token_iterator& operator=(const regex_token_iterator& that);
+
    regex_token_iterator& operator=(const regex_token_iterator& that);
 
    
 
    
         Effects: sets *this to be equal to that.
@@ -272,24 +265,21 @@
       
    
 
    
       
    
-
    -bool operator==(const regex_token_iterator&)const;
+
    bool operator==(const regex_token_iterator&)const;
 
    
 
    
         Effects: returns true if *this is the same position as that.
       
    
 
    
       
    
-
    -bool operator!=(const regex_token_iterator&)const;
+
    bool operator!=(const regex_token_iterator&)const;
 
    
 
    
         Effects: returns !(*this == that).
       
    
 
    
       
    
-
    -const value_type& operator*()const;
+
    const value_type& operator*()const;
 
    
 
    
         Effects: returns the current character sequence
@@ -297,16 +287,14 @@
       
    
 
    
       
    
-
    -const value_type* operator->()const;
+
    const value_type* operator->()const;
 
    
 
    
         Effects: returns &(*this).
       
    
 
    
       
    
-
    -regex_token_iterator& operator++();
+
    regex_token_iterator& operator++();
 
    
 
    
         Effects: Moves on to the next character
@@ -325,8 +313,7 @@
       
    
 
    
       
    
-
    -regex_token_iterator& operator++(int);
+
    regex_token_iterator& operator++(int);
 
    
 
    
         Effects: constructs a copy result of *this, then
@@ -337,8 +324,7 @@
       
    
 
    
       
    
-
    -template <class charT, class traits>
+
    template <class charT, class traits>
 regex_token_iterator<const charT*, charT, traits> 
    make_regex_token_iterator(
          const charT* p, 
@@ -389,22 +375,21 @@
          regex_constants::match_flag_type m = regex_constants::match_default);
 
    
 
    
-        Effects: returns a regex_token_iterator that enumerates
-        one sub_match
+        Effects: returns a regex_token_iterator that enumerates
+        one sub_match
         for each value in submatch for each occurrence of regular
         expression e in string p, matched
-        using match_flag_type
+        using match_flag_type
         m.
       
    
 
    
-
-        Examples
+
+        Examples
       
    
 
    
         The following example takes a string and splits it into a series of tokens:
       
    
-
    -#include <iostream>
+
    #include <iostream>
 #include <boost/regex.hpp>
 
 using namespace std;
@@ -442,8 +427,7 @@
         The following example takes a html file and outputs a list of all the linked
         files:
       
    
-
    -#include <fstream>
+
    #include <fstream>
 #include <iostream>
 #include <iterator>
 #include <boost/regex.hpp>
diff --git a/doc/html/boost_regex/ref/regex_traits.html b/doc/html/boost_regex/ref/regex_traits.html
index e596eb28..f7c9d503 100644
--- a/doc/html/boost_regex/ref/regex_traits.html
+++ b/doc/html/boost_regex/ref/regex_traits.html
@@ -3,7 +3,7 @@
 
 regex_traits
 
-
+
 
 
 
@@ -24,10 +24,9 @@
 
    
 
    
 
    
-
    -namespace boost{
+
    namespace boost{
 
 template <class charT, class implementationT = sensible_default_choice>
 struct regex_traits : public implementationT
@@ -47,8 +46,8 @@
 } // namespace boost
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
         The class regex_traits is
@@ -87,7 +86,7 @@
         
 
    
 
    
-        All these traits classes fulfil the traits
+        All these traits classes fulfil the traits
         class requirements.
       
    
 
diff --git a/doc/html/boost_regex/ref/sub_match.html b/doc/html/boost_regex/ref/sub_match.html
index 5949de64..90af7ec8 100644
--- a/doc/html/boost_regex/ref/sub_match.html
+++ b/doc/html/boost_regex/ref/sub_match.html
@@ -3,7 +3,7 @@
 
 sub_match
 
-
+
 
 
 
@@ -24,39 +24,38 @@
 
 
    
 
    
-
    -#include <boost/regex.hpp>
+
    #include <boost/regex.hpp>
 
    
 
    
         Regular expressions are different from many simple pattern-matching algorithms
         in that as well as finding an overall match they can also produce sub-expression
         matches: each sub-expression being delimited in the pattern by a pair of
         parenthesis (...). There has to be some method for reporting sub-expression
-        matches back to the user: this is achieved this by defining a class match_results
+        matches back to the user: this is achieved this by defining a class match_results
         that acts as an indexed collection of sub-expression matches, each sub-expression
-        match being contained in an object of type sub_match.
+        match being contained in an object of type sub_match.
       
    
 
    
-        Objects of type sub_match
-        may only be obtained by subscripting an object of type match_results.
+        Objects of type sub_match
+        may only be obtained by subscripting an object of type match_results.
       
    
 
    
-        Objects of type sub_match
+        Objects of type sub_match
         may be compared to objects of type std::basic_string,
         or const charT* or const
         charT.
       
    
 
    
-        Objects of type sub_match
+        Objects of type sub_match
         may be added to objects of type std::basic_string,
         or const charT* or const
         charT, to produce a new std::basic_string
         object.
       
    
 
    
-        When the marked sub-expression denoted by an object of type sub_match participated in a regular
+        When the marked sub-expression denoted by an object of type sub_match participated in a regular
         expression match then member matched evaluates to true,
         and members first and second denote
         the range of characters [first,second) which formed that match. Otherwise
@@ -65,25 +64,24 @@
         values.
       
    
 
    
-        When the marked sub-expression denoted by an object of type sub_match was repeated, then the
-        sub_match
+        When the marked sub-expression denoted by an object of type sub_match was repeated, then the
+        sub_match
         object represents the match obtained by the last repeat.
         The complete set of all the captures obtained for all the repeats, may be
         accessed via the captures() member function (Note: this has serious performance
         implications, you have to explicitly enable this feature).
       
    
 
    
-        If an object of type sub_match represents sub-expression
+        If an object of type sub_match represents sub-expression
         0 - that is to say the whole match - then member matched
-        is always true, unless a partial
+        is always true, unless a partial
         match was obtained as a result of the flag match_partial
         being passed to a regular expression algorithm, in which case member matched
         is false, and members first and
         second represent the character range that formed the
         partial match.
       
    
-
    -namespace boost{
+
    namespace boost{
 
 template <class BidirectionalIterator>
 class sub_match;
@@ -97,44 +95,44 @@
 class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator>
 {
 public:
-   typedef typename iterator_traits<BidirectionalIterator>::value_type       value_type;
-   typedef typename iterator_traits<BidirectionalIterator>::difference_type  difference_type;
-   typedef          BidirectionalIterator                                    iterator;
+   typedef typename iterator_traits<BidirectionalIterator>::value_type       value_type;
+   typedef typename iterator_traits<BidirectionalIterator>::difference_type  difference_type;
+   typedef          BidirectionalIterator                                    iterator;
 
-   bool matched;
+   bool matched;
 
-   difference_type length()const;
-   operator basic_string<value_type>()const;
-   basic_string<value_type> str()const;
+   difference_type length()const;
+   operator basic_string<value_type>()const;
+   basic_string<value_type> str()const;
 
-   int compare(const sub_match& s)const;
-   int compare(const basic_string<value_type>& s)const;
-   int compare(const value_type* s)const;
+   int compare(const sub_match& s)const;
+   int compare(const basic_string<value_type>& s)const;
+   int compare(const value_type* s)const;
 #ifdef BOOST_REGEX_MATCH_EXTRA
-   typedef implementation-private capture_sequence_type;
-   const capture_sequence_type& captures()const;
+   typedef implementation-private capture_sequence_type;
+   const capture_sequence_type& captures()const;
 #endif
 };
 //
 // comparisons to another sub_match:
 //
 template <class BidirectionalIterator>
-bool operator == (const sub_match<BidirectionalIterator>& lhs,
+bool operator == (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 template <class BidirectionalIterator>
-bool operator != (const sub_match<BidirectionalIterator>& lhs,
+bool operator != (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 template <class BidirectionalIterator>
-bool operator < (const sub_match<BidirectionalIterator>& lhs,
+bool operator < (const sub_match<BidirectionalIterator>& lhs,
                const sub_match<BidirectionalIterator>& rhs);
 template <class BidirectionalIterator>
-bool operator <= (const sub_match<BidirectionalIterator>& lhs,
+bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 template <class BidirectionalIterator>
-bool operator >= (const sub_match<BidirectionalIterator>& lhs,
+bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 template <class BidirectionalIterator>
-bool operator > (const sub_match<BidirectionalIterator>& lhs,
+bool operator > (const sub_match<BidirectionalIterator>& lhs,
                const sub_match<BidirectionalIterator>& rhs);
 
 
@@ -142,63 +140,63 @@
 // comparisons to a basic_string:
 //
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator == (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 operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator != (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 operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator < (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 operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator > (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 operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator >= (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 operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
+bool operator <= (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 operator == (const sub_match<BidirectionalIterator>& lhs,
+bool operator == (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
                                           Allocator>& rhs);
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator != (const sub_match<BidirectionalIterator>& lhs,
+bool operator != (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
                                           Allocator>& rhs);
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator < (const sub_match<BidirectionalIterator>& lhs,
+bool operator < (const sub_match<BidirectionalIterator>& lhs,
                const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                        traits, 
                                        Allocator>& rhs);
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator > (const sub_match<BidirectionalIterator>& lhs,
+bool operator > (const sub_match<BidirectionalIterator>& lhs,
                const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                        traits, 
                                        Allocator>& rhs);
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator >= (const sub_match<BidirectionalIterator>& lhs,
+bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                        traits, 
                                        Allocator>& rhs);
 template <class BidirectionalIterator, class traits, class Allocator> 
-bool operator <= (const sub_match<BidirectionalIterator>& lhs,
+bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
                                           Allocator>& rhs);
@@ -207,117 +205,117 @@
 // comparisons to a pointer to a character array:
 //
 template <class BidirectionalIterator> 
-bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
+bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
 template <class BidirectionalIterator> 
-bool operator == (const sub_match<BidirectionalIterator>& lhs, 
+bool operator == (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 template <class BidirectionalIterator> 
-bool operator != (const sub_match<BidirectionalIterator>& lhs, 
+bool operator != (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 template <class BidirectionalIterator> 
-bool operator < (const sub_match<BidirectionalIterator>& lhs, 
+bool operator < (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 template <class BidirectionalIterator> 
-bool operator > (const sub_match<BidirectionalIterator>& lhs, 
+bool operator > (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 template <class BidirectionalIterator> 
-bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
+bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 template <class BidirectionalIterator> 
-bool operator <= (const sub_match<BidirectionalIterator>& lhs, 
+bool operator <= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
 //
 // comparisons to a single character:
 //
 template <class BidirectionalIterator> 
-bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 template <class BidirectionalIterator> 
-bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
+bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
 template <class BidirectionalIterator> 
-bool operator == (const sub_match<BidirectionalIterator>& lhs, 
+bool operator == (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 template <class BidirectionalIterator> 
-bool operator != (const sub_match<BidirectionalIterator>& lhs, 
+bool operator != (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 template <class BidirectionalIterator> 
-bool operator < (const sub_match<BidirectionalIterator>& lhs, 
+bool operator < (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 template <class BidirectionalIterator> 
-bool operator > (const sub_match<BidirectionalIterator>& lhs, 
+bool operator > (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 template <class BidirectionalIterator> 
-bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
+bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 template <class BidirectionalIterator> 
-bool operator <= (const sub_match<BidirectionalIterator>& lhs, 
+bool operator <= (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> 
-   operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, 
+   operator + (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>
-   operator + (const sub_match<BidirectionalIterator>& m, 
+   operator + (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> 
-   operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s, 
+   operator + (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> 
-   operator + (const sub_match<BidirectionalIterator>& m, 
+   operator + (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> 
-   operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s, 
+   operator + (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> 
-   operator + (const sub_match<BidirectionalIterator>& m, 
+   operator + (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> 
-   operator + (const sub_match<BidirectionalIterator>& m1,
+   operator + (const sub_match<BidirectionalIterator>& m1,
                const sub_match<BidirectionalIterator>& m2);
 
 //
@@ -325,63 +323,57 @@
 //
 template <class charT, class traits, class BidirectionalIterator>
 basic_ostream<charT, traits>&
-   operator << (basic_ostream<charT, traits>& os,
+   operator << (basic_ostream<charT, traits>& os,
                const sub_match<BidirectionalIterator>& m);
 
 } // namespace boost
 
    
 
    
-
-        Description
+
+        Description
       
    
 
    
-
-        Members
+
+        Members
       
    
 
    
       
    
-
    -typedef typename std::iterator_traits<iterator>::value_type value_type;
+
    typedef typename std::iterator_traits<iterator>::value_type value_type;
 
    
 
    
         The type pointed to by the iterators.
       
    
 
    
       
    
-
    -typedef typename std::iterator_traits<iterator>::difference_type difference_type;
+
    typedef typename std::iterator_traits<iterator>::difference_type difference_type;
 
    
 
    
         A type that represents the difference between two iterators.
       
    
 
    
       
    
-
    -typedef BidirectionalIterator iterator;
+
    typedef BidirectionalIterator iterator;
 
    
 
    
         The iterator type.
       
    
 
    
       
    
-
    -iterator first
+
    iterator first
 
    
 
    
         An iterator denoting the position of the start of the match.
       
    
 
    
       
    
-
    -iterator second
+
    iterator second
 
    
 
    
         An iterator denoting the position of the end of the match.
       
    
 
    
       
    
-
    -bool matched
+
    bool matched
 
    
 
    
         A Boolean value denoting whether this sub-expression participated in the
@@ -389,8 +381,7 @@
       
    
 
    
       
    
-
    -static difference_type length();
+
    static difference_type length();
 
    
 
    
         Effects: returns the length of this matched
@@ -398,16 +389,14 @@
       
    
 
    
       
    
-
    -operator basic_string<value_type>()const;
+
    operator basic_string<value_type>()const;
 
    
 
    
         Effects: converts *this into a string: returns (matched ? basic_string<value_type>(first, second) : basic_string<value_type>()).
       
    
 
    
       
    
-
    -basic_string<value_type> str()const;
+
    basic_string<value_type> str()const;
 
    
 
    
         Effects: returns a string representation
@@ -417,8 +406,7 @@
       
    
 
    
       
    
-
    -int compare(const sub_match& s)const;
+
    int compare(const sub_match& s)const;
 
    
 
    
         Effects: performs a lexical comparison to
@@ -426,8 +414,7 @@
       
    
 
    
       
    
-
    -int compare(const basic_string<value_type>& s)const;
+
    int compare(const basic_string<value_type>& s)const;
 
    
 
    
         Effects: compares *this to the string s:
@@ -435,8 +422,7 @@
       
    
 
    
       
    
-
    -int compare(const value_type* s)const;
+
    int compare(const value_type* s)const;
 
    
 
    
         Effects: compares *this to the null-terminated string s:
@@ -444,8 +430,7 @@
       
    
 
    
       
    
-
    -typedef implementation-private capture_sequence_type;
+
    typedef implementation-private capture_sequence_type;
 
    
 
    
         Defines an implementation-specific type that satisfies the requirements of
@@ -455,8 +440,7 @@
       
    
 
    
       
    
-
    -const capture_sequence_type& captures()const; 
+
    const capture_sequence_type& captures()const; 
 
    
 
    
         Effects: returns a sequence containing all
@@ -466,7 +450,7 @@
         Preconditions: the library must be built
         and used with BOOST_REGEX_MATCH_EXTRA defined, and you must pass the flag
         match_extra to the regex
-        matching functions ( regex_match, regex_search, regex_iterator or regex_token_iterator) in order for
+        matching functions ( regex_match, regex_search, regex_iterator or regex_token_iterator) in order for
         this member #function to be defined and return useful information.
       
    
 
    
@@ -489,14 +473,13 @@
         
 
    
 
    
-
-        sub_match
+
+        sub_match
         non-member operators
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator == (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -506,8 +489,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator != (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -517,8 +499,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator < (const sub_match<BidirectionalIterator>& lhs,
                const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -528,8 +509,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -539,8 +519,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                   const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -550,8 +529,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator>
+
    template <class BidirectionalIterator>
 bool operator > (const sub_match<BidirectionalIterator>& lhs,
                const sub_match<BidirectionalIterator>& rhs);
 
    
@@ -561,8 +539,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                                           traits,
                                                           Allocator>& lhs, 
@@ -574,8 +551,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                                           traits, 
                                                           Allocator>& lhs,
@@ -587,8 +563,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                          traits, 
                                          Allocator>& lhs,
@@ -600,8 +575,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                                          traits, 
                                                          Allocator>& lhs,
@@ -613,8 +587,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
                                           Allocator>& lhs,
@@ -626,8 +599,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
                                           Allocator>& lhs,
@@ -639,8 +611,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator == (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
@@ -652,8 +623,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator != (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
@@ -665,8 +635,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator < (const sub_match<BidirectionalIterator>& lhs,
                const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                        traits, 
@@ -678,8 +647,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator > (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                          traits, 
@@ -691,8 +659,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
@@ -704,8 +671,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator, class traits, class Allocator> 
+
    template <class BidirectionalIterator, class traits, class Allocator> 
 bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                   const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, 
                                           traits, 
@@ -717,8 +683,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -728,8 +693,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -739,8 +703,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -750,8 +713,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -761,8 +723,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -772,8 +733,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -783,8 +743,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator == (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -794,8 +753,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator != (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -805,8 +763,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator < (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -816,8 +773,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator > (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -827,8 +783,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -838,8 +793,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator <= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const* rhs); 
 
    
@@ -849,8 +803,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -860,8 +813,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -871,8 +823,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -882,8 +833,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -893,8 +843,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -904,8 +853,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, 
                   const sub_match<BidirectionalIterator>& rhs); 
 
    
@@ -915,8 +863,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator == (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -926,8 +873,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator != (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -937,8 +883,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator < (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -948,8 +893,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator > (const sub_match<BidirectionalIterator>& lhs, 
                typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -959,8 +903,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator >= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -970,8 +913,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 bool operator <= (const sub_match<BidirectionalIterator>& lhs, 
                   typename iterator_traits<BidirectionalIterator>::value_type const& rhs); 
 
    
@@ -980,14 +922,13 @@
         <= rhs.
       
    
 
    
-        The addition operators for sub_match allow you to add a sub_match
+        The addition operators for sub_match allow you to add a sub_match
         to any type to which you can add a std::string
         and obtain a new string as the result.
       
    
 
    
       
    
-
    -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> 
    operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, 
                                        traits, 
@@ -1000,8 +941,7 @@
       
    
 
    
       
    
-
    -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>
    operator + (const sub_match<BidirectionalIterator>& m, 
                const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, 
@@ -1014,8 +954,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    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); 
@@ -1026,8 +965,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    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);
@@ -1038,8 +976,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    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); 
@@ -1050,8 +987,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    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); 
@@ -1062,8 +998,7 @@
       
    
 
    
       
    
-
    -template <class BidirectionalIterator> 
+
    template <class BidirectionalIterator> 
 std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> 
    operator + (const sub_match<BidirectionalIterator>& m1,
                const sub_match<BidirectionalIterator>& m2);
@@ -1073,13 +1008,12 @@
         + m2.str().
       
    
 
    
-
-        Stream inserter
+
+        Stream inserter
       
    
 
    
       
    
-
    -template <class charT, class traits, class BidirectionalIterator>
+
    template <class charT, class traits, class BidirectionalIterator>
 basic_ostream<charT, traits>&
    operator << (basic_ostream<charT, traits>& os
                const sub_match<BidirectionalIterator>& m);
diff --git a/doc/html/boost_regex/ref/syntax_option_type.html b/doc/html/boost_regex/ref/syntax_option_type.html
index 3d5b6df9..3a855b9f 100644
--- a/doc/html/boost_regex/ref/syntax_option_type.html
+++ b/doc/html/boost_regex/ref/syntax_option_type.html
@@ -3,7 +3,7 @@
 
 syntax_option_type
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_basic.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_basic.html
index 798dbecd..bb375d9c 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_basic.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_basic.html
@@ -3,7 +3,7 @@
 
 Options for POSIX Basic Regular Expressions
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
@@ -69,7 +69,7 @@
 
                 
    
                   Specifies that the grammar recognized by the regular expression
-                  engine is the same as that used by POSIX
+                  engine is the same as that used by POSIX
                   basic regular expressions in IEEE Std 1003.1-2001, Portable
                   Operating System Interface (POSIX ), Base Definitions and Headers,
                   Section 9, Regular Expressions (FWD.1).
@@ -112,7 +112,7 @@
                   Section 4, Utilit\ies, grep (FWD.1).
                 
    
                 
    
-                  That is to say, the same as POSIX
+                  That is to say, the same as POSIX
                   basic syntax, but with the newline character acting as an
                   alternation character; the expression is treated as a newline separated
                   list of alternatives.
@@ -132,7 +132,7 @@
                 
 
                 
    
-                  Specifies that the grammar recognised is the superset of the POSIX-Basic syntax
+                  Specifies that the grammar recognised is the superset of the POSIX-Basic syntax
                   used by the emacs program.
                 
    
                 
@@ -199,7 +199,7 @@
                 
    
                   Specifies that when a regular expression is matched against a character
                   container sequence, then no sub-expression matches are to be stored
-                  in the supplied match_results structure.
+                  in the supplied match_results structure.
                 
    
                 
 
@@ -238,7 +238,7 @@
 
                 
    
                   Specifies that character ranges of the form [a-b]
-                  should be locale sensitive. This bit is on by default for POSIX-Basic regular expressions,
+                  should be locale sensitive. This bit is on by default for POSIX-Basic regular expressions,
                   but can be unset to force ranges to be compared by code point only.
                 
    
                 
@@ -295,7 +295,7 @@
                 
    
                   When set this makes the escape character ordinary inside lists,
                   so that [\b] would match either '\' or 'b'.
-                  This bit is on by default for POSIX-basic
+                  This bit is on by default for POSIX-basic
                   regular expressions, but can be unset to force escapes to
                   be recognised inside lists.
                 
    
@@ -368,7 +368,7 @@
                 
 
                 
    
-                  Prevents basic_regex from throwing
+                  Prevents basic_regex from throwing
                   an exception when an invalid expression is encountered.
                 
    
                 
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_extended.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_extended.html
index e6a89108..127a40b8 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_extended.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_extended.html
@@ -3,7 +3,7 @@
 
 Options for POSIX Extended Regular Expressions
 
-
+
 
 
 
@@ -24,11 +24,11 @@
 
    
 
    
 
    
 
    
-          Exactly one of the following must always be set for POSIX
+          Exactly one of the following must always be set for POSIX
           extended regular expressions:
         
    
 
    
@@ -75,7 +75,7 @@
                   (FWD.1).
                 
    
-                  Refer to the POSIX
+                  Refer to the POSIX
                   extended regular expression guide for more information.
                 
    
@@ -106,7 +106,7 @@
                   grep (FWD.1).
                 
    
-                  That is to say, the same as POSIX
+                  That is to say, the same as POSIX
                   extended syntax, but with the newline character acting as
                   an alternation character in addition to "|".
                 
    
@@ -131,7 +131,7 @@
                   and Utilities, Section 4, awk (FWD.1).
                 
    
-                  That is to say: the same as POSIX
+                  That is to say: the same as POSIX
                   extended syntax, but with escape sequences in character
                   classes permitted.
                 
    
@@ -207,7 +207,7 @@
                 
    
                   Specifies that when a regular expression is matched against a character
                   container sequence, then no sub-expression matches are to be stored
-                  in the supplied match_results structure.
+                  in the supplied match_results structure.
                 
    
@@ -323,7 +323,7 @@
                 
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_literal.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_literal.html
index 0607fa98..5ef09b83 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_literal.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_literal.html
@@ -3,7 +3,7 @@
 Options for Literal Strings
-
+
@@ -24,7 +24,7 @@
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_overview.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_overview.html
index b8614c51..1ce0acd9 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_overview.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_overview.html
@@ -3,7 +3,7 @@
 
 Overview of syntax_option_type
 
-
+
 
 
 
@@ -24,13 +24,13 @@
 
    
 
    
 
    
-          The type syntax_option_type is an implementation
+          The type syntax_option_type is an implementation
           specific bitmask type (see C++ standard 17.3.2.1.2). Setting its elements
-          has the effects listed in the table below, a valid value of type syntax_option_type
+          has the effects listed in the table below, a valid value of type syntax_option_type
           will always have exactly one of the elements normal,
           basic, extended,
           awk, grep,
@@ -39,23 +39,20 @@
         
    
 
    
           Note that for convenience all the constants listed here are duplicated
-          within the scope of class template basic_regex, so you can use any
+          within the scope of class template basic_regex, so you can use any
           of:
         
    
-
    -boost::regex_constants::constant_name
+
    boost::regex_constants::constant_name
 
    
 
    
           or
         
    
-
    -boost::regex::constant_name
+
    boost::regex::constant_name
 
    
 
    
           or
         
    
-
    -boost::wregex::constant_name
+
    boost::wregex::constant_name
 
    
 
    
           in an interchangeable manner.
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_perl.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_perl.html
index f60f42a2..64365cc8 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_perl.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_perl.html
@@ -3,7 +3,7 @@
 
 Options for Perl Regular Expressions
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
@@ -73,7 +73,7 @@
                   part 10, RegExp (Regular Expression) Objects (FWD.1).
                 
    
                 
    
-                  This is functionally identical to the Perl
+                  This is functionally identical to the Perl
                   regular expression syntax.
                 
    
                 
    
@@ -211,7 +211,7 @@
                 
    
                   Specifies that when a regular expression is matched against a character
                   container sequence, then no sub-expression matches are to be stored
-                  in the supplied match_results structure.
+                  in the supplied match_results structure.
                 
    
                 
 
    
@@ -286,7 +286,7 @@
                 
diff --git a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_synopsis.html b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_synopsis.html
index d8a8a2c4..fed4fdff 100644
--- a/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_synopsis.html
+++ b/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_synopsis.html
@@ -3,7 +3,7 @@
 syntax_option_type Synopsis
-
+
@@ -24,18 +24,17 @@
 
    
 
    
 
    
-          Type syntax_option_type
+          Type syntax_option_type
           is an implementation specific bitmask type that controls how a regular
           expression string is to be interpreted. For convenience note that all the
           constants listed here, are also duplicated within the scope of class template
-          basic_regex.
+          basic_regex.
         
    
-
    -namespace std{ namespace regex_constants{
+
    namespace std{ namespace regex_constants{
 
 typedef implementation-specific-bitmask-type syntax_option_type;
 
diff --git a/doc/html/boost_regex/syntax.html b/doc/html/boost_regex/syntax.html
index 99daf34c..20b9a184 100644
--- a/doc/html/boost_regex/syntax.html
+++ b/doc/html/boost_regex/syntax.html
@@ -3,7 +3,7 @@
 
 Regular Expression Syntax
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
     Perl Regular Expression
@@ -63,15 +63,15 @@
     
    
 
    
diff --git a/doc/html/boost_regex/syntax/basic_extended.html b/doc/html/boost_regex/syntax/basic_extended.html
index 42591dd0..ab953647 100644
--- a/doc/html/boost_regex/syntax/basic_extended.html
+++ b/doc/html/boost_regex/syntax/basic_extended.html
@@ -3,7 +3,7 @@
 
 POSIX Extended Regular Expression Syntax
 
-
+
 
 
 
@@ -24,12 +24,12 @@
 
    
 
    
 
    
 
    
-
-        Synopsis
+
+        Synopsis
       
    
 
    
         The POSIX-Extended regular expression syntax is supported by the POSIX C
@@ -38,8 +38,7 @@
         the flag extended to the
         regex constructor, for example:
       
    
-
    -// e1 is a case sensitive POSIX-Extended expression:
+
    // e1 is a case sensitive POSIX-Extended expression:
 boost::regex e1(my_expression, boost::regex::extended);
 // e2 a case insensitive POSIX-Extended expression:
 boost::regex e2(my_expression, boost::regex::extended|boost::regex::icase);
@@ -47,8 +46,8 @@
 
    
       
    
 
    
-
-        POSIX
+
+        POSIX
         Extended Syntax
       
    
 
    
@@ -57,8 +56,8 @@
       
    
 
    .[{()\*+?|^$
    
 
    
-
-        Wildcard:
+
+        Wildcard:
       
    
 
    
         The single character '.' when used outside of a character set will match
@@ -75,8 +74,8 @@
         
 
    
 
    
-
-        Anchors:
+
+        Anchors:
       
    
 
    
         A '^' character shall match the start of a line when used as the first character
@@ -87,8 +86,8 @@
         of an expression, or the last character of a sub-expression.
       
    
 
    
-
-        Marked
+
+        Marked
         sub-expressions:
       
    
 
    
@@ -99,8 +98,8 @@
         to by a back-reference.
       
    
 
    
-
-        Repeats:
+
+        Repeats:
       
    
 
    
         Any atom (a single character, a marked sub-expression, or a character class)
@@ -165,31 +164,28 @@ cab
 
    
         Will match either of:
       
    
-
    -aa
+
    aa
 aaa
 
    
 
    
         But neither of:
       
    
-
    -a
+
    a
 aaaa
 
    
 
    
         It is an error to use a repeat operator, if the preceding construct can not
         be repeated, for example:
       
    
-
    -a(*)
+
    a(*)
 
    
 
    
         Will raise an error, as there is nothing for the *
         operator to be applied to.
       
    
 
    
-
-        Back references:
+
+        Back references:
       
    
 
    
         An escape character followed by a digit n, where n
@@ -200,14 +196,12 @@ cab
 
    
         Will match the string:
       
    
-
    -aaabbaaa
+
    aaabbaaa
 
    
 
    
         But not the string:
       
    
-
    -aaabba
+
    aaabba
 
    
 
    
                 
                 
                 
                 
                 
 
 
    
                 
    
-                  Prevents basic_regex from throwing
+                  Prevents basic_regex from throwing
                   an exception when an invalid expression is encountered.
                 
    
                     		
 
 
 
 
 
 
 
 
    
 
    
                 
    
-                  Prevents basic_regex from throwing
+                  Prevents basic_regex from throwing
                   an exception when an invalid expression is encountered.
                 
    
                     		
 
 
 
 
 
 
 
    
@@ -220,8 +214,8 @@ cab
         
    
 
    
 
    
 
    
-
-        Alternation
+
+        Alternation
       
    
 
    
         The | operator will match either
@@ -233,8 +227,8 @@ cab
         will match either of "abd" or "abef".
       
    
 
    
-
-        Character
+
+        Character
         sets:
       
    
 
    
@@ -246,8 +240,8 @@ cab
         A bracket expression may contain any combination of the following:
       
    
 
    
-
-        Single
+
+        Single
         characters:
       
    
 
    
@@ -255,8 +249,8 @@ cab
         or 'c'.
       
    
 
    
-
-        Character
+
+        Character
         ranges:
       
    
 
    
@@ -266,13 +260,13 @@ cab
         within the range y to z, if it
         collates within that range; this results in locale specific behavior . This
         behavior can be turned off by unsetting the collate
-        option flag - in
+        option flag - in
         which case whether a character appears within a range is determined by comparing
         the code points of the characters only.
       
    
 
    
-
-        Negation:
+
+        Negation:
       
    
 
    
         If the bracket-expression begins with the ^ character, then it matches the
@@ -280,18 +274,18 @@ cab
         range a-c.
       
    
 
    
-
-        Character
+
+        Character
         classes:
       
    
 
    
         An expression of the form [[:name:]]
         matches the named character class "name", for example [[:lower:]] matches any lower case character. See
-        character class names.
+        character class names.
       
    
 
    
-
-        Collating
+
+        Collating
         Elements:
       
    
 
    
@@ -310,24 +304,23 @@ cab
         match either one of the characters 'abc^'.
       
    
 
    
-        As an extension, a collating element may also be specified via its symbolic name, for example:
+        As an extension, a collating element may also be specified via its symbolic name, for example:
       
    
-
    -[[.NUL.]]
+
    [[.NUL.]]
 
    
 
    
         matches a NUL character.
       
    
 
    
-
-        Equivalence
+
+        Equivalence
         classes:
       
    
 
    
         An expression of the form [[=col=]],
         matches any character or collating element whose primary sort key is the
         same as that for collating element col, as with colating
-        elements the name col may be a symbolic
+        elements the name col may be a symbolic
         name. A primary sort key is one that ignores case, accentation, or
         locale-specific tailorings; so for example [[=a=]] matches
         any of the characters: a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å. Unfortunately implementation
@@ -336,16 +329,16 @@ cab
         or even all locales on one platform.
       
    
 
    
-
-        Combinations:
+
+        Combinations:
       
    
 
    
         All of the above can be combined in one character set declaration, for example:
         [[:digit:]a-c[.NUL.]].
       
    
 
    
-
-        Escapes
+
+        Escapes
       
    
 
    
         The POSIX standard defines no escape sequences for POSIX-Extended regular
@@ -370,8 +363,8 @@ cab
         extensions are also supported by Boost.Regex:
       
    
 
    
-
-        Escapes
+
+        Escapes
         matching a specific character
       
    
 
    
@@ -559,8 +552,8 @@ cab
 
 
    
 
    
-
-        "Single
+
+        "Single
         character" character classes:
       
    
 
    
@@ -713,8 +706,8 @@ cab
 
 
    
 
    
-
-        Character
+
+        Character
         Properties
       
    
 
    
@@ -820,8 +813,8 @@ cab
         matches any "digit" character, as does \p{digit}.
       
    
 
    
-
-        Word Boundaries
+
+        Word Boundaries
       
    
 
    
         The following escape sequences match the boundaries of words:
@@ -895,8 +888,8 @@ cab
 
 
 
    
-
-        Buffer
+
+        Buffer
         boundaries
       
    
 
    
@@ -986,8 +979,8 @@ cab
 
 
 
    
-
-        Continuation
+
+        Continuation
         Escape
       
    
 
    
@@ -998,8 +991,8 @@ cab
         match to start where the last one ended.
       
    
 
    
-
-        Quoting
+
+        Quoting
         escape
       
    
 
    
@@ -1008,13 +1001,12 @@ cab
         as literals, until either the end of the regular expression or \E is found.
         For example the expression: \Q\*+\Ea+ would match either of:
       
    
-
    -\*+a
+
    \*+a
 \*+aaa
 
    
 
    
-
-        Unicode
+
+        Unicode
         escapes
       
    
 
    
@@ -1064,8 +1056,8 @@ cab
 
    
 
    
 
    
-
-        Any other
+
+        Any other
         escape
       
    
 
    
@@ -1073,8 +1065,8 @@ cab
         \@ matches a literal '@'.
       
    
 
    
-
-        Operator
+
+        Operator
         precedence
       
    
 
    
@@ -1109,32 +1101,31 @@ cab
 
 
 
    
-
-        What
+
+        What
         Gets Matched
       
    
 
    
         When there is more that one way to match a regular expression, the "best"
-        possible match is obtained using the leftmost-longest
+        possible match is obtained using the leftmost-longest
         rule.
       
    
 
    
-
-        Variations
+
+        Variations
       
    
 
    
-
-        Egrep
+
+        Egrep
       
    
 
    
-        When an expression is compiled with the flag
+        When an expression is compiled with the flag
         egrep set, then the
-        expression is treated as a newline separated list of POSIX-Extended
+        expression is treated as a newline separated list of POSIX-Extended
         expressions, a match is found if any of the expressions in the list
         match, for example:
       
    
-
    -boost::regex e("abc\ndef", boost::regex::egrep);
+
    boost::regex e("abc\ndef", boost::regex::egrep);
 
    
 
    
         will match either of the POSIX-Basic expressions "abc" or "def".
@@ -1145,11 +1136,11 @@ cab
         used with the -E option.
       
    
 
    
-
-        awk
+
+        awk
       
    
 
    
-        In addition to the POSIX-Extended
+        In addition to the POSIX-Extended
         features the escape character is special inside a character class
         declaration.
       
    
@@ -1159,21 +1150,21 @@ cab
         these by default anyway.
       
    
 
    
-
-        Options
+
+        Options
       
    
 
    
-        There are a variety
+        There are a variety
         of flags that may be combined with the extended
         and egrep options when constructing
-        the regular expression, in particular note that the newline_alt option alters the syntax,
-        while the collate, nosubs
+        the regular expression, in particular note that the newline_alt option alters the syntax,
+        while the collate, nosubs
         and icase options
         modify how the case and locale sensitivity are to be applied.
       
    
 
    
-
-        References
+
+        References
       
    
 
    
         IEEE
diff --git a/doc/html/boost_regex/syntax/basic_syntax.html b/doc/html/boost_regex/syntax/basic_syntax.html
index ca53a066..934a8838 100644
--- a/doc/html/boost_regex/syntax/basic_syntax.html
+++ b/doc/html/boost_regex/syntax/basic_syntax.html
@@ -3,7 +3,7 @@
 
 POSIX Basic Regular Expression Syntax
 
-
+
 
 
 
@@ -24,21 +24,20 @@
 
 
    
 
    
 
    
-
-        Synopsis
+
+        Synopsis
       
    
 
    
         The POSIX-Basic regular expression syntax is used by the Unix utility sed, and variations are used by grep and emacs.
         You can construct POSIX basic regular expressions in Boost.Regex by passing
         the flag basic to the regex
-        constructor (see syntax_option_type), for example:
+        constructor (see syntax_option_type), for example:
       
    
-
    -// e1 is a case sensitive POSIX-Basic expression:
+
    // e1 is a case sensitive POSIX-Basic expression:
 boost::regex e1(my_expression, boost::regex::basic);
 // e2 a case insensitive POSIX-Basic expression:
 boost::regex e2(my_expression, boost::regex::basic|boost::regex::icase);
@@ -46,8 +45,8 @@
 
    
       
    
 
    
-
-        POSIX
+
+        POSIX
         Basic Syntax
       
    
 
    
@@ -56,8 +55,8 @@
       
    
 
    .[\*^$
    
 
    
-
-        Wildcard:
+
+        Wildcard:
       
    
 
    
         The single character '.' when used outside of a character set will match
@@ -74,8 +73,8 @@
         
 
    
 
    
-
-        Anchors:
+
+        Anchors:
       
    
 
    
         A '^' character shall match the start of a line when used as the first character
@@ -86,8 +85,8 @@
         of an expression, or the last character of a sub-expression.
       
    
 
    
-
-        Marked
+
+        Marked
         sub-expressions:
       
    
 
    
@@ -98,8 +97,8 @@
         by a back-reference.
       
    
 
    
-
-        Repeats:
+
+        Repeats:
       
    
 
    
         Any atom (a single character, a marked sub-expression, or a character class)
@@ -156,8 +155,8 @@ aaaa
         to.
       
    
 
    
-
-        Back references:
+
+        Back references:
       
    
 
    
         An escape character followed by a digit n, where n
@@ -174,8 +173,8 @@ aaaa
       
    
 
    aaabba
    
 
    
-
-        Character
+
+        Character
         sets:
       
    
 
    
@@ -187,8 +186,8 @@ aaaa
         A bracket expression may contain any combination of the following:
       
    
 
    
-
-        Single
+
+        Single
         characters:
       
    
 
    
@@ -196,8 +195,8 @@ aaaa
         or 'c'.
       
    
 
    
-
-        Character
+
+        Character
         ranges:
       
    
 
    
@@ -212,8 +211,8 @@ aaaa
         of the characters only.
       
    
 
    
-
-        Negation:
+
+        Negation:
       
    
 
    
         If the bracket-expression begins with the ^ character, then it matches the
@@ -221,18 +220,18 @@ aaaa
         range a-c.
       
    
 
    
-
-        Character
+
+        Character
         classes:
       
    
 
    
         An expression of the form [[:name:]]
         matches the named character class "name", for example [[:lower:]] matches any lower case character. See
-        character class names.
+        character class names.
       
    
 
    
-
-        Collating
+
+        Collating
         Elements:
       
    
 
    
@@ -256,19 +255,19 @@ aaaa
       
    
 
    [[.NUL.]]
    
 
    
-        matches a 'NUL' character. See collating
+        matches a 'NUL' character. See collating
         element names.
       
    
 
    
-
-        Equivalence
+
+        Equivalence
         classes:
       
    
 
    
         An expression of theform [[=col=]],
         matches any character or collating element whose primary sort key is the
         same as that for collating element col, as with collating
-        elements the name col may be a collating
+        elements the name col may be a collating
         symbolic name. A primary sort key is one that ignores case, accentation,
         or locale-specific tailorings; so for example [[=a=]] matches
         any of the characters: a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å. Unfortunately implementation
@@ -277,16 +276,16 @@ aaaa
         or even all locales on one platform.
       
    
 
    
-
-        Combinations:
+
+        Combinations:
       
    
 
    
         All of the above can be combined in one character set declaration, for example:
         [[:digit:]a-c[.NUL.]].
       
    
 
    
-
-        Escapes
+
+        Escapes
       
    
 
    
         With the exception of the escape sequences \{, \}, \(, and \), which are
@@ -300,46 +299,45 @@ aaaa
         will match either a literal '\' or a '^'.
       
    
 
    
-
-        What Gets
+
+        What Gets
         Matched
       
    
 
    
         When there is more that one way to match a regular expression, the "best"
-        possible match is obtained using the leftmost-longest
+        possible match is obtained using the leftmost-longest
         rule.
       
    
 
    
-
-        Variations
+
+        Variations
       
    
 
    
       
    
 
    
-
-        Grep
+
+        Grep
       
    
 
    
         When an expression is compiled with the flag grep
-        set, then the expression is treated as a newline separated list of POSIX-Basic expressions, a match
+        set, then the expression is treated as a newline separated list of POSIX-Basic expressions, a match
         is found if any of the expressions in the list match, for example:
       
    
-
    -boost::regex e("abc\ndef", boost::regex::grep);
+
    boost::regex e("abc\ndef", boost::regex::grep);
 
    
 
    
-        will match either of the POSIX-Basic
+        will match either of the POSIX-Basic
         expressions "abc" or "def".
       
    
 
    
         As its name suggests, this behavior is consistent with the Unix utility grep.
       
    
 
    
-
-        emacs
+
+        emacs
       
    
 
    
-        In addition to the POSIX-Basic features
+        In addition to the POSIX-Basic features
         the following characters are also special:
       
    
 
    
@@ -608,29 +606,29 @@ aaaa
 
    
 
    
         Finally, you should note that emacs style regular expressions are matched
-        according to the Perl
+        according to the Perl
         "depth first search" rules. Emacs expressions are matched
         this way because they contain Perl-like extensions, that do not interact
-        well with the POSIX-style
+        well with the POSIX-style
         leftmost-longest rule.
       
    
 
    
-
-        Options
+
+        Options
       
    
 
    
-        There are a variety
+        There are a variety
         of flags that may be combined with the basic
         and grep options when constructing
-        the regular expression, in particular note that the newline_alt, no_char_classes,
+        the regular expression, in particular note that the newline_alt, no_char_classes,
         no-intervals, bk_plus_qm
         and bk_plus_vbar options
-        all alter the syntax, while the collate and icase
+        all alter the syntax, while the collate and icase
         options modify how the case and locale sensitivity are to be applied.
       
    
 
    
-
-        References
+
+        References
       
    
 
    
         IEEE
diff --git a/doc/html/boost_regex/syntax/character_classes.html b/doc/html/boost_regex/syntax/character_classes.html
index 7fb38f80..f23ea716 100644
--- a/doc/html/boost_regex/syntax/character_classes.html
+++ b/doc/html/boost_regex/syntax/character_classes.html
@@ -3,7 +3,7 @@
 
 Character Class Names
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/syntax/character_classes/optional_char_class_names.html b/doc/html/boost_regex/syntax/character_classes/optional_char_class_names.html
index 5dd89434..e3856bba 100644
--- a/doc/html/boost_regex/syntax/character_classes/optional_char_class_names.html
+++ b/doc/html/boost_regex/syntax/character_classes/optional_char_class_names.html
@@ -3,7 +3,7 @@
 
 Character classes that are supported by Unicode Regular Expressions
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/syntax/character_classes/std_char_clases.html b/doc/html/boost_regex/syntax/character_classes/std_char_clases.html
index 9925611d..302a05d9 100644
--- a/doc/html/boost_regex/syntax/character_classes/std_char_clases.html
+++ b/doc/html/boost_regex/syntax/character_classes/std_char_clases.html
@@ -3,7 +3,7 @@
 
 Character Classes that are Always Supported
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/syntax/collating_names.html b/doc/html/boost_regex/syntax/collating_names.html
index 6a56ab5f..a6997bf4 100644
--- a/doc/html/boost_regex/syntax/collating_names.html
+++ b/doc/html/boost_regex/syntax/collating_names.html
@@ -3,7 +3,7 @@
 
 Collating Names
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
 
     Digraphs
    
diff --git a/doc/html/boost_regex/syntax/collating_names/digraphs.html b/doc/html/boost_regex/syntax/collating_names/digraphs.html
index 2bda9b77..50892354 100644
--- a/doc/html/boost_regex/syntax/collating_names/digraphs.html
+++ b/doc/html/boost_regex/syntax/collating_names/digraphs.html
@@ -3,7 +3,7 @@
 
 Digraphs
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
           The following are treated as valid digraphs when used as a collating name:
diff --git a/doc/html/boost_regex/syntax/collating_names/named_unicode.html b/doc/html/boost_regex/syntax/collating_names/named_unicode.html
index c6c09460..e9c3bc90 100644
--- a/doc/html/boost_regex/syntax/collating_names/named_unicode.html
+++ b/doc/html/boost_regex/syntax/collating_names/named_unicode.html
@@ -3,7 +3,7 @@
 
 Named Unicode Characters
 
-
+
 
 
 
@@ -24,11 +24,11 @@
 
    
 
    
 
    
 
    
-          When using Unicode aware regular expressions
+          When using Unicode aware regular expressions
           (with the u32regex type),
           all the normal symbolic names for Unicode characters (those given in Unidata.txt)
           are recognised. So for example:
diff --git a/doc/html/boost_regex/syntax/collating_names/posix_symbolic_names.html b/doc/html/boost_regex/syntax/collating_names/posix_symbolic_names.html
index 7e06aabc..220c7e81 100644
--- a/doc/html/boost_regex/syntax/collating_names/posix_symbolic_names.html
+++ b/doc/html/boost_regex/syntax/collating_names/posix_symbolic_names.html
@@ -3,7 +3,7 @@
 
 POSIX Symbolic Names
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/syntax/leftmost_longest_rule.html b/doc/html/boost_regex/syntax/leftmost_longest_rule.html
index 0256f1d8..39b8e146 100644
--- a/doc/html/boost_regex/syntax/leftmost_longest_rule.html
+++ b/doc/html/boost_regex/syntax/leftmost_longest_rule.html
@@ -3,7 +3,7 @@
 
 The Leftmost Longest Rule
 
-
+
 
 
 
@@ -24,7 +24,7 @@
 
    
 
    
 
    
 
    
diff --git a/doc/html/boost_regex/syntax/perl_syntax.html b/doc/html/boost_regex/syntax/perl_syntax.html
index 7a279c18..4911c61e 100644
--- a/doc/html/boost_regex/syntax/perl_syntax.html
+++ b/doc/html/boost_regex/syntax/perl_syntax.html
@@ -3,7 +3,7 @@
 
 Perl Regular Expression Syntax
 
-
+
 
 
 
@@ -24,30 +24,29 @@
 
    
 
    
 
    
 
    
-
-        Synopsis
+
+        Synopsis
       
    
 
    
         The Perl regular expression syntax is based on that used by the programming
         language Perl . Perl regular expressions are the default behavior in Boost.Regex
         or you can pass the flag perl
-        to the basic_regex
+        to the basic_regex
         constructor, for example:
       
    
-
    -// e1 is a case sensitive Perl regular expression: 
+
    // e1 is a case sensitive Perl regular expression: 
 // since Perl is the default option there's no need to explicitly specify the syntax used here:
 boost::regex e1(my_expression);
 // e2 a case insensitive Perl regular expression:
 boost::regex e2(my_expression, boost::regex::perl|boost::regex::icase);
 
    
 
    
-
-        Perl
+
+        Perl
         Regular Expression Syntax
       
    
 
    
@@ -56,8 +55,8 @@
       
    
 
    .[{()\*+?|^$
    
 
    
-
-        Wildcard
+
+        Wildcard
       
    
 
    
         The single character '.' when used outside of a character set will match
@@ -65,19 +64,19 @@
       
    
 
    
 
    
-
-        Anchors
+
+        Anchors
       
    
 
    
         A '^' character shall match the start of a line.
@@ -86,8 +85,8 @@
         A '$' character shall match the end of a line.
       
    
 
    
-
-        Marked
+
+        Marked
         sub-expressions
       
    
 
    
@@ -98,8 +97,8 @@
         to by a back-reference.
       
    
 
    
-
-        Non-marking
+
+        Non-marking
         grouping
       
    
 
    
@@ -112,8 +111,8 @@
         out any separate sub-expressions.
       
    
 
    
-
-        Repeats
+
+        Repeats
       
    
 
    
         Any atom (a single character, a marked sub-expression, or a character class)
@@ -126,8 +125,7 @@
         preceding atom zero or more times, for example the expression a*b
         will match any of the following:
       
    
-
    -b
+
    b
 ab
 aaaaaaaab
 
    
@@ -136,30 +134,26 @@
         preceding atom one or more times, for example the expression a+b
         will match any of the following:
       
    
-
    -ab
+
    ab
 aaaaaaaab
 
    
 
    
         But will not match:
       
    
-
    -b
+
    b
 
    
 
    
         The ? operator will match the
         preceding atom zero or one times, for example the expression ca?b will match
         any of the following:
       
    
-
    -cb
+
    cb
 cab
 
    
 
    
         But will not match:
       
    
-
    -caab
+
    caab
 
    
 
    
         An atom can also be repeated with a bounded repeat:
@@ -183,31 +177,28 @@
 
    
         Will match either of:
       
    
-
    -aa
+
    aa
 aaa
 
    
 
    
         But neither of:
       
    
-
    -a
+
    a
 aaaa
 
    
 
    
         It is an error to use a repeat operator, if the preceding construct can not
         be repeated, for example:
       
    
-
    -a(*)
+
    a(*)
 
    
 
    
         Will raise an error, as there is nothing for the *
         operator to be applied to.
       
    
 
    
-
-        Non greedy
+
+        Non greedy
         repeats
       
    
 
    
@@ -237,8 +228,8 @@
         input as possible.
       
    
 
    
-
-        Back references
+
+        Back references
       
    
 
    
         An escape character followed by a digit n, where n
@@ -249,18 +240,16 @@
 
    
         Will match the string:
       
    
-
    -aaabbaaa
+
    aaabbaaa
 
    
 
    
         But not the string:
       
    
-
    -aaabba
+
    aaabba
 
    
 
    
-
-        Alternation
+
+        Alternation
       
    
 
    
         The | operator will match either
@@ -288,8 +277,8 @@
         (?:abc)?? has exactly the same effect.
       
    
 
    
-
-        Character sets
+
+        Character sets
       
    
 
    
         A character set is a bracket-expression starting with [
@@ -301,16 +290,16 @@
         A bracket expression may contain any combination of the following:
       
    
 
    
-
-        Single characters
+
+        Single characters
       
    
 
    
         For example [abc], will match any of the characters 'a', 'b',
         or 'c'.
       
    
 
    
-
-        Character
+
+        Character
         ranges
       
    
 
    
@@ -318,12 +307,12 @@
         will match any single character in the range 'a' to 'c'. By default, for
         Perl regular expressions, a character x is within the range y to z, if the
         code point of the character lies within the codepoints of the endpoints of
-        the range. Alternatively, if you set the collate flag when constructing the
+        the range. Alternatively, if you set the collate flag when constructing the
         regular expression, then ranges are locale sensitive.
       
    
 
    
-
-        Negation
+
+        Negation
       
    
 
    
         If the bracket-expression begins with the ^ character, then it matches the
@@ -331,18 +320,18 @@
         range a-c.
       
    
 
    
-
-        Character
+
+        Character
         classes
       
    
 
    
         An expression of the form [[:name:]]
         matches the named character class "name", for example [[:lower:]] matches any lower case character. See
-        character class names.
+        character class names.
       
    
 
    
-
-        Collating
+
+        Collating
         Elements
       
    
 
    
@@ -356,25 +345,24 @@
         a single collating element in the current locale.
       
    
 
    
-        As an extension, a collating element may also be specified via it's symbolic name, for example:
+        As an extension, a collating element may also be specified via it's symbolic name, for example:
       
    
-
    -[[.NUL.]]
+
    [[.NUL.]]
 
    
 
    
         matches a \0
         character.
       
    
 
    
-
-        Equivalence
+
+        Equivalence
         classes
       
    
 
    
         An expression of the form [[=col=]],
         matches any character or collating element whose primary sort key is the
         same as that for collating element col, as with collating
-        elements the name col may be a symbolic
+        elements the name col may be a symbolic
         name. A primary sort key is one that ignores case, accentation, or
         locale-specific tailorings; so for example [[=a=]] matches
         any of the characters: a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å. Unfortunately implementation
@@ -383,8 +371,8 @@
         or even all locales on one platform.
       
    
 
    
-
-        Escaped
+
+        Escaped
         Characters
       
    
 
    
@@ -395,16 +383,16 @@
         is not a "word" character.
       
    
 
    
-
-        Combinations
+
+        Combinations
       
    
 
    
         All of the above can be combined in one character set declaration, for example:
         [[:digit:]a-c[.NUL.]].
       
    
 
    
-
-        Escapes
+
+        Escapes
       
    
 
    
         Any special character preceded by an escape shall match itself.
@@ -588,7 +576,7 @@
               
 
               
    
-                Matches the single character which has the symbolic
+                Matches the single character which has the symbolic
                 name name. For example \N{newline} matches the single character \n.
               
    
               
@@ -596,8 +584,8 @@
 
 
    
 
    
-
-        "Single
+
+        "Single
         character" character classes:
       
    
 
    
@@ -750,13 +738,13 @@
 
 
    
 
    
-
-        Character
+
+        Character
         Properties
       
    
 
    
         The character property names in the following table are all equivalent to
-        the names used in character
+        the names used in character
         classes.
       
    
 
    
@@ -858,8 +846,8 @@
         matches any "digit" character, as does \p{digit}.
       
    
-
-        Word Boundaries
+
+        Word Boundaries
       
    
         The following escape sequences match the boundaries of words:
@@ -880,8 +868,8 @@
         Matches only when not at a word boundary.
       
    
-
-        Buffer boundaries
+
+        Buffer boundaries
       
    
         The following match only at buffer boundaries: a "buffer" in this
@@ -905,8 +893,8 @@
         to the regular expression \n*\z
       
    
-
-        Continuation
+
+        Continuation
         Escape
       
    
@@ -917,8 +905,8 @@
         match to start where the last one ended.
       
    
-
-        Quoting escape
+
+        Quoting escape
       
    
         The escape sequence \Q
@@ -926,13 +914,12 @@
         as literals, until either the end of the regular expression or \E is found.
         For example the expression: \Q\*+\Ea+ would match either of:
       
    
-
    -\*+a
+
    \*+a
 \*+aaa
 
    
 
    
-
-        Unicode escapes
+
+        Unicode escapes
       
    
 
    
         \C
@@ -942,8 +929,8 @@
         combining characters.
       
    
 
    
-
-        Any other
+
+        Any other
         escape
       
    
 
    
@@ -951,8 +938,8 @@
         \@ matches a literal '@'.
       
    
 
    
-
-        Perl
+
+        Perl
         Extended Patterns
       
    
 
    
@@ -960,8 +947,8 @@
         (?.
       
    
 
    
-
-        Comments
+
+        Comments
       
    
 
    
         (?# ...
@@ -969,8 +956,8 @@
         are ignored.
       
    
 
    
-
-        Modifiers
+
+        Modifiers
       
    
 
    
         (?imsx-imsx ... ) alters
@@ -984,8 +971,8 @@
         applies the specified modifiers to pattern only.
       
    
 
    
-
-        Non-marking
+
+        Non-marking
         groups
       
    
 
    
@@ -993,8 +980,8 @@
         an additional sub-expression.
       
    
 
    
-
-        Lookahead
+
+        Lookahead
       
    
 
    
         (?=pattern) consumes zero characters, only if pattern
@@ -1010,15 +997,14 @@
         letter, a punctuation symbol, and be at least 6 characters long, then the
         expression:
       
    
-
    -(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}
+
    (?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}
 
    
 
    
         could be used to validate the password.
       
    
 
    
-
-        Lookbehind
+
+        Lookbehind
       
    
 
    
         (?<=pattern) consumes zero characters, only if pattern
@@ -1031,8 +1017,8 @@
         (pattern must be of fixed length).
       
    
 
    
-
-        Independent
+
+        Independent
         sub-expressions
       
    
 
    
@@ -1044,8 +1030,8 @@
         no match is found at all.
       
    
 
    
-
-        Conditional
+
+        Conditional
         Expressions
       
    
 
    
@@ -1064,8 +1050,8 @@
         sub-expression has been matched).
       
    
 
    
-
-        Operator
+
+        Operator
         precedence
       
    
 
    
@@ -1100,8 +1086,8 @@
         
 
 
    
-
-        What gets
+
+        What gets
         matched
       
    
 
    
@@ -1113,7 +1099,7 @@
         Alternatively:
       
    
 
    
-        The best match found is the leftmost
+        The best match found is the leftmost
         match, with individual elements matched as follows;
       
    
 
    
 
 
 
 
 
 
 
 
    
@@ -1285,20 +1271,20 @@
 
 
    
 
    
-
-        Variations
+
+        Variations
       
    
 
    
-        The options
+        The options
         normal, ECMAScript,
         JavaScript and JScript are all synonyms for perl.
       
    
 
    
-
-        Options
+
+        Options
       
    
 
    
-        There are a variety
+        There are a variety
         of flags that may be combined with the perl
         option when constructing the regular expression, in particular note that
         the newline_alt option alters
@@ -1307,20 +1293,20 @@
         sensitivity are to be applied.
       
    
 
    
-
-        Pattern
+
+        Pattern
         Modifiers
       
    
 
    
         The perl smix modifiers can
         either be applied using a (?smix-smix) prefix to the regular expression, or with
-        one of the regex-compile
+        one of the regex-compile
         time flags no_mod_m, mod_x, mod_s,
         and no_mod_s.
       
    
 
    
-
-        References
+
+        References
       
    
 
    
         Perl 5.8.
diff --git a/doc/html/boost_regex/unicode.html b/doc/html/boost_regex/unicode.html
index 6f20484d..f01c3510 100644
--- a/doc/html/boost_regex/unicode.html
+++ b/doc/html/boost_regex/unicode.html
@@ -3,7 +3,7 @@
 
 Unicode and Boost.Regex
 
-
+
 
 
 
@@ -24,14 +24,14 @@
 
    
 
    
 
    
 
    
       There are two ways to use Boost.Regex with Unicode strings:
     
    
 
    
-
-      Rely on wchar_t
+
+      Rely on wchar_t
     
    
 
    
       If your platform's wchar_t type
@@ -56,16 +56,16 @@
       
 
    
 
    
-
-      Use
+
+      Use
       a Unicode Aware Regular Expression Type.
     
    
 
    
       If you have the ICU
-      library, then Boost.Regex can be configured
+      library, then Boost.Regex can be configured
       to make use of it, and provide a distinct regular expression type (boost::u32regex),
       that supports both Unicode specific character properties, and the searching
-      of text that is encoded in either UTF-8, UTF-16, or UTF-32. See: ICU
+      of text that is encoded in either UTF-8, UTF-16, or UTF-32. See: ICU
       string class support.
     
    
 
diff --git a/doc/html/index.html b/doc/html/index.html
index 3ce82e03..388dfc44 100644
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -3,7 +3,7 @@
 
 Boost.Regex
 
-
+
 
 
 
@@ -28,7 +28,7 @@
 
 
    Copyright © 1998 -2007 John Maddock
    
 
    
-
    
+
    
         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)
       
    
@@ -196,7 +196,7 @@
   
    
 
    
 
-
+
    Last revised: March 15, 2008 at 14:03:54 GMT
    Last revised: April 11, 2008 at 08:50:33 GMT
    		
 
    		
 
    
 
    
diff --git a/doc/syntax_perl.qbk b/doc/syntax_perl.qbk
index 916ed018..9a76276d 100644
--- a/doc/syntax_perl.qbk
+++ b/doc/syntax_perl.qbk
@@ -34,7 +34,7 @@ The single character '.' when used outside of a character set will match
 any single character except:
 
 * The NULL character when the [link boost_regex.ref.match_flag_type flag 
-   `match_no_dot_null`] is passed to the matching algorithms.
+   `match_not_dot_null`] is passed to the matching algorithms.
 * The newline character when the [link boost_regex.ref.match_flag_type 
    flag `match_not_dot_newline`] is passed to 
    the matching algorithms.
diff --git a/example/snippets/icu_example.cpp b/example/snippets/icu_example.cpp
index 8e5f22ca..8f4a41ed 100644
--- a/example/snippets/icu_example.cpp
+++ b/example/snippets/icu_example.cpp
@@ -157,7 +157,7 @@ int main()
    assert(greek == L"\x0391\x039D\x0395\x0398\x0391 2004");
 
    // extract currency symbols with associated value, use iterator interface:
-   std::string text2 = " $100.23 or \xC2\xA3""198.12 "; // \xC2\xA3 is the £ sign encoded in UTF-8
+   std::string text2 = " $100.23 or \xC2\xA3""198.12 "; // \xC2\xA3 is the pound sign encoded in UTF-8
    enumerate_currencies(text2);
    enumerate_currencies2(text2);
 
diff --git a/include/boost/regex/concepts.hpp b/include/boost/regex/concepts.hpp
index 0f5677a2..99c6eea5 100644
--- a/include/boost/regex/concepts.hpp
+++ b/include/boost/regex/concepts.hpp
@@ -368,8 +368,6 @@ struct BaseRegexConcept
 
       // access:
       const Regex ce;
-      bool b = ce.empty();
-      ignore_unused_variable_warning(b);
       unsigned i = ce.mark_count();
       ignore_unused_variable_warning(i);
       m_flags = ce.flags();
@@ -385,7 +383,7 @@ struct BaseRegexConcept
       typedef typename sub_match_type::iterator sub_iter_type;
       BOOST_STATIC_ASSERT((::boost::is_same::value));
       BOOST_STATIC_ASSERT((::boost::is_same::value));
-      b = m_sub.matched;
+      bool b = m_sub.matched;
       ignore_unused_variable_warning(b);
       BidiIterator bi = m_sub.first;
       ignore_unused_variable_warning(bi);
@@ -806,6 +804,8 @@ struct BoostRegexConcept
       ignore_unused_variable_warning(i2);
       bool b = ce == ce2;
       ignore_unused_variable_warning(b);
+      b = ce.empty();
+      ignore_unused_variable_warning(b);
       b = ce != ce2;
       ignore_unused_variable_warning(b);
       b = ce < ce2;
diff --git a/include/boost/regex/pending/object_cache.hpp b/include/boost/regex/pending/object_cache.hpp
index bc37e276..2a7e00bc 100644
--- a/include/boost/regex/pending/object_cache.hpp
+++ b/include/boost/regex/pending/object_cache.hpp
@@ -119,7 +119,7 @@ boost::shared_ptr object_cache::do_get(const Key& k,
    //
    // Add it to the list, and index it:
    //
-   s_data.cont.push_back(value_type(result, 0));
+   s_data.cont.push_back(value_type(result, static_cast(0)));
    s_data.index.insert(std::make_pair(k, --(s_data.cont.end())));
    s_data.cont.back().second = &(s_data.index.find(k)->first);
    map_size_type s = s_data.index.size();
diff --git a/include/boost/regex/pending/unicode_iterator.hpp b/include/boost/regex/pending/unicode_iterator.hpp
index 14196c0a..657ca0a4 100644
--- a/include/boost/regex/pending/unicode_iterator.hpp
+++ b/include/boost/regex/pending/unicode_iterator.hpp
@@ -68,6 +68,7 @@ Accepts UTF-32 code points and forwards them on as UTF-16 code points.
 #include 
 #ifndef BOOST_NO_STD_LOCALE
 #include 
+#include 
 #endif
 #include  // CHAR_BIT
 
diff --git a/include/boost/regex/v4/basic_regex_creator.hpp b/include/boost/regex/v4/basic_regex_creator.hpp
index fec755f8..35de0cef 100644
--- a/include/boost/regex/v4/basic_regex_creator.hpp
+++ b/include/boost/regex/v4/basic_regex_creator.hpp
@@ -1270,6 +1270,19 @@ void basic_regex_creator::probe_leading_repeat(re_syntax_base* st
             state = state->next.p;
             continue;
          }
+         if((static_cast(state)->index == -1)
+            || (static_cast(state)->index == -2))
+         {
+            // skip past the zero width assertion:
+            state = static_cast(state->next.p)->alt.p->next.p;
+            continue;
+         }
+         if(static_cast(state)->index == -3)
+         {
+            // Have to skip the leading jump state:
+            state = state->next.p->next.p;
+            continue;
+         }
          return;
       case syntax_element_endmark:
       case syntax_element_start_line:
diff --git a/include/boost/regex/v4/instances.hpp b/include/boost/regex/v4/instances.hpp
index b9898cb0..d12dc6b2 100644
--- a/include/boost/regex/v4/instances.hpp
+++ b/include/boost/regex/v4/instances.hpp
@@ -71,32 +71,39 @@ template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher 1310
+#           define BOOST_REGEX_TEMPLATE_DECL
+#        endif
 #        define template extern template
 #     endif
 #  endif
 
+#ifndef BOOST_REGEX_TEMPLATE_DECL
+#  define BOOST_REGEX_TEMPLATE_DECL BOOST_REGEX_DECL
+#endif
+
 #  ifdef BOOST_MSVC
 #     pragma warning(push)
 #     pragma warning(disable : 4251 4231 4660)
 #  endif
 
-template class BOOST_REGEX_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;
+template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template class BOOST_REGEX_DECL match_results< const BOOST_REGEX_CHAR_T* >;
+template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;
 #endif
 #ifndef BOOST_NO_STD_ALLOCATOR
-template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher::allocator_type BOOST_REGEX_TRAITS_T >;
+template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher::allocator_type BOOST_REGEX_TRAITS_T >;
 #endif
 #if !(defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB <= 1))\
    && !(defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 800))\
    && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))\
    && !defined(BOOST_REGEX_ICU_INSTANCES)
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template class BOOST_REGEX_DECL match_results< std::basic_string::const_iterator >;
+template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string::const_iterator >;
 #endif
 #ifndef BOOST_NO_STD_ALLOCATOR
-template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher< std::basic_string::const_iterator, match_results< std::basic_string::const_iterator >::allocator_type, boost::regex_traits >;
+template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::basic_string::const_iterator, match_results< std::basic_string::const_iterator >::allocator_type, boost::regex_traits >;
 #endif
 #endif
 
@@ -109,6 +116,8 @@ template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher< std::basic_str
 #     undef template
 #  endif
 
+#undef BOOST_REGEX_TEMPLATE_DECL
+
 #elif (defined(__GNUC__) && (__GNUC__ >= 3))
 
 #  ifndef BOOST_REGEX_INSTANTIATE
diff --git a/include/boost/regex/v4/perl_matcher_common.hpp b/include/boost/regex/v4/perl_matcher_common.hpp
index 72e43d00..399caa3b 100644
--- a/include/boost/regex/v4/perl_matcher_common.hpp
+++ b/include/boost/regex/v4/perl_matcher_common.hpp
@@ -535,7 +535,7 @@ bool perl_matcher::match_within_word()
    if(position == last)
       return false;
    // both prev and this character must be m_word_mask:
-   if(traits_inst.isctype(*position, m_word_mask))
+   bool prev = traits_inst.isctype(*position, m_word_mask);
    {
       bool b;
       if((position == backstop) && ((m_match_flags & match_prev_avail) == 0)) 
@@ -546,7 +546,7 @@ bool perl_matcher::match_within_word()
          b = traits_inst.isctype(*position, m_word_mask);
          ++position;
       }
-      if(b)
+      if(b == prev)
       {
          pstate = pstate->next.p;
          return true;
diff --git a/include/boost/regex/v4/perl_matcher_non_recursive.hpp b/include/boost/regex/v4/perl_matcher_non_recursive.hpp
index 3bf34601..e6bf1bba 100644
--- a/include/boost/regex/v4/perl_matcher_non_recursive.hpp
+++ b/include/boost/regex/v4/perl_matcher_non_recursive.hpp
@@ -1193,6 +1193,9 @@ bool perl_matcher::unwind_char_repeat(bool r)
          pstate = rep->next.p;
       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
    }   
+   // remember where we got to if this is a leading repeat:
+   if((rep->leading) && (count < rep->max))
+      restart = position;
    if(position == last)
    {
       // can't repeat any more, remove the pushed state: 
@@ -1259,6 +1262,9 @@ bool perl_matcher::unwind_short_set_repeat(bool
          pstate = rep->next.p;
       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
    }   
+   // remember where we got to if this is a leading repeat:
+   if((rep->leading) && (count < rep->max))
+      restart = position;
    if(position == last)
    {
       // can't repeat any more, remove the pushed state: 
@@ -1326,6 +1332,9 @@ bool perl_matcher::unwind_long_set_repeat(bool
          pstate = rep->next.p;
       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
    }   
+   // remember where we got to if this is a leading repeat:
+   if((rep->leading) && (count < rep->max))
+      restart = position;
    if(position == last)
    {
       // can't repeat any more, remove the pushed state:
diff --git a/src/posix_api.cpp b/src/posix_api.cpp
index 907c60c3..1564cedb 100644
--- a/src/posix_api.cpp
+++ b/src/posix_api.cpp
@@ -62,6 +62,8 @@ const char* names[] = {
 };
 } // namespace
 
+typedef boost::basic_regex > c_regex_type;
+
 BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA* expression, const char* ptr, int f)
 {
    if(expression->re_magic != magic_value)
@@ -70,7 +72,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA* expression, const char
 #ifndef BOOST_NO_EXCEPTIONS
       try{
 #endif
-      expression->guts = new regex();
+      expression->guts = new c_regex_type();
 #ifndef BOOST_NO_EXCEPTIONS
       } catch(...)
       {
@@ -120,9 +122,9 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA* expression, const char
    try{
 #endif
       expression->re_magic = magic_value;
-      static_cast(expression->guts)->set_expression(ptr, p2, flags);
-      expression->re_nsub = static_cast(expression->guts)->mark_count() - 1;
-      result = static_cast(expression->guts)->error_code();
+      static_cast(expression->guts)->set_expression(ptr, p2, flags);
+      expression->re_nsub = static_cast(expression->guts)->mark_count() - 1;
+      result = static_cast(expression->guts)->error_code();
 #ifndef BOOST_NO_EXCEPTIONS
    } 
    catch(const boost::regex_error& be)
@@ -187,7 +189,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
    {
       std::string p;
       if((e) && (e->re_magic == magic_value))
-         p = static_cast(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
+         p = static_cast(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
       else
       {
          p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
@@ -236,7 +238,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA* expression, cons
 #endif
    if(expression->re_magic == magic_value)
    {
-      result = regex_search(start, end, m, *static_cast(expression->guts), flags);
+      result = regex_search(start, end, m, *static_cast(expression->guts), flags);
    }
    else
       return result;
@@ -274,7 +276,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA* expression)
 {
    if(expression->re_magic == magic_value)
    {
-      delete static_cast(expression->guts);
+      delete static_cast(expression->guts);
    }
    expression->re_magic = 0;
 }
diff --git a/src/usinstances.cpp b/src/usinstances.cpp
index 337d815f..e633659e 100644
--- a/src/usinstances.cpp
+++ b/src/usinstances.cpp
@@ -25,6 +25,8 @@
 
 #ifdef _DLL_CPPLIB
 #include 
+#include 
+#include 
 //
 // This is a horrible workaround, without declaring these symbols extern we get
 // duplicate symbol errors when linking if the application is built without
@@ -49,6 +51,9 @@ template _CRTIMP2 bool __cdecl operator>(
 #if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
 template<> _CRTIMP2 std::size_t __cdecl char_traits::length(unsigned short const*);
 #endif
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+template _CRTIMP2 allocator::allocator();
+#endif
 }
 #endif
 
diff --git a/src/wc_regex_traits.cpp b/src/wc_regex_traits.cpp
index 9daf0804..aee2da18 100644
--- a/src/wc_regex_traits.cpp
+++ b/src/wc_regex_traits.cpp
@@ -19,9 +19,42 @@
 
 #define BOOST_REGEX_SOURCE
 
-#include 
+#include 
 #include 
 
+#ifdef _DLL_CPPLIB
+#include 
+#include 
+//
+// This is a horrible workaround, without declaring these symbols extern we get
+// duplicate symbol errors when linking if the application is built without
+// /Zc:wchar_t
+//
+namespace std{
+template _CRTIMP2 bool __cdecl operator==(
+   const basic_string, allocator >&,
+   const basic_string, allocator >&);
+template _CRTIMP2 bool __cdecl operator==(
+   const unsigned short *,
+   const basic_string, allocator >&);
+template _CRTIMP2 bool __cdecl operator==(
+   const basic_string, allocator >&,
+   const unsigned short *);
+template _CRTIMP2 bool __cdecl operator<(
+   const basic_string, allocator >&,
+   const basic_string, allocator >&);
+template _CRTIMP2 bool __cdecl operator>(
+   const basic_string, allocator >&,
+   const basic_string, allocator >&);
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
+template<> _CRTIMP2 std::size_t __cdecl char_traits::length(unsigned short const*);
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+template _CRTIMP2 allocator::allocator();
+#endif
+}
+#endif
+
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
 
 #include 
diff --git a/src/wide_posix_api.cpp b/src/wide_posix_api.cpp
index 184b1cea..83d651b8 100644
--- a/src/wide_posix_api.cpp
+++ b/src/wide_posix_api.cpp
@@ -69,6 +69,8 @@ const wchar_t* wnames[] = {
 };
 }
 
+typedef boost::basic_regex > c_regex_type;
+
 BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wchar_t* ptr, int f)
 {
    if(expression->re_magic != wmagic_value)
@@ -77,7 +79,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wcha
 #ifndef BOOST_NO_EXCEPTIONS
       try{
 #endif
-      expression->guts = new wregex();
+      expression->guts = new c_regex_type();
 #ifndef BOOST_NO_EXCEPTIONS
       } catch(...)
       {
@@ -127,9 +129,9 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wcha
    try{
 #endif
       expression->re_magic = wmagic_value;
-      static_cast(expression->guts)->set_expression(ptr, p2, flags);
-      expression->re_nsub = static_cast(expression->guts)->mark_count() - 1;
-      result = static_cast(expression->guts)->error_code();
+      static_cast(expression->guts)->set_expression(ptr, p2, flags);
+      expression->re_nsub = static_cast(expression->guts)->mark_count() - 1;
+      result = static_cast(expression->guts)->error_code();
 #ifndef BOOST_NO_EXCEPTIONS
    } 
    catch(const boost::regex_error& be)
@@ -208,7 +210,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
    {
       std::string p;
       if((e) && (e->re_magic == wmagic_value))
-         p = static_cast(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
+         p = static_cast(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
       else
       {
          p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
@@ -257,7 +259,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW* expression, cons
 #endif
    if(expression->re_magic == wmagic_value)
    {
-      result = regex_search(start, end, m, *static_cast(expression->guts), flags);
+      result = regex_search(start, end, m, *static_cast(expression->guts), flags);
    }
    else
       return result;
@@ -294,7 +296,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW* expression)
 {
    if(expression->re_magic == wmagic_value)
    {
-      delete static_cast(expression->guts);
+      delete static_cast(expression->guts);
    }
    expression->re_magic = 0;
 }
diff --git a/test/regress/test_escapes.cpp b/test/regress/test_escapes.cpp
index aa842130..ba78c454 100644
--- a/test/regress/test_escapes.cpp
+++ b/test/regress/test_escapes.cpp
@@ -109,6 +109,9 @@ void test_assertion_escapes()
    TEST_REGEX_SEARCH("a\\B", perl, "ab", match_default, make_array(0, 1, -2, -2));
    TEST_REGEX_SEARCH("a\\B", perl, "a", match_default, make_array(-2, -2));
    TEST_REGEX_SEARCH("a\\B", perl, "a ", match_default, make_array(-2, -2));
+   TEST_REGEX_SEARCH("\\By\\b", perl, "xy", match_default, make_array(1, 2, -2, -2));
+   TEST_REGEX_SEARCH("\\by\\B", perl, "yz", match_default, make_array(0, 1, -2, -2));
+   TEST_REGEX_SEARCH("\\B\\*\\B", perl, " * ", match_default, make_array(1, 2, -2, -2));
    // buffer operators:
    TEST_REGEX_SEARCH("\\`abc", perl, "abc", match_default, make_array(0, 3, -2, -2));
    TEST_REGEX_SEARCH("\\`abc", perl, "\nabc", match_default, make_array(-2, -2));