[boost-doc-zh] r396 committed - 翻译 regex 库的 qbk 文件并生成 html 目录

Revision: 396
Author: alai04
Date: Thu May 27 20:09:44 2010
Log: 翻译 regex 库的 qbk 文件并生成 html 目录
http://code.google.com/p/boost-doc-zh/source/detail?r=396

Modified:
 /trunk/libs/regex/doc/acknowledgements.qbk
 /trunk/libs/regex/doc/bad_expression.qbk
 /trunk/libs/regex/doc/basic_regex.qbk
 /trunk/libs/regex/doc/captures.qbk
 /trunk/libs/regex/doc/character_class_names.qbk
 /trunk/libs/regex/doc/collating_names.qbk
 /trunk/libs/regex/doc/concepts.qbk
 /trunk/libs/regex/doc/configuration.qbk
 /trunk/libs/regex/doc/error_type.qbk
 /trunk/libs/regex/doc/examples.qbk
 /trunk/libs/regex/doc/faq.qbk
 /trunk/libs/regex/doc/format_boost_syntax.qbk
 /trunk/libs/regex/doc/format_perl_syntax.qbk
 /trunk/libs/regex/doc/format_sed_syntax.qbk
 /trunk/libs/regex/doc/format_syntax.qbk
 /trunk/libs/regex/doc/further_info.qbk
 /trunk/libs/regex/doc/gcc-performance.html
 /trunk/libs/regex/doc/headers.qbk
 /trunk/libs/regex/doc/history.qbk
/trunk/libs/regex/doc/html/boost_regex/background_information/acknowledgements.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/examples.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/faq.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/futher.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/headers.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/history.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/locale.html
/trunk/libs/regex/doc/html/boost_regex/background_information/performance.html
 /trunk/libs/regex/doc/html/boost_regex/background_information/redist.html
/trunk/libs/regex/doc/html/boost_regex/background_information/standards.html /trunk/libs/regex/doc/html/boost_regex/background_information/thread_safety.html
 /trunk/libs/regex/doc/html/boost_regex/background_information.html
 /trunk/libs/regex/doc/html/boost_regex/captures.html
 /trunk/libs/regex/doc/html/boost_regex/configuration/algorithm.html
 /trunk/libs/regex/doc/html/boost_regex/configuration/compiler.html
 /trunk/libs/regex/doc/html/boost_regex/configuration/linkage.html
 /trunk/libs/regex/doc/html/boost_regex/configuration/locale.html
 /trunk/libs/regex/doc/html/boost_regex/configuration/tuning.html
 /trunk/libs/regex/doc/html/boost_regex/configuration.html
 /trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html
 /trunk/libs/regex/doc/html/boost_regex/format/perl_format.html
 /trunk/libs/regex/doc/html/boost_regex/format/sed_format.html
 /trunk/libs/regex/doc/html/boost_regex/format.html
 /trunk/libs/regex/doc/html/boost_regex/install.html
 /trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html
 /trunk/libs/regex/doc/html/boost_regex/partial_matches.html
 /trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html
 /trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html
 /trunk/libs/regex/doc/html/boost_regex/ref/concepts/charT_concept.html
 /trunk/libs/regex/doc/html/boost_regex/ref/concepts/iterator_concepts.html
 /trunk/libs/regex/doc/html/boost_regex/ref/concepts/traits_concept.html
 /trunk/libs/regex/doc/html/boost_regex/ref/concepts.html
/trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/old_regex.html /trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_format.html /trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_grep.html /trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces/regex_split.html
 /trunk/libs/regex/doc/html/boost_regex/ref/deprecated_interfaces.html
 /trunk/libs/regex/doc/html/boost_regex/ref/error_type.html
 /trunk/libs/regex/doc/html/boost_regex/ref/match_flag_type.html
 /trunk/libs/regex/doc/html/boost_regex/ref/match_results.html
 /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/intro.html
/trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
 /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/icu.html
/trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
 /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings/mfc_strings.html
 /trunk/libs/regex/doc/html/boost_regex/ref/non_std_strings.html
 /trunk/libs/regex/doc/html/boost_regex/ref/posix.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_iterator.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_match.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_replace.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_search.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_token_iterator.html
 /trunk/libs/regex/doc/html/boost_regex/ref/regex_traits.html
 /trunk/libs/regex/doc/html/boost_regex/ref/sub_match.html
/trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_basic.html /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_extended.html /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_literal.html /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_overview.html /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_perl.html /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type/syntax_option_type_synopsis.html
 /trunk/libs/regex/doc/html/boost_regex/ref/syntax_option_type.html
 /trunk/libs/regex/doc/html/boost_regex/ref.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/basic_extended.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/basic_syntax.html
/trunk/libs/regex/doc/html/boost_regex/syntax/character_classes/optional_char_class_names.html /trunk/libs/regex/doc/html/boost_regex/syntax/character_classes/std_char_clases.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/character_classes.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/collating_names/digraphs.html
/trunk/libs/regex/doc/html/boost_regex/syntax/collating_names/named_unicode.html /trunk/libs/regex/doc/html/boost_regex/syntax/collating_names/posix_symbolic_names.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/collating_names.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/leftmost_longest_rule.html
 /trunk/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
 /trunk/libs/regex/doc/html/boost_regex/syntax.html
 /trunk/libs/regex/doc/html/boost_regex/unicode.html
 /trunk/libs/regex/doc/html/index.html
 /trunk/libs/regex/doc/icu_strings.qbk
 /trunk/libs/regex/doc/install.qbk
 /trunk/libs/regex/doc/introduction.qbk
 /trunk/libs/regex/doc/leftmost_longest.qbk
 /trunk/libs/regex/doc/locale.qbk
 /trunk/libs/regex/doc/match_flag_type.qbk
 /trunk/libs/regex/doc/match_result.qbk
 /trunk/libs/regex/doc/mfc_strings.qbk
 /trunk/libs/regex/doc/non_std_strings.qbk
 /trunk/libs/regex/doc/old_regex.qbk
 /trunk/libs/regex/doc/partial_matches.qbk
 /trunk/libs/regex/doc/performance.qbk
 /trunk/libs/regex/doc/posix_api.qbk
 /trunk/libs/regex/doc/redistributables.qbk
 /trunk/libs/regex/doc/regex.qbk
 /trunk/libs/regex/doc/regex_format.qbk
 /trunk/libs/regex/doc/regex_grep.qbk
 /trunk/libs/regex/doc/regex_iterator.qbk
 /trunk/libs/regex/doc/regex_match.qbk
 /trunk/libs/regex/doc/regex_replace.qbk
 /trunk/libs/regex/doc/regex_search.qbk
 /trunk/libs/regex/doc/regex_split.qbk
 /trunk/libs/regex/doc/regex_token_iterator.qbk
 /trunk/libs/regex/doc/regex_traits.qbk
 /trunk/libs/regex/doc/standards.qbk
 /trunk/libs/regex/doc/sub_match.qbk
 /trunk/libs/regex/doc/syntax.qbk
 /trunk/libs/regex/doc/syntax_basic.qbk
 /trunk/libs/regex/doc/syntax_extended.qbk
 /trunk/libs/regex/doc/syntax_option_type.qbk
 /trunk/libs/regex/doc/syntax_perl.qbk
 /trunk/libs/regex/doc/thread_safety.qbk
 /trunk/libs/regex/doc/unicode.qbk
 /trunk/libs/regex/doc/vc71-performance.html

=======================================
--- /trunk/libs/regex/doc/acknowledgements.qbk  Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/acknowledgements.qbk  Thu May 27 20:09:44 2010
@@ -6,7 +6,7 @@
 ]


-[section:acknowledgements Acknowledgements]
+[section:acknowledgements Acknowledgements 鸣谢]

The author can be contacted at john - at - johnmaddock.co.uk; the home page for this
 library is at [@http://www.boost.org www.boost.org].
=======================================
--- /trunk/libs/regex/doc/bad_expression.qbk    Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/bad_expression.qbk    Thu May 27 20:09:44 2010
@@ -8,13 +8,14 @@

 [section:bad_expression bad_expression]

-[h4 Synopsis]
+[h4 Synopsis 概要]

    #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.
+expression to a finite state machine.  \n
+类 `regex_error` 定义了在将正则表达式字符串转换到有限状态机过程中出现错误时 扔出的异常类型。

    namespace boost{

@@ -32,20 +33,23 @@

    } // namespace boost

-[h4 Description]
+[h4 Description 说明]

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.
+[*Effects:] Constructs an object of class regex_error.\n
+[*效果]:构造一个 `regex_error` 类的对象。

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

-[*Effects:] returns the error code that represents parsing error that occurred. +[*Effects:] returns the error code that represents parsing error that occurred.\n
+[*效果]:返回表示所发生的分析错误的错误代码。

    std::ptrdiff_t position()const;

-[*Effects:] returns the location in the expression where parsing stopped.
+[*Effects:] returns the location in the expression where parsing stopped.\n
+[*效果]:返回表达式中停止分析的位置。

Footnotes: the choice of `std::runtime_error` as the base class for `regex_error`
 is moot; depending upon how the library is used exceptions may be either
@@ -53,6 +57,10 @@
 (user supplied expressions).  The library previously used `bad_pattern`
 and `bad_expression` for errors, these have been replaced by the single
 class `regex_error` to keep the library in synchronization with the
-[tr1].
+[tr1].\n
+脚注:将 `std::runtime_error` 作为 `regex_error` 的基类是无实际意义的;
+依赖于库如何被使用,异常可能是逻辑错误(程序员提供的表达式)或运行时错误(用户 提供的表达式)。 +库之前使用 `bad_pattern` 和 `bad_expression` 用于错误,现在已经被替换为单个 类 `regex_error`,
+保持本库与 [tr1] 同步。

 [endsect]
=======================================
--- /trunk/libs/regex/doc/basic_regex.qbk       Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/basic_regex.qbk       Thu May 27 20:09:44 2010
@@ -7,25 +7,31 @@

 [section:basic_regex basic_regex]

-[h4 Synopsis]
+[h4 Synopsis 摘要]

    #include <boost/regex.hpp>

 The template class `basic_regex` encapsulates regular expression
-parsing and compilation. The class takes two template parameters:
+parsing and compilation. The class takes two template parameters:\n
+模板类 `basic_regex` 封装了正则表达式的解析和编译。这个类接受两个模板参数:

 * `charT`: determines the character type, i.e. either `char` or `wchar_t`;
-see [link boost_regex.ref.concepts.charT_concept charT concept].
+see [link boost_regex.ref.concepts.charT_concept charT concept].\n
+ `charT`:决定字符类型,如 `char` 或 `wchar_t`;见 [link boost_regex.ref.concepts.charT_concept charT概念]。 * `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
-[link boost_regex.ref.concepts.traits_concept traits concept].
+[link boost_regex.ref.concepts.traits_concept traits concept].\n
+ `traits`: 决定字符类型的行为,例如哪些字符类名称可以被识别。默认的特性 类:`regex_traits<charT>`。
+  见 [link boost_regex.ref.concepts.traits_concept traits 概念]。

 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
 [link boost_regex.ref.non_std_strings.icu unicode support]),
-you won't need to use anything other than these:
+you won't need to use anything other than these:\n
+为了使用简单,有两个typedef定义了两个标准的 `basic_regex` 实例,除非你想要 使用自定义特性类或非标准的字符类型(例如 +[link boost_regex.ref.non_std_strings.icu 对unicode的支持]),否则你不需要使 用另外的定义:

    namespace boost{

@@ -38,7 +44,8 @@
    }

 The definition of `basic_regex` follows: it is based very closely on class
-`basic_string`, and fulfils the requirements for a constant-container of `charT`. +`basic_string`, and fulfils the requirements for a constant-container of `charT`.\n +`basic_regex` 定义如下:其基础非常接近于类 `basic_string`,并且满足作为 `charT` 的常量容器的需求。

    namespace boost{

@@ -211,9 +218,10 @@

    } // namespace boost

-[h4 Description]
-
-Class `basic_regex` has the following public members:
+[h4 Description 说明]
+
+Class `basic_regex` has the following public members:\n
+类 `basic_regex` 有下面的公共成员:

    // main option selection:
    static const regex_constants::``[syntax_option_type]`` normal
@@ -272,21 +280,25 @@
= regex_constants::newline_alt;

 The meaning of these options is documented in the [syntax_option_type]
-section.
+section.\n
+这些选项的意义记录于 [syntax_option_type] 一节中。

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] declared in namespace `boost::regex_constants` then a constant with the same name,
-type and value is declared within the scope of basic_regex.
+type and value is declared within the scope of basic_regex.\n
+这些静态常量成员和命名空间 `boost::regex_constants` 定义的常量是同义的;对 每个定义于命名空间 +`boost::regex_constants` 的 [syntax_option_type] 类型常量,都有相同的名字、 类型和值定义于basic_regex的作用域内。

 [#boost_regex.basic_regex.construct1]

    basic_regex();

-[*Effects]: Constructs an object of class `basic_regex`.
-
-[table basic_regex default construction postconditions
-[[Element][Value]]
+[*Effects]: Constructs an object of class `basic_regex`. \n
+[*作用]: 构建 `basic_regex` 类的一个对象。
+
+[table basic_regex default construction postconditions 缺省构建的后验条件
+[[Element 元素][Value 值]]
 [[`empty()`][`true`]]
 [[`size()`][`0`]]
 [[`str()`][`basic_string<charT>()`]]
@@ -296,24 +308,29 @@

    basic_regex(const charT* p, flag_type f = regex_constants::normal);

-[*Requires]: /p/ shall not be a null pointer.
+[*Requires]: /p/ shall not be a null pointer.\n
+[*要求]: /p/ 不能为空指针。

 [*Throws]: [bad_expression] if /p/ is not a valid regular expression,
-unless the flag `no_except` is set in /f/.
+unless the flag `no_except` is set in /f/.\n
+[*抛出]: [bad_expression] 如果 /p/ 不是有效的正则表达式,否则 /f/ 中被设置 标志 `no_except`。

[*Effects]: Constructs an object of class [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
 [link boost_regex.ref.syntax_option_type option
-flags] specified in /f/.
-
-[table Postconditions for basic_regex construction
-[[Element][Value]]
+flags] specified in /f/. \n
+[*作用]: 构造类 [basic_regex] 的一个对象;对象内部的有限状态机通过null结尾 的字符串 /p/ 内的正则表达式构造, +并且根据 /f/ 指定的 [link boost_regex.ref.syntax_option_type 选项标签] 解 释。
+
+[table Postconditions for basic_regex construction basic_regex构建的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][`char_traits<charT>::length(p)`]]
 [[`str()`][`basic_string<charT>(p)`]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.construct3]
@@ -321,46 +338,56 @@
    basic_regex(const charT* p1, const charT* p2,
                flag_type f = regex_constants::normal);

-[*Requires]: /p1/ and /p2/ are not null pointers, `p1 < p2`.
+[*Requires]: /p1/ and /p2/ are not null pointers, `p1 < p2`.\n
+[*要求]: /p1/ 和 /p2/ 不是空指针,`p1 < p2`.

[*Throws]: bad_expression if \[p1,p2) is not a valid regular expression, unless
-the flag `no_except` is set in /f/.
+the flag `no_except` is set in /f/.\n
+[*抛出]: bad_expression 如果 \[p1,p2) 不是有效的正则表达式,否则 /f/ 中被设 置标志 `no_except`。

 [*Effects]: Constructs an object of class [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
-[link boost_regex.ref.syntax_option_type option flags] specified in /f/.
-
-[table Postconditions for basic_regex construction
-[[Element][Value]]
+[link boost_regex.ref.syntax_option_type option flags] specified in /f/. \n
+[*作用]: 构造类 [basic_regex] 的一个对象;对象内部的有限自动机从字符串序列 \[p1,p2) 内包含的正则表达式构造, +并且根据 /f/ 指定的 [link boost_regex.ref.syntax_option_type 选项标签] 来解 释。
+
+[table Postconditions for basic_regex construction basic_regex构建的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][`std::distance(p1,p2)`]]
 [[`str()`][`basic_string<charT>(p1,p2)`]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.construct4]

    basic_regex(const charT* p, size_type len, flag_type f);

-[*Requires]: /p/ shall not be a null pointer, `len < max_size()`.
+[*Requires]: /p/ shall not be a null pointer, `len < max_size()`.\n
+[*要求]: /p/ 不应为空指针,`len < max_size()`。

[*Throws]: [bad_expression] if /p/ is not a valid regular expression, unless
-the flag `no_except` is set in /f/.
+the flag `no_except` is set in /f/.\n
+[*抛出]: [bad_expression] 如果 /p/ 不是有效的正则表达式,否则 /f/ 中被设置 标志 `no_except`。

 [*Effects]: Constructs an object of class [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 Postconditions for basic_regex construction
-[[Element][Value]]
+according the option flags specified in /f/. \n
+[*作用]: 构造类 [basic_regex] 的一个对象;对象内部的有限状态机从字符序列 \[p,p+len) 包含的正则表达式构造,
+并且根据f指定的选项标签来解释。
+
+[table Postconditions for basic_regex construction basic_regex构建的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][['len]]]
 [[`str()`][`basic_string<charT>(p, len)`]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.construct5]
@@ -368,7 +395,8 @@
    basic_regex(const basic_regex& e);

[*Effects]: Constructs an object of class [basic_regex] as a copy of the object
-/e/.
+/e/. \n
+[*作用]: 构造类 [basic_regex] 的一个对象,作为对象 /e/ 的一份拷贝。

 [#boost_regex.basic_regex.construct6]

@@ -377,20 +405,24 @@
                flag_type f = regex_constants::normal);

 [*Throws]: [bad_expression] if /s/ is not a valid regular expression,
-unless the flag `no_except` is set in /f/.
+unless the flag `no_except` is set in /f/.\n
+[*抛出]: [bad_expression] 如果 /s/ 不是有效的正则表达式,否则 /f/ 中被设置 标志 `no_except`。

 [*Effects]: Constructs an object of class [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 [link boost_regex.ref.syntax_option_type option
-flags] specified in /f/.
-
-[table Postconditions for basic_regex construction
-[[Element][Value]]
+flags] specified in /f/. \n
+[*作用]: 构造类 [basic_regex] 的一个对象;对象内部的有限状态机从字符串 /s/ 包含的正则表达式构造, +并且根据 /f/ 指定的 [link boost_regex.ref.syntax_option_type 选项标签] 来解 释。
+
+[table Postconditions for basic_regex construction basic_regex构建的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][`s.size()`]]
 [[`str()`][['s]]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.construct7]
@@ -400,42 +432,50 @@
                flag_type f = regex_constants::normal);

 [*Throws]: [bad_expression] if the sequence \[first, last) is not a valid
-regular expression, unless the flag `no_except` is set in /f/.
+regular expression, unless the flag `no_except` is set in /f/.\n
+[*抛出]: [bad_expression] 如果 \[first, last) 不是有效的正则表达式,否则 /f/ 中被设置标志 `no_except`。

 [*Effects]: Constructs an object of class [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 [link boost_regex.ref.syntax_option_type option flags] specified in /f/.
-
-[table Postconditions for basic_regex construction
-[[Element][Value]]
+according to the [link boost_regex.ref.syntax_option_type option flags] specified in /f/. \n +[*作用]: 构造类 [basic_regex] 的一个对象;对象内部的有限状态机从字符串 \[first, last) 包含的正则表达式构造, +并且根据 /f/ 指定的 [link boost_regex.ref.syntax_option_type 选项标签] 来解 释。
+
+[table Postconditions for basic_regex construction basic_regex构建的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][`distance(first,last)`]]
 [[`str()`][`basic_string<charT>(first,last)`]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.opeq1]

    basic_regex& operator=(const basic_regex& e);

-[*Effects]: Returns the result of `assign(e.str(), e.flags())`.
+[*Effects]: Returns the result of `assign(e.str(), e.flags())`.\n
+[*作用]: 返回 `assign(e.str(), e.flags())` 的结果。

 [#boost_regex.basic_regex.opeq2]

    basic_regex& operator=(const charT* ptr);

-[*Requires]: /p/ shall not be a null pointer.
-
-[*Effects]: Returns the result of `assign(ptr)`.
+[*Requires]: /p/ shall not be a null pointer.\n
+[*要求]: /p/ 不应为空指针。
+
+[*Effects]: Returns the result of `assign(ptr)`.\n
+[*作用]: 返回 `assign(ptr)` 的结果。

 [#boost_regex.basic_regex.opeq3]

    template <class ST, class SA>
    basic_regex& operator=(const basic_string<charT, ST, SA>& p);

-[*Effects]: Returns the result of `assign(p)`.
+[*Effects]: Returns the result of `assign(p)`.\n
+[*作用]: 返回 `assign(p)` 的结果。

 [#boost_regex.basic_regex.subexpression]

@@ -443,69 +483,81 @@

 [*Effects]: Returns a pair of iterators denoting the location of
 marked subexpression /n/ within the original regular expression string.
-The returned iterators are relative to `begin()` and `end()`.
+The returned iterators are relative to `begin()` and `end()`.\n
+[*作用]: 返回一对迭代器,表示标记子表达式 /n/ 在原正则表达式串中的位置。返 回的迭代器相对于 `begin()` 和 `end()`。

 [*Requires]: The expression must have been compiled with the
 [syntax_option_type] save_subexpression_location set.  Argument
-/n/ must be in within the range `1 <= n < mark_count()`.
+/n/ must be in within the range `1 <= n < mark_count()`.\n
+[*要求]: 该表达式必须已经用 [syntax_option_type] save_subexpression_location 置位来编译。
+参数 /n/ 必须位于区间 `1 <= n < mark_count()`。

 [#boost_regex.basic_regex.begin]

    const_iterator begin() const;

[*Effects]: Returns a starting iterator to a sequence of characters representing
-the regular expression.
+the regular expression.\n
+[*作用]: 返回表示正则表达式的字符序列的起始迭代器。

 [#boost_regex.basic_regex.end]

    const_iterator end() const;

[*Effects]: Returns termination iterator to a sequence of characters representing
-the regular expression.
+the regular expression.\n
+[*作用]: 返回表示正则表达式的字符序列的结束迭代器。

 [#boost_regex.basic_regex.size]

    size_type size() const;

-[*Effects]: Returns the length of the sequence of characters representing the regular expression. +[*Effects]: Returns the length of the sequence of characters representing the regular expression.\n
+[*作用]: 返回表示正则表达式的字符序列的长度。

 [#boost_regex.basic_regex.max_size]

    size_type max_size() const;

[*Effects]: Returns the maximum length of the sequence of characters representing
-the regular expression.
+the regular expression.\n
+[*作用]: 返回表示正则表达式的字符序列的最大长度。

 [#boost_regex.basic_regex.empty]

    bool empty() const;

[*Effects]: Returns true if the object does not contain a valid regular expression,
-otherwise false.
+otherwise false.\n
+[*作用]: 如果该对象未包含一个有效的正则表达式则返回 true,否则返回 false.

 [#boost_regex.basic_regex.mark_count]

    unsigned mark_count() const;

-[*Effects]: Returns the number of marked sub-expressions within the regular expresion. +[*Effects]: Returns the number of marked sub-expressions within the regular expresion.\n
+[*作用]: 返回正则表达式内的标记子表达式的数量。

 [#boost_regex.basic_regex.assign1]

    basic_regex& assign(const basic_regex& that);

-[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(that.str(), that.flags())`]. +[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(that.str(), that.flags())`].\n +[*作用]: 返回 [link boost_regex.basic_regex.assign4 `assign(that.str(), that.flags())`].

 [#boost_regex.basic_regex.assign2]

basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);

-[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr), f)`]. +[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr), f)`].\n +[*作用]: 返回 [link boost_regex.basic_regex.assign4 `assign(string_type(ptr), f)`].

 [#boost_regex.basic_regex.assign3]

    basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);

-[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr, len), f)`]. +[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr, len), f)`].\n +[*作用]: 返回 [link boost_regex.basic_regex.assign4 `assign(string_type(ptr, len), f)`].

 [#boost_regex.basic_regex.assign4]

@@ -514,21 +566,24 @@
                      flag_type f = regex_constants::normal);

 [*Throws]: [bad_expression] if /s/ is not a valid regular expression,
-unless the flag `no_except` is set in /f/.
+unless the flag `no_except` is set in /f/.\n
+[*抛出]: [bad_expression] 如果 /s/ 不是有效的正则表达式,否则 /f/ 中被设置 标志 `no_except`。

 [*Returns]: *this.

 [*Effects]: Assigns the regular expression contained in the string /s/,
interpreted according the [link boost_regex.ref.syntax_option_type option flags]
-specified in /f/.
-
-[table Postconditions for basic_regex::assign
-[[Element][Value]]
+specified in /f/. \n
+[*作用]: 赋与字符串 /s/ 中所含的正则表达式,根据 /f/ 中指定的 [link boost_regex.ref.syntax_option_type 选项标签] 来解释。
+
+[table Postconditions for basic_regex::assign basic_regex::assign的后验条
+[[Element 元素][Value 值]]
 [[`empty()`][`false`]]
 [[`size()`][`s.size()`]]
 [[`str()`][['s]]]
 [[`flags()`][['f]]]
-[[`mark_count()`][The number of marked sub-expressions within the expression.]] +[[`mark_count()`][The number of marked sub-expressions within the expression.\n
+表达式中标记子表达式的数量。]]
 ]

 [#boost_regex.basic_regex.assign5]
@@ -539,9 +594,11 @@

 [*Requires]: The type `InputIterator` corresponds to the
 [@http://input_iterator Input Iterator requirements
-(24.1.1)].
-
-[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(first, last), f)`].
+(24.1.1)].\n
+[*要求]: 类型 `InputIterator` 对应于 [@http://input_iterator 输入迭代器要求 (24.1.1)]。
+
+[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(first, last), f)`].\n +[*作用]: 返回 [link boost_regex.basic_regex.assign4 `assign(string_type(first, last), f)`].

 [#boost_regex.basic_regex.flags]

@@ -549,7 +606,9 @@

 [*Effects]: Returns a copy of the [link boost_regex.ref.syntax_option_type
regular expression syntax flags] that were passed to the object's constructor,
-or the last call to `assign`.
+or the last call to `assign`.\n
+[*作用]: 返回传入至该对象构造函数或最后一次 `assign` 调用的 [link boost_regex.ref.syntax_option_type
+正则表达式语法标签] 的一份拷贝,

 [#boost_regex.basic_regex.status]

@@ -557,21 +616,24 @@

[*Effects]: Returns zero if the expression contains a valid regular expression,
 otherwise an error code.  This member function is retained for use in
-environments that cannot use exception handling.
+environments that cannot use exception handling.\n
+[*作用]: 如果包含的是有效的正则表达式则返回0,否则返回错误码。这个成员函数 为不使用异常处理的环境保留。

 [#boost_regex.basic_regex.str]

    basic_string<charT> str() const;

[*Effects]: Returns a copy of the character sequence passed to the object's constructor,
-or the last call to assign.
+or the last call to assign.\n
+[*作用]: 返回传入对象构造函数或最后一次调用 `assign` 的字符序列的拷贝。

 [#boost_regex.basic_regex.compare]

    int compare(basic_regex& e)const;

[*Effects]: If `flags() == e.flags()` then returns `str().compare(e.str())`,
-otherwise returns `flags() - e.flags()`.
+otherwise returns `flags() - e.flags()`.\n
+[*作用]: 如果 `flags() == e.flags()` 则返回 `str().compare(e.str())`, 否则 返回 `flags() - e.flags()`.

 [#boost_regex.basic_regex.imbue]

@@ -580,9 +642,12 @@
[*Effects]: Returns the result of `traits_inst.imbue(l)` where `traits_inst` is
 a (default initialized) instance of the template parameter `traits` stored
 within the object. Calls to `imbue` invalidate any currently contained
-regular expression.
-
-[*Postcondition]: `empty() == true`.
+regular expression.\n
+[*作用]: 返回 `traits_inst.imbue(l)` 的结果,其中 `traits_inst` 是模板参数 `traits` 的默认初始化的实例。
+调用 `imbue` 使当前存储的正则表达式无效。
+
+[*Postcondition]: `empty() == true`.\n
+[*后验条件]: `empty() == true`.

 [#boost_regex.basic_regex.getloc]

@@ -590,23 +655,28 @@

[*Effects]: Returns the result of `traits_inst.getloc()` where `traits_inst` is
 a (default initialized) instance of the template parameter traits stored
-within the object.
+within the object.\n
+[*作用]: 返回 `traits_inst.imbue(l)` 的结果,其中 `traits_inst` 是模板参数 `traits` 的默认初始化的实例。

 [#boost_regex.basic_regex.swap]

    void swap(basic_regex& e) throw();

-[*Effects]: Swaps the contents of the two regular expressions.
+[*Effects]: Swaps the contents of the two regular expressions.\n
+[*作用]: 交换两个正则表达式的内容。

[*Postcondition]: `*this` contains the regular expression that was in /e/, /e/ contains
-the regular expression that was in `*this`.
-
-[*Complexity]: constant time.
+the regular expression that was in `*this`.\n
+[*后验条件]: `*this` 包含 /e/ 中原有的正则表达式,/e/ 则包含 `*this` 中原有 的正则表达式。
+
+[*Complexity]: constant time.\n
+[*复杂度]: 常量时间。

 [note Comparisons between [basic_regex] objects are provided on an
 experimental basis: please note that these are not present in the [tr1],
 so use with care if you are writing code that may need to be ported
-to other implementations of [basic_regex].]
+to other implementations of [basic_regex].\n
+[basic_regex] 对象间的比较是实验性的:注意这不在 [tr1] 中,所以如果你想要移 植到其他 [basic_regex] 实现时需要注意。]

 [#boost_regex.basic_regex.op_eq]

@@ -614,7 +684,8 @@
    bool operator == (const basic_regex<charT, traits>& lhs,
                      const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) == 0`.
+[*Effects]: Returns `lhs.compare(rhs) == 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) == 0`.

 [#boost_regex.basic_regex.op_ne]

@@ -622,7 +693,8 @@
    bool operator != (const basic_regex<charT, traits>& lhs,
                      const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) != 0`.
+[*Effects]: Returns `lhs.compare(rhs) != 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) != 0`.

 [#boost_regex.basic_regex.op_lt]

@@ -630,7 +702,8 @@
    bool operator < (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) < 0`.
+[*Effects]: Returns `lhs.compare(rhs) < 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) < 0`.

 [#boost_regex.basic_regex.op_le]

@@ -638,7 +711,8 @@
    bool operator <= (const basic_regex<charT, traits>& lhs,
                      const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) <= 0`.
+[*Effects]: Returns `lhs.compare(rhs) <= 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) <= 0`.

 [#boost_regex.basic_regex.op_ge]

@@ -646,7 +720,8 @@
    bool operator >= (const basic_regex<charT, traits>& lhs,
                      const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) >= 0`.
+[*Effects]: Returns `lhs.compare(rhs) >= 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) >= 0`.

 [#boost_regex.basic_regex.op_gt]

@@ -654,10 +729,12 @@
    bool operator > (const basic_regex<charT, traits>& lhs,
                   const basic_regex<charT, traits>& rhs);

-[*Effects]: Returns `lhs.compare(rhs) > 0`.
+[*Effects]: Returns `lhs.compare(rhs) > 0`.\n
+[*作用]: 返回 `lhs.compare(rhs) > 0`.

 [note The basic_regex stream inserter is provided on an experimental basis,
-and outputs the textual representation of the expression to the stream.]
+and outputs the textual representation of the expression to the stream.\n
+basic_regex 的流插入是实验性的,表达式到流的文本表示的输出同样是实验性的。]

 [#boost_regex.basic_regex.op_stream]

@@ -666,7 +743,8 @@
       operator << (basic_ostream<charT, io_traits>& os
                   const basic_regex<charT, re_traits>& e);

-[*Effects]: Returns `(os << e.str())`.
+[*Effects]: Returns `(os << e.str())`.\n
+[*作用]: 返回 `(os << e.str())`.

 [#boost_regex.basic_regex.op_swap]

@@ -674,7 +752,8 @@
    void swap(basic_regex<charT, traits>& lhs,
             basic_regex<charT, traits>& rhs);

-[*Effects]: calls `lhs.swap(rhs)`.
+[*Effects]: calls `lhs.swap(rhs)`.\n
+[*作用]: 调用 `lhs.swap(rhs)`.

 [endsect]

=======================================
--- /trunk/libs/regex/doc/captures.qbk  Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/captures.qbk  Thu May 27 20:09:44 2010
@@ -6,29 +6,35 @@
 ]


-[section:captures Understanding Marked Sub-Expressions and Captures]
+[section:captures Understanding Marked Sub-Expressions and Captures 理解被 标记子表达式和捕捉]

 Captures are the iterator ranges that are "captured" by marked
 sub-expressions as a regular expression gets matched.  Each marked
 sub-expression can result in more than one capture, if it is matched
 more than once.  This document explains how captures and marked
-sub-expressions in Boost.Regex are represented and accessed.
-
-[h4 Marked sub-expressions]
+sub-expressions in Boost.Regex are represented and accessed.\n
+捕捉是当正则表达式匹配时由被标记的子表达式"捕获"的迭代器范围。
+每个被标记的子表达式可以导致一个或多个捕捉(如果匹配多次)。
+本文档解释了捕捉和被标记子表达式在Boost.Regex中如何被表示和做到的。
+
+[h4 Marked sub-expressions 被标记子表达式]

 Every time a Perl regular expression contains a parenthesis group `()`, it
 spits out an extra field, known as a marked sub-expression,
-for example the expression:
+for example the expression:\n
+Perl正则表达式每包含一个括号组 `()`,就会分离出一部分区域,命名为被标记子表 达式,例如:

 [pre (\w+)\W+(\w+)]

 Has two marked sub-expressions (known as $1 and $2 respectively), in
 addition the complete match is known as $&, everything before the
 first match as $\`, and everything after the match as $'.  So
-if the above expression is searched for within `"@abc def--"`, then we obtain: +if the above expression is searched for within `"@abc def--"`, then we obtain:\n +有两个标记子表达式(分别为$1和$2),全部的匹配被命名为$&,第一个匹配前的部分 为$\`,匹配后的部分为$'。
+如果上面的表达式用来搜索 `"@abc def--"`,会有:

 [table
-[[Sub-expression][Text found]]
+[[Sub-expression 子表达式][Text found 得到的文本]]
 [[$\`]["@"]]
 [[$&]["abc def"]]
 [[$1]["abc"]]
@@ -38,11 +44,14 @@

 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:
+([regex_search], [regex_match], or [regex_iterator]).  So given:\n
+在Boost.Regex中上面所有都可以通过 [match_results] 类获得,
+这个类在以下某个正则表达式匹配算法([regex_search], [regex_match], 或 [regex_iterator])中被填充。如下:

    boost::match_results<IteratorType> m;

-The Perl and Boost.Regex equivalents are as follows:
+The Perl and Boost.Regex equivalents are as follows:\n
+Perl和Boost.Regex按照下面的方式对应:

 [table
 [[Perl][Boost.Regex]]
@@ -58,40 +67,51 @@
 operators provided so that objects of 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.
-
-[h4 Unmatched Sub-Expressions]
+streamed out to an output stream.\n
+在Boost.Regex中每个子表达式的匹配都用一个 [sub_match] 对象来表示,最基本的 只是一对迭代器用来标识子表达式匹配的起始和终止位置, +但还有一些额外的操作符,使得 [sub_match] 类的对象看起来像 `std::basic_string`:例如它们可以被隐式转换为 `basic_string`,
+可以与字符串作比较,添加到字符中,或者流出到一个输出流中。
+
+[h4 Unmatched Sub-Expressions 不匹配的子表达式]

 When a regular expression match is found there is no need for all of the
-marked sub-expressions to have participated in the match, for example the expression: +marked sub-expressions to have participated in the match, for example the expression:\n
+当正则表达式找到一个匹配时,并不需要所有的标记子表达式都有匹配,例如:

 [pre (abc)|(def)]

 can match either $1 or $2, but never both at the same time.  In Boost.Regex
 you can determine which sub-expressions matched by accessing the
-`sub_match::matched` data member.
-
-[h4 Repeated Captures]
+`sub_match::matched` data member.\n
+可以匹配$1或者$2,但绝不会同时。在Boost.Regex中你可以通过访问 `sub_match::matched` 数据成员来知道哪个子表达式被匹配了。
+
+[h4 Repeated Captures 重复捕捉]

 When a marked sub-expression is repeated, then the sub-expression gets
"captured" multiple times, however normally only the final capture is available,
-for example if
+for example if\n
+标记子表达式被重复时,子表达式被"捕捉"多次,但通常只有最后一次捕捉可得,例 如,如果

 [pre (?:(\w+)\W+)+]

-is matched against
+is matched against\n
+用于匹配

 [pre one fine day]

Then $1 will contain the string "day", and all the previous captures will have
-been forgotten.
+been forgotten.\n
+$1包含字符串"day",前面所有的捕捉都被抛弃了。

However, Boost.Regex has an experimental feature that allows all the capture
 information to be retained - this is accessed either via the
`match_results::captures` member function or the `sub_match::captures` member function. These functions return a container that contains a sequence of all the captures obtained during the regular expression matching. The following
-example program shows how this information may be used:
+example program shows how this information may be used:\n
+但是,Boost.Regex有一个实验性的特性使得所有捕获的信息都被保留 - 这可以通过 `match_results::captures` 成员函数或 +`sub_match::captures` 成员函数获取。这些函数返回一个容器包含在正则表达式匹 配过程中所有捕获信息的序列。
+下面的例子展示了这个信息如何被使用:

    #include <boost/regex.hpp>
    #include <iostream>
@@ -139,7 +159,8 @@
       return 0;
    }

-Which produces the following output:
+Which produces the following output:\n
+输出如下:

 [pre
 Expression:  "(([[:lower:\]\]+)|([[:upper:\]\]+))+"
@@ -191,10 +212,13 @@

 Unfortunately enabling this feature has an impact on performance
 (even if you don't use it), and a much bigger impact if you do use it,
-therefore to use this feature you need to:
-
-* Define BOOST_REGEX_MATCH_EXTRA for all translation units including the library source (the best way to do this is to uncomment this define in boost/regex/user.hpp and then rebuild everything. -* Pass the match_extra flag to the particular algorithms where you actually need the captures information (regex_search, regex_match, or regex_iterator).
+therefore to use this feature you need to:\n
+不幸的是,激活这个特性会造成性能影响(即使你不使用),如果你使用就会有更大的 影响,因此为了使用这个特性你需要:
+
+* Define BOOST_REGEX_MATCH_EXTRA for all translation units including the library source (the best way to do this is to uncomment this define in boost/regex/user.hpp and then rebuild everything.\n + 在所有编译单元中定义BOOST_REGEX_MATCH_EXTRA,包括库源码(最好的方式是在 boost/regex/user.hpp中取消注释这行,然后重新生成所有的东西)。 +* Pass the match_extra flag to the particular algorithms where you actually need the captures information (regex_search, regex_match, or regex_iterator).\n + 将参数match_extra标记传入你想要使用这个捕获信息的特定算法(regex_search、 regex_match或regex_iterator)。

 [endsect]

=======================================
--- /trunk/libs/regex/doc/character_class_names.qbk     Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/character_class_names.qbk     Thu May 27 20:09:44 2010
@@ -6,45 +6,66 @@
 ]


-[section:character_classes Character Class Names]
-
-[section:std_char_clases Character Classes that are Always Supported]
-
-The following character class names are always supported by Boost.Regex:
+[section:character_classes Character Class Names 字符类名称]
+
+[section:std_char_clases Character Classes that are Always Supported 均被支 持的字符类]
+
+The following character class names are always supported by Boost.Regex:\n
+下面的字符类名称总被Boost.Regex支持:

 [table
-[[Name]        [POSIX-standard name]   [Description]]
-[[alnum]       [Yes]   [Any alpha-numeric character.]]
-[[alpha]       [Yes]   [Any alphabetic character.]]
-[[blank]       [Yes]   [Any whitespace character that is not a line 
separator.]]
-[[cntrl]       [Yes]   [Any control character.]]
-[[d]         [No]      [Any decimal digit]]
-[[digit]       [Yes]   [Any decimal digit.]]
-[[graph]       [Yes]   [Any graphical character.]]
-[[l]         [No]      [Any lower case character.]]
-[[lower]       [Yes]   [Any lower case character.]]
-[[print]       [Yes]   [Any printable character.]]
-[[punct]       [Yes]   [Any punctuation character.]]
-[[s]         [No]      [Any whitespace character.]]
-[[space]       [Yes]   [Any whitespace character.]]
-[[unicode] [No] [Any extended character whose code point is above 255 in value.]]
-[[u]         [No]      [Any upper case character.]]
-[[upper]       [Yes]   [Any upper case character.]]
-[[w] [No] [Any word character (alphanumeric characters plus the underscore).]] -[[word] [No] [Any word character (alphanumeric characters plus the underscore).]]
-[[xdigit]      [Yes]   [Any hexadecimal digit character.]]
+[[Name 名称]       [POSIX-standard name 是否POSIX标准名称]     [Description 说明]]
+[[alnum]       [Yes]   [Any alpha-numeric character.\n
+任意单词-数字字符。]]
+[[alpha]       [Yes]   [Any alphabetic character.\n
+任意单词字符。]]
+[[blank]       [Yes]   [Any whitespace character that is not a line 
separator.\n
+非行分隔符的任意空白字符。]]
+[[cntrl]       [Yes]   [Any control character.\n
+任意控制字符。]]
+[[d]         [No]      [Any decimal digit\n
+任意数字字符。]]
+[[digit]       [Yes]   [Any decimal digit.\n
+任意数字字符。]]
+[[graph]       [Yes]   [Any graphical character.\n
+任意图形字符。]]
+[[l]         [No]      [Any lower case character.\n
+任意小写字符。]]
+[[lower]       [Yes]   [Any lower case character.\n
+任意小写字符]]
+[[print]       [Yes]   [Any printable character.\n
+任意可打印字符。]]
+[[punct]       [Yes]   [Any punctuation character.\n
+任意标点字符。]]
+[[s]         [No]      [Any whitespace character.\n
+任意空白字符。]]
+[[space]       [Yes]   [Any whitespace character.\n
+任意空白字符。]]
+[[unicode] [No] [Any extended character whose code point is above 255 in value.\n
+任意码点高于255的扩展字符。 ]]
+[[u]         [No]      [Any upper case character.\n
+任意大写字符。]]
+[[upper]       [Yes]   [Any upper case character.\n
+任意大写字符。]]
+[[w] [No] [Any word character (alphanumeric characters plus the underscore).\n
+任意单词字符(字母、数字和下划线)。]]
+[[word] [No] [Any word character (alphanumeric characters plus the underscore).\n
+任意单词字符(字母、数字和下划线)。]]
+[[xdigit]      [Yes]   [Any hexadecimal digit character.\n
+任意十六进制数字字符。]]
 ]

 [endsect]

-[section:optional_char_class_names Character classes that are supported by Unicode Regular Expressions] +[section:optional_char_class_names Character classes that are supported by Unicode Regular Expressions 被Unicode正则表达式支持的字符类]

The following character classes are only supported by Unicode Regular Expressions:
 that is those that use the `u32regex` type.  The names used are the same as
-those from Chapter 4 of the Unicode standard.
+those from Chapter 4 of the Unicode standard.\n
+下面的字符类只被Unicode正则表达式支持:那些使用 `u32regex` 的情况。使用的名 称和第4章Unicode标准中使用的一样。

 [table
-[[Short Name]  [Long Name]]
+[[Short Name 短名称]         [Long Name 长名称]]
 [[ ]   [ASCII]]
 [[ ]   [Any]]
 [[ ]   [Assigned]]
=======================================
--- /trunk/libs/regex/doc/collating_names.qbk   Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/collating_names.qbk   Thu May 27 20:09:44 2010
@@ -6,33 +6,38 @@
 ]


-[section:collating_names Collating Names]
-
-[section:digraphs Digraphs]
-
-The following are treated as valid digraphs when used as a collating name:
+[section:collating_names Collating Names 对照名称]
+
+[section:digraphs Digraphs 连字]
+
+The following are treated as valid digraphs when used as a collating name:\n
+作为对照元素名称时下面的情况被当作合法的连字:

 "ae", "Ae", "AE", "ch", "Ch", "CH", "ll", "Ll", "LL", "ss", "Ss", "SS", "nj", "Nj", "NJ", "dz", "Dz", "DZ", 
"lj", "Lj", "LJ".

-So for example the expression:
+So for example the expression:\n
+如下例:

 [pre \[\[.ae.\]-c\] ]

-will match any character that collates between the digraph "ae" and the character "c". +will match any character that collates between the digraph "ae" and the character "c".\n
+可以匹配在连字"ae"到字符"c"范围之间的任意字符。

 [endsect]

-[section:posix_symbolic_names POSIX Symbolic Names]
+[section:posix_symbolic_names POSIX Symbolic Names  POSIX符号名]

The following symbolic names are recognised as valid collating element names,
-in addition to any single character, this allows you to write for example:
+in addition to any single character, this allows you to write for example:\n +下面的符号名称可以被识别为合法的对照元素名称,对于单字符的补充,你可以下面 这样写:

 [pre \[\[.left-square-bracket.\]\[.right-square-bracket.\]\]]

-if you wanted to match either "\[" or "\]".
+if you wanted to match either "\[" or "\]".\n
+如果你想要匹配 "\[" 或 "\]"。

 [table
-[[Name][Character]]
+[[Name 名称][Character 字符]]
 [[NUL]         [\\x00]]
 [[SOH]         [\\x01]]
 [[STX]         [\\x02]]
@@ -113,15 +118,18 @@

 [endsect]

-[section:named_unicode Named Unicode Characters]
+[section:named_unicode Named Unicode Characters 命名Unicode字符]

When using [link boost_regex.unicode 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:
+are recognised.  So for example:\n
+使用 [link boost_regex.unicode Unicode相关正则表达式] (使用 `u32regex` 类型 ),
+所有应用于Unicode字符(见Unidata.txt)的符号名称都可以被识别。例如:

 [pre \[\[.CYRILLIC CAPITAL LETTER I.\]\] ]

-would match the Unicode character 0x0418.
+would match the Unicode character 0x0418.\n
+匹配Unicode字符0x0418。

 [endsect]
 [endsect]
=======================================
--- /trunk/libs/regex/doc/concepts.qbk  Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/concepts.qbk  Thu May 27 20:09:44 2010
@@ -6,42 +6,57 @@
 ]


-[section:concepts Concepts]
-
-[section:charT_concept charT Requirements]
+[section:concepts Concepts 概念]
+
+[section:charT_concept charT Requirements  charT的要求]

 Type `charT` used a template 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/ and /c2/ of type `charT const`,
-and /i/ of type `int`:
+and /i/ of type `int`:\n
+类型 `charT` 作为类模板 [basic_regex] 的参数,必须有平凡的默认构造函数,拷 贝构造函数,赋值操作符和析构函数。 +另外,对于对象 (/c/ 类型为 `charT`、/c1/ 和 /c2/ 类型为 `charT const`、/i/ 类型为 `int`),下面的需求必须被满足:

 [table
-[[Expression]  [Return type]   [Assertion / Note / Pre- / Post-condition]]
-[[charT c]     [charT]         [Default constructor (must be trivial).]]
-[[charT c(c1)]         [charT]         [Copy constructor (must be trivial).]]
-[[c1 = c2]     [charT]         [Assignment operator (must be trivial).]]
-[[c1 == c2]    [bool]  [true if c1 has the same value as c2.]]
-[[c1 != c2]    [bool]  [true if c1 and c2 are not equal.]]
-[[c1 < c2]     [bool]       [true if the value of c1 is less than c2.]]
-[[c1 > c2]  [bool]  [true if the value of c1 is greater than c2.]]
-[[c1 <= c2]         [bool]  [true if c1 is less than or equal to c2.]]
-[[c1 >= c2]         [bool]  [true if c1 is greater than or equal to c2.]]
-[[intmax_t i = c1]     [int    ] [charT must be convertible to an integral 
type.
-
-Note: type charT is not required to support this operation, if the traits class used supports the full Boost-specific interface, rather than the minimal standardised-interface (see traits class requirements below).]] -[[charT c(i);] [charT] [charT must be constructable from an integral type.]] +[[Expression 表达式] [Return type 返回类型] [Assertion / Note / Pre- / Post-condition 断言/说明/前提条件/后验条件]]
+[[charT c]     [charT]         [Default constructor (must be trivial).\n
+缺省构造函数(必须是平凡的)。]]
+[[charT c(c1)]         [charT]         [Copy constructor (must be trivial).\n
+复制构造函数(必须是平凡的)。]]
+[[c1 = c2]     [charT]         [Assignment operator (must be trivial).\n
+赋值操作符(必须是平凡的)。]]
+[[c1 == c2]    [bool]  [true if c1 has the same value as c2.\n
+如果 c1 具有与 c2 相同的值则为 true。]]
+[[c1 != c2]    [bool]  [true if c1 and c2 are not equal.\n
+如果 c1 与 c2 不相等则为 true。]]
+[[c1 < c2]     [bool]       [true if the value of c1 is less than c2.\n
+如果 c1 的值小于 c2 则为 true。]]
+[[c1 > c2]  [bool]  [true if the value of c1 is greater than c2.\n
+如果 c1 的值大于 c2 则为 true。]]
+[[c1 <= c2]         [bool]  [true if c1 is less than or equal to c2.\n
+如果 c1 的值小于或等于 c2 则为 true。]]
+[[c1 >= c2]         [bool]  [true if c1 is greater than or equal to c2.\n
+如果 c1 的值大于或等于 c2 则为 true。]]
+[[intmax_t i = c1] [int ] [charT must be convertible to an integral type.\n
+charT 必须能被转化为整数类型。
+
+Note: type charT is not required to support this operation, if the traits class used supports the full Boost-specific interface, rather than the minimal standardised-interface (see traits class requirements below).\n +注意:如果使用的特性类支持全部的 Boost 特定接口,而不是最小的标准接口 (参见 下面的 traits类的要求),类型 charT 并不要求支持这个操作。]] +[[charT c(i);] [charT] [charT must be constructable from an integral type.\n
+charT 必须能从整数类型构造。]]
 ]

 [endsect]

-[section:traits_concept Traits Class Requirements]
+[section:traits_concept Traits Class Requirements  Traits类的要求]

 There are two sets of requirements for the `traits` template argument to
[basic_regex]: a mininal interface (which is part of the regex standardization proposal),
-and an optional Boost-specific enhanced interface.
-
-[h4 Minimal requirements.]
+and an optional Boost-specific enhanced interface.\n
+[basic_regex] 使用的 `traits` 模板参数有两种需求的集合:最小接口(正则表达式 标准化提议的一部分),和可选的 Boost 特定的增强接口。
+
+[h4 Minimal requirements 最小要求]

In the following table `X` denotes a traits class defining types and functions for
 the character container type `charT`; /u/ is an object of type `X`; /v/ is
@@ -50,55 +65,89 @@
 /s/ is an object of type `X::string_type`; /cs/ is an object of type
 `const X::string_type`; /b/ is a value of type `bool`; /I/ is a value of
 type `int`; /F1/ and /F2/ are values of type `const charT*`; and /loc/ is
-an object of type `X::locale_type`.
+an object of type `X::locale_type`.\n
+在下面的表格中 `X` 表示为字符容器类型 `charT` 定义类型和函数的特性类;/u/ 是类型 `X` 的对象;/v/ 是类型 `const X` 的对象; +/p/ 是类型为 `const charT*` 的值;/I1/ 和 /I2/ 是输入迭代器;/c/ 是 `const charT` 类型的值;/s/ 是 `X::string_type` 类型的对象; +/cs/ 是 `const X::string_type` 类型的对象;/b/ 是 `bool` 类型的值;/I/ 是 `int` 类型的值;/F1/ 和 /F2/ 是 `const charT*` 类型的值;
+/loc/ 是 `X::locale_type` 类型的对象。

 [table
-[[Expression][Return type][Assertion / Note Pre / Post condition]]
-[[X::char_type][charT][The character container type used in the implementation of class template basic_regex.]] -[[X::size_type][][An unsigned integer type, capable of holding the length of a null-terminated string of charT's.]] +[[Expression 表达式][Return type 返回类型][Assertion / Note Pre / Post condition 断言/说明/前提条件/后验条件]] +[[X::char_type][charT][The character container type used in the implementation of class template basic_regex.\n
+用于实现类模板 basic_regex 的字符容器类型。]]
+[[X::size_type][][An unsigned integer type, capable of holding the length of a null-terminated string of charT's.\n
+无符号整数类型,用于存储 NULL 结尾的 charT 类型的字符串长度。]]
 [[X::string_type][std::basic_string<charT> or std::vector<charT>][]]
-[[X::locale_type][Implementation defined][A copy constructible type that represents the locale used by the traits class.]] -[[X::char_class_type][Implementation defined][A bitmask type representing a particular character classification. Multiple values of this type can be bitwise-or'ed together to obtain a new valid value.]] -[[X::length(p)][X::size_type][Yields the smallest i such that p\[i\] == 0. Complexity is linear in i.]] -[[v.translate(c)][X::char_type][Returns a character such that for any character d that is to be considered equivalent to c then v.translate(c) == v.translate(d).]] -[[v.translate_nocase(c)][X::char_type][For all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then v.translate_nocase(c) == v.translate_nocase(C).]] -[[v.transform(F1, F2)][X::string_type][Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if the character sequence \[G1, G2) sorts before the character sequence [H1, H2) then v.transform(G1, G2) < v.transform(H1, H2). ]] -[[v.transform_primary(F1, F2)][X::string_type][Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if the character sequence [G1, G2) sorts before the character sequence \[H1, H2) when character case is not considered then v.transform_primary(G1, G2) < v.transform_primary(H1, H2).]] -[[v.lookup_classname(F1, F2)][X::char_class_type][Converts the character sequence designated by the iterator range \[F1,F2) into a bitmask type that can subsequently be passed to isctype. Values returned from lookup_classname can be safely bitwise or'ed together. Returns 0 if the character sequence is not the name of a character class recognized by X. The value returned shall be independent of the case of the characters in the sequence.]] -[[v.lookup_collatename(F1, F2)][X::string_type][Returns a sequence of characters that represents the collating element consisting of the character sequence designated by the iterator range \[F1, F2). Returns an empty string if the character sequence is not a valid collating element.]] -[[v.isctype(c, v.lookup_classname (F1, F2))][bool][Returns true if character c is a member of the character class designated by the iterator range \[F1, F2), false otherwise.]] -[[v.value(c, I)][int][Returns the value represented by the digit c in base I if the character c is a valid digit in base I; otherwise returns -1. \[Note: the value of I will only be 8, 10, or 16. -end note\]]] -[[u.imbue(loc)][X::locale_type][Imbues u with the locale loc, returns the previous locale used by u if any. ]] -[[v.getloc()][X::locale_type][Returns the current locale used by v if any. ]] +[[X::locale_type][Implementation defined][A copy constructible type that represents the locale used by the traits class.\n
+特性类用于表示区域 (locale) 的可拷贝构造类型。 ]]
+[[X::char_class_type][Implementation defined][A bitmask type representing a particular character classification. Multiple values of this type can be bitwise-or'ed together to obtain a new valid value.\n +用于表示特定字符分类的位掩码类型。该类的多个值可以通过位式运算得到一个新的 合法值。]] +[[X::length(p)][X::size_type][Yields the smallest i such that p\[i\] == 0. Complexity is linear in i.\n
+返回使 p\[i\] == 0 的最小的 i。i 的线性复杂度。]]
+[[v.translate(c)][X::char_type][Returns a character such that for any character d that is to be considered equivalent to c then v.translate(c) == v.translate(d).\n +返回一个字符,使得对于任意字符 d,如果 v.translate(c) == v.translate(d),则 d 和 c 被认为相等。]] +[[v.translate_nocase(c)][X::char_type][For all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then v.translate_nocase(c) == v.translate_nocase(C).\n +对所有字符 C,如果忽略大小写比较和 c 相等,则 v.translate_nocase(c) == v.translate_nocase(C)。]] +[[v.transform(F1, F2)][X::string_type][Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if the character sequence \[G1, G2) sorts before the character sequence [H1, H2) then v.transform(G1, G2) < v.transform(H1, H2). \n +返回由迭代器范围 \[F1, F2) 指定字符序列的排序关键字。即如果字符序列 \[G1, G2) 排在字符序列 \[H1, H2) 之前,则 v.transform(G1, G2) < v.transform(H1, H2)。]] +[[v.transform_primary(F1, F2)][X::string_type][Returns a sort key for the character sequence designated by the iterator range \[F1, F2) such that if the character sequence [G1, G2) sorts before the character sequence \[H1, H2) when character case is not considered then v.transform_primary(G1, G2) < v.transform_primary(H1, H2).\n +返回由迭代器范围 \[F1, F2) 指定字符序列的排序关键字。 如果不考虑字符大小 写,字符序列 \[G1, G2) 排在字符序列 \[H1, H2) 之前,则 v.transform_primary(G1, G2) < v.transform_primary(H1, H2)。 ]] +[[v.lookup_classname(F1, F2)][X::char_class_type][Converts the character sequence designated by the iterator range \[F1,F2) into a bitmask type that can subsequently be passed to isctype. Values returned from lookup_classname can be safely bitwise or'ed together. Returns 0 if the character sequence is not the name of a character class recognized by X. The value returned shall be independent of the case of the characters in the sequence.\n +返回由迭代器范围 \[F1,F2) 指定字符序列转换的可传入 isctype 的位掩码类型。 lookup_classname 返回的值可以用位或运算安全地组合。 如果字符序列不是 X 能识 别的字符类名称则返回 0。 返回值应与序列中字符的大小写无关。]] +[[v.lookup_collatename(F1, F2)][X::string_type][Returns a sequence of characters that represents the collating element consisting of the character sequence designated by the iterator range \[F1, F2). Returns an empty string if the character sequence is not a valid collating element.\n +返回由迭代器序列 \[F1, F2) 指定字符序列组成的对照元素所对应的字符序列。 如 果字符序列不是有效的对照元素则返回空字符串。]] +[[v.isctype(c, v.lookup_classname (F1, F2))][bool][Returns true if character c is a member of the character class designated by the iterator range \[F1, F2), false otherwise.\n +如果 c 是迭代器范围 \[F1, F2) 指定字符类的成员则返回 true,否则返回 false。 ]] +[[v.value(c, I)][int][Returns the value represented by the digit c in base I if the character c is a valid digit in base I; otherwise returns -1. \[Note: the value of I will only be 8, 10, or 16. -end note\]\n +如果字符 c 在基数 I 下是合法的数字则返回这个数字;否则返回 -1。\[Note: I 的 值只能是 8、10 或 16。-end note\] ]] +[[u.imbue(loc)][X::locale_type][Imbues u with the locale loc, returns the previous locale used by u if any. \n
+将 u 的区域设为 loc,返回 u 之前使用的区域。]]
+[[v.getloc()][X::locale_type][Returns the current locale used by v if any. \n
+返回 v 当前使用的区域。]]
 ]

-[h4 Additional Optional Requirements]
+[h4 Additional Optional Requirements 其它的可选要求]

 The following additional requirements are strictly optional,
 however in 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 or absense of the member `boost_extensions_tag` and
-configure itself appropriately.
+configure itself appropriately.\n
+下面额外的需求是可选的,然而如果要 [basic_regex] 能够使用额外接口的优势,下 面所有的需求都必须满足; +[basic_regex] 会自动检测成员 `boost_extensions_tag` 存在与否来适当地设置自 己。


 [table
-[[Expression][Result][Assertion / Note Pre / Post condition]]
-[[X::boost_extensions_tag][An unspecified type.][When present, all of the extensions listed in this table must be present.]] -[[v.syntax_type(c)][regex_constants::syntax_type][Returns a symbolic value of type regex_constants::syntax_type that signifies the meaning of character c within the regular expression grammar.]] -[[v.escape_syntax_type(c)][regex_constants::escape_syntax_type][Returns a symbolic value of type regex_constants::escape_syntax_type, that signifies the meaning of character c within the regular expression grammar, when c has been preceded by an escape character. Precondition: if b is the character preceding c in the expression being parsed then: `v.syntax_type(b) == syntax_escape`]] -[[v.translate(c, b)][X::char_type][Returns a character d such that: for any character d that is to be considered equivalent to c then `v.translate(c,false)==v.translate(d,false)`. Likewise for all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then `v.translate(c,true)==v.translate(C,true)`.]] -[[v.toi(I1, I2, i)][An integer type capable of holding either a charT or an int.][Behaves as follows: if `p == q` or if `*p` is not a digit character then returns -1. Otherwise performs formatted numeric input on the sequence \[p,q) and returns the result as an int. Postcondition: either p == q or *p is a non-digit character.]] -[[v.error_string(I)][std::string][Returns a human readable error string for the error condition i, where i is one of the values enumerated by type regex_constants::error_type. If the value /I/ is not recognized then returns the string "Unknown error" or a localized equivalent.]] -[[v.tolower(c)][X::char_type][Converts c to lower case, used for Perl-style \l and \L formating operations.]] -[[v.toupper(c)][X::char_type][Converts c to upper case, used for Perl-style \u and \U formating operations.]] +[[Expression 表达式][Result 结果][Assertion / Note Pre / Post condition 断 言/说明/前提条件/后验条件]] +[[X::boost_extensions_tag][An unspecified type.][When present, all of the extensions listed in this table must be present.\n
+如果存在,则下面表格列出的所有扩展都必须存在。]]
+[[v.syntax_type(c)][regex_constants::syntax_type][Returns a symbolic value of type regex_constants::syntax_type that signifies the meaning of character c within the regular expression grammar.\n +返回 regex_constants::syntax_type 类型的符号值,用于表示字符 c 在正则表达式 文法中的含义。]] +[[v.escape_syntax_type(c)][regex_constants::escape_syntax_type][Returns a symbolic value of type regex_constants::escape_syntax_type, that signifies the meaning of character c within the regular expression grammar, when c has been preceded by an escape character. Precondition: if b is the character preceding c in the expression being parsed then: `v.syntax_type(b) == syntax_escape`\n +返回 regex_constants::escape_syntax_type 类型的符号值,用于表示在正则表达式 文法中字符 c 前跟转义符号时的含义。 +前提条件:如果字符 b 是在表达式翻译中 c 之前的字符,则:`v.syntax_type(b) == syntax_escape`]] +[[v.translate(c, b)][X::char_type][Returns a character d such that: for any character d that is to be considered equivalent to c then `v.translate(c,false)==v.translate(d,false)`. Likewise for all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then `v.translate(c,true)==v.translate(C,true)`.\n +返回满足如下条件的字符 d:对于任意被认为与 c 相等的字符 d,则有 `v.translate(c,false)==v.translate(d,false)`。 +同样,对于所有忽略大小写比较中认为与 c 相等的字符 C,有 `v.translate(c,true)==v.translate(C,true)`。 ]] +[[v.toi(I1, I2, i)][An integer type capable of holding either a charT or an int.\n +能够容纳 charT 或 int 的整数类型。][Behaves as follows: if `p == q` or if `*p` is not a digit character then returns -1. Otherwise performs formatted numeric input on the sequence \[p,q) and returns the result as an int. Postcondition: either `p == q` or `*p` is a non-digit character.\n +行为如下:如果 `p == q` 或如果 `*p` 不是数字字符,则返回 -1。否则在序列 \[p,q) 上执行数值格式输入并返回输入的结果 (int)。
+后验条件:`p == q` 或 `*p` 不是数字字符。]]
+[[v.error_string(I)][std::string][Returns a human readable error string for the error condition i, where i is one of the values enumerated by type regex_constants::error_type. If the value /I/ is not recognized then returns the string "Unknown error" or a localized equivalent.\n +为错误条件 i 返回可读的错误字符串,其中 i 是类型 regex_constants::error_type 的枚举值之一。如果 /I/ 不能被识别则返 回 "Unknown error" 或本地化等价的字符串。]] +[[v.tolower(c)][X::char_type][Converts c to lower case, used for Perl-style \l and \L formating operations.\n
+将 c 转为小写,用于 Perl 风格的 \l 和 \L 格式化操作。]]
+[[v.toupper(c)][X::char_type][Converts c to upper case, used for Perl-style \u and \U formating operations.\n
+将 c 转为大写,用于 Perl 风格的 \u 和 \U 格式化操作。]]
 ]

 [endsect]

-[section:iterator_concepts Iterator Requirements]
+[section:iterator_concepts Iterator Requirements 迭代器的要求]

 The regular expression algorithms (and iterators) take all require a
-Bidirectional-Iterator.
+Bidirectional-Iterator.\n
+正则表达式算法 (包括迭代器) 都要求双向迭代器。

 [endsect]

=======================================
--- /trunk/libs/regex/doc/configuration.qbk     Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/configuration.qbk     Thu May 27 20:09:44 2010
@@ -6,68 +6,86 @@
 ]


-[section:configuration Configuration]
-
-[section:compiler Compiler Setup]
+[section:configuration Configuration 配置]
+
+[section:compiler Compiler Setup 编译器设置]

 You shouldn't need to do anything special to configure Boost.Regex for use
with your compiler - the [@../../../config/index.html Boost.Config subsystem] should already take care of it,
 if you do have problems (or you are using a particularly obscure compiler
-or platform) then [@../../../config/index.html Boost.Config] has a configure script that you can run. +or platform) then [@../../../config/index.html Boost.Config] has a configure script that you can run.\n +你不需要为了使用Boost.Regex而对你的编译器做任何特殊的配置 - [@../../../config/index.html Boost.Config子系统] 会负责照管的, +如果你确实有问题(或者你使用了某个偏门的编译器或平台),那么 [@../../../config/index.html Boost.Config] 有一个你可以用的配置脚本。

 [endsect]

-[section:locale Locale and traits class selection]
+[section:locale Locale and traits class selection 本地化和traits类的选择]

The following macros (see [@../../../../boost/regex/user.hpp user.hpp]) control how Boost.Regex interacts with
-the user's locale:
+the user's locale:\n
+下面的宏(见 [@../../../../boost/regex/user.hpp user.hpp])控制了 Boost.Regex如果与用户的locale进行交互:

 [table
-[[macro][description]]
-[[BOOST_REGEX_USE_C_LOCALE][Forces Boost.Regex to use the global C locale in its traits class support: this is now deprecated in favour of the C++ locale.]] -[[BOOST_REGEX_USE_CPP_LOCALE][Forces Boost.Regex to use std::locale in it's default traits class, regular expressions can then be imbued with an instance specific locale. This is the default behaviour on non-Windows platforms.]] -[[BOOST_REGEX_NO_W32][Tells Boost.Regex not to use any Win32 API's even when available (implies BOOST_REGEX_USE_CPP_LOCALE unless BOOST_REGEX_USE_C_LOCALE is set).]]
+[[macro 宏][description 说明]]
+[[BOOST_REGEX_USE_C_LOCALE][Forces Boost.Regex to use the global C locale in its traits class support: this is now deprecated in favour of the C++ locale.\n +强制Boost.Regex使用C的全局locale设置:现在已经不推荐使用了,最好用C++的 locale代替。]] +[[BOOST_REGEX_USE_CPP_LOCALE][Forces Boost.Regex to use std::locale in it's default traits class, regular expressions can then be imbued with an instance specific locale. This is the default behaviour on non-Windows platforms.\n +强制Boost.Regex使用std::locale和默认的特性类,正则表达式就可以使用特定的 locale了。这是非Windows平台的默认选项。]] +[[BOOST_REGEX_NO_W32][Tells Boost.Regex not to use any Win32 API's even when available (implies BOOST_REGEX_USE_CPP_LOCALE unless BOOST_REGEX_USE_C_LOCALE is set).\n +告诉Boost.Regex不使用Win32的API,即使可以使用(默认为 BOOST_REGEX_USE_CPP_LOCALE除非定义了BOOST_REGEX_USE_C_LOCALE)。]]
 ]

 [endsect]


-[section:linkage Linkage Options]
+[section:linkage Linkage Options 链接选项]

 [table
-[[macro][description]]
-[[BOOST_REGEX_DYN_LINK][For Microsoft and Borland C++ builds, this tells Boost.Regex that it should link to the dll build of the Boost.Regex. By default boost.regex will link to its static library build, even if the dynamic C runtime library is in use.]] -[[BOOST_REGEX_NO_LIB][For Microsoft and Borland C++ builds, this tells Boost.Regex that it should not automatically select the library to link to.]]
+[[macro 宏][description 说明]]
+[[BOOST_REGEX_DYN_LINK][For Microsoft and Borland C++ builds, this tells Boost.Regex that it should link to the dll build of the Boost.Regex. By default boost.regex will link to its static library build, even if the dynamic C runtime library is in use.\n +对于Microsoft和Borland的C++编译器来说,这个宏告诉Boost.Regex链接到dll版本。 Boost.Regex默认链接到静态库,即使使用的是C动态运行时库。]] +[[BOOST_REGEX_NO_LIB][For Microsoft and Borland C++ builds, this tells Boost.Regex that it should not automatically select the library to link to.\n +对于Microsoft和Borland的C++编译器来说,这个宏告诉Boost.Regex不要自动选择链 接的库。]]
 ]

 [endsect]

-[section:algorithm Algorithm Selection]
+[section:algorithm Algorithm Selection 算法选择]

 [table
-[[macro][description]]
-[[BOOST_REGEX_RECURSIVE][Tells Boost.Regex to use a stack-recursive matching algorithm. This is generally the fastest option (although there is very little in it), but can cause stack overflow in extreme cases, on Win32 this can be handled safely, but this is not the case on other platforms.]] -[[BOOST_REGEX_NON_RECURSIVE][Tells Boost.Regex to use a non-stack recursive matching algorithm, this can be slightly slower than the alternative, but is always safe no matter how pathological the regular expression. This is the default on non-Win32 platforms.]]
+[[macro 宏][description 说明]]
+[[BOOST_REGEX_RECURSIVE][Tells Boost.Regex to use a stack-recursive matching algorithm. This is generally the fastest option (although there is very little in it), but can cause stack overflow in extreme cases, on Win32 this can be handled safely, but this is not the case on other platforms.\n +Boost.Regex将使用栈递归的匹配算法。通常这是最快的选项(改善可能很小),但在极 端情况下可能导致栈溢出,Win32平台上这可以被安全地处理,
+但在其它平台上不能。]]
+[[BOOST_REGEX_NON_RECURSIVE][Tells Boost.Regex to use a non-stack recursive matching algorithm, this can be slightly slower than the alternative, but is always safe no matter how pathological the regular expression. This is the default on non-Win32 platforms.\n +Boost.Regex将使用非栈递归匹配算法,这可能会稍微慢一点,但无论正则表达式如何 变态都总是安全的。这是非Win32平台的默认选项。]]
 ]

 [endsect]

-[section:tuning Algorithm Tuning]
-
-The following option applies only if BOOST_REGEX_RECURSIVE is set.
+[section:tuning Algorithm Tuning 算法调优]
+
+The following option applies only if BOOST_REGEX_RECURSIVE is set.\n
+下面选项只有当BOOST_REGEX_RECURSIVE定义时才有效:

 [table
-[[macro][description]]
-[[BOOST_REGEX_HAS_MS_STACK_GUARD][Tells Boost.Regex that Microsoft style __try - __except blocks are supported, and can be used to safely trap stack overflow.]]
+[[macro 宏][description 说明]]
+[[BOOST_REGEX_HAS_MS_STACK_GUARD][Tells Boost.Regex that Microsoft style __try - __except blocks are supported, and can be used to safely trap stack overflow.\n
+使Boost.Regex支持Microsoft的__try - __except块,能够安全地处理栈溢出。]]
 ]


-The following options apply only if BOOST_REGEX_NON_RECURSIVE is set.
+The following options apply only if BOOST_REGEX_NON_RECURSIVE is set.\n
+当BOOST_REGEX_NON_RECURSIVE被定义时下面选项有效:

 [table
-[[macro][description]]
-[[BOOST_REGEX_BLOCKSIZE][In non-recursive mode, Boost.Regex uses largish blocks of memory to act as a stack for the state machine, the larger the block size then the fewer allocations that will take place. This defaults to 4096 bytes, which is large enough to match the vast majority of regular expressions without further allocations, however, you can choose smaller or larger values depending upon your platforms characteristics.]] -[[BOOST_REGEX_MAX_BLOCKS][Tells Boost.Regex how many blocks of size BOOST_REGEX_BLOCKSIZE it is permitted to use. If this value is exceeded then Boost.Regex will stop trying to find a match and throw a std::runtime_error. Defaults to 1024, don't forget to tweek this value if you alter BOOST_REGEX_BLOCKSIZE by much.]]
+[[macro 宏][description 说明]]
+[[BOOST_REGEX_BLOCKSIZE][In non-recursive mode, Boost.Regex uses largish blocks of memory to act as a stack for the state machine, the larger the block size then the fewer allocations that will take place. This defaults to 4096 bytes, which is large enough to match the vast majority of regular expressions without further allocations, however, you can choose smaller or larger values depending upon your platforms characteristics.\n +在非递归模式下,Boost.Regex使用大块的内存作为状态机的栈,块越大则分配行为越 少。 +默认为4096字符,对于大多数正则表达式来说不需要额外分配就足够了,但是,你可 以根据自己平台特性来选择更大或更小的数值。]] +[[BOOST_REGEX_MAX_BLOCKS][Tells Boost.Regex how many blocks of size BOOST_REGEX_BLOCKSIZE it is permitted to use. If this value is exceeded then Boost.Regex will stop trying to find a match and throw a std::runtime_error. Defaults to 1024, don't forget to tweek this value if you alter BOOST_REGEX_BLOCKSIZE by much.\n +定义BOOST_REGEX_BLOCKSIZE大小的块最多可以有多少个。如果这个值被超过了,那么 Boost.Regex将停止匹配尝试并扔出std::runtime_error。
+默认为1024,如果你大幅度改动BOOST_REGEX_BLOCKSIZE,别忘了修改这个值。]]
[[BOOST_REGEX_MAX_CACHE_BLOCKS][Tells Boost.Regex how many memory blocks to store in it's internal cache - memory blocks are taken from this cache rather than by calling ::operator new. Generally speeking this can be an order of magnitude faster than
@@ -76,7 +94,12 @@
up to 16 blocks each of BOOST_REGEX_BLOCKSIZE size). If memory is tight then try defining this to 0 (disables all caching), or if that is too slow, then a value of 1 or 2, may be sufficient. On the other hand, on large multi-processor,
-multi-threaded systems, you may find that a higher value is in order.]]
+multi-threaded systems, you may find that a higher value is in order.\n
+定义在内部缓存中存储多少内存块 - 内存块将优先从缓存中取得而不是调 用::operator new。
+通常来说,这会比每次需要内存时都调用::operator new快上一个数量级,
+但当Boost.Regex持有一大块缓存时会呈下降趋势(默认为16个 BOOST_REGEX_BLOCKSIZE大小的内存块)。 +如果内存紧张可以尝试将其定义为0(禁用所有缓存),如果太慢,那么1或2可能就足够 了。 +另一方面,对于一个大型的多处理器、多线程系统,你可能会觉得一个更大的数值可 能更好。]]
 ]

 [endsect]
=======================================
--- /trunk/libs/regex/doc/error_type.qbk        Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/error_type.qbk        Thu May 27 20:09:44 2010
@@ -8,10 +8,11 @@

 [section:error_type error_type]

-[h4 Synopsis]
+[h4 Synopsis 概要]

 Type error type represents the different types of errors that can be raised
-by the library when parsing a regular expression.
+by the library when parsing a regular expression.\n
+`error_type` 类型表示库分析正则表达式时可能遇到的不同类型错误。

    namespace boost{ namespace regex_constants{

@@ -36,27 +37,42 @@
    } // namespace boost


-[h4 Description]
+[h4 Description 说明]

The type `error_type` is an implementation-specific enumeration type that may
-take one of the following values:
+take one of the following values:\n
+`error_type` 类型是实现相关的枚举类型,可以有如下值:

 [table
-[[Constant][Meaning]]
-[[error_collate][An invalid collating element was specified in a \[\[.name.\]\] block.]] -[[error_ctype][An invalid character class name was specified in a \[\[:name:\]\] block.]]
-[[error_escape][An invalid or trailing escape was encountered.]]
-[[error_backref][A back-reference to a non-existant marked sub-expression was encountered.]]
-[[error_brack][An invalid character set \[...\] was encountered.]]
-[[error_paren][Mismatched '(' and ')'.]]
-[[error_brace][Mismatched '{' and '}'.]]
-[[error_badbrace][Invalid contents of a {...} block.]]
-[[error_range][A character range was invalid, for example \[d-a\].]]
-[[error_space][Out of memory.]]
-[[error_badrepeat][An attempt to repeat something that can not be repeated - for example a*+]]
-[[error_complexity][The expression became too complex to handle.]]
-[[error_stack][Out of program stack space.]]
-[[error_bad_pattern][Other unspecified errors.]]
+[[Constant 常量][Meaning 含义]]
+[[error_collate][An invalid collating element was specified in a \[\[.name.\]\] block.\n
+\[\[.name.\]\] 块中指定了非法的对照元素。]]
+[[error_ctype][An invalid character class name was specified in a \[\[:name:\]\] block.\n
+\[\[:name:\]\] 块中指定了无效的字符类名称。]]
+[[error_escape][An invalid or trailing escape was encountered.\n
+出现了无效或末尾的转义符。]]
+[[error_backref][A back-reference to a non-existant marked sub-expression was encountered.\n
+指向不存在的标记子表达式的后向引用。]]
+[[error_brack][An invalid character set \[...\] was encountered.\n
+无效的字符集 \[...\]。]]
+[[error_paren][Mismatched '(' and ')'.\n
+'(' 和 ')' 不匹配。]]
+[[error_brace][Mismatched '{' and '}'.\n
+'{' 和 '}' 不匹配。]]
+[[error_badbrace][Invalid contents of a {...} block.\n
+{...} 块内容无效。]]
+[[error_range][A character range was invalid, for example \[d-a\].\n
+字符范围无效,例如 \[d-a\]。]]
+[[error_space][Out of memory.\n
+内存溢出。]]
+[[error_badrepeat][An attempt to repeat something that can not be repeated - for example a*+\n
+试图将某些不能重复的东西重复 - 例如 a*+ ]]
+[[error_complexity][The expression became too complex to handle.\n
+表达式过于复杂,无法处理。]]
+[[error_stack][Out of program stack space.\n
+程序栈空间溢出。]]
+[[error_bad_pattern][Other unspecified errors.\n
+其他未指定错误。]]
 ]

 [endsect]
=======================================
--- /trunk/libs/regex/doc/examples.qbk  Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/examples.qbk  Thu May 27 20:09:44 2010
@@ -6,9 +6,9 @@
 ]


-[section:examples Test and Example Programs]
-
-[h4 Test Programs]
+[section:examples Test and Example Programs 测试与示例程序]
+
+[h4 Test Programs 测试程序]

 [*regress:]

@@ -16,9 +16,12 @@
 full workout. The presence of this program is your guarantee that the
 library will behave as claimed - at least as far as those items tested
 are concerned - if anyone spots anything that isn't being tested I'd be
-glad to hear about it.
-
-Files:
+glad to hear about it.\n
+回归测试程序对匹配/查找算法一次充分的考验。该程序的存在是本库能按要求工作的 保证 - 至少对于这些被测试的项目来说 -
+如果有人指出有哪件事情未被测试到,我很乐意听到。
+
+Files:\n
+文件:

 * [@../../test/regress/main.cpp main.cpp]
 * [@../../test/regress/basic_tests.cpp basic_tests.cpp]
@@ -46,33 +49,38 @@
 [*bad_expression_test:]

 Verifies that "bad" regular expressions don't cause the matcher to go into
-infinite loops, but to throw an exception instead.
+infinite loops, but to throw an exception instead.\n
+验证“坏的”正则表达式不会导致匹配器陷入无限循环,而是会抛出一个异常。

Files: [@../../test/pathology/bad_expression_test.cpp bad_expression_test.cpp].

 [*recursion_test:]

-Verifies that the matcher can't overrun the stack (no matter what the expression). +Verifies that the matcher can't overrun the stack (no matter what the expression).\n
+验证匹配器不会栈溢出(无论是什么表达式)。

 Files: [@../../test/pathology/recursion_test.cpp recursion_test.cpp].

 [*concepts:]

-Verifies that the library meets all documented concepts (a compile only test). +Verifies that the library meets all documented concepts (a compile only test).\n
+验证本库符合所列出的所有概念(只需测试编译)。

 Files: [@../../test/concepts/concept_check.cpp concept_check.cpp].

 [*captures_test:]

-Test code for captures.
+Test code for captures.\n
+有关捕获的测试代码。

 Files: [@../../test/captures/captures_test.cpp captures_test.cpp].

-[h4 Example programs]
+[h4 Example programs 示例程序]

 [*grep]

-A simple grep implementation, run with the -h command line option to find out its usage. +A simple grep implementation, run with the -h command line option to find out its usage.\n
+一个简单的 grep 实现,使用 -h 命令行选项运行,可以看到它的用法。

 Files: [@../../example/grep/grep.cpp grep.cpp]

@@ -80,13 +88,15 @@

 A simple interactive expression matching application, the results of all
matches are timed, allowing the programmer to optimize their regular expressions
-where performance is critical.
+where performance is critical.\n
+一个简单的交互式表达式匹配程序,所有匹配的结果被计时,允许程序员在性能是关 键因素时优化他们的正则表达式。

 Files: [@../../example/timer/regex_timer.cpp regex_timer.cpp].

-[h4 Code snippets]
-
-The snippets examples contain the code examples used in the documentation:
+[h4 Code snippets 代码片断]
+
+The snippets examples contain the code examples used in the documentation:\n
+这些代码片断包含了本文档中使用的示例代码:

[@../../example/snippets/captures_example.cpp captures_example.cpp]: Demonstrates the use of captures.

@@ -110,7 +120,8 @@

[@../../example/snippets/regex_token_iterator_eg_2.cpp regex_token_iterator_eg_2.cpp]: enumerate the linked URL's in a HTML file.

-The following are deprecated:
+The following are deprecated:\n
+以下是不再使用的:

[@../../example/snippets/regex_grep_example_1.cpp regex_grep_example_1.cpp]: regex_grep example 1: searches a cpp file for class definitions.

=======================================
--- /trunk/libs/regex/doc/faq.qbk       Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/faq.qbk       Thu May 27 20:09:44 2010
@@ -5,24 +5,31 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:faq FAQ]
-
-[*Q.] I can't get regex++ to work with escape characters, what's going on?
+[section:faq FAQ 常见问题]
+
+[*Q.] I can't get regex++ to work with escape characters, what's going on?\n
+[*Q.] 为什么我不能使 regex++ 与转义字符一起工作?

[*A.] If you embed regular expressions in C++ code, then remember that escape
 characters are processed twice: once by the C++ compiler, and once by the
 Boost.Regex expression compiler, so to pass the regular expression \d+
 to Boost.Regex, you need to embed "\\d+" in your code. Likewise to match a
-literal backslash you will need to embed "\\\\" in your code.
-
-[*Q.] No matter what I do regex_match always returns false, what's going on?
+literal backslash you will need to embed "\\\\" in your code.\n
+[*A.] 如果你将正则表达式嵌入 C++ 代码中,记得转义字符需要写两遍:一次提供 给 C++ 编译器,一次提供给 +Boost.Regex 正则表达式编译器,所以想要将正则表达式 \d+ 传给 Boost.Regex,你 需要在代码中嵌入 "\\d+"。
+同样如果你要想匹配字面的反斜杠,需要写 "\\\\"。
+
+[*Q.] No matter what I do regex_match always returns false, what's going on?\n
+[*Q.] regex_match 总返回 false,为什么?

[*A.] The algorithm regex_match only succeeds if the expression matches *all* of the text, if you want to *find* a sub-string within the text that matches
-the expression then use regex_search instead.
+the expression then use regex_search instead.\n
+[*A.] 算法 regex_match 只在表达式匹配 *全部* 文本时才成功,如果你想要在文本 中 *寻找* 一个匹配的子字符串时使用 regex_search。

 [*Q.] Why does using parenthesis in a POSIX regular expression change the
-result of a match?
+result of a match?\n
+[*Q.] 在 POSIX 正则表达式中使用括号为什么会改变匹配结果?

[*A.] For POSIX (extended and basic) regular expressions, but not for perl regexes,
 parentheses don't only mark; they determine what the best match is as well.
@@ -30,26 +37,33 @@
follows the POSIX standard leftmost longest rule for determining what matched. So if there is more than one possible match after considering the whole expression, it looks next at the first sub-expression and then the second sub-expression
-and so on. So...
+and so on. So...\n
+[*A.] 对于 POSIX (扩展和基本) 正则表达式,不是 perl 正则表达式,括号并不仅 仅标记;它们同时决定最佳匹配。 +当表达式作为 POSIX 基本或扩展正则表达式编译时,Boost.Regex 遵循 POSIX 标准 的最左最长原则决定匹配结果。 +所以如果在考虑完整个表达式后有多于一个可能的匹配,会关注第一个子表达式,然 后第二个,依此类推。 所以...

 "'''(0*)([0-9]*)'''" against "00123" would produce
 $1 = "00"
 $2 = "123"

-where as
+where as\n
+而

 "0*([0-9])*" against "00123" would produce
 $1 = "00123"

If you think about it, had $1 only matched the "123", this would be "less good"
 than the match "00123" which is both further to the left and longer. If you
-want $1 to match only the "123" part, then you need to use something like:
+want $1 to match only the "123" part, then you need to use something like:\n +考虑一下,如果 $1 只匹配 "123",这 "不如" 匹配 "00123",离左边更远,也更 长。如果要想 $1 只匹配 "123",那么需要使用下面的:

 "0*([1-9][0-9]*)"

-as the expression.
-
-[*Q.] Why don't character ranges work properly (POSIX mode only)?
+as the expression.\n
+这样的表达式。
+
+[*Q.] Why don't character ranges work properly (POSIX mode only)?\n
+[*Q.] 为什么字符范围工作不正常 (POSIX 模式)?

 [*A.] The POSIX standard specifies that character range expressions are
 locale sensitive - so for example the expression [A-Z] will match any
@@ -66,10 +80,17 @@
 `regex_constants::extended` or `regex_constants::basic` internally.
 [Note - when `regex_constants::nocollate` in effect, the library behaves
 "as if" the LC_COLLATE locale category were always "C", regardless of what
-its actually set to - end note].
+its actually set to - end note].\n
+[*A.] POSIX 标准说明字符范围表达式是区域敏感的 - 例如表达式 [A-Z] 可以匹配 任意对应 'A' 到 'Z' 之间的对照元素。 +这意味着对于大多数非 "C" 非 "POSIX" 的区域而言,[A-Z] 可以匹配单字 符 't',而不是人们期望的 - 至少不是大多数人所期望的。 +基于这个原因,Boost.Regex 的默认行为 (perl 模式) 关闭对照的区域敏感,不设 定 regex_constants::collate 编译时标签。 +然而当你设置非默认编译时标签 - 例如 `regex_constants::extended` 或 `regex_constants::basic`,区域相关对照会被开启, +这同时会应用到内部使用 `regex_constants::extended` 或 `regex_constants::basic` 的 POSIX API 函数。 +[Note - 当使用 `regex_constants::nocollate` 时,库认为 LC_COLLATE 区域分类 总是 "C",而不管实际值 - end note]。

 [*Q.] Why are there no throw specifications on any of the functions?
-What exceptions can the library throw?
+What exceptions can the library throw?\n
+[*Q.] 函数为什么没有异常规格声明?库会抛出什么异常?

 [*A.] Not all compilers support (or honor) throw specifications, others
 support them but with reduced efficiency. Throw specifications may be added
@@ -80,10 +101,16 @@
catalogue 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 of the functions in this library. +`std::bad_alloc` can be thrown by just about any of the functions in this library.\n +[*A.] 不是所有编译器都支持 (或承认) 异常规格声明,有一些会支持,但会降低效 率。 +异常规格声明可能在以后编译器能更好处理的时候加入。库只会抛出三种类型的异 常: +[boost::regex_error] 可能在 [basic_regex] 编译表达式时抛 出,`std::runtime_error` 可能在调用 `basic_regex::imbue` +试图打开不存在的信息目录,或调用 [regex_search] 或 [regex_match] 导致 "永远 的" 搜索,或调用 +`RegEx::GrepFiles` 或 `RegEx::FindFiles` 试图打开不能打开的文件时抛出,最 后 `std::bad_alloc` 可能在库的任意函数中抛出。

 [*Q.] Why can't I use the "convenience" versions of regex_match /
-regex_search / regex_grep / regex_format / regex_merge?
+regex_search / regex_grep / regex_format / regex_merge?\n
+[*Q.] 为什么我不能使用 regex_match / regex_search / regex_format / regex_merge 的 "简化" 版本?

 [*A.] These versions may or may not be available depending upon the
 capabilities of your compiler, the rules determining the format of
@@ -92,7 +119,10 @@
 what your compiler supports, run <boost/regex.hpp> through your
 C++ pre-processor, and search the output file for the function
 that you are interested in.  Note however, that very few current
-compilers still have problems with these overloaded functions.
+compilers still have problems with these overloaded functions.\n
+[*A.] 这些版本是否能用取决于你编译器的能力,规则很复杂 - 只有标准兼容的编译 器可见的版本在帮助中给出。 +要找出编译器支持的版本,用 C++ 预处理器运行 <boost/regex.hpp>,在输出文件中 搜索你感兴趣的函数。
+注意,现在只有很少的编译器对这些重载函数仍不支持。

 [endsect]

=======================================
--- /trunk/libs/regex/doc/format_boost_syntax.qbk       Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/format_boost_syntax.qbk       Thu May 27 20:09:44 2010
@@ -6,95 +6,132 @@
 ]


-[section:boost_format_syntax Boost-Extended Format String Syntax]
+[section:boost_format_syntax Boost-Extended Format String Syntax Boost扩展 格式化串语法]

 Boost-Extended format strings treat all characters as literals except for
-'$', '\\', '(', ')', '?', and ':'.
-
-[h4 Grouping]
+'$', '\\', '(', ')', '?', and ':'.\n
+Boost扩展格式化字符串将'$'、'\\'、'('、')'、'?'和':'特殊对待。
+
+[h4 Grouping 分组]

The characters '(' and ')' perform lexical grouping, so use \\( and \\) if you
-want a to output literal parenthesis.
-
-[h4 Conditionals]
-
-The character '?' begins a conditional expression, the general form is:
+want a to output literal parenthesis.\n
+字符'('和')'实现字面分组,使用\\(和\\)来输出字面的括号。
+
+[h4 Conditionals 条件]
+
+The character '?' begins a conditional expression, the general form is:\n
+字符'?'开始一个条件表达式,通用格式为:

 ?Ntrue-expression:false-expression

-where N is decimal digit.
+where N is decimal digit.\n
+其中N为数字。

If sub-expression N was matched, then true-expression is evaluated and sent to
-output, otherwise false-expression is evaluated and sent to output.
+output, otherwise false-expression is evaluated and sent to output.\n
+如果子表达式N被匹配,那么true-expression被求值并送到输出,否则 false-expression被求值并送到输出。

You will normally need to surround a conditional-expression with parenthesis in
-order to prevent ambiguities.
+order to prevent ambiguities.\n
+通常都需要将条件表达式用括号围绕起来,以防止二义性。

For example, the format string "(?1foo:bar)" will replace each match found with "foo" if
-the sub-expression $1 was matched, and with "bar" otherwise.
-
-For sub-expressions with an index greater than 9, or for access to named sub-expressions use:
+the sub-expression $1 was matched, and with "bar" otherwise.\n
+例如,格式化字符串"(?1foo:bar)",如果子表达式$1匹配了,会将每个匹配替换 为"foo",否则为"bar"。
+
+For sub-expressions with an index greater than 9, or for access to named sub-expressions use:\n
+对于索引数大于9的子表达式,或要访问命名的子表达式,使用:

 ?{INDEX}true-expression:false-expression

-or
+or\n
+或者

 ?{NAME}true-expression:false-expression


-[h4 Placeholder Sequences]
+[h4 Placeholder Sequences 占位符序列]

Placeholder sequences specify that some part of what matched the regular expression
-should be sent to output as follows:
+should be sent to output as follows:\n
+占位符序列指明了正则表达式匹配的哪部分将被输出:

 [table
-[[Placeholder][Meaning]]
-[[$&][Outputs what matched the whole expression.]]
+[[Placeholder 占位符][Meaning 意义]]
+[[$&][Outputs what matched the whole expression.\n
+输出整个表达式的匹配。]]
 [[$MATCH][As $&]]
 [[${^MATCH}][As $&]]
 [[$\`][Outputs the text between the end of the last match found (or the
       start of the text if no previous match was found), and the start
-      of the current match.]]
+      of the current match.\n
+ 输出从前一个匹配的终点(如果没有前一次匹配则为文本的开始),到当前匹配 开始处之间的文本。]]
 [[$PREMATCH][As $\`]]
 [[${^PREMATCH}][As $\`]]
-[[$'][Outputs all the text following the end of the current match.]]
+[[$'][Outputs all the text following the end of the current match.\n
+输出当前匹配终点之后的所有文本。]]
 [[$POSTMATCH][As $']]
 [[${^POSTMATCH}][As $']]
-[[$+][Outputs what matched the last marked sub-expression in the regular expression.]] +[[$+][Outputs what matched the last marked sub-expression in the regular expression.\n
+输出与正则表达式中最后一个被标记的子表达式相匹配的文本。]]
 [[$LAST_PAREN_MATCH][As $+]]
-[[$LAST_SUBMATCH_RESULT][Outputs what matched the last sub-expression to be actually matched.]] +[[$LAST_SUBMATCH_RESULT][Outputs what matched the last sub-expression to be actually matched.\n
+输出被实际匹配的最后子表达式的结果。]]
 [[$^N][As $LAST_SUBMATCH_RESULT]]
-[[$$][Outputs a literal '$']]
-[[$n][Outputs what matched the n'th sub-expression.]]
-[[${n}][Outputs what matched the n'th sub-expression.]]
-[[$+{NAME}][Outputs whatever matched the sub-expression named "NAME".]]
+[[$$][Outputs a literal '$'\n
+输出字面符号'$' ]]
+[[$n][Outputs what matched the n'th sub-expression.\n
+输出第n个子表达式的匹配。]]
+[[${n}][Outputs what matched the n'th sub-expression.\n
+输出第n个子表达式的匹配。]]
+[[$+{NAME}][Outputs whatever matched the sub-expression named "NAME".\n
+输出名为"NAME"的子表达式的匹配。]]
 ]

-Any $-placeholder sequence not listed above, results in '$' being treated as a literal.
-
-[h4 Escape Sequences]
+Any $-placeholder sequence not listed above, results in '$' being treated as a literal.\n
+任何不在上面列出的$-占位符序列,都将导致'$'被作为字面符号。
+
+[h4 Escape Sequences 转义序列]

An escape character followed by any character x, outputs that character unless
-x is one of the escape sequences shown below.
+x is one of the escape sequences shown below.\n
+一个转义符号后跟字符x,除非x是下面的转义序列之一,则输出字符x。

 [table
-[[Escape][Meaning]]
-[[\\a][Outputs the bell character: '\\a'.]]
-[[\\e][Outputs the ANSI escape character (code point 27).]]
-[[\\f][Outputs a form feed character: '\\f']]
-[[\\n][Outputs a newline character: '\\n'.]]
-[[\\r][Outputs a carriage return character: '\\r'.]]
-[[\\t][Outputs a tab character: '\\t'.]]
-[[\\v][Outputs a vertical tab character: '\\v'.]]
-[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD]]
-[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD]]
-[[\\cX][Outputs the ANSI escape sequence "escape-X".]]
-[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.]] -[[\\l][Causes the next character to be outputted, to be output in lower case.]] -[[\\u][Causes the next character to be outputted, to be output in upper case.]] -[[\\L][Causes all subsequent characters to be output in lower case, until a \\E is found.]] -[[\\U][Causes all subsequent characters to be output in upper case, until a \\E is found.]]
-[[\\E][Terminates a \\L or \\U sequence.]]
+[[Escape 转义序列][Meaning 意义]]
+[[\\a][Outputs the bell character: '\\a'.\n
+输出铃响字符:'\\a'。]]
+[[\\e][Outputs the ANSI escape character (code point 27).\n
+输出ANSI转义字符(码点为27)。]]
+[[\\f][Outputs a form feed character: '\\f'\n
+输出换页字符:'\\f'。]]
+[[\\n][Outputs a newline character: '\\n'.\n
+输出换行字符:'\\n'。]]
+[[\\r][Outputs a carriage return character: '\\r'.\n
+输出回车字符:'\\r'。]]
+[[\\t][Outputs a tab character: '\\t'.\n
+输出制表符:'\\t'。]]
+[[\\v][Outputs a vertical tab character: '\\v'.\n
+输出垂直制表符:'\\v'。]]
+[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD\n
+输出码点为0xDD的十六进制字符]]
+[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD\n
+输出码点为0xDDDD的十六进制字符]]
+[[\\cX][Outputs the ANSI escape sequence "escape-X".\n
+输出ANSI转义序列"escape-X"。]]
+[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.\n
+如果D是1-9范围内的数字,则输出子表达式D匹配的文本。]]
+[[\\l][Causes the next character to be outputted, to be output in lower case.\n
+使下一个被输出的字符输出为小写。]]
+[[\\u][Causes the next character to be outputted, to be output in upper case.\n
+使下一个被输出的字符输出为大写。]]
+[[\\L][Causes all subsequent characters to be output in lower case, until a \\E is found.\n
+使后面所有的字符都输出为小写,直到碰到\E。]]
+[[\\U][Causes all subsequent characters to be output in upper case, until a \\E is found.\n
+使后面所有的字符都输出为大写,直到碰到\E。]]
+[[\\E][Terminates a \\L or \\U sequence.\n
+结束\L或\U的序列。]]
 ]

 [endsect]
=======================================
--- /trunk/libs/regex/doc/format_perl_syntax.qbk        Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/format_perl_syntax.qbk        Thu May 27 20:09:44 2010
@@ -6,62 +6,91 @@
 ]


-[section:perl_format Perl Format String Syntax]
+[section:perl_format Perl Format String Syntax  Perl格式化串语法]

 Perl-style format strings treat all characters as literals except
-'$' and '\\' which start placeholder and escape sequences respectively.
+'$' and '\\' which start placeholder and escape sequences respectively.\n
+Perl风格格式化字符串将所有字符当作字面符号,除了'$'和'\\',分别为占位符和转 义序列的开始。

Placeholder sequences specify that some part of what matched the regular expression
-should be sent to output as follows:
+should be sent to output as follows:\n
+占位符序列指明了正则表达式匹配的哪部分被送到输出中:

 [table
-[[Placeholder][Meaning]]
-[[$&][Outputs what matched the whole expression.]]
+[[Placeholder 占位符][Meaning 意义]]
+[[$&][Outputs what matched the whole expression.\n
+输出整个表达式的匹配。]]
 [[$MATCH][As $&]]
 [[${^MATCH}][As $&]]
 [[$\`][Outputs the text between the end of the last match found (or the
       start of the text if no previous match was found), and the start
-      of the current match.]]
+      of the current match.\n
+ 输出上次匹配结束(如果没有上次匹配则为文本的开始),到当前匹配开始之间 的文本。]]
 [[$PREMATCH][As $\`]]
 [[${^PREMATCH}][As $\`]]
-[[$'][Outputs all the text following the end of the current match.]]
+[[$'][Outputs all the text following the end of the current match.\n
+输出当前匹配结束之后的所有文本。]]
 [[$POSTMATCH][As $']]
 [[${^POSTMATCH}][As $']]
-[[$+][Outputs what matched the last marked sub-expression in the regular expression.]] +[[$+][Outputs what matched the last marked sub-expression in the regular expression.\n
+输出与正则表达式最后一个被标记子表达式的匹配。]]
 [[$LAST_PAREN_MATCH][As $+]]
-[[$LAST_SUBMATCH_RESULT][Outputs what matched the last sub-expression to be actually matched.]] +[[$LAST_SUBMATCH_RESULT][Outputs what matched the last sub-expression to be actually matched.\n
+输出实际匹配的最后一个子表达式的匹配。]]
 [[$^N][As $LAST_SUBMATCH_RESULT]]
-[[$$][Outputs a literal '$']]
-[[$n][Outputs what matched the n'th sub-expression.]]
-[[${n}][Outputs what matched the n'th sub-expression.]]
-[[$+{NAME}][Outputs whatever matched the sub-expression named "NAME".]]
+[[$$][Outputs a literal '$'\n
+输出字面字符'$']]
+[[$n][Outputs what matched the n'th sub-expression.\n
+输出第n个子表达式的匹配。]]
+[[${n}][Outputs what matched the n'th sub-expression.\n
+输出第n个子表达式的匹配。]]
+[[$+{NAME}][Outputs whatever matched the sub-expression named "NAME".\n
+输出名为"NAME"的子表达式的匹配。]]
 ]

 Any $-placeholder sequence not listed above, results in '$' being treated
-as a literal.
+as a literal.\n
+任何不在上面列出的$-占位符序列,将'$'当作字面符号。

An escape character followed by any character x, outputs that character unless
-x is one of the escape sequences shown below.
+x is one of the escape sequences shown below.\n
+一个转义字符后跟任意字符x,如果x不是下面列出的转义序列之一,则输出字符x。


 [table
-[[Escape][Meaning]]
-[[\\a][Outputs the bell character: '\\a'.]]
-[[\\e][Outputs the ANSI escape character (code point 27).]]
-[[\\f][Outputs a form feed character: '\\f']]
-[[\\n][Outputs a newline character: '\\n'.]]
-[[\\r][Outputs a carriage return character: '\\r'.]]
-[[\\t][Outputs a tab character: '\\t'.]]
-[[\\v][Outputs a vertical tab character: '\\v'.]]
-[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD]]
-[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD]]
-[[\\cX][Outputs the ANSI escape sequence "escape-X".]]
-[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.]] -[[\\l][Causes the next character to be outputted, to be output in lower case.]] -[[\\u][Causes the next character to be outputted, to be output in upper case.]] -[[\\L][Causes all subsequent characters to be output in lower case, until a \\E is found.]] -[[\\U][Causes all subsequent characters to be output in upper case, until a \\E is found.]]
-[[\\E][Terminates a \\L or \\U sequence.]]
+[[Escape 转义序列][Meaning 意义]]
+[[\\a][Outputs the bell character: '\\a'.\n
+输出铃响字符:'\\a'。]]
+[[\\e][Outputs the ANSI escape character (code point 27).\n
+输出ANSI转义字符(码点为27)。]]
+[[\\f][Outputs a form feed character: '\\f'\n
+输出换页字符:'\\f'。]]
+[[\\n][Outputs a newline character: '\\n'.\n
+输出换行字符:'\\n'。]]
+[[\\r][Outputs a carriage return character: '\\r'.\n
+输出回车字符:'\\r'。]]
+[[\\t][Outputs a tab character: '\\t'.\n
+输出制表符:'\\t'。]]
+[[\\v][Outputs a vertical tab character: '\\v'.\n
+输出垂直制表符:'\\v'。]]
+[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD\n
+输出码点为0xDD的十六进制字符]]
+[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD\n
+输出码点为0xDDDD的十六进制字符]]
+[[\\cX][Outputs the ANSI escape sequence "escape-X".\n
+输出ANSI转义序列"escape-X"。]]
+[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.\n
+如果D是1-9范围内的数字,则输出子表达式D匹配的文本。]]
+[[\\l][Causes the next character to be outputted, to be output in lower case.\n
+使下一个被输出的字符输出为小写。]]
+[[\\u][Causes the next character to be outputted, to be output in upper case.\n
+使下一个被输出的字符输出为大写。]]
+[[\\L][Causes all subsequent characters to be output in lower case, until a \\E is found.\n
+使后面所有的字符都输出为小写,直到碰到\E。]]
+[[\\U][Causes all subsequent characters to be output in upper case, until a \\E is found.\n
+使后面所有的字符都输出为大写,直到碰到\E。]]
+[[\\E][Terminates a \\L or \\U sequence.\n
+结束\L或\U的序列。]]
 ]

 [endsect]
=======================================
--- /trunk/libs/regex/doc/format_sed_syntax.qbk Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/format_sed_syntax.qbk Thu May 27 20:09:44 2010
@@ -6,34 +6,49 @@
 ]


-[section:sed_format Sed Format String Syntax]
-
-Sed-style format strings treat all characters as literals except:
+[section:sed_format Sed Format String Syntax  Sed格式化串语法]
+
+Sed-style format strings treat all characters as literals except:\n
+Sed风格格式化字符串将所有字符字面对待,除了:

 [table
-[[character][description]]
+[[character 字符][description 说明]]
 [[&][The ampersand character is replaced in the output stream by
    the the whole of what matched the regular expression.  Use
-   \\& to output a literal '&' character.]]
-[[\\][Specifies an escape sequence.]]
+   \\& to output a literal '&' character.\n
+   &字符在输出中被替换为正则表达式的整个匹配。使用\\&输出字面的'&'字符。 ]]
+[[\\][Specifies an escape sequence.\n
+指明一个转义序列。]]
 ]

An escape character followed by any character x, outputs that character unless x
-is one of the escape sequences shown below.
+is one of the escape sequences shown below.\n
+转义字符后跟任意字符x,输出这个字符,除非x是下面显示的转义序列。

 [table
-[[Escape][Meaning]]
-[[\\a][Outputs the bell character: '\\a'.]]
-[[\\e][Outputs the ANSI escape character (code point 27).]]
-[[\\f][Outputs a form feed character: '\\f']]
-[[\\n][Outputs a newline character: '\\n'.]]
-[[\\r][Outputs a carriage return character: '\\r'.]]
-[[\\t][Outputs a tab character: '\\t'.]]
-[[\\v][Outputs a vertical tab character: '\\v'.]]
-[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD]]
-[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD]]
-[[\\cX][Outputs the ANSI escape sequence "escape-X".]]
-[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.]]
+[[Escape 转义序列][Meaning 意义]]
+[[\\a][Outputs the bell character: '\\a'.\n
+输出铃响字符:'\\a'。]]
+[[\\e][Outputs the ANSI escape character (code point 27).\n
+输出ANSI转义字符(码点为27)。]]
+[[\\f][Outputs a form feed character: '\\f'\n
+输出换页字符:'\\f'。]]
+[[\\n][Outputs a newline character: '\\n'.\n
+输出换行字符:'\\n'。]]
+[[\\r][Outputs a carriage return character: '\\r'.\n
+输出回车字符:'\\r'。]]
+[[\\t][Outputs a tab character: '\\t'.\n
+输出制表字符:'\\t'。]]
+[[\\v][Outputs a vertical tab character: '\\v'.\n
+输出垂直制表符:'\v'。]]
+[[\\xDD][Outputs the character whose hexadecimal code point is 0xDD\n
+输出十六进制码点为0xDD的字符]]
+[[\\x{DDDD}][Outputs the character whose hexadecimal code point is 0xDDDDD\n
+输出十六进制码点为0xDDDD的字符]]
+[[\\cX][Outputs the ANSI escape sequence "escape-X".\n
+输出ANSI转义序列"escape-X"。]]
+[[\\D][If D is a decimal digit in the range 1-9, then outputs the text that matched sub-expression D.\n
+如果D是1-9范围内的数字,那么输出子表达式D匹配的文本。]]
 ]

 [endsect]
=======================================
--- /trunk/libs/regex/doc/format_syntax.qbk     Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/format_syntax.qbk     Thu May 27 20:09:44 2010
@@ -6,16 +6,19 @@
 ]


-[section:format Search and Replace Format String Syntax]
+[section:format Search and Replace Format String Syntax 查找与替换的格式化 串语法]

 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_format], [perl_format] and [boost_extended_format]. +[match_results_format], and are used to transform one string into another.\n +格式化串被算法 [regex_replace] 和 [match_results_format] 使用,用来将一个字 符串转换为另外一个。
+
+There are three kind of format string: [sed_format], [perl_format] and [boost_extended_format].\n +有三种格式化字符串:[sed_format], [perl_format] 和 [boost_extended_format]。

Alternatively, when the flag `format_literal` is passed to one of these functions, then the format string is treated as a string literal, and is copied unchanged
-to the output.
+to the output.\n
+另外,如果标签 `format_literal` 被传入到这些函数,那么格式化字符串就被当作 字面字符串,被不变地拷贝到输出中。

 [include format_sed_syntax.qbk]
 [include format_perl_syntax.qbk]
=======================================
--- /trunk/libs/regex/doc/further_info.qbk      Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/further_info.qbk      Thu May 27 20:09:44 2010
@@ -6,30 +6,39 @@
 ]


-[section:futher References and Further Information]
+[section:futher References and Further Information 参考资料及进一步的信息]

 Short tutorials on regular expressions can be
 [@http://etext.lib.virginia.edu/helpsheets/regex.html found here] and
-[@http://www.linuxpcug.org/lessons/regexp.html here].
+[@http://www.linuxpcug.org/lessons/regexp.html here].\n
+关于正则表达式的简短教程可在 [@http://etext.lib.virginia.edu/helpsheets/regex.html 这里] 和
+[@http://www.linuxpcug.org/lessons/regexp.html 这里] 找到。

 The main book on regular expressions is
-[@http://www.oreilly.com/catalog/regex/ Mastering Regular Expressions, published by O'Reilly].
-
-Boost.Regex forms the basis for the regular expression chapter of the [tr1]. +[@http://www.oreilly.com/catalog/regex/ Mastering Regular Expressions, published by O'Reilly].\n +正则表达式的主要书目:[@http://www.oreilly.com/catalog/regex/ Mastering Regular Expressions, published by O'Reilly]。
+
+Boost.Regex forms the basis for the regular expression chapter of the [tr1].\n
+Boost.Regex 被作为 [tr1] 中关于正则表达式一章的基础。

The [@http://www.opengroup.org/onlinepubs/7908799/toc.htm Open Unix Specification]
 contains a wealth of useful material,
-including the POSIX regular expression syntax.
+including the POSIX regular expression syntax.\n
+[@http://www.opengroup.org/onlinepubs/7908799/toc.htm Open Unix Specification] 中有许多有用的材料,包括POSIX正则表达式语法。

 The [@http://www.cs.ucr.edu/~stelo/pattern.html Pattern Matching Pointers]
-site is a "must visit" resource for anyone interested in pattern matching.
+site is a "must visit" resource for anyone interested in pattern matching.\n +[@http://www.cs.ucr.edu/~stelo/pattern.html Pattern Matching Pointers] 对于 任何对模式匹配有兴趣的人,是一个"必须看"的网站。

 [@http://glimpse.cs.arizona.edu/ Glimpse and Agrep], use a simplified
-regular expression syntax to achieve faster search times.
+regular expression syntax to achieve faster search times.\n
+[@http://glimpse.cs.arizona.edu/ Glimpse and Agrep] 使用了一个简化的正则表 达式语法来获得更快的搜索时间。

 [@http://glimpse.cs.arizona.edu/udi.html Udi Manber]
 and [@http://www.dcc.uchile.cl/~rbaeza/ Ricardo Baeza-Yates] both have a
-selection of useful pattern matching papers available from their respective web sites. +selection of useful pattern matching papers available from their respective web sites.\n +[@http://glimpse.cs.arizona.edu/udi.html Udi Manber] 和 [@http://www.dcc.uchile.cl/~rbaeza/ Ricardo Baeza-Yates]
+在他们的网站上都有一些有用的关于模式匹配的论文。

 [endsect]

=======================================
--- /trunk/libs/regex/doc/gcc-performance.html  Thu Sep  4 19:42:35 2008
+++ /trunk/libs/regex/doc/gcc-performance.html  Thu May 27 20:09:44 2010
Binary file, no diff available.
=======================================
--- /trunk/libs/regex/doc/headers.qbk   Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/headers.qbk   Thu May 27 20:09:44 2010
@@ -6,16 +6,19 @@
 ]


-[section:headers Headers]
+[section:headers Headers 头文件]

 There are two main headers used by this library: `<boost/regex.hpp>`
provides full access to the main template library, while `<boost/cregex.hpp>`
 provides access to the (deprecated) high level class RegEx, and the
-POSIX API functions.
+POSIX API functions.\n
+本库有两个主要的头文件:`<boost/regex.hpp>` 提供对主要模板库的完全访 问,`<boost/cregex.hpp>`
+提供对(废弃的)高层类 RegEx,以及 POSIX API 函数的访问。

 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 not need the full definitions.
+[basic_regex], but otherwise does not need the full definitions.\n
+同样有一个包含所有前向声明的头文件 `<boost/regex_fwd.hpp>`,当接口依赖于 [basic_regex],但又不需要完全定义时使用。

 [endsect]

=======================================
--- /trunk/libs/regex/doc/history.qbk   Mon Feb  8 18:55:11 2010
+++ /trunk/libs/regex/doc/history.qbk   Thu May 27 20:09:44 2010
@@ -6,21 +6,28 @@
 ]


-[section:history History]
+[section:history History 历史]

New issues should be submitted at [@http:svn.boost.org svn.boost.org] - don't forget to include your
-email address in the ticket!
-
-Currently open issues can be viewed [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component here].
-
-All issues including closed ones can be viewed [@https://svn.boost.org/trac/boost/query?status=assigned&status=closed&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component here].
+email address in the ticket!\n
+新发现的问题应提交到 [@http:svn.boost.org svn.boost.org] - 不要忘记带上你的 email地址!
+
+Currently open issues can be viewed [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component here].\n +当前未关闭的问题请见 [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component 这里]。
+
+All issues including closed ones can be viewed [@https://svn.boost.org/trac/boost/query?status=assigned&status=closed&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component here].\n +所有问题,包括已关闭的,请见 [@https://svn.boost.org/trac/boost/query?status=assigned&status=closed&status=new&status=reopened&component=regex&order=priority&col=id&col=summary&col=status&col=type&col=milestone&col=component 这里]。

 [h4 Boost 1.42]

-* Added support for Functors rather than strings as format expressions.
-* Improved error reporting when throwing exceptions to include better more relevant information.
-* Improved performance and reduced stack usage of recursive expressions.
-* Fixed tickets
+* Added support for Functors rather than strings as format expressions.\n
+  除了以字符串作为格式化表达式之外,新增了以仿函数作为格式化表达式。
+* Improved error reporting when throwing exceptions to include better more relevant information.\n
+  改进了抛出异常时的错误报告,包含了更多信息。
+* Improved performance and reduced stack usage of recursive expressions.\n
+  改进了性能以及对递归表达式减少了栈的使用。
+* Fixed tickets\n
+  修复以下故障
 [@https://svn.boost.org/trac/boost/ticket/2802 #2802],
 [@https://svn.boost.org/trac/boost/ticket/3425 #3425],
 [@https://svn.boost.org/trac/boost/ticket/3507 #3507],
@@ -35,7 +42,8 @@
 [h4 Boost 1.40]

 * Added support for many Perl 5.10 syntax elements including named
-sub-expressions, branch resets and recursive regular expressions.
+sub-expressions, branch resets and recursive regular expressions.\n
+ 增加了对许多 Perl 5.10 语法元素的支持,包括命名子表达式、分支重置和递归正 则表达式。

 [h4 Boost 1.38]

@@ -44,13 +52,22 @@
 been added for Perl compatibility, when the new [syntax_option_type]
 ['no_empty_expressions] is set then the old behaviour is preserved and
 empty expressions are prohibited.  This is issue
+[@https://svn.boost.org/trac/boost/ticket/1081 #1081].\n
+  [*破坏性修改]: 现在在使用 Perl 正则表达式语法时,允许空表达式和空选择。
+这是为了 Perl 兼容性而新增的,当新的 [syntax_option_type] ['no_empty_expressions]
+被置位,将保留旧有行为并禁止空表达式。这是问题
 [@https://svn.boost.org/trac/boost/ticket/1081 #1081].
 * Added support for Perl style ${n} expressions in format strings
-(issue [@https://svn.boost.org/trac/boost/ticket/2556 #2556]).
+(issue [@https://svn.boost.org/trac/boost/ticket/2556 #2556]).\n
+  增加对在格式化字符串中的 Perl 风格的 ${n} 表达式的支持
+(问题 [@https://svn.boost.org/trac/boost/ticket/2556 #2556])。
 * Added support for accessing the location of sub-expressions within the
 regular expression string
-(issue [@https://svn.boost.org/trac/boost/ticket/2269 #2269]).
-* Fixed compiler compatibility issues
+(issue [@https://svn.boost.org/trac/boost/ticket/2269 #2269]).\n
+  增加对正则表达式字符串内部子表达式位置的访问
+(问题 [@https://svn.boost.org/trac/boost/ticket/2269 #2269]).
+* Fixed compiler compatibility issues \n
+  修复编译器兼容性问题
 [@https://svn.boost.org/trac/boost/ticket/2244 #2244],
 [@https://svn.boost.org/trac/boost/ticket/2514 #2514],
 and
@@ -59,10 +76,14 @@

 [h4 Boost 1.34]

-* Fix for non-greedy repeats and partial matches not working correctly in some cases. -* Fix for non-greedy repeats on VC++ not working in some cases (bug report 1515830). -* Changed match_results::position() to return a valid result when *this represents a partial match. -* Fixed the grep and egrep options so that the newline character gets treated the same as |. +* Fix for non-greedy repeats and partial matches not working correctly in some cases.\n
+  修复在某些情况下非贪婪重复和部分匹配工作不正确的缺陷。
+* Fix for non-greedy repeats on VC++ not working in some cases (bug report 1515830).\n
+  修复在某些情况下非贪婪重复在VC++上不能工作的问题(bug report 1515830)。
+* Changed match_results::position() to return a valid result when *this represents a partial match.\n + 修改 match_results::position() 以在 *this 表示一个部分匹配时返回有效结 果。 +* Fixed the grep and egrep options so that the newline character gets treated the same as |.\n
+  修复 grep 和 egrep 选项,以使得换行符的作用与 | 相同。

 [h4 Boost 1.33.1]

=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/acknowledgements.html Thu Sep 4 19:42:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/acknowledgements.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Acknowledgements</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Acknowledgements &#40483;&#35874;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="redist.html" title="Redistributables">
-<link rel="next" href="history.html" title="History">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="redist.html" title="Redistributables &#37325;&#20998;&#21457;">
+<link rel="next" href="history.html" title="History &#21382;&#21490;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,8 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.acknowledgements"></a><a href="acknowledgements.html" title="Acknowledgements">
-      Acknowledgements</a>
+<a name="boost_regex.background_information.acknowledgements"></a><a class="link" href="acknowledgements.html" title="Acknowledgements &#40483;&#35874;">
+      Acknowledgements &#40483;&#35874;</a>
 </h3></div></div></div>
 <p>
The author can be contacted at john - at - johnmaddock.co.uk; the home page
@@ -49,13 +49,13 @@
       </p>
 <p>
The following people have all contributed useful comments or fixes: Dave - Abrahams, Mike Allison, Edan Ayal, Jayashree Balasubramanian, Jan Bölsche, + Abrahams, Mike Allison, Edan Ayal, Jayashree Balasubramanian, Jan B&#246;lsche, Beman Dawes, Paul Baxter, David Bergman, David Dennerline, Edward Diener, Peter Dimov, Robert Dunn, Fabio Forno, Tobias Gabrielsson, Rob Gillen, Marc Gregoire, Chris Hecker, Nick Hodapp, Jesse Jones, Martin Jost, Boris Krasnovskiy, Jan Hermelink, Max Leung, Wei-hao Lin, Jens Maurer, Richard Peters, Heiko Schmidt, Jason Shirk, Gerald Slacik, Scobie Smith, Mike Smyth, Alexander - Sokolovsky, Hervé Poirier, Michael Raykh, Marc Recht, Scott VanCamp, Bruno + Sokolovsky, Herv&#233; Poirier, Michael Raykh, Marc Recht, Scott VanCamp, Bruno Voigt, Alexey Voinov, Jerry Waldorf, Rob Ward, Lealon Watts, John Wismar,
         Thomas Witt and Yuval Yosef.
       </p>
@@ -74,7 +74,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/examples.html Thu Sep 4 19:42:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/examples.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Test and Example Programs</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Test and Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;</title> <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="thread_safety.html" title="Thread Safety">
-<link rel="next" href="futher.html" title="References and Further Information"> +<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="thread_safety.html" title="Thread Safety &#32447;&#31243;&#23433;&#20840;&#24615;"> +<link rel="next" href="futher.html" title="References and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,13 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.examples"></a><a href="examples.html" title="Test and Example Programs"> Test and
-      Example Programs</a>
+<a name="boost_regex.background_information.examples"></a><a class="link" href="examples.html" title="Test and Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;"> Test and + Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;</a>
 </h3></div></div></div>
-<a name="boost_regex.background_information.examples.test_programs"></a><h5>
-<a name="id657134"></a>
- <a href="examples.html#boost_regex.background_information.examples.test_programs">Test
-        Programs</a>
+<a name="boost_regex.background_information.examples.test_programs_____________"></a><h5>
+<a name="id5034401"></a>
+ <a class="link" href="examples.html#boost_regex.background_information.examples.test_programs_____________">Test
+        Programs &#27979;&#35797;&#31243;&#24207;</a>
       </h5>
 <p>
         <span class="bold"><strong>regress:</strong></span>
@@ -40,10 +40,11 @@
a full workout. The presence of this program is your guarantee that the library will behave as claimed - at least as far as those items tested are concerned - if anyone spots anything that isn't being tested I'd be glad to hear about
-        it.
+ it.<br> &#22238;&#24402;&#27979;&#35797;&#31243;&#24207;&#23545;&#21305;&#37197;/&#26597;&#25214;&#31639;&#27861;&#19968;&#27425;&#20805;&#20998;&#30340;&#32771;&#39564;&#12290;&#35813;&#31243;&#24207;&#30340;&#23384;&#22312;&#26159;&#26412;&#24211;&#33021;&#25353;&#35201;&#27714;&#24037;&#20316;&#30340;&#20445;&#35777; + - &#33267;&#23569;&#23545;&#20110;&#36825;&#20123;&#34987;&#27979;&#35797;&#30340;&#39033;&#30446;&#26469;&#35828; - &#22914;&#26524;&#26377;&#20154;&#25351;&#20986;&#26377;&#21738;&#20214;&#20107;&#24773;&#26410;&#34987;&#27979;&#35797;&#21040;&#65292;&#25105;&#24456;&#20048;&#24847;&#21548;&#21040;&#12290;
       </p>
 <p>
-        Files:
+        Files:<br> &#25991;&#20214;&#65306;
       </p>
 <div class="itemizedlist"><ul type="disc">
<li><a href="../../../../test/regress/main.cpp" target="_top">main.cpp</a></li>
@@ -74,7 +75,7 @@
       </p>
 <p>
         Verifies that "bad" regular expressions don't cause the matcher
-        to go into infinite loops, but to throw an exception instead.
+ to go into infinite loops, but to throw an exception instead.<br> &#39564;&#35777;&#8220;&#22351;&#30340;&#8221;&#27491;&#21017;&#34920;&#36798;&#24335;&#19981;&#20250;&#23548;&#33268;&#21305;&#37197;&#22120;&#38519;&#20837;&#26080;&#38480;&#24490;&#29615;&#65292;&#32780;&#26159;&#20250;&#25243;&#20986;&#19968;&#20010;&#24322;&#24120;&#12290;
       </p>
 <p>
Files: <a href="../../../../test/pathology/bad_expression_test.cpp" target="_top">bad_expression_test.cpp</a>.
@@ -83,7 +84,8 @@
         <span class="bold"><strong>recursion_test:</strong></span>
       </p>
 <p>
- Verifies that the matcher can't overrun the stack (no matter what the expression). + Verifies that the matcher can't overrun the stack (no matter what the expression).<br> + &#39564;&#35777;&#21305;&#37197;&#22120;&#19981;&#20250;&#26632;&#28322;&#20986;(&#26080;&#35770;&#26159;&#20160;&#20040;&#34920;&#36798;&#24335;)&#12290;
       </p>
 <p>
Files: <a href="../../../../test/pathology/recursion_test.cpp" target="_top">recursion_test.cpp</a>.
@@ -92,7 +94,8 @@
         <span class="bold"><strong>concepts:</strong></span>
       </p>
 <p>
- Verifies that the library meets all documented concepts (a compile only test). + Verifies that the library meets all documented concepts (a compile only test).<br> + &#39564;&#35777;&#26412;&#24211;&#31526;&#21512;&#25152;&#21015;&#20986;&#30340;&#25152;&#26377;&#27010;&#24565;(&#21482;&#38656;&#27979;&#35797;&#32534;&#35793;)&#12290;
       </p>
 <p>
Files: <a href="../../../../test/concepts/concept_check.cpp" target="_top">concept_check.cpp</a>.
@@ -101,22 +104,22 @@
         <span class="bold"><strong>captures_test:</strong></span>
       </p>
 <p>
-        Test code for captures.
+ Test code for captures.<br> &#26377;&#20851;&#25429;&#33719;&#30340;&#27979;&#35797;&#20195;&#30721;&#12290;
       </p>
 <p>
Files: <a href="../../../../test/captures/captures_test.cpp" target="_top">captures_test.cpp</a>.
       </p>
-<a name="boost_regex.background_information.examples.example_programs"></a><h5>
-<a name="id657522"></a>
- <a href="examples.html#boost_regex.background_information.examples.example_programs">Example
-        programs</a>
+<a name="boost_regex.background_information.examples.example_programs_____________"></a><h5>
+<a name="id5034789"></a>
+ <a class="link" href="examples.html#boost_regex.background_information.examples.example_programs_____________">Example
+        programs &#31034;&#20363;&#31243;&#24207;</a>
       </h5>
 <p>
         <span class="bold"><strong>grep</strong></span>
       </p>
 <p>
A simple grep implementation, run with the -h command line option to find
-        out its usage.
+ out its usage.<br> &#19968;&#20010;&#31616;&#21333;&#30340; grep &#23454;&#29616;&#65292;&#20351;&#29992; -h &#21629;&#20196;&#34892;&#36873;&#39033;&#36816;&#34892;&#65292;&#21487;&#20197;&#30475;&#21040;&#23427;&#30340;&#29992;&#27861;&#12290;
       </p>
 <p>
Files: <a href="../../../../example/grep/grep.cpp" target="_top">grep.cpp</a>
@@ -127,18 +130,19 @@
 <p>
A simple interactive expression matching application, the results of all matches are timed, allowing the programmer to optimize their regular expressions
-        where performance is critical.
+ where performance is critical.<br> &#19968;&#20010;&#31616;&#21333;&#30340;&#20132;&#20114;&#24335;&#34920;&#36798;&#24335;&#21305;&#37197;&#31243;&#24207;&#65292;&#25152;&#26377;&#21305;&#37197;&#30340;&#32467;&#26524;&#34987;&#35745;&#26102;&#65292;&#20801;&#35768;&#31243;&#24207;&#21592;&#22312;&#24615;&#33021;&#26159;&#20851;&#38190;&#22240;&#32032;&#26102;&#20248;&#21270;&#20182;&#20204;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#12290;
       </p>
 <p>
Files: <a href="../../../../example/timer/regex_timer.cpp" target="_top">regex_timer.cpp</a>.
       </p>
-<a name="boost_regex.background_information.examples.code_snippets"></a><h5>
-<a name="id657602"></a>
- <a href="examples.html#boost_regex.background_information.examples.code_snippets">Code
-        snippets</a>
+<a name="boost_regex.background_information.examples.code_snippets_____________"></a><h5>
+<a name="id5034875"></a>
+ <a class="link" href="examples.html#boost_regex.background_information.examples.code_snippets_____________">Code
+        snippets &#20195;&#30721;&#29255;&#26029;</a>
       </h5>
 <p>
- The snippets examples contain the code examples used in the documentation: + The snippets examples contain the code examples used in the documentation:<br> + &#36825;&#20123;&#20195;&#30721;&#29255;&#26029;&#21253;&#21547;&#20102;&#26412;&#25991;&#26723;&#20013;&#20351;&#29992;&#30340;&#31034;&#20363;&#20195;&#30721;&#65306;
       </p>
 <p>
<a href="../../../../example/snippets/captures_example.cpp" target="_top">captures_example.cpp</a>:
@@ -185,7 +189,7 @@
         enumerate the linked URL's in a HTML file.
       </p>
 <p>
-        The following are deprecated:
+ The following are deprecated:<br> &#20197;&#19979;&#26159;&#19981;&#20877;&#20351;&#29992;&#30340;&#65306;
       </p>
 <p>
<a href="../../../../example/snippets/regex_grep_example_1.cpp" target="_top">regex_grep_example_1.cpp</a>:
@@ -217,7 +221,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/faq.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/faq.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>FAQ</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>FAQ &#24120;&#35265;&#38382;&#39064;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information"> -<link rel="prev" href="futher.html" title="References and Further Information">
-<link rel="next" href="performance.html" title="Performance">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="futher.html" title="References and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;"> +<link rel="next" href="performance.html" title="Performance &#24615;&#33021;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,13 +24,12 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.faq"></a><a href="faq.html" title="FAQ"> FAQ</a> +<a name="boost_regex.background_information.faq"></a><a class="link" href="faq.html" title="FAQ &#24120;&#35265;&#38382;&#39064;"> FAQ &#24120;&#35265;&#38382;&#39064;</a>
 </h3></div></div></div>
 <p>
<span class="bold"><strong>Q.</strong></span> I can't get regex++ to work with escape
-        characters, what's going on?
-        <br />
- <span class="bold"><strong>Q.</strong></span> 为什么我不能使 regex++ 与转义字符一起工作? + characters, what's going on?<br> <span class="bold"><strong>Q.</strong></span> &#20026;&#20160;&#20040;&#25105;&#19981;&#33021;&#20351; + regex++ &#19982;&#36716;&#20041;&#23383;&#31526;&#19968;&#36215;&#24037;&#20316;&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> If you embed regular expressions in C++
@@ -38,34 +37,30 @@
C++ compiler, and once by the Boost.Regex expression compiler, so to pass
         the regular expression \d+ to Boost.Regex, you need to embed "\d+"
in your code. Likewise to match a literal backslash you will need to embed
-        "\\" in your code.
-        <br />
- <span class="bold"><strong>A.</strong></span> 如果你将正则表达式嵌 入 C++ 代码中, - 记得转义字符需要写两遍:一次提供给 C++ 编译器,一次提供给 Boost.Regex 正则表达式编译器, - 所以想要将正则表达式 \d+ 传给 Boost.Regex,你需要在代码中嵌 入 "\\d+" (原文可能有错误 -- 译者注)。 - 同样如果你要想匹配字面的反斜杠,需要写 "\\\\" (原文可能有错误 -- 译 者注)。 + "\\" in your code.<br> <span class="bold"><strong>A.</strong></span> &#22914;&#26524;&#20320;&#23558;&#27491;&#21017;&#34920;&#36798;&#24335;&#23884;&#20837; + C++ &#20195;&#30721;&#20013;&#65292;&#35760;&#24471;&#36716;&#20041;&#23383;&#31526;&#38656;&#35201;&#20889;&#20004;&#36941;&#65306;&#19968;&#27425;&#25552;&#20379;&#32473; C++ &#32534;&#35793;&#22120;&#65292;&#19968;&#27425;&#25552;&#20379;&#32473; + Boost.Regex &#27491;&#21017;&#34920;&#36798;&#24335;&#32534;&#35793;&#22120;&#65292;&#25152;&#20197;&#24819;&#35201;&#23558;&#27491;&#21017;&#34920;&#36798;&#24335; \d+ + &#20256;&#32473; Boost.Regex&#65292;&#20320;&#38656;&#35201;&#22312;&#20195;&#30721;&#20013;&#23884;&#20837; "\d+"&#12290; &#21516;&#26679;&#22914;&#26524;&#20320;&#35201;&#24819;&#21305;&#37197;&#23383;&#38754;&#30340;&#21453;&#26012;&#26464;&#65292;&#38656;&#35201;&#20889;
+        "\\"&#12290;
       </p>
 <p>
<span class="bold"><strong>Q.</strong></span> No matter what I do regex_match always
-        returns false, what's going on?
-        <br />
- <span class="bold"><strong>Q.</strong></span> regex_match 总返回 false,为什么? + returns false, what's going on?<br> <span class="bold"><strong>Q.</strong></span> + regex_match &#24635;&#36820;&#22238; false&#65292;&#20026;&#20160;&#20040;&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> The algorithm regex_match only succeeds if the expression matches <span class="bold"><strong>all</strong></span> of the text, if you want to <span class="bold"><strong>find</strong></span> a sub-string within
-        the text that matches the expression then use regex_search instead.
-        <br />
- <span class="bold"><strong>A.</strong></span> 算法 regex_match 只在 表达式匹配
-        <span class="bold"><strong>全部</strong></span>文本时才成功,
- 如果你想要在文本中<span class="bold"><strong>寻找</strong></span>一 个匹配的子字符串时使用 regex_search。 + the text that matches the expression then use regex_search instead.<br> + <span class="bold"><strong>A.</strong></span> &#31639;&#27861; regex_match &#21482;&#22312;&#34920;&#36798;&#24335;&#21305;&#37197; + *&#20840;&#37096;* &#25991;&#26412;&#26102;&#25165;&#25104;&#21151;&#65292;&#22914;&#26524;&#20320;&#24819;&#35201;&#22312;&#25991;&#26412;&#20013; *&#23547;&#25214;* &#19968;&#20010;&#21305;&#37197;&#30340;&#23376;&#23383;&#31526;&#20018;&#26102;&#20351;&#29992;
+        regex_search&#12290;
       </p>
 <p>
<span class="bold"><strong>Q.</strong></span> Why does using parenthesis in a POSIX
-        regular expression change the result of a match?
-        <br />
- <span class="bold"><strong>Q.</strong></span> 在 POSIX 正则表达式中 使用括号为什么会改变匹配结果? + regular expression change the result of a match?<br> <span class="bold"><strong>Q.</strong></span> + &#22312; POSIX &#27491;&#21017;&#34920;&#36798;&#24335;&#20013;&#20351;&#29992;&#25324;&#21495;&#20026;&#20160;&#20040;&#20250;&#25913;&#21464;&#21305;&#37197;&#32467;&#26524;&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> For POSIX (extended and basic) regular
@@ -75,20 +70,18 @@
leftmost longest rule for determining what matched. So if there is more than one possible match after considering the whole expression, it looks next at the first sub-expression and then the second sub-expression and so on.
-        So...
-        <br />
- <span class="bold"><strong>A.</strong></span> 对于 POSIX (扩展和基 本) 正则表达式,不是 perl 正则表达式,
-        括号并不仅仅标记;它们同时决定最佳匹配。
- 当表达式作为 POSIX 基本或扩展正则表达式编译时,Boost.Regex 遵循 POSIX 标准的最左最长原则决定匹配结果。 - 所以如果在考虑完整个表达式后有多于一个可能的匹配,会关注第一个子表 达式,然后第二个,依此类推。
-        所以...
+ So...<br> <span class="bold"><strong>A.</strong></span> &#23545;&#20110; POSIX (&#25193;&#23637;&#21644;&#22522;&#26412;) + &#27491;&#21017;&#34920;&#36798;&#24335;&#65292;&#19981;&#26159; perl &#27491;&#21017;&#34920;&#36798;&#24335;&#65292;&#25324;&#21495;&#24182;&#19981;&#20165;&#20165;&#26631;&#35760;&#65307;&#23427;&#20204;&#21516;&#26102;&#20915;&#23450;&#26368;&#20339;&#21305;&#37197;&#12290; + &#24403;&#34920;&#36798;&#24335;&#20316;&#20026; POSIX &#22522;&#26412;&#25110;&#25193;&#23637;&#27491;&#21017;&#34920;&#36798;&#24335;&#32534;&#35793;&#26102;&#65292;Boost.Regex + &#36981;&#24490; POSIX &#26631;&#20934;&#30340;&#26368;&#24038;&#26368;&#38271;&#21407;&#21017;&#20915;&#23450;&#21305;&#37197;&#32467;&#26524;&#12290; &#25152;&#20197;&#22914;&#26524;&#22312;&#32771;&#34385;&#23436;&#25972;&#20010;&#34920;&#36798;&#24335;&#21518;&#26377;&#22810;&#20110;&#19968;&#20010;&#21487;&#33021;&#30340;&#21305;&#37197;&#65292;&#20250;&#20851;&#27880;&#31532;&#19968;&#20010;&#23376;&#34920;&#36798;&#24335;&#65292;&#28982;&#21518;&#31532;&#20108;&#20010;&#65292;&#20381;&#27492;&#31867;&#25512;&#12290;
+        &#25152;&#20197;...
       </p>
 <p>
         "(0*)([0-9]*)" against "00123" would produce $1 = "00"
         $2 = "123"
       </p>
 <p>
-        where as
+        where as<br> &#32780;
       </p>
 <p>
         "0*([0-9])*" against "00123" would produce $1 = "00123"
@@ -97,22 +90,20 @@
         If you think about it, had $1 only matched the "123", this would
         be "less good" than the match "00123" which is both further
         to the left and longer. If you want $1 to match only the "123"
-        part, then you need to use something like:
-        <br />
- 考虑一下,如果 $1 只匹配 "123",这 "不如" 匹配 "00123",离左边更 远,也更长。
-        如果要想 $1 只匹配 "123",那么需要使用下面的:
+ part, then you need to use something like:<br> &#32771;&#34385;&#19968;&#19979;&#65292;&#22914;&#26524; $1 + &#21482;&#21305;&#37197; "123"&#65292;&#36825; "&#19981;&#22914;" &#21305;&#37197; "00123"&#65292;&#31163;&#24038;&#36793;&#26356;&#36828;&#65292;&#20063;&#26356;&#38271;&#12290;&#22914;&#26524;&#35201;&#24819; + $1 &#21482;&#21305;&#37197; "123"&#65292;&#37027;&#20040;&#38656;&#35201;&#20351;&#29992;&#19979;&#38754;&#30340;&#65306;
       </p>
 <p>
         "0*([1-9][0-9]*)"
       </p>
 <p>
-        as the expression.
+ as the expression.<br> &#36825;&#26679;&#30340;&#34920;&#36798;&#24335;&#12290;
       </p>
 <p>
<span class="bold"><strong>Q.</strong></span> Why don't character ranges work properly
-        (POSIX mode only)?
-        <br />
- <span class="bold"><strong>Q.</strong></span> 为什么字符范围工作不 正常 (POSIX 模式)? + (POSIX mode only)?<br> <span class="bold"><strong>Q.</strong></span> &#20026;&#20160;&#20040;&#23383;&#31526;&#33539;&#22260;&#24037;&#20316;&#19981;&#27491;&#24120;
+        (POSIX &#27169;&#24335;)&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> The POSIX standard specifies that character
@@ -130,48 +121,51 @@
POSIX API functions which use either <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">extended</span></code> or <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">basic</span></code> internally. [Note - when <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">nocollate</span></code> in effect, the library behaves
         "as if" the LC_COLLATE locale category were always "C",
-        regardless of what its actually set to - end note].
-        <br />
- <span class="bold"><strong>A.</strong></span> POSIX 标准说明字符范 围表达式是区域敏感的
-        - 例如表达式 [A-Z] 可以匹配任意对应 'A' 到 'Z' 之间的对照元素。
- 这意味着对于大多数非 "C" 非 "POSIX" 的区域而言,[A-Z] 可以匹配单字 符 't',而不是人们期望的
-        - 至少不是大多数人所期望的。
- 基于这个原因,Boost.Regex 的默认行为 (perl 模式) 关闭对照的区域敏 感,不设定 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">collate</span></code> 编译 时标签。 - 然而当你设置非默认编译时标签 - 例如 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">extended</span></code> 或 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">basic</span></code>,
-        区域相关对照会被开启,
- 这同时会应用到内部使用 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">extended</span></code> 或 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">basic</span></code> 的 POSIX API 函数。 - [Note - 当使用 <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">nocollate</span></code> 时,库认为 LC_COLLATE 区域分类总是 "C",而不管实际值 - end note]。 + regardless of what its actually set to - end note].<br> <span class="bold"><strong>A.</strong></span> + POSIX &#26631;&#20934;&#35828;&#26126;&#23383;&#31526;&#33539;&#22260;&#34920;&#36798;&#24335;&#26159;&#21306;&#22495;&#25935;&#24863;&#30340; - &#20363;&#22914;&#34920;&#36798;&#24335; + [A-Z] &#21487;&#20197;&#21305;&#37197;&#20219;&#24847;&#23545;&#24212; 'A' &#21040; 'Z' &#20043;&#38388;&#30340;&#23545;&#29031;&#20803;&#32032;&#12290; &#36825;&#24847;&#21619;&#30528;&#23545;&#20110;&#22823;&#22810;&#25968;&#38750; + "C" &#38750; "POSIX" &#30340;&#21306;&#22495;&#32780;&#35328;&#65292;[A-Z] &#21487;&#20197;&#21305;&#37197;&#21333;&#23383;&#31526; + 't'&#65292;&#32780;&#19981;&#26159;&#20154;&#20204;&#26399;&#26395;&#30340; - &#33267;&#23569;&#19981;&#26159;&#22823;&#22810;&#25968;&#20154;&#25152;&#26399;&#26395;&#30340;&#12290; + &#22522;&#20110;&#36825;&#20010;&#21407;&#22240;&#65292;Boost.Regex &#30340;&#40664;&#35748;&#34892;&#20026; (perl &#27169;&#24335;) &#20851;&#38381;&#23545;&#29031;&#30340;&#21306;&#22495;&#25935;&#24863;&#65292;&#19981;&#35774;&#23450; + regex_constants::collate &#32534;&#35793;&#26102;&#26631;&#31614;&#12290; &#28982;&#32780;&#24403;&#20320;&#35774;&#32622;&#38750;&#40664;&#35748;&#32534;&#35793;&#26102;&#26631;&#31614; + - &#20363;&#22914; <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">extended</span></code> + &#25110; <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">basic</span></code>&#65292;&#21306;&#22495;&#30456;&#20851;&#23545;&#29031;&#20250;&#34987;&#24320;&#21551;&#65292; + &#36825;&#21516;&#26102;&#20250;&#24212;&#29992;&#21040;&#20869;&#37096;&#20351;&#29992; <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">extended</span></code> + &#25110; <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">basic</span></code> &#30340; POSIX API &#20989;&#25968;&#12290; [Note - &#24403;&#20351;&#29992; + <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">nocollate</span></code> &#26102;&#65292;&#24211;&#35748;&#20026; LC_COLLATE &#21306;&#22495;&#20998;&#31867;&#24635;&#26159; + "C"&#65292;&#32780;&#19981;&#31649;&#23454;&#38469;&#20540; - end note]&#12290;
       </p>
 <p>
<span class="bold"><strong>Q.</strong></span> Why are there no throw specifications
-        on any of the functions? What exceptions can the library throw?
-        <br />
- <span class="bold"><strong>Q.</strong></span> 函数为什么没有异常规 格声明?库会抛出什么异常? + on any of the functions? What exceptions can the library throw?<br> <span class="bold"><strong>Q.</strong></span> &#20989;&#25968;&#20026;&#20160;&#20040;&#27809;&#26377;&#24322;&#24120;&#35268;&#26684;&#22768;&#26126;&#65311;&#24211;&#20250;&#25243;&#20986;&#20160;&#20040;&#24322;&#24120;&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> Not all compilers support (or honor) 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 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> when compiling a regular + can be thrown by <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> when compiling a regular expression, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> can be thrown when a call to <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">::</span><span class="identifier">imbue</span></code> tries to open a message catalogue - that doesn't exist, or when a call to <a href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> or <a href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> results in an "everlasting" + that doesn't exist, or when a call to <a class="link" href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> or <a class="link" href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> results in an "everlasting" search, or when a call to <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">GrepFiles</span></code> or <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">FindFiles</span></code> tries to open a file that cannot be opened, finally <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code> can be thrown by just about any
-        of the functions in this library.
-        <br />
- <span class="bold"><strong>A.</strong></span> 不是所有编译器都支持 (或承认) 异常规格声明, - 另一些支持,但会降低效率。异常规格声明可能在以后编译器能更好处理的 时候加入。 - 库只会抛出三种类型的异常:[boost::regex_error] 可能在 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 编译表达式时抛出, - <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> 可能在调用 <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">::</span><span class="identifier">imbue</span></code> 试图打 开不存在的信息目录,或调用 <a href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> 或 <a href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> 导致 "永远的" 搜索,或调用 <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">GrepFiles</span></code> 或 <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">FindFiles</span></code> 试 图打开不能打开的文件时抛出,最后 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code> 可能在库的任意函数中抛出。 + of the functions in this library.<br> <span class="bold"><strong>A.</strong></span> + &#19981;&#26159;&#25152;&#26377;&#32534;&#35793;&#22120;&#37117;&#25903;&#25345; (&#25110;&#25215;&#35748;) &#24322;&#24120;&#35268;&#26684;&#22768;&#26126;&#65292;&#26377;&#19968;&#20123;&#20250;&#25903;&#25345;&#65292;&#20294;&#20250;&#38477;&#20302;&#25928;&#29575;&#12290; + &#24322;&#24120;&#35268;&#26684;&#22768;&#26126;&#21487;&#33021;&#22312;&#20197;&#21518;&#32534;&#35793;&#22120;&#33021;&#26356;&#22909;&#22788;&#29702;&#30340;&#26102;&#20505;&#21152;&#20837;&#12290;&#24211;&#21482;&#20250;&#25243;&#20986;&#19977;&#31181;&#31867;&#22411;&#30340;&#24322;&#24120;&#65306; + [boost::regex_error] &#21487;&#33021;&#22312; <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> &#32534;&#35793;&#34920;&#36798;&#24335;&#26102;&#25243;&#20986;&#65292;<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> + &#21487;&#33021;&#22312;&#35843;&#29992; <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">::</span><span class="identifier">imbue</span></code> + &#35797;&#22270;&#25171;&#24320;&#19981;&#23384;&#22312;&#30340;&#20449;&#24687;&#30446;&#24405;&#65292;&#25110;&#35843;&#29992; <a class="link" href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> &#25110; <a class="link" href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> &#23548;&#33268; "&#27704;&#36828;&#30340;" + &#25628;&#32034;&#65292;&#25110;&#35843;&#29992; <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">GrepFiles</span></code> + &#25110; <code class="computeroutput"><span class="identifier">RegEx</span><span class="special">::</span><span class="identifier">FindFiles</span></code> &#35797;&#22270;&#25171;&#24320;&#19981;&#33021;&#25171;&#24320;&#30340;&#25991;&#20214;&#26102;&#25243;&#20986;&#65292;&#26368;&#21518; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code> &#21487;&#33021;&#22312;&#24211;&#30340;&#20219;&#24847;&#20989;&#25968;&#20013;&#25243;&#20986;&#12290;
       </p>
 <p>
<span class="bold"><strong>Q.</strong></span> Why can't I use the "convenience" - versions of regex_match / regex_search / regex_grep / regex_format / regex_merge?
-        <br />
- <span class="bold"><strong>Q.</strong></span> 为什么我不能使用 regex_match / regex_search / regex_format / regex_merge 的 "简化" 版本? + versions of regex_match / regex_search / regex_grep / regex_format / regex_merge?<br> + <span class="bold"><strong>Q.</strong></span> &#20026;&#20160;&#20040;&#25105;&#19981;&#33021;&#20351;&#29992; regex_match + / regex_search / regex_format / regex_merge &#30340; "&#31616;&#21270;" &#29256;&#26412;&#65311;
       </p>
 <p>
<span class="bold"><strong>A.</strong></span> These versions may or may not be available
@@ -181,17 +175,15 @@
your compiler supports, run &lt;boost/regex.hpp&gt; through your C++ pre-processor, and search the output file for the function that you are interested in. Note however, that very few current compilers still have problems with these overloaded
-        functions.
-        <br />
- <span class="bold"><strong>A.</strong></span> 这些版本是否能用取决 于你编译器的能力,规则很复杂
-        - 只有标准兼容的编译器可见的版本在帮助中给出。
- 要找出编译器支持的版本,用 C++ 预处理器运行 &lt;boost/regex.hpp&gt;,在输出文件中搜索你感兴趣的函数。
-        注意,现在只有很少的编译器对这些重载函数仍不支持。
+ functions.<br> <span class="bold"><strong>A.</strong></span> &#36825;&#20123;&#29256;&#26412;&#26159;&#21542;&#33021;&#29992;&#21462;&#20915;&#20110;&#20320;&#32534;&#35793;&#22120;&#30340;&#33021;&#21147;&#65292;&#35268;&#21017;&#24456;&#22797;&#26434; + - &#21482;&#26377;&#26631;&#20934;&#20860;&#23481;&#30340;&#32534;&#35793;&#22120;&#21487;&#35265;&#30340;&#29256;&#26412;&#22312;&#24110;&#21161;&#20013;&#32473;&#20986;&#12290; &#35201;&#25214;&#20986;&#32534;&#35793;&#22120;&#25903;&#25345;&#30340;&#29256;&#26412;&#65292;&#29992; + C++ &#39044;&#22788;&#29702;&#22120;&#36816;&#34892; &lt;boost/regex.hpp&gt;&#65292;&#22312;&#36755;&#20986;&#25991;&#20214;&#20013;&#25628;&#32034;&#20320;&#24863;&#20852;&#36259;&#30340;&#20989;&#25968;&#12290; + &#27880;&#24847;&#65292;&#29616;&#22312;&#21482;&#26377;&#24456;&#23569;&#30340;&#32534;&#35793;&#22120;&#23545;&#36825;&#20123;&#37325;&#36733;&#20989;&#25968;&#20173;&#19981;&#25903;&#25345;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/futher.html Thu Sep 4 19:42:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/futher.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>References and Further Information</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>References and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;</title> <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="examples.html" title="Test and Example Programs">
-<link rel="next" href="faq.html" title="FAQ">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="examples.html" title="Test and Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;"> +<link rel="next" href="faq.html" title="FAQ &#24120;&#35265;&#38382;&#39064;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,45 +24,55 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.futher"></a><a href="futher.html" title="References and Further Information"> References
-      and Further Information</a>
+<a name="boost_regex.background_information.futher"></a><a class="link" href="futher.html" title="References and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;"> References + and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;</a>
 </h3></div></div></div>
 <p>
Short tutorials on regular expressions can be <a href="http://etext.lib.virginia.edu/helpsheets/regex.html"; target="_top">found - here</a> and <a href="http://www.linuxpcug.org/lessons/regexp.html"; target="_top">here</a>. + here</a> and <a href="http://www.linuxpcug.org/lessons/regexp.html"; target="_top">here</a>.<br> + &#20851;&#20110;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#31616;&#30701;&#25945;&#31243;&#21487;&#22312; <a href="http://etext.lib.virginia.edu/helpsheets/regex.html"; target="_top">&#36825;&#37324;</a> + &#21644; <a href="http://www.linuxpcug.org/lessons/regexp.html"; target="_top">&#36825;&#37324;</a>
+        &#25214;&#21040;&#12290;
       </p>
 <p>
The main book on regular expressions is <a href="http://www.oreilly.com/catalog/regex/"; target="_top">Mastering
-        Regular Expressions, published by O'Reilly</a>.
+ Regular Expressions, published by O'Reilly</a>.<br> &#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#20027;&#35201;&#20070;&#30446;&#65306;<a href="http://www.oreilly.com/catalog/regex/"; target="_top">Mastering Regular Expressions,
+        published by O'Reilly</a>&#12290;
       </p>
 <p>
Boost.Regex forms the basis for the regular expression chapter of the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical
-        Report on C++ Library Extensions</a>.
+ Report on C++ Library Extensions</a>.<br> Boost.Regex &#34987;&#20316;&#20026; <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical + Report on C++ Library Extensions</a> &#20013;&#20851;&#20110;&#27491;&#21017;&#34920;&#36798;&#24335;&#19968;&#31456;&#30340;&#22522;&#30784;&#12290;
       </p>
 <p>
The <a href="http://www.opengroup.org/onlinepubs/7908799/toc.htm"; target="_top">Open Unix Specification</a> contains a wealth of useful material, including
-        the POSIX regular expression syntax.
+ the POSIX regular expression syntax.<br> <a href="http://www.opengroup.org/onlinepubs/7908799/toc.htm"; target="_top">Open + Unix Specification</a> &#20013;&#26377;&#35768;&#22810;&#26377;&#29992;&#30340;&#26448;&#26009;&#65292;&#21253;&#25324;POSIX&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#12290;
       </p>
 <p>
The <a href="http://www.cs.ucr.edu/~stelo/pattern.html"; target="_top">Pattern Matching
         Pointers</a> site is a "must visit" resource for anyone interested
-        in pattern matching.
+ in pattern matching.<br> <a href="http://www.cs.ucr.edu/~stelo/pattern.html"; target="_top">Pattern + Matching Pointers</a> &#23545;&#20110;&#20219;&#20309;&#23545;&#27169;&#24335;&#21305;&#37197;&#26377;&#20852;&#36259;&#30340;&#20154;&#65292;&#26159;&#19968;&#20010;"&#24517;&#39035;&#30475;"&#30340;&#32593;&#31449;&#12290;
       </p>
 <p>
<a href="http://glimpse.cs.arizona.edu/"; target="_top">Glimpse and Agrep</a>, use - a simplified regular expression syntax to achieve faster search times. + a simplified regular expression syntax to achieve faster search times.<br> + <a href="http://glimpse.cs.arizona.edu/"; target="_top">Glimpse and Agrep</a> &#20351;&#29992;&#20102;&#19968;&#20010;&#31616;&#21270;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#26469;&#33719;&#24471;&#26356;&#24555;&#30340;&#25628;&#32034;&#26102;&#38388;&#12290;
       </p>
 <p>
<a href="http://glimpse.cs.arizona.edu/udi.html"; target="_top">Udi Manber</a> and <a href="http://www.dcc.uchile.cl/~rbaeza/"; target="_top">Ricardo Baeza-Yates</a> both have a selection of useful pattern matching papers available from their
-        respective web sites.
+ respective web sites.<br> <a href="http://glimpse.cs.arizona.edu/udi.html"; target="_top">Udi + Manber</a> &#21644; <a href="http://www.dcc.uchile.cl/~rbaeza/"; target="_top">Ricardo + Baeza-Yates</a> &#22312;&#20182;&#20204;&#30340;&#32593;&#31449;&#19978;&#37117;&#26377;&#19968;&#20123;&#26377;&#29992;&#30340;&#20851;&#20110;&#27169;&#24335;&#21305;&#37197;&#30340;&#35770;&#25991;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/headers.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/headers.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Headers</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Headers &#22836;&#25991;&#20214;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information"> -<link rel="prev" href="../background_information.html" title="Background Information">
-<link rel="next" href="locale.html" title="Localization">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="next" href="locale.html" title="Localization &#26412;&#22320;&#21270;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,30 +24,28 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.headers"></a><a href="headers.html" title="Headers"> Headers</a> +<a name="boost_regex.background_information.headers"></a><a class="link" href="headers.html" title="Headers &#22836;&#25991;&#20214;"> Headers
+      &#22836;&#25991;&#20214;</a>
 </h3></div></div></div>
 <p>
There are two main headers used by this library: <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> provides full access to the main template library, while <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> provides access to the (deprecated) high level class RegEx, and the POSIX
-        API functions.
-        <br />
-        本库有两个主要的头文件:
- <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 提供对主要模板库的完全访问, - <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 提供对 (废弃的) 高层类 RegEx,以及 POSIX API 函数的访问。 + API functions.<br> &#26412;&#24211;&#26377;&#20004;&#20010;&#20027;&#35201;&#30340;&#22836;&#25991;&#20214;&#65306;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + &#25552;&#20379;&#23545;&#20027;&#35201;&#27169;&#26495;&#24211;&#30340;&#23436;&#20840;&#35775;&#38382;&#65292;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + &#25552;&#20379;&#23545;(&#24223;&#24323;&#30340;)&#39640;&#23618;&#31867; RegEx&#65292;&#20197;&#21450; POSIX API &#20989;&#25968;&#30340;&#35775;&#38382;&#12290;
       </p>
 <p>
There is also a header containing only forward declarations <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex_fwd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> - for use when an interface is dependent upon <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>, but otherwise does
-        not need the full definitions.
-        <br />
- 同样有一个包含所有前向声明的头文件 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex_fwd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>, - 当接口依赖于 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>,但又不需要完全定义时使用。 + for use when an interface is dependent upon <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>, but otherwise does + not need the full definitions.<br> &#21516;&#26679;&#26377;&#19968;&#20010;&#21253;&#21547;&#25152;&#26377;&#21069;&#21521;&#22768;&#26126;&#30340;&#22836;&#25991;&#20214; + <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex_fwd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>&#65292;&#24403;&#25509;&#21475;&#20381;&#36182;&#20110; + <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>&#65292;&#20294;&#21448;&#19981;&#38656;&#35201;&#23436;&#20840;&#23450;&#20041;&#26102;&#20351;&#29992;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/history.html Sat Sep 12 00:52:19 2009 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/history.html Thu May 27 20:09:44 2010
@@ -1,72 +1,149 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-<title>History</title><link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>History &#21382;&#21490;</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information"> -<link rel="prev" href="acknowledgements.html" title="Acknowledgements"></head> -<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-<table cellpadding="2" width="100%"><tbody><tr>
-<td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td> +<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="acknowledgements.html" title="Acknowledgements &#40483;&#35874;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="acknowledgements.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../background_information.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.history"></a><a href="history.html" title="History"> History</a> +<a name="boost_regex.background_information.history"></a><a class="link" href="history.html" title="History &#21382;&#21490;"> History
+      &#21382;&#21490;</a>
 </h3></div></div></div>
-<h5><a name="id807313"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_40">Boost
-1.40</a> </h5>
-<div class="itemizedlist">
-<ul type="disc"><li>Added support for many Perl 5.10 syntax elements including named
-sub-expressions, branch resets and recursive regular expressions.
-</li></ul></div><h5><a name="id688173"></a><a class="link" href="history.html#boost_regex.background_information.history.boost_1_38">Boost
-1.38</a> </h5>
-<div class="itemizedlist">
-<ul type="disc"><li><span class="bold"><strong>Breaking change</strong></span>: empty expressions, -and empty alternatives are now allowed when using the Perl regular expression -syntax. This change has been added for Perl compatibility, when the new <a class="link" title="syntax_option_type" href="../ref/syntax_option_type.html"><code class="computeroutput"><span class="identifier">syntax_option_type</span></code></a><span class="emphasis"><em>no_empty_expressions</em></span> is set then the old -behaviour is preserved and empty expressions are prohibited. This is issue <a href="https://svn.boost.org/trac/boost/ticket/1081"; target="_top">#1081</a>. -</li><li>Added support for Perl style ${n} expressions in format strings (issue <a href="https://svn.boost.org/trac/boost/ticket/2556"; target="_top">#2556</a>). -</li><li>Added support for accessing the location of sub-expressions within the -regular expression string (issue <a href="https://svn.boost.org/trac/boost/ticket/2269"; target="_top">#2269</a>). -</li><li>Fixed compiler compatibility issues <a href="https://svn.boost.org/trac/boost/ticket/2244"; target="_top">#2244</a>, <a href="https://svn.boost.org/trac/boost/ticket/2514"; target="_top">#2514</a>, and -<a href="https://svn.boost.org/trac/boost/ticket/2244"; target="_top">#2458</a>. -</li></ul></div><a name="boost_regex.background_information.history.boost_1_34"></a><h5>
-<a name="id659744"></a>
- <a href="history.html#boost_regex.background_information.history.boost_1_34">Boost
+<p>
+ New issues should be submitted at <a href="http:svn.boost.org" target="_top">svn.boost.org</a> + - don't forget to include your email address in the ticket!<br> &#26032;&#21457;&#29616;&#30340;&#38382;&#39064;&#24212;&#25552;&#20132;&#21040; + <a href="http:svn.boost.org" target="_top">svn.boost.org</a> - &#19981;&#35201;&#24536;&#35760;&#24102;&#19978;&#20320;&#30340;email&#22320;&#22336;&#65281;
+      </p>
+<p>
+ Currently open issues can be viewed <a href="https://svn.boost.org/trac/boost/query?status=assigned&amp;status=new&amp;status=reopened&amp;component=regex&amp;order=priority&amp;col=id&amp;col=summary&amp;col=status&amp;col=type&amp;col=milestone&amp;col=component"; target="_top">here</a>.<br> + &#24403;&#21069;&#26410;&#20851;&#38381;&#30340;&#38382;&#39064;&#35831;&#35265; <a href="https://svn.boost.org/trac/boost/query?status=assigned&amp;status=new&amp;status=reopened&amp;component=regex&amp;order=priority&amp;col=id&amp;col=summary&amp;col=status&amp;col=type&amp;col=milestone&amp;col=component"; target="_top">&#36825;&#37324;</a>&#12290;
+      </p>
+<p>
+ All issues including closed ones can be viewed <a href="https://svn.boost.org/trac/boost/query?status=assigned&amp;status=closed&amp;status=new&amp;status=reopened&amp;component=regex&amp;order=priority&amp;col=id&amp;col=summary&amp;col=status&amp;col=type&amp;col=milestone&amp;col=component"; target="_top">here</a>.<br> + &#25152;&#26377;&#38382;&#39064;&#65292;&#21253;&#25324;&#24050;&#20851;&#38381;&#30340;&#65292;&#35831;&#35265; <a href="https://svn.boost.org/trac/boost/query?status=assigned&amp;status=closed&amp;status=new&amp;status=reopened&amp;component=regex&amp;order=priority&amp;col=id&amp;col=summary&amp;col=status&amp;col=type&amp;col=milestone&amp;col=component"; target="_top">&#36825;&#37324;</a>&#12290;
+      </p>
+<a name="boost_regex.background_information.history.boost_1_42"></a><h5>
+<a name="id5037777"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_42">Boost
+        1.42</a>
+      </h5>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Added support for Functors rather than strings as format expressions.<br> + &#38500;&#20102;&#20197;&#23383;&#31526;&#20018;&#20316;&#20026;&#26684;&#24335;&#21270;&#34920;&#36798;&#24335;&#20043;&#22806;&#65292;&#26032;&#22686;&#20102;&#20197;&#20223;&#20989;&#25968;&#20316;&#20026;&#26684;&#24335;&#21270;&#34920;&#36798;&#24335;&#12290;
+        </li>
+<li>
+ Improved error reporting when throwing exceptions to include better more + relevant information.<br> &#25913;&#36827;&#20102;&#25243;&#20986;&#24322;&#24120;&#26102;&#30340;&#38169;&#35823;&#25253;&#21578;&#65292;&#21253;&#21547;&#20102;&#26356;&#22810;&#20449;&#24687;&#12290;
+        </li>
+<li>
+ Improved performance and reduced stack usage of recursive expressions.<br> + &#25913;&#36827;&#20102;&#24615;&#33021;&#20197;&#21450;&#23545;&#36882;&#24402;&#34920;&#36798;&#24335;&#20943;&#23569;&#20102;&#26632;&#30340;&#20351;&#29992;&#12290;
+        </li>
+<li>
+ Fixed tickets<br> &#20462;&#22797;&#20197;&#19979;&#25925;&#38556; <a href="https://svn.boost.org/trac/boost/ticket/2802"; target="_top">#2802</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3425"; target="_top">#3425</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3507"; target="_top">#3507</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3546"; target="_top">#3546</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3631"; target="_top">#3631</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3632"; target="_top">#3632</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3715"; target="_top">#3715</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3718"; target="_top">#3718</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3763"; target="_top">#3763</a>, + <a href="https://svn.boost.org/trac/boost/ticket/3764"; target="_top">#3764</a>
+</li>
+</ul></div>
+<a name="boost_regex.background_information.history.boost_1_40"></a><h5>
+<a name="id5037907"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_40">Boost
+        1.40</a>
+      </h5>
+<div class="itemizedlist"><ul type="disc"><li>
+ Added support for many Perl 5.10 syntax elements including named sub-expressions, + branch resets and recursive regular expressions.<br> &#22686;&#21152;&#20102;&#23545;&#35768;&#22810; + Perl 5.10 &#35821;&#27861;&#20803;&#32032;&#30340;&#25903;&#25345;&#65292;&#21253;&#25324;&#21629;&#21517;&#23376;&#34920;&#36798;&#24335;&#12289;&#20998;&#25903;&#37325;&#32622;&#21644;&#36882;&#24402;&#27491;&#21017;&#34920;&#36798;&#24335;&#12290;
+        </li></ul></div>
+<a name="boost_regex.background_information.history.boost_1_38"></a><h5>
+<a name="id5037946"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_38">Boost
+        1.38</a>
+      </h5>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<span class="bold"><strong>Breaking change</strong></span>: empty expressions, and + empty alternatives are now allowed when using the Perl regular expression + syntax. This change has been added for Perl compatibility, when the new + <a class="link" href="../ref/syntax_option_type.html" title="syntax_option_type"><code class="computeroutput"><span class="identifier">syntax_option_type</span></code></a><span class="emphasis"><em>no_empty_expressions</em></span> is set then the old behaviour + is preserved and empty expressions are prohibited. This is issue <a href="https://svn.boost.org/trac/boost/ticket/1081"; target="_top">#1081</a>.<br><span class="bold"><strong>&#30772;&#22351;&#24615;&#20462;&#25913;</strong></span>: &#29616;&#22312;&#22312;&#20351;&#29992; Perl + &#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#26102;&#65292;&#20801;&#35768;&#31354;&#34920;&#36798;&#24335;&#21644;&#31354;&#36873;&#25321;&#12290; &#36825;&#26159;&#20026;&#20102; + Perl &#20860;&#23481;&#24615;&#32780;&#26032;&#22686;&#30340;&#65292;&#24403;&#26032;&#30340; <a class="link" href="../ref/syntax_option_type.html" title="syntax_option_type"><code class="computeroutput"><span class="identifier">syntax_option_type</span></code></a><span class="emphasis"><em>no_empty_expressions</em></span> + &#34987;&#32622;&#20301;&#65292;&#23558;&#20445;&#30041;&#26087;&#26377;&#34892;&#20026;&#24182;&#31105;&#27490;&#31354;&#34920;&#36798;&#24335;&#12290;&#36825;&#26159;&#38382;&#39064; + <a href="https://svn.boost.org/trac/boost/ticket/1081"; target="_top">#1081</a>.
+        </li>
+<li>
+ Added support for Perl style ${n} expressions in format strings (issue + <a href="https://svn.boost.org/trac/boost/ticket/2556"; target="_top">#2556</a>).<br> + &#22686;&#21152;&#23545;&#22312;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#20013;&#30340; Perl &#39118;&#26684;&#30340; ${n} &#34920;&#36798;&#24335;&#30340;&#25903;&#25345; + (&#38382;&#39064; <a href="https://svn.boost.org/trac/boost/ticket/2556"; target="_top">#2556</a>)&#12290;
+        </li>
+<li>
+ Added support for accessing the location of sub-expressions within the + regular expression string (issue <a href="https://svn.boost.org/trac/boost/ticket/2269"; target="_top">#2269</a>).<br> + &#22686;&#21152;&#23545;&#27491;&#21017;&#34920;&#36798;&#24335;&#23383;&#31526;&#20018;&#20869;&#37096;&#23376;&#34920;&#36798;&#24335;&#20301;&#32622;&#30340;&#35775;&#38382; (&#38382;&#39064; + <a href="https://svn.boost.org/trac/boost/ticket/2269"; target="_top">#2269</a>).
+        </li>
+<li>
+ Fixed compiler compatibility issues <br> &#20462;&#22797;&#32534;&#35793;&#22120;&#20860;&#23481;&#24615;&#38382;&#39064; + <a href="https://svn.boost.org/trac/boost/ticket/2244"; target="_top">#2244</a>, + <a href="https://svn.boost.org/trac/boost/ticket/2514"; target="_top">#2514</a>, + and <a href="https://svn.boost.org/trac/boost/ticket/2244"; target="_top">#2458</a>.
+        </li>
+</ul></div>
+<a name="boost_regex.background_information.history.boost_1_34"></a><h5>
+<a name="id5038131"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_34">Boost
         1.34</a>
       </h5>
 <div class="itemizedlist"><ul type="disc">
 <li>
Fix for non-greedy repeats and partial matches not working correctly in
-          some cases.
+ some cases.<br> &#20462;&#22797;&#22312;&#26576;&#20123;&#24773;&#20917;&#19979;&#38750;&#36138;&#23146;&#37325;&#22797;&#21644;&#37096;&#20998;&#21305;&#37197;&#24037;&#20316;&#19981;&#27491;&#30830;&#30340;&#32570;&#38519;&#12290;
         </li>
 <li>
Fix for non-greedy repeats on VC++ not working in some cases (bug report
-          1515830).
+ 1515830).<br> &#20462;&#22797;&#22312;&#26576;&#20123;&#24773;&#20917;&#19979;&#38750;&#36138;&#23146;&#37325;&#22797;&#22312;VC++&#19978;&#19981;&#33021;&#24037;&#20316;&#30340;&#38382;&#39064;(bug
+          report 1515830)&#12290;
         </li>
 <li>
Changed match_results::position() to return a valid result when *this represents
-          a partial match.
+ a partial match.<br> &#20462;&#25913; match_results::position() &#20197;&#22312; *this &#34920;&#31034;&#19968;&#20010;&#37096;&#20998;&#21305;&#37197;&#26102;&#36820;&#22238;&#26377;&#25928;&#32467;&#26524;&#12290;
         </li>
 <li>
Fixed the grep and egrep options so that the newline character gets treated
-          the same as |.
+ the same as |.<br> &#20462;&#22797; grep &#21644; egrep &#36873;&#39033;&#65292;&#20197;&#20351;&#24471;&#25442;&#34892;&#31526;&#30340;&#20316;&#29992;&#19982;
+          | &#30456;&#21516;&#12290;
         </li>
 </ul></div>
 <a name="boost_regex.background_information.history.boost_1_33_1"></a><h5>
-<a name="id659795"></a>
- <a href="history.html#boost_regex.background_information.history.boost_1_33_1">Boost
+<a name="id5038199"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_1">Boost
         1.33.1</a>
       </h5>
 <div class="itemizedlist"><ul type="disc">
@@ -135,8 +212,8 @@
         </li>
 </ul></div>
 <a name="boost_regex.background_information.history.boost_1_33_0"></a><h5>
-<a name="id659924"></a>
- <a href="history.html#boost_regex.background_information.history.boost_1_33_0">Boost
+<a name="id5038318"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_33_0">Boost
         1.33.0</a>
       </h5>
 <div class="itemizedlist"><ul type="disc">
@@ -190,16 +267,16 @@
         </li>
 </ul></div>
 <a name="boost_regex.background_information.history.boost_1_32_1"></a><h5>
-<a name="id660024"></a>
- <a href="history.html#boost_regex.background_information.history.boost_1_32_1">Boost
+<a name="id5038417"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_32_1">Boost
         1.32.1</a>
       </h5>
 <div class="itemizedlist"><ul type="disc"><li>
           Fixed bug in partial matches of bounded repeats of '.'.
         </li></ul></div>
 <a name="boost_regex.background_information.history.boost_1_31_0"></a><h5>
-<a name="id660057"></a>
- <a href="history.html#boost_regex.background_information.history.boost_1_31_0">Boost
+<a name="id5038447"></a>
+ <a class="link" href="history.html#boost_regex.background_information.history.boost_1_31_0">Boost
         1.31.0</a>
       </h5>
 <div class="itemizedlist"><ul type="disc">
@@ -234,16 +311,17 @@
         </li>
 </ul></div>
 </div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tbody><tr> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
 </div></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="acknowledgements.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../background_information.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
 </div>
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/locale.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/locale.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Localization</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Localization &#26412;&#22320;&#21270;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="headers.html" title="Headers">
-<link rel="next" href="thread_safety.html" title="Thread Safety">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="headers.html" title="Headers &#22836;&#25991;&#20214;"> +<link rel="next" href="thread_safety.html" title="Thread Safety &#32447;&#31243;&#23433;&#20840;&#24615;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,13 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.locale"></a><a href="locale.html" title="Localization"> Localization 本地化</a> +<a name="boost_regex.background_information.locale"></a><a class="link" href="locale.html" title="Localization &#26412;&#22320;&#21270;"> Localization
+      &#26412;&#22320;&#21270;</a>
 </h3></div></div></div>
 <p>
Boost.Regex provides extensive support for run-time localization, the localization
-        model used can be split into two parts: front-end and back-end.
-        <br />
- Boost.Regex 对运行时本地化提供扩展支持,本地化模型分为两部分:前端 和后端。 + model used can be split into two parts: front-end and back-end.<br> Boost.Regex + &#23545;&#36816;&#34892;&#26102;&#26412;&#22320;&#21270;&#25552;&#20379;&#25193;&#23637;&#25903;&#25345;&#65292;&#26412;&#22320;&#21270;&#27169;&#22411;&#20998;&#20026;&#20004;&#37096;&#20998;&#65306;&#21069;&#31471;&#21644;&#21518;&#31471;&#12290;
       </p>
 <p>
Front-end localization deals with everything which the user sees - error
@@ -38,12 +38,10 @@
application could change [[:word:]] to [[:mot:]] and \w to \m. Modifying the front end locale requires active support from the developer, by providing the library with a message catalogue to load, containing the localized strings.
-        Front-end locale is affected by the LC_MESSAGES category only.
-        <br />
- 前端本地化处理所有用户要见的东西 - 错误信息,以及自己的正则表达式语 法。
-        例如,法语程序可以将 [[:word:]] 替换为 [[:mot:]],\w 替换为 \m。
- 修改前端区域需要开发者的主动支持,为库提供包含本地化字符串的信息目 录。
-        前端区域只被 LC_MESSAGES 种类影响。
+ Front-end locale is affected by the LC_MESSAGES category only.<br> &#21069;&#31471;&#26412;&#22320;&#21270;&#22788;&#29702;&#25152;&#26377;&#29992;&#25143;&#35201;&#35265;&#30340;&#19996;&#35199; + - &#38169;&#35823;&#20449;&#24687;&#65292;&#20197;&#21450;&#33258;&#24049;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#12290;&#20363;&#22914;&#65292;&#27861;&#35821;&#31243;&#24207;&#21487;&#20197;&#23558; + [[:word:]] &#26367;&#25442;&#20026; [[:mot:]]&#65292;\w &#26367;&#25442;&#20026; \m&#12290;&#20462;&#25913;&#21069;&#31471;&#21306;&#22495;&#38656;&#35201;&#24320;&#21457;&#32773;&#30340;&#20027;&#21160;&#25903;&#25345;&#65292;&#20026;&#24211;&#25552;&#20379;&#21253;&#21547;&#26412;&#22320;&#21270;&#23383;&#31526;&#20018;&#30340;&#20449;&#24687;&#30446;&#24405;&#12290; + &#21069;&#31471;&#21306;&#22495;&#21482;&#34987; LC_MESSAGES &#31181;&#31867;&#24433;&#21709;&#12290;
       </p>
 <p>
Back-end localization deals with everything that occurs after the expression
@@ -59,42 +57,41 @@
your code will always match a whole word, if the program is run on a machine with, for example, a Greek locale, then it will still match a whole word, but in Greek characters rather than Latin ones. The back-end locale is affected
-        by the LC_TYPE and LC_COLLATE categories.
-        <br />
- 后端本地化处理表达式被分析后出现的所有事物 - 换句话说,所有用户看不 到或不直接交互的东西。
-        它处理大小写转换,对照和字符分类成员。
- 后端区域不需要程序员的干涉 - 库通过从操作系统 / 运行时库的当前区域 取得所有信息。 - 这意味着如果程序用户并不直接与正则表达式交互 - 例如正则表达式嵌入 在 C++ 代码中 - 就不需要显式的本地化,库本身会处理所有的事情。 - 例如在表达式中嵌入 [[:word:]]+ 总会匹配整个单词,如果程序运行在,例 如 Greek 区域,仍会匹配整个单词,只是使用 Greek 字符而不是 Latin 字符。
-        后端区域被 LC_TYPE 和 LC_COLLATE 种类影响。
+ by the LC_TYPE and LC_COLLATE categories.<br> &#21518;&#31471;&#26412;&#22320;&#21270;&#22788;&#29702;&#34920;&#36798;&#24335;&#34987;&#20998;&#26512;&#21518;&#20986;&#29616;&#30340;&#25152;&#26377;&#20107;&#29289; + - &#25442;&#21477;&#35805;&#35828;&#65292;&#25152;&#26377;&#29992;&#25143;&#30475;&#19981;&#21040;&#25110;&#19981;&#30452;&#25509;&#20132;&#20114;&#30340;&#19996;&#35199;&#12290; &#23427;&#22788;&#29702;&#22823;&#23567;&#20889;&#36716;&#25442;&#65292;&#23545;&#29031;&#21644;&#23383;&#31526;&#20998;&#31867;&#25104;&#21592;&#12290;&#21518;&#31471;&#21306;&#22495;&#19981;&#38656;&#35201;&#31243;&#24207;&#21592;&#30340;&#24178;&#28041; + - &#24211;&#36890;&#36807;&#20174;&#25805;&#20316;&#31995;&#32479; / &#36816;&#34892;&#26102;&#24211;&#30340;&#24403;&#21069;&#21306;&#22495;&#21462;&#24471;&#25152;&#26377;&#20449;&#24687;&#12290; + &#36825;&#24847;&#21619;&#30528;&#22914;&#26524;&#31243;&#24207;&#29992;&#25143;&#24182;&#19981;&#30452;&#25509;&#19982;&#27491;&#21017;&#34920;&#36798;&#24335;&#20132;&#20114; - &#20363;&#22914;&#27491;&#21017;&#34920;&#36798;&#24335;&#23884;&#20837;&#22312; + C++ &#20195;&#30721;&#20013; - &#23601;&#19981;&#38656;&#35201;&#26174;&#24335;&#30340;&#26412;&#22320;&#21270;&#65292;&#24211;&#26412;&#36523;&#20250;&#22788;&#29702;&#25152;&#26377;&#30340;&#20107;&#24773;&#12290; + &#20363;&#22914;&#22312;&#34920;&#36798;&#24335;&#20013;&#23884;&#20837; [[:word:]]+ &#24635;&#20250;&#21305;&#37197;&#25972;&#20010;&#21333;&#35789;&#65292;&#22914;&#26524;&#31243;&#24207;&#36816;&#34892;&#22312;&#65292;&#20363;&#22914; + Greek &#21306;&#22495;&#65292;&#20173;&#20250;&#21305;&#37197;&#25972;&#20010;&#21333;&#35789;&#65292;&#21482;&#26159;&#20351;&#29992; Greek &#23383;&#31526;&#32780;&#19981;&#26159; + Latin &#23383;&#31526;&#12290;&#21518;&#31471;&#21306;&#22495;&#34987; LC_TYPE &#21644; LC_COLLATE &#31181;&#31867;&#24433;&#21709;&#12290;
       </p>
 <p>
- There are three separate localization mechanisms supported by Boost.Regex:
-        <br />
-        Boost.Regex 支持三种独立的本地化机制:
+ There are three separate localization mechanisms supported by Boost.Regex:<br> + Boost.Regex &#25903;&#25345;&#19977;&#31181;&#29420;&#31435;&#30340;&#26412;&#22320;&#21270;&#26426;&#21046;&#65306;
       </p>
-<a name="boost_regex.background_information.locale.win32_localization_model_"></a><h5>
-<a name="id653642"></a>
- <a href="locale.html#boost_regex.background_information.locale.win32_localization_model_">Win32
-        localization model.</a>
+<a name="boost_regex.background_information.locale.win32_localization_model__win32__________________"></a><h5>
+<a name="id5030215"></a>
+ <a class="link" href="locale.html#boost_regex.background_information.locale.win32_localization_model__win32__________________">Win32 + localization model Win32&#30340;&#26412;&#22320;&#21270;&#27169;&#24335;</a>
       </h5>
 <p>
This is the default model when the library is compiled under Win32, and is encapsulated by the traits class <code class="computeroutput"><span class="identifier">w32_regex_traits</span></code>. - When this model is in effect each <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> object gets it's own + When this model is in effect each <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 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 <code class="computeroutput"><span class="identifier">basic_regex</span></code> object to set it's locale to some other LCID if you wish. All the settings used by Boost.Regex are acquired directly from the operating system bypassing the C run time library. Front-end localization requires a resource dll, containing a string table with the user-defined strings. The traits class exports the
-        function:
-        <br />
- 这是库在 Win32 下编译的默认模型,并由特性类 <code class="computeroutput"><span class="identifier">w32_regex_traits</span></code> 封装。 - 使用这个模型,每个 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 都有自己的 LCID,默认为 GetUserDefaultLCID 返回的用户默认设置,但也可以调用 <code class="computeroutput"><span class="identifier">basic_regex</span></code> 的 imbue 设置为其它的 LCID。
-        Boost.Regex 使用的所有设置都绕过 C 运行时库直接从操作系统取得。
- 前端本地化需要资源 dll,包含一个用户自定义字符串的字符串表格 (string table)。
-        特性类导出如下函数:
+ function:<br> &#36825;&#26159;&#24211;&#22312; Win32 &#19979;&#32534;&#35793;&#30340;&#40664;&#35748;&#27169;&#22411;&#65292;&#24182;&#30001;&#29305;&#24615;&#31867; + <code class="computeroutput"><span class="identifier">w32_regex_traits</span></code> &#23553;&#35013;&#12290;&#20351;&#29992;&#36825;&#20010;&#27169;&#22411;&#65292;&#27599;&#20010; + <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> + &#37117;&#26377;&#33258;&#24049;&#30340; LCID&#65292;&#40664;&#35748;&#20026; GetUserDefaultLCID &#36820;&#22238;&#30340;&#29992;&#25143;&#40664;&#35748;&#35774;&#32622;&#65292;&#20294;&#20063;&#21487;&#20197;&#35843;&#29992; + <code class="computeroutput"><span class="identifier">basic_regex</span></code> &#30340; imbue &#35774;&#32622;&#20026;&#20854;&#23427;&#30340; + LCID&#12290;Boost.Regex &#20351;&#29992;&#30340;&#25152;&#26377;&#35774;&#32622;&#37117;&#32469;&#36807; C &#36816;&#34892;&#26102;&#24211;&#30452;&#25509;&#20174;&#25805;&#20316;&#31995;&#32479;&#21462;&#24471;&#12290;&#21069;&#31471;&#26412;&#22320;&#21270;&#38656;&#35201;&#36164;&#28304; + dll&#65292;&#21253;&#21547;&#19968;&#20010;&#29992;&#25143;&#33258;&#23450;&#20041;&#23383;&#31526;&#20018;&#30340;&#23383;&#31526;&#20018;&#34920;&#26684;&#12290; &#29305;&#24615;&#31867;&#23548;&#20986;&#22914;&#19979;&#20989;&#25968;&#65306;
       </p>
<pre class="programlisting"><span class="keyword">static</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">set_message_catalogue</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">);</span>
 </pre>
@@ -102,23 +99,23 @@
which needs to be called with a string identifying the name of the resource dll, before your code compiles any regular expressions (but not necessarily before you construct any <code class="computeroutput"><span class="identifier">basic_regex</span></code>
-        instances):
-        <br />
- 需要在你的代码编译任何正则表达式之前 (但不必在构造任意 <code class="computeroutput"><span class="identifier">basic_regex</span></code> 实 例之前) 调用,通过字符串确定资源 dll 的名称。 + instances):<br> &#38656;&#35201;&#22312;&#20320;&#30340;&#20195;&#30721;&#32534;&#35793;&#20219;&#20309;&#27491;&#21017;&#34920;&#36798;&#24335;&#20043;&#21069;(&#20294;&#19981;&#24517;&#22312;&#26500;&#36896;&#20219;&#24847; + <code class="computeroutput"><span class="identifier">basic_regex</span></code> &#23454;&#20363;&#20043;&#21069;)&#35843;&#29992;&#65292;&#36890;&#36807;&#23383;&#31526;&#20018;&#30830;&#23450;&#36164;&#28304;
+        dll &#30340;&#21517;&#31216;&#12290;
       </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">w32_regex_traits</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">set_message_catalogue</span><span class="special">(</span><span class="string">"mydll.dll"</span><span class="special">);</span>
 </pre>
 <p>
The library provides full Unicode support under NT, under Windows 9x the library degrades gracefully - characters 0 to 255 are supported, the remainder
-        are treated as "unknown" graphic characters.
-        <br />
- 库在 NT 下提供完全的 Unicode 支持,在 Windows 9x 下,库适度地退化 - 0 到 255 之间的字符被支持,其余的被认为是 "未知的" 图形字符。 + are treated as "unknown" graphic characters.<br> &#24211;&#22312; NT &#19979;&#25552;&#20379;&#23436;&#20840;&#30340; + Unicode &#25903;&#25345;&#65292;&#22312; Windows 9x &#19979;&#65292;&#24211;&#36866;&#24230;&#22320;&#36864;&#21270; - 0 &#21040; 255 &#20043;&#38388;&#30340;&#23383;&#31526;&#34987;&#25903;&#25345;&#65292;&#20854;&#20313;&#30340;&#34987;&#35748;&#20026;&#26159;
+        "&#26410;&#30693;&#30340;" &#22270;&#24418;&#23383;&#31526;&#12290;
       </p>
-<a name="boost_regex.background_information.locale.c_localization_model_"></a><h5>
-<a name="id653880"></a>
- <a href="locale.html#boost_regex.background_information.locale.c_localization_model_">C
-        localization model.</a>
+<a name="boost_regex.background_information.locale.c_localization_model__c__________________"></a><h5>
+<a name="id5030525"></a>
+ <a class="link" href="locale.html#boost_regex.background_information.locale.c_localization_model__c__________________">C + localization model C&#30340;&#26412;&#22320;&#21270;&#27169;&#24335;</a>
       </h5>
 <p>
This model has been deprecated in favor of the C++ locale for all non-Windows
@@ -128,66 +125,61 @@
BOOST_REGEX_USE_C_LOCALE. When this model is in effect there is a single global locale, as set by <code class="computeroutput"><span class="identifier">setlocale</span></code>. All settings are acquired from your run time library, consequently Unicode
-        support is dependent upon your run time library implementation.
-        <br />
-        这个模型被废弃了,在所有非 Windows 编译器下用 C++ 区域代替。
- 这个区域用特性类 <code class="computeroutput"><span class="identifier">c_regex_traits</span></code> 封装,Win32 用户可以通过定义 预处理符号 BOOST_REGEX_USE_C_LOCALE 来强迫使用这个模型。 - 使用这个模型时只有一个全局的区域,通过 <code class="computeroutput"><span class="identifier">setlocale</span></code> 设 置。 - 所有的设置都从运行时库取得,所以 Unicode 支持也取决于运行时库的实 现。 + support is dependent upon your run time library implementation.<br> &#36825;&#20010;&#27169;&#22411;&#34987;&#24223;&#24323;&#20102;&#65292;&#22312;&#25152;&#26377;&#38750; + Windows &#32534;&#35793;&#22120;&#19979;&#29992; C++ &#21306;&#22495;&#20195;&#26367;&#12290;&#36825;&#20010;&#21306;&#22495;&#29992;&#29305;&#24615;&#31867; <code class="computeroutput"><span class="identifier">c_regex_traits</span></code> &#23553;&#35013;&#65292;Win32 &#29992;&#25143;&#21487;&#20197;&#36890;&#36807;&#23450;&#20041;&#39044;&#22788;&#29702;&#31526;&#21495; + BOOST_REGEX_USE_C_LOCALE &#26469;&#24378;&#36843;&#20351;&#29992;&#36825;&#20010;&#27169;&#22411;&#12290;&#20351;&#29992;&#36825;&#20010;&#27169;&#22411;&#26102;&#21482;&#26377;&#19968;&#20010;&#20840;&#23616;&#30340;&#21306;&#22495;&#65292;&#36890;&#36807; + <code class="computeroutput"><span class="identifier">setlocale</span></code> &#35774;&#32622;&#12290; &#25152;&#26377;&#30340;&#35774;&#32622;&#37117;&#20174;&#36816;&#34892;&#26102;&#24211;&#21462;&#24471;&#65292;&#25152;&#20197; + Unicode &#25903;&#25345;&#20063;&#21462;&#20915;&#20110;&#36816;&#34892;&#26102;&#24211;&#30340;&#23454;&#29616;&#12290;
       </p>
 <p>
-        Front end localization is not supported.
-        <br />
-        不支持前端本地化。
+ Front end localization is not supported.<br> &#19981;&#25903;&#25345;&#21069;&#31471;&#26412;&#22320;&#21270;&#12290;
       </p>
 <p>
Note that calling setlocale invalidates all compiled regular expressions, calling <code class="computeroutput"><span class="identifier">setlocale</span><span class="special">(</span><span class="identifier">LC_ALL</span><span class="special">,</span> <span class="string">"C"</span><span class="special">)</span></code> will make this library behave equivalent to most traditional regular expression
-        libraries including version 1 of this library.
-        <br />
-        注意调用 setlocale 会使所有已编译的正则表达式无效,
- 调用 <code class="computeroutput"><span class="identifier">setlocale</span><span class="special">(</span><span class="identifier">LC_ALL</span><span class="special">,</span> <span class="string">"C"</span><span class="special">)</span></code> 会使本库行为 和大多数传统的正则表达式库 (本库的版本 1 包含) 一致。 + libraries including version 1 of this library.<br> &#27880;&#24847;&#35843;&#29992; <code class="computeroutput"><span class="identifier">setlocale</span></code> &#20250;&#20351;&#25152;&#26377;&#24050;&#32534;&#35793;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#26080;&#25928;&#65292;&#35843;&#29992; + <code class="computeroutput"><span class="identifier">setlocale</span><span class="special">(</span><span class="identifier">LC_ALL</span><span class="special">,</span> <span class="string">"C"</span><span class="special">)</span></code> + &#20250;&#20351;&#26412;&#24211;&#34892;&#20026;&#21644;&#22823;&#22810;&#25968;&#20256;&#32479;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#24211; (&#26412;&#24211;&#30340;&#29256;&#26412;1&#21253;&#21547;)&#19968;&#33268;&#12290;
       </p>
-<a name="boost_regex.background_information.locale.c___localization_model_"></a><h5>
-<a name="id653992"></a>
- <a href="locale.html#boost_regex.background_information.locale.c___localization_model_">C++
-        localization model.</a>
+<a name="boost_regex.background_information.locale.c___localization_model__c_________________"></a><h5>
+<a name="id5030725"></a>
+ <a class="link" href="locale.html#boost_regex.background_information.locale.c___localization_model__c_________________">C++
+        localization model C++&#26412;&#22320;&#21270;&#27169;&#24335;</a>
       </h5>
 <p>
-        This model is the default for non-Windows compilers.
-        <br />
-        这是非 Windows 编译器的默认模型。
+ This model is the default for non-Windows compilers.<br> &#36825;&#26159;&#38750; Windows + &#32534;&#35793;&#22120;&#30340;&#40664;&#35748;&#27169;&#22411;&#12290;
       </p>
 <p>
- When this model is in effect each instance of <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> has its own instance - of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span></code>, class <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> also has a member function + When this model is in effect each instance of <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> has its own instance + of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span></code>, class <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> also has a member function <code class="computeroutput"><span class="identifier">imbue</span></code> 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 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">messages</span></code> - facet of the expression's locale, the traits class exports the symbol:
-        <br />
- 使用这个模型时,<a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 的每个实例都有自己的 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span></code> 实 例, - 类 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 也有成员函数 <code class="computeroutput"><span class="identifier">imbue</span></code> 用来为表 达式的每个实例设置区域。 - 前端本地化需要 POSIX 信息目录,通过表达式区域的 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">messages</span></code> facet 调入,
-        特性类导出如下符号:
+ facet of the expression's locale, the traits class exports the symbol:<br> + &#20351;&#29992;&#36825;&#20010;&#27169;&#22411;&#26102;&#65292; <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> &#30340;&#27599;&#20010;&#23454;&#20363;&#37117;&#26377;&#33258;&#24049;&#30340; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span></code> &#23454;&#20363;&#65292;&#31867; <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> &#20063;&#26377;&#25104;&#21592;&#20989;&#25968; + <code class="computeroutput"><span class="identifier">imbue</span></code> &#29992;&#26469;&#20026;&#34920;&#36798;&#24335;&#30340;&#27599;&#20010;&#23454;&#20363;&#35774;&#32622;&#21306;&#22495;&#12290;&#21069;&#31471;&#26412;&#22320;&#21270;&#38656;&#35201; + POSIX &#20449;&#24687;&#30446;&#24405;&#65292;&#36890;&#36807;&#34920;&#36798;&#24335;&#21306;&#22495;&#30340; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">messages</span></code> + facet &#35843;&#20837;&#65292;&#29305;&#24615;&#31867;&#23548;&#20986;&#22914;&#19979;&#31526;&#21495;&#65306;
       </p>
<pre class="programlisting"><span class="keyword">static</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">set_message_catalogue</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">);</span>
 </pre>
 <p>
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):
-        <br />
- 需要在你的代码编译任何正则表达式之前 (但不必在构造任意 <code class="computeroutput"><span class="identifier">basic_regex</span></code> 实 例之前) 调用,通过字符串确定信息目录的名称。 + before you construct any basic_regex instances):<br> &#38656;&#35201;&#22312;&#20320;&#30340;&#20195;&#30721;&#32534;&#35793;&#20219;&#20309;&#27491;&#21017;&#34920;&#36798;&#24335;&#20043;&#21069; + (&#20294;&#19981;&#24517;&#22312;&#26500;&#36896;&#20219;&#24847; basic_regex &#23454;&#20363;&#20043;&#21069;) &#35843;&#29992;&#65292;&#36890;&#36807;&#23383;&#31526;&#20018;&#30830;&#23450;&#20449;&#24687;&#30446;&#24405;&#30340;&#21517;&#31216;&#12290;
       </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">cpp_regex_traits</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">set_message_catalogue</span><span class="special">(</span><span class="string">"mycatalogue"</span><span class="special">);</span>
 </pre>
 <p>
Note that calling <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;&gt;::</span><span class="identifier">imbue</span></code> - will invalidate any expression currently compiled in that instance of <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>.
-        <br />
- 注意调用 <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;&gt;::</span><span class="identifier">imbue</span></code> 会使当前 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 实例内已编译的表达式失效。 + will invalidate any expression currently compiled in that instance of <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>.<br> + &#27880;&#24847;&#65292;&#35843;&#29992; <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;&gt;::</span><span class="identifier">imbue</span></code> + &#20250;&#20351;&#24403;&#21069; <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> + &#23454;&#20363;&#20869;&#24050;&#32534;&#35793;&#30340;&#34920;&#36798;&#24335;&#22833;&#25928;&#12290;
       </p>
 <p>
Finally note that if you build the library with a non-default localization
@@ -195,26 +187,29 @@
or BOOST_REGEX_USE_CPP_LOCALE) must be defined both when you build the support library, and when you include <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> or <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> - in your code. The best way to ensure this is to add the #define to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
-        <br />
- 最后注意如果你使用非默认的本地化模型生成库,那么合适的预编译符号 (BOOST_REGEX_USE_C_LOCALE 或 BOOST_REGEX_USE_CPP_LOCALE) 必须同时在生成支持 库,和包含 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 或 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 的代码中定义。 - 保证这点的最好方式可能是将 #define 加入到 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 中。 + in your code. The best way to ensure this is to add the #define to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.<br> + &#26368;&#21518;&#27880;&#24847;&#22914;&#26524;&#20320;&#20351;&#29992;&#38750;&#40664;&#35748;&#30340;&#26412;&#22320;&#21270;&#27169;&#22411;&#29983;&#25104;&#24211;&#65292;&#37027;&#20040;&#21512;&#36866;&#30340;&#39044;&#32534;&#35793;&#31526;&#21495; + (BOOST_REGEX_USE_C_LOCALE &#25110; BOOST_REGEX_USE_CPP_LOCALE) &#24517;&#39035;&#21516;&#26102;&#22312;&#29983;&#25104;&#25903;&#25345;&#24211;&#65292;&#21644;&#21253;&#21547; + <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + &#25110; <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cregex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + &#30340;&#20195;&#30721;&#20013;&#23450;&#20041;&#12290; &#20445;&#35777;&#36825;&#28857;&#30340;&#26368;&#22909;&#26041;&#24335;&#21487;&#33021;&#26159;&#23558; #define &#21152;&#20837;&#21040; + <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">user</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        &#20013;&#12290;
       </p>
-<a name="boost_regex.background_information.locale.providing_a_message_catalogue"></a><h5>
-<a name="id654452"></a>
- <a href="locale.html#boost_regex.background_information.locale.providing_a_message_catalogue">Providing
-        a message catalogue</a>
+<a name="boost_regex.background_information.locale.providing_a_message_catalogue_________________________"></a><h5>
+<a name="id5031438"></a>
+ <a class="link" href="locale.html#boost_regex.background_information.locale.providing_a_message_catalogue_________________________">Providing + a message catalogue &#25552;&#20379;&#19968;&#20010;&#20449;&#24687;&#30446;&#24405;</a>
       </h5>
 <p>
In order to localize the front end of the library, you need to provide the library with the appropriate message strings contained either in a resource dll's string table (Win32 model), or a POSIX message catalogue (C++ models). In the latter case the messages must appear in message set zero of the catalogue.
-        The messages and their id's are as follows:
-        <br />
- 为了提供库前端的本地化,你需要提供合适的信息字符串,包含在资源 dll 的字符串表格 (string table)(Win32 模型) 或 POSIX 信息目录 (C++ 模型)中。
-        下面的信息必须出现在目录中的信息集合 0 中。
-        信息和 id 如下:
+ The messages and their id's are as follows:<br> &#20026;&#20102;&#25552;&#20379;&#24211;&#21069;&#31471;&#30340;&#26412;&#22320;&#21270;&#65292;&#20320;&#38656;&#35201;&#25552;&#20379;&#21512;&#36866;&#30340;&#20449;&#24687;&#23383;&#31526;&#20018;&#65292;&#21253;&#21547;&#22312;&#36164;&#28304; + dll &#30340;&#23383;&#31526;&#20018;&#34920;&#26684;(Win32 &#27169;&#22411;) &#25110; POSIX &#20449;&#24687;&#30446;&#24405; (C++ &#27169;&#22411;)&#20013;&#12290; + &#19979;&#38754;&#30340;&#20449;&#24687;&#24517;&#39035;&#20986;&#29616;&#22312;&#30446;&#24405;&#20013;&#30340;&#20449;&#24687;&#38598;&#21512; 0 &#20013;&#12290;&#20449;&#24687;&#21644;
+        id &#22914;&#19979;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -225,7 +220,7 @@
 <thead><tr>
 <th>
               <p>
-                Message
+                Message &#20449;&#24687;
               </p>
               </th>
 <th>
@@ -235,12 +230,12 @@
               </th>
 <th>
               <p>
-                Meaning
+                Meaning &#21547;&#20041;
               </p>
               </th>
 <th>
               <p>
-                Default value
+                Default value &#32570;&#30465;&#20540;
               </p>
               </th>
 </tr></thead>
@@ -253,9 +248,7 @@
               </td>
 <td>
               <p>
-                The character used to start a sub-expression.
-                <br />
-                用于开始一个子表达式的字符。
+ The character used to start a sub-expression.<br> &#29992;&#20110;&#24320;&#22987;&#19968;&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -272,9 +265,7 @@
               </td>
 <td>
               <p>
-                The character used to end a sub-expression declaration.
-                <br />
-                用于结束一个子表达式声明的字符。
+ The character used to end a sub-expression declaration.<br> &#29992;&#20110;&#32467;&#26463;&#19968;&#20010;&#23376;&#34920;&#36798;&#24335;&#22768;&#26126;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -291,9 +282,7 @@
               </td>
 <td>
               <p>
-                The character used to denote an end of line assertion.
-                <br />
-                用于判断行结束的字符。
+ The character used to denote an end of line assertion.<br> &#29992;&#20110;&#21028;&#26029;&#34892;&#32467;&#26463;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -310,9 +299,7 @@
               </td>
 <td>
               <p>
-                The character used to denote the start of line assertion.
-                <br />
-                用于判断行开始的字符。
+ The character used to denote the start of line assertion.<br> &#29992;&#20110;&#21028;&#26029;&#34892;&#24320;&#22987;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -329,9 +316,8 @@
               </td>
 <td>
               <p>
- The character used to denote the "match any character expression".
-                <br />
-                用于 "匹配任意字符表达式" 的字符。
+ The character used to denote the "match any character expression".<br> + &#29992;&#20110; "&#21305;&#37197;&#20219;&#24847;&#23383;&#31526;&#34920;&#36798;&#24335;" &#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -348,9 +334,7 @@
               </td>
 <td>
               <p>
-                The match zero or more times repetition operator.
-                <br />
-                用于匹配零或多次重复的操作符。
+ The match zero or more times repetition operator.<br> &#29992;&#20110;&#21305;&#37197;&#38646;&#25110;&#22810;&#27425;&#37325;&#22797;&#30340;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -367,9 +351,7 @@
               </td>
 <td>
               <p>
-                The match one or more repetition operator.
-                <br />
-                用于匹配一次或多次重复的操作符。
+ The match one or more repetition operator.<br> &#29992;&#20110;&#21305;&#37197;&#19968;&#27425;&#25110;&#22810;&#27425;&#37325;&#22797;&#30340;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -386,9 +368,7 @@
               </td>
 <td>
               <p>
-                The match zero or one repetition operator.
-                <br />
-                用于匹配零次或一次重复的操作符。
+ The match zero or one repetition operator.<br> &#29992;&#20110;&#21305;&#37197;&#38646;&#27425;&#25110;&#19968;&#27425;&#37325;&#22797;&#30340;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -405,9 +385,7 @@
               </td>
 <td>
               <p>
-                The character set opening character.
-                <br />
-                字符集开始字符。
+ The character set opening character.<br> &#23383;&#31526;&#38598;&#24320;&#22987;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -424,9 +402,7 @@
               </td>
 <td>
               <p>
-                The character set closing character.
-                <br />
-                字符集结束字符。
+ The character set closing character.<br> &#23383;&#31526;&#38598;&#32467;&#26463;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -443,9 +419,7 @@
               </td>
 <td>
               <p>
-                The alternation operator.
-                <br />
-                选择操作符。
+ The alternation operator.<br> &#36873;&#25321;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -462,9 +436,7 @@
               </td>
 <td>
               <p>
-                The escape character.
-                <br />
-                转义字符。
+ The escape character.<br> &#36716;&#20041;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -481,9 +453,7 @@
               </td>
 <td>
               <p>
-                The hash character (not currently used).
-                <br />
-                bash 字符 (目前未使用)。
+ The hash character (not currently used).<br> &#25955;&#21015;&#23383;&#31526; (&#30446;&#21069;&#26410;&#20351;&#29992;)&#12290;
               </p>
               </td>
 <td>
@@ -500,9 +470,7 @@
               </td>
 <td>
               <p>
-                The range operator.
-                <br />
-                范围操作符。
+ The range operator.<br> &#33539;&#22260;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -519,9 +487,7 @@
               </td>
 <td>
               <p>
-                The repetition operator opening character.
-                <br />
-                重复操作符开始字符。
+ The repetition operator opening character.<br> &#37325;&#22797;&#25805;&#20316;&#31526;&#24320;&#22987;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -538,9 +504,7 @@
               </td>
 <td>
               <p>
-                The repetition operator closing character.
-                <br />
-                重复操作符结束字符。
+ The repetition operator closing character.<br> &#37325;&#22797;&#25805;&#20316;&#31526;&#32467;&#26463;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -557,9 +521,7 @@
               </td>
 <td>
               <p>
-                The digit characters.
-                <br />
-                数字字符。
+ The digit characters.<br> &#25968;&#23383;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -577,9 +539,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the word boundary assertion.
-                <br />
-                前跟转义字符用于判断单词边界的字符。
+ the word boundary assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#21333;&#35789;&#36793;&#30028;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -597,9 +557,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the non-word boundary assertion.
-                <br />
-                前跟转义字符用于判断非单词边界的字符。
+ the non-word boundary assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#38750;&#21333;&#35789;&#36793;&#30028;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -617,9 +575,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the word-start boundary assertion.
-                <br />
-                前跟转义字符用于判断单词开始边界的字符。
+ the word-start boundary assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#21333;&#35789;&#24320;&#22987;&#36793;&#30028;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -637,9 +593,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the word-end boundary assertion.
-                <br />
-                前跟转义字符用于判断单词结束边界的字符。
+ the word-end boundary assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#21333;&#35789;&#32467;&#26463;&#36793;&#30028;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -657,9 +611,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any word character.
-                <br />
-                前跟转义字符用于表示任意单词字符的字符。
+ any word character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#21333;&#35789;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -677,9 +629,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                a non-word character.
-                <br />
-                前跟转义字符用于表示任意非单词字符的字符。
+ a non-word character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#38750;&#21333;&#35789;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -697,9 +647,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                a start of buffer assertion.
-                <br />
-                前跟转义字符用于判断缓冲区开始的字符。
+ a start of buffer assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#32531;&#20914;&#21306;&#24320;&#22987;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -717,9 +665,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                an end of buffer assertion.
-                <br />
-                前跟转义字符用于判断缓冲区结束的字符。
+ an end of buffer assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#32531;&#20914;&#21306;&#32467;&#26463;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -736,9 +682,7 @@
               </td>
 <td>
               <p>
-                The newline character.
-                <br />
-                换行符。
+ The newline character. <br> &#25442;&#34892;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -755,9 +699,7 @@
               </td>
 <td>
               <p>
-                The comma separator.
-                <br />
-                逗号操作符。
+ The comma separator.<br> &#36887;&#21495;&#25805;&#20316;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -775,9 +717,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the bell character.
-                <br />
-                前跟转义字符用于表示响铃字符的字符。
+ the bell character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#21709;&#38083;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -795,9 +735,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the form feed character.
-                <br />
-                前跟转义字符用于表示换页字符的字符。
+ the form feed character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#25442;&#39029;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -815,9 +753,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the newline character.
-                <br />
-                前跟转义字符用于表示换行符的字符。
+ the newline character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#25442;&#34892;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -835,9 +771,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the carriage return character.
-                <br />
-                前跟转义字符用于表示回车字符的字符。
+ the carriage return character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#22238;&#36710;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -855,9 +789,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the tab character.
-                <br />
-                前跟转义字符用于表示制表符的字符。
+ the tab character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#21046;&#34920;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -875,9 +807,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the vertical tab character.
-                <br />
-                前跟转义字符用于表示垂直制表符的字符。
+ the vertical tab character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#22402;&#30452;&#21046;&#34920;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -895,9 +825,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the start of a hexadecimal character constant.
-                <br />
-                前跟转义字符用于标识十六进制字符常量开始的字符。
+ the start of a hexadecimal character constant.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#26631;&#35782;&#21313;&#20845;&#36827;&#21046;&#23383;&#31526;&#24120;&#37327;&#24320;&#22987;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -915,9 +843,8 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the start of an ASCII escape character.
-                <br />
-                前跟转义字符用于标识 ASCII 转义字符开始的字符。
+ the start of an ASCII escape character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#26631;&#35782; + ASCII &#36716;&#20041;&#23383;&#31526;&#24320;&#22987;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -934,9 +861,7 @@
               </td>
 <td>
               <p>
-                The colon character.
-                <br />
-                冒号字符。
+ The colon character.<br> &#20882;&#21495;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -953,9 +878,7 @@
               </td>
 <td>
               <p>
-                The equals character.
-                <br />
-                等号字符。
+ The equals character.<br> &#31561;&#21495;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -973,9 +896,8 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the ASCII escape character.
-                <br />
-                前跟转义字符用于表示 ASCII 转义字符的字符。
+ the ASCII escape character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034; + ASCII &#36716;&#20041;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -993,9 +915,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any lower case character.
-                <br />
-                前跟转义字符用于表示任意小写字母的字符。
+ any lower case character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#23567;&#20889;&#23383;&#27597;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1013,9 +933,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any non-lower case character.
-                <br />
-                前跟转义字符用于表示任意非小写字母的字符。
+ any non-lower case character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#38750;&#23567;&#20889;&#23383;&#27597;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1033,9 +951,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any upper case character.
-                <br />
-                前跟转义字符用于表示任意大写字母的字符。
+ any upper case character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#22823;&#20889;&#23383;&#27597;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1053,9 +969,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any non-upper case character.
-                <br />
-                前跟转义字符用于表示任意非大写字母的字符。
+ any non-upper case character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#38750;&#22823;&#20889;&#23383;&#27597;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1073,9 +987,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any space character.
-                <br />
-                前跟转义字符用于表示任意空白字符的字符。
+ any space character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#31354;&#30333;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1093,9 +1005,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any non-space character.
-                <br />
-                前跟转义字符用于表示任意非空白字符的字符。
+ any non-space character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#38750;&#31354;&#30333;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1113,9 +1023,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any digit character.
-                <br />
-                前跟转义字符用于表示任意数字字符的字符。
+ any digit character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#25968;&#23383;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1133,9 +1041,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any non-digit character.
-                <br />
-                前跟转义字符用于表示任意非数字字符的字符。
+ any non-digit character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#38750;&#25968;&#23383;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1153,9 +1059,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the end quote operator.
-                <br />
-                前跟转义字符用于标识引用操作符结束的字符。
+ the end quote operator.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#26631;&#35782;&#24341;&#29992;&#25805;&#20316;&#31526;&#32467;&#26463;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1173,9 +1077,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the start quote operator.
-                <br />
-                前跟转义字符用于标识引用操作符开始的字符。
+ the start quote operator.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#26631;&#35782;&#24341;&#29992;&#25805;&#20316;&#31526;&#24320;&#22987;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1193,9 +1095,8 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                a Unicode combining character sequence.
-                <br />
-                前跟转义字符用于表示 Unicode 组合字符序列的字符。
+ a Unicode combining character sequence.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034; + Unicode &#32452;&#21512;&#23383;&#31526;&#24207;&#21015;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1213,9 +1114,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                any single character.
-                <br />
-                前跟转义字符用于表示任意单个字符的字符。
+ any single character.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#34920;&#31034;&#20219;&#24847;&#21333;&#20010;&#23383;&#31526;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1233,9 +1132,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                end of buffer operator.
-                <br />
-                前跟转义字符用于标识缓冲区操作符结束的字符。
+ end of buffer operator.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#26631;&#35782;&#32531;&#20914;&#21306;&#25805;&#20316;&#31526;&#32467;&#26463;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1253,9 +1150,7 @@
 <td>
               <p>
The character which when preceded by an escape character represents
-                the continuation assertion.
-                <br />
-                前跟转义字符用于判断继续的字符。
+ the continuation assertion.<br> &#21069;&#36319;&#36716;&#20041;&#23383;&#31526;&#29992;&#20110;&#21028;&#26029;&#32487;&#32493;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1273,9 +1168,8 @@
 <td>
               <p>
The character which when preceeded by (? indicates a zero width negated
-                forward lookahead assert.
-                <br />
-                前跟 (? 用于判断前向匹配长度是否不为 0 的字符。
+ forward lookahead assert.<br> &#21069;&#36319; (? &#29992;&#20110;&#21028;&#26029;&#21069;&#21521;&#21305;&#37197;&#38271;&#24230;&#26159;&#21542;&#19981;&#20026;
+                0 &#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 <td>
@@ -1287,9 +1181,7 @@
 </tbody>
 </table></div>
 <p>
-        Custom error messages are loaded as follows:
-        <br />
-        自定义错误信息如下调入:
+ Custom error messages are loaded as follows: <br> &#33258;&#23450;&#20041;&#38169;&#35823;&#20449;&#24687;&#22914;&#19979;&#35843;&#20837;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -1300,17 +1192,17 @@
 <thead><tr>
 <th>
               <p>
-                Message ID
+                Message ID &#20449;&#24687;ID
               </p>
               </th>
 <th>
               <p>
-                Error message ID
+                Error message ID &#38169;&#35823;&#20449;&#24687;ID
               </p>
               </th>
 <th>
               <p>
-                Default string
+                Default string &#32570;&#30465;&#23383;&#31526;&#20018;
               </p>
               </th>
 </tr></thead>
@@ -1430,12 +1322,14 @@
               </td>
 <td>
               <p>
-                "Unmatched [ or <code class="literal">" </code>
+                "Unmatched [ or \["
               </p>
               </td>
+</tr>
+<tr>
 <td>
               <p>
-                [208
+                208
               </p>
               </td>
 <td>
@@ -1465,9 +1359,6 @@
                 "Unmatched \{"
               </p>
               </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
 </tr>
 <tr>
 <td>
@@ -1485,9 +1376,6 @@
                 "Invalid content of \{\}"
               </p>
               </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
 </tr>
 <tr>
 <td>
@@ -1505,9 +1393,6 @@
                 "Invalid range end"
               </p>
               </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
 </tr>
 <tr>
 <td>
@@ -1525,9 +1410,6 @@
                 "Memory exhausted"
               </p>
               </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
-<td class="auto-generated"> </td>
 </tr>
 <tr>
 <td>
@@ -1545,9 +1427,6 @@
                 "Invalid preceding regular expression"
               </p>
               </td>
-<td class="auto-generated"> </td>
***The diff for this file has been truncated for email.***
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/performance.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/performance.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Performance</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Performance &#24615;&#33021;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="faq.html" title="FAQ">
-<link rel="next" href="standards.html" title="Standards Conformance">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="faq.html" title="FAQ &#24120;&#35265;&#38382;&#39064;"> +<link rel="next" href="standards.html" title="Standards Conformance &#26631;&#20934;&#31526;&#21512;&#24230;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,33 +24,34 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.performance"></a><a href="performance.html" title="Performance"> Performance</a> +<a name="boost_regex.background_information.performance"></a><a class="link" href="performance.html" title="Performance &#24615;&#33021;"> Performance
+      &#24615;&#33021;</a>
 </h3></div></div></div>
 <p>
The performance of Boost.Regex in both recursive and non-recursive modes should be broadly comparable to other regular expression libraries: recursive mode is slightly faster (especially where memory allocation requires thread synchronisation), but not by much. The following pages compare Boost.Regex - with various other regular expression libraries for the following compilers:
-        <br />
-        Boost.Regex 递归和非递归模式的性能可以和其它任何正则表达式库比较:
-        递归模式相对较快 (尤其当内存分配需要线程同步时),但不会快很多。
- 后面几页比较 Boost.Regex 和其它几个正则表达式库在下面编译器上的性 能: + with various other regular expression libraries for the following compilers:<br> + Boost.Regex &#36882;&#24402;&#21644;&#38750;&#36882;&#24402;&#27169;&#24335;&#30340;&#24615;&#33021;&#21487;&#20197;&#21644;&#20854;&#23427;&#20219;&#20309;&#27491;&#21017;&#34920;&#36798;&#24335;&#24211;&#27604;&#36739;&#65306;&#36882;&#24402;&#27169;&#24335;&#30456;&#23545;&#36739;&#24555;(&#23588;&#20854;&#24403;&#20869;&#23384;&#20998;&#37197;&#38656;&#35201;&#32447;&#31243;&#21516;&#27493;&#26102;)&#65292;&#20294;&#19981;&#20250;&#24555;&#24456;&#22810;&#12290; + &#21518;&#38754;&#20960;&#39029;&#27604;&#36739; Boost.Regex &#21644;&#20854;&#23427;&#20960;&#20010;&#27491;&#21017;&#34920;&#36798;&#24335;&#24211;&#22312;&#19979;&#38754;&#32534;&#35793;&#22120;&#19978;&#30340;&#24615;&#33021;&#65306;
       </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
<a href="../../../vc71-performance.html" target="_top">Visual Studio.Net 2003 (recursive
-          Boost.Regex implementation)</a>.
+ Boost.Regex implementation)</a>.<br><a href="../../../vc71-performance.html" target="_top">Visual + Studio.Net 2003 (&#36882;&#24402;&#30340; Boost.Regex &#23454;&#29616;)</a>.
         </li>
 <li>
<a href="../../../gcc-performance.html" target="_top">Gcc 3.2 (cygwin) (non-recursive Boost.Regex
-          implementation)</a>.
+ implementation)</a>.<br><a href="../../../gcc-performance.html" target="_top">Gcc + 3.2 (cygwin) (&#38750;&#36882;&#24402;&#30340; Boost.Regex &#23454;&#29616;)</a>.
         </li>
 </ul></div>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/redist.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/redist.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Redistributables</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Redistributables &#37325;&#20998;&#21457;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="standards.html" title="Standards Conformance">
-<link rel="next" href="acknowledgements.html" title="Acknowledgements">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="standards.html" title="Standards Conformance &#26631;&#20934;&#31526;&#21512;&#24230;"> +<link rel="next" href="acknowledgements.html" title="Acknowledgements &#40483;&#35874;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.redist"></a><a href="redist.html" title="Redistributables"> Redistributables</a> +<a name="boost_regex.background_information.redist"></a><a class="link" href="redist.html" title="Redistributables &#37325;&#20998;&#21457;"> Redistributables
+      &#37325;&#20998;&#21457;</a>
 </h3></div></div></div>
 <p>
If you are using Microsoft or Borland C++ and link to a dll version of the
@@ -37,26 +38,26 @@
link to a static version of Boost.Regex and no dll's will need to be distributed. The possible Boost.Regex dll and library names are computed according to the formula given in <a href="../../../../../../more/getting_started.html" target="_top">the
-        getting started guide</a>.
-        <br />
- 如果你使用 Microsoft 或 Borland C++ 并且链接到 dll 版本的运行时 库,你也可以选择链接到 Boost.Regex 的 dll 版本,
-        通过在编译时定义符号 BOOST_REGEX_DYN_LINK。
- 因为 dll 是可再发行的,所以没有 "标准" 版本,所以在安装到用户的电脑 上时,你应该将这些 dll 放到程序的私有目录下,
-        而不是电脑的 path 目录。
- 如果你链接到静态版本的运行时库,你也会链接到 Boost.Regex 的静态版 本,不需要分发 dll。 - Boost.Regex dll 和库可能的名称是通过 <a href="../../../../../../more/getting_started.html" target="_top">the getting started guide</a> 中给出的公式计算得到的。 + getting started guide</a>.<br> &#22914;&#26524;&#20320;&#20351;&#29992; Microsoft &#25110; Borland + C++ &#24182;&#19988;&#38142;&#25509;&#21040; dll &#29256;&#26412;&#30340;&#36816;&#34892;&#26102;&#24211;&#65292;&#20320;&#20063;&#21487;&#20197;&#36873;&#25321;&#38142;&#25509;&#21040; + Boost.Regex &#30340; dll &#29256;&#26412;&#65292; &#36890;&#36807;&#22312;&#32534;&#35793;&#26102;&#23450;&#20041;&#31526;&#21495; BOOST_REGEX_DYN_LINK&#12290;&#22240;&#20026; + dll &#26159;&#21487;&#20877;&#21457;&#34892;&#30340;&#65292;&#25152;&#20197;&#27809;&#26377; "&#26631;&#20934;" &#29256;&#26412;&#65292;&#25152;&#20197;&#22312;&#23433;&#35013;&#21040;&#29992;&#25143;&#30340;&#30005;&#33041;&#19978;&#26102;&#65292; + &#20320;&#24212;&#35813;&#23558;&#36825;&#20123; dll &#25918;&#21040;&#31243;&#24207;&#30340;&#31169;&#26377;&#30446;&#24405;&#19979;&#65292;&#32780;&#19981;&#26159;&#30005;&#33041;&#30340; + path &#30446;&#24405;&#12290;&#22914;&#26524;&#20320;&#38142;&#25509;&#21040;&#38745;&#24577;&#29256;&#26412;&#30340;&#36816;&#34892;&#26102;&#24211;&#65292;&#20320;&#20063;&#20250;&#38142;&#25509;&#21040; + Boost.Regex &#30340;&#38745;&#24577;&#29256;&#26412;&#65292;&#19981;&#38656;&#35201;&#20998;&#21457; dll&#12290;Boost.Regex dll &#21644;&#24211;&#21487;&#33021;&#30340;&#21517;&#31216;&#26159;&#36890;&#36807; + <a href="../../../../../../more/getting_started.html" target="_top">&#20837;&#38376;&#25351;&#21335;</a> &#20013;&#32473;&#20986;&#30340;&#20844;&#24335;&#35745;&#31639;&#24471;&#21040;&#30340;&#12290;
       </p>
 <p>
Note: you can disable automatic library selection by defining the symbol BOOST_REGEX_NO_LIB when compiling, this is useful if you want to build Boost.Regex
-        yourself in your IDE, or if you need to debug Boost.Regex.
-        <br />
- 注意:你可以在编译时定义符号 BOOST_REGEX_NO_LIB 关闭库的自动选 择,你在自己的 IDE 上生成 Boost.Regex,或调试 Boost.Regex 的时候会有用。 + yourself in your IDE, or if you need to debug Boost.Regex. <br> &#27880;&#24847;&#65306;&#20320;&#21487;&#20197;&#22312;&#32534;&#35793;&#26102;&#23450;&#20041;&#31526;&#21495; + BOOST_REGEX_NO_LIB &#20851;&#38381;&#24211;&#30340;&#33258;&#21160;&#36873;&#25321;&#65292;&#20320;&#22312;&#33258;&#24049;&#30340; IDE &#19978;&#29983;&#25104; + Boost.Regex&#65292;&#25110;&#35843;&#35797; Boost.Regex &#30340;&#26102;&#20505;&#20250;&#26377;&#29992;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/standards.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/standards.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Standards Conformance</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Standards Conformance &#26631;&#20934;&#31526;&#21512;&#24230;</title> <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="performance.html" title="Performance">
-<link rel="next" href="redist.html" title="Redistributables">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="performance.html" title="Performance &#24615;&#33021;"> +<link rel="next" href="redist.html" title="Redistributables &#37325;&#20998;&#21457;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,91 +24,79 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.standards"></a><a href="standards.html" title="Standards Conformance"> Standards
-      Conformance</a>
+<a name="boost_regex.background_information.standards"></a><a class="link" href="standards.html" title="Standards Conformance &#26631;&#20934;&#31526;&#21512;&#24230;"> Standards
+      Conformance &#26631;&#20934;&#31526;&#21512;&#24230;</a>
 </h3></div></div></div>
 <a name="boost_regex.background_information.standards.c__"></a><h5>
-<a name="id658582"></a>
- <a href="standards.html#boost_regex.background_information.standards.c__">C++</a>
+<a name="id5036360"></a>
+ <a class="link" href="standards.html#boost_regex.background_information.standards.c__">C++</a>
       </h5>
 <p>
Boost.Regex is intended to conform to the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical
-        Report on C++ Library Extensions</a>.
-        <br />
- Boost.Regex 试图与 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical Report on C++ Library Extensions</a> 一致。 + Report on C++ Library Extensions</a>.<br> Boost.Regex &#30340;&#30446;&#30340;&#23601;&#26159;&#19982; + <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical
+        Report on C++ Library Extensions</a> &#19968;&#33268;&#12290;
       </p>
<a name="boost_regex.background_information.standards.ecmascript___javascript"></a><h5>
-<a name="id658620"></a>
- <a href="standards.html#boost_regex.background_information.standards.ecmascript___javascript">ECMAScript
+<a name="id5036405"></a>
+ <a class="link" href="standards.html#boost_regex.background_information.standards.ecmascript___javascript">ECMAScript
         / JavaScript</a>
       </h5>
 <p>
All of the ECMAScript regular expression syntax features are supported, except
-        that:
-        <br />
-        ECMAScript 正则表达式所有语法特性都被支持,除了:
+ that:<br> ECMAScript &#27491;&#21017;&#34920;&#36798;&#24335;&#25152;&#26377;&#35821;&#27861;&#29305;&#24615;&#37117;&#34987;&#25903;&#25345;&#65292;&#38500;&#20102;&#65306;
       </p>
 <p>
The escape sequence \u matches any upper case character (the same as [[:upper:]]) - rather than a Unicode escape sequence; use \x{DDDD} for Unicode escape sequences.
-        <br />
- 转义序列 \u 匹配任意大小字符 (和 [[:upper:]] 一样) 而不是 Unicode 转义序列;
-        使用 \x{DDDD} 匹配 Unicode 转义序列。
+ rather than a Unicode escape sequence; use \x{DDDD} for Unicode escape sequences.<br> + &#36716;&#20041;&#24207;&#21015; \u &#21305;&#37197;&#20219;&#24847;&#22823;&#23567;&#23383;&#31526; (&#21644; [[:upper:]] &#19968;&#26679;) &#32780;&#19981;&#26159; + Unicode &#36716;&#20041;&#24207;&#21015;&#65307;&#20351;&#29992; \x{DDDD} &#21305;&#37197; Unicode &#36716;&#20041;&#24207;&#21015;&#12290;
       </p>
 <a name="boost_regex.background_information.standards.perl"></a><h5>
-<a name="id658659"></a>
- <a href="standards.html#boost_regex.background_information.standards.perl">Perl</a>
+<a name="id5036453"></a>
+ <a class="link" href="standards.html#boost_regex.background_information.standards.perl">Perl</a>
       </h5>
 <p>
-        Almost all Perl features are supported, except for:
-        <br />
-        支持 Perl 几乎所有的特性,除了:
+ Almost all Perl features are supported, except for:<br> &#25903;&#25345; Perl &#20960;&#20046;&#25152;&#26377;&#30340;&#29305;&#24615;&#65292;&#38500;&#20102;&#65306;
       </p>
 <p>
-        (?{code}) Not implementable in a compiled strongly typed language.
-        <br />
-        在强类型编译语言中无法实现 (?{code})。
+ (?{code}) Not implementable in a compiled strongly typed language.<br> + &#22312;&#24378;&#31867;&#22411;&#32534;&#35793;&#35821;&#35328;&#20013;&#26080;&#27861;&#23454;&#29616; (?{code})&#12290;
       </p>
 <p>
-        (??{code}) Not implementable in a compiled strongly typed language.
-        <br />
-        在强类型编译语言中无法实现 (??{code})。
+ (??{code}) Not implementable in a compiled strongly typed language.<br> + &#22312;&#24378;&#31867;&#22411;&#32534;&#35793;&#35821;&#35328;&#20013;&#26080;&#27861;&#23454;&#29616; (??{code})&#12290;
       </p>
 <a name="boost_regex.background_information.standards.posix"></a><h5>
-<a name="id658698"></a>
- <a href="standards.html#boost_regex.background_information.standards.posix">POSIX</a>
+<a name="id5036501"></a>
+ <a class="link" href="standards.html#boost_regex.background_information.standards.posix">POSIX</a>
       </h5>
 <p>
All the POSIX basic and extended regular expression features are supported,
-        except that:
-        <br />
-        支持 POSIX 基本和扩展的所有的正则表达式特性,除了:
+ except that:<br> &#25903;&#25345; POSIX &#22522;&#26412;&#21644;&#25193;&#23637;&#30340;&#25152;&#26377;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#29305;&#24615;&#65292;&#38500;&#20102;&#65306;
       </p>
 <p>
No character collating names are recognized except those specified in the POSIX standard for the C locale, unless they are explicitly registered with
-        the traits class.
-        <br />
- 除了 POSIX 标准为 C locale 指定的字符对照名称,不识别其它字符对照名 称,除非它们显式地用特性类注册。 + the traits class.<br> &#38500;&#20102; POSIX &#26631;&#20934;&#20026; C locale &#25351;&#23450;&#30340;&#23383;&#31526;&#23545;&#29031;&#21517;&#31216;&#65292;&#19981;&#35782;&#21035;&#20854;&#23427;&#23383;&#31526;&#23545;&#29031;&#21517;&#31216;&#65292;&#38500;&#38750;&#23427;&#20204;&#26174;&#24335;&#22320;&#29992;&#29305;&#24615;&#31867;&#27880;&#20876;&#12290;
       </p>
 <p>
Character equivalence classes ( [[=a=]] etc) are probably buggy except on Win32. Implementing this feature requires knowledge of the format of the string sort keys produced by the system; if you need this, and the default implementation doesn't work on your platform, then you will need to supply
-        a custom traits class.
-        <br />
-        字符等价分类 (如 [[=a=]]) 在非 Win32 平台上可能有很多 bug。
- 这个特性的实现需要系统提供的字符串排序关键字信息;如果你需要,并且 在你的平台上默认实现不能工作,
-        你可能需要提供一个自定义的特性类。
+ a custom traits class.<br> &#23383;&#31526;&#31561;&#20215;&#20998;&#31867; (&#22914; [[=a=]]) &#22312;&#38750; Win32 + &#24179;&#21488;&#19978;&#21487;&#33021;&#26377;&#24456;&#22810; bug&#12290; &#36825;&#20010;&#29305;&#24615;&#30340;&#23454;&#29616;&#38656;&#35201;&#31995;&#32479;&#25552;&#20379;&#30340;&#23383;&#31526;&#20018;&#25490;&#24207;&#20851;&#38190;&#23383;&#20449;&#24687;&#65307;&#22914;&#26524;&#20320;&#38656;&#35201;&#65292;&#24182;&#19988;&#22312;&#20320;&#30340;&#24179;&#21488;&#19978;&#40664;&#35748;&#23454;&#29616;&#19981;&#33021;&#24037;&#20316;&#65292;&#20320;&#21487;&#33021;&#38656;&#35201;&#25552;&#20379;&#19968;&#20010;&#33258;&#23450;&#20041;&#30340;&#29305;&#24615;&#31867;&#12290;
       </p>
 <a name="boost_regex.background_information.standards.unicode"></a><h5>
-<a name="id658745"></a>
- <a href="standards.html#boost_regex.background_information.standards.unicode">Unicode</a>
+<a name="id5036568"></a>
+ <a class="link" href="standards.html#boost_regex.background_information.standards.unicode">Unicode</a>
       </h5>
 <p>
The following comments refer to <a href="http://unicode.org/reports/tr18/"; target="_top">Unicode
-        Technical Standard #18: Unicode Regular Expressions version 11</a>.
+ Technical Standard #18: Unicode Regular Expressions version 11</a>.<br> + &#19979;&#34920;&#20013;&#30340;&#39033;&#30446;&#24341;&#29992;&#33267; <a href="http://unicode.org/reports/tr18/"; target="_top">Unicode&#25216;&#26415;&#26631;&#20934;#18: + Unicode&#27491;&#21017;&#34920;&#36798;&#24335;&#29256;&#26412;11</a>&#12290;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -119,17 +107,17 @@
 <thead><tr>
 <th>
               <p>
-                Item
+                Item &#39033;&#30446;
               </p>
               </th>
 <th>
               <p>
-                Feature
+                Feature &#29305;&#24615;
               </p>
               </th>
 <th>
               <p>
-                Support
+                Support &#25903;&#25345;
               </p>
               </th>
 </tr></thead>
@@ -142,12 +130,13 @@
               </td>
 <td>
               <p>
-                Hex Notation
+ Hex Notation<br> &#21313;&#20845;&#36827;&#21046;&#35760;&#21495;
               </p>
               </td>
 <td>
               <p>
-                Yes: use \x{DDDD} to refer to code point UDDDD.
+ Yes: use \x{DDDD} to refer to code point UDDDD.<br> &#26159;&#65306;&#29992; \x{DDDD}
+                &#26469;&#34920;&#31034;&#30721;&#28857; UDDDD.
               </p>
               </td>
 </tr>
@@ -159,15 +148,15 @@
               </td>
 <td>
               <p>
-                Character Properties
+                Character Properties<br> &#23383;&#31526;&#23646;&#24615;
               </p>
               </td>
 <td>
               <p>
All the names listed under the General Category Property are supported.
-                Script names and Other Names are not currently supported.
-                <br />
- 所有 General Category Property 中列出的名称都被支持。 Script 名称和 Other 名称目前还未支持。 + Script names and Other Names are not currently supported.<br> &#25152;&#26377; + General Category Property &#20013;&#21015;&#20986;&#30340;&#21517;&#31216;&#37117;&#34987;&#25903;&#25345;&#12290;Script + &#21517;&#31216;&#21644; Other &#21517;&#31216;&#30446;&#21069;&#36824;&#26410;&#25903;&#25345;&#12290;
               </p>
               </td>
 </tr>
@@ -179,30 +168,26 @@
               </td>
 <td>
               <p>
-                Subtraction and Intersection
+ Subtraction and Intersection<br> &#30456;&#20943;&#19982;&#20132;&#38598;
               </p>
               </td>
 <td>
               <p>
-                Indirectly support by forward-lookahead:
-                <br />
-                前向搜索间接支持:
+ Indirectly support by forward-lookahead:<br> &#21069;&#21521;&#25628;&#32034;&#38388;&#25509;&#25903;&#25345;&#65306;
               </p>
               <p>
<code class="computeroutput"><span class="special">(?=[[:</span><span class="identifier">X</span><span class="special">:]])[[:</span><span class="identifier">Y</span><span class="special">:]]</span></code>
               </p>
               <p>
-                Gives the intersection of character properties X and Y.
-                <br />
-                给出字符属性 X 和 Y 的交集。
+ Gives the intersection of character properties X and Y.<br> &#32473;&#20986;&#23383;&#31526;&#23646;&#24615;
+                X &#21644; Y &#30340;&#20132;&#38598;&#12290;
               </p>
               <p>
<code class="computeroutput"><span class="special">(?![[:</span><span class="identifier">X</span><span class="special">:]])[[:</span><span class="identifier">Y</span><span class="special">:]]</span></code>
               </p>
               <p>
-                Gives everything in Y that is not in X (subtraction).
-                <br />
-                给出在 Y 中但不在 X 中的属性 (差)。
+ Gives everything in Y that is not in X (subtraction).<br> &#32473;&#20986;&#22312; + Y &#20013;&#20294;&#19981;&#22312; X &#20013;&#30340;&#23646;&#24615; (&#24046;)&#12290;
               </p>
               </td>
 </tr>
@@ -214,14 +199,13 @@
               </td>
 <td>
               <p>
-                Simple Word Boundaries
+ Simple Word Boundaries<br> &#31616;&#21333;&#30340;&#35789;&#36793;&#30028;
               </p>
               </td>
 <td>
               <p>
- Conforming: non-spacing marks are included in the set of word characters.
-                <br />
-                标准化中:非空白标记包含在单词字符集中。(???)
+ Conforming: non-spacing marks are included in the set of word characters.<br> + &#26631;&#20934;&#21270;&#20013;&#65306;&#38750;&#31354;&#30333;&#26631;&#35760;&#21253;&#21547;&#22312;&#21333;&#35789;&#23383;&#31526;&#38598;&#20013;&#12290;
               </p>
               </td>
 </tr>
@@ -233,16 +217,16 @@
               </td>
 <td>
               <p>
-                Caseless Matching
+ Caseless Matching<br> &#19981;&#20998;&#22823;&#23567;&#20889;&#21305;&#37197;
               </p>
               </td>
 <td>
               <p>
Supported, note that at this level, case transformations are 1:1, many to many case folding operations are not supported (for example
-                "ß" to "SS").
-                <br />
- 支持,注意在这个级别上,大小写转换是 1:1 的,多对多的语法折 叠操作是不支持的 (例如 "ß" 到 "SS")。 + "&#223;" to "SS").<br> &#25903;&#25345;&#65292;&#27880;&#24847;&#22312;&#36825;&#20010;&#32423;&#21035;&#19978;&#65292;&#22823;&#23567;&#20889;&#36716;&#25442;&#26159; + 1:1 &#30340;&#65292;&#22810;&#23545;&#22810;&#30340;&#35821;&#27861;&#25240;&#21472;&#25805;&#20316;&#26159;&#19981;&#25903;&#25345;&#30340; (&#20363;&#22914; "&#223;"
+                &#21040; "SS")&#12290;
               </p>
               </td>
 </tr>
@@ -254,16 +238,16 @@
               </td>
 <td>
               <p>
-                Line Boundaries
+                Line Boundaries<br> &#34892;&#36793;&#30028;
               </p>
               </td>
 <td>
               <p>
                 Supported, except that "." matches only one character of
                 "\r\n". Other than that word boundaries match correctly;
-                including not matching in the middle of a "\r\n" sequence.
-                <br />
- 支持,除了 "." 只匹配 "\r\n" 的一个字符,除了这个以外,单词 边界匹配正确;包括不匹配 "\r\n" 序列的中间。 + including not matching in the middle of a "\r\n" sequence.<br> + &#25903;&#25345;&#65292;&#38500;&#20102; "." &#21482;&#21305;&#37197; "\r\n" &#30340;&#19968;&#20010;&#23383;&#31526;&#65292;&#38500;&#20102;&#36825;&#20010;&#20197;&#22806;&#65292;&#21333;&#35789;&#36793;&#30028;&#21305;&#37197;&#27491;&#30830;&#65307;&#21253;&#25324;&#19981;&#21305;&#37197;
+                "\r\n" &#24207;&#21015;&#30340;&#20013;&#38388;&#12290;
               </p>
               </td>
 </tr>
@@ -275,15 +259,15 @@
               </td>
 <td>
               <p>
-                Code Points
+                Code Points<br> &#30721;&#28857;
               </p>
               </td>
 <td>
               <p>
Supported: provided you use the u32* algorithms, then UTF-8, UTF-16 - and UTF-32 are all treated as sequences of 32-bit code points.
-                <br />
- 支持:使用 u32* 算法,UTF-8、UTF-16 和 UTF-32 都被当作 32 位码点的序列。 + and UTF-32 are all treated as sequences of 32-bit code points.<br> + &#25903;&#25345;&#65306;&#20351;&#29992; u32* &#31639;&#27861;&#65292;UTF-8&#12289;UTF-16 &#21644; UTF-32 &#37117;&#34987;&#24403;&#20316;
+                32 &#20301;&#30721;&#28857;&#30340;&#24207;&#21015;&#12290;
               </p>
               </td>
 </tr>
@@ -301,9 +285,8 @@
 <td>
               <p>
Not supported: it is up to the user of the library to convert all - text into the same canonical form as the regular expression.
-                <br />
- 不支持:依赖于用户的库将所有文本转换为正则表达式的规范形 式。(???) + text into the same canonical form as the regular expression.<br> + &#19981;&#25903;&#25345;&#65306;&#20381;&#36182;&#20110;&#29992;&#25143;&#30340;&#24211;&#23558;&#25152;&#26377;&#25991;&#26412;&#36716;&#25442;&#20026;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#35268;&#33539;&#24418;&#24335;&#12290;
               </p>
               </td>
 </tr>
@@ -320,27 +303,22 @@
               </td>
 <td>
               <p>
-                Not supported.
+                Not supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
 <tr>
 <td>
               <p>
-                2.3
+ 2.3Default Word Boundaries<br> &#32570;&#30465;&#30340;&#35789;&#36793;&#30028;
               </p>
-          </td>
-<td>
-              <p>
-              </p>
-                Default Word Boundaries
               </td>
 <td>
               <p>
-                Not supported.
+                Not supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
-<td class="auto-generated"> </td>
+<td class="auto-generated">&#160;</td>
 </tr>
 <tr>
 <td>
@@ -350,12 +328,12 @@
               </td>
 <td>
               <p>
-                Default Loose Matches
+ Default Loose Matches<br> &#32570;&#30465;&#30340;&#23485;&#26494;&#21305;&#37197;
               </p>
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -367,15 +345,14 @@
               </td>
 <td>
               <p>
-                Named Properties
+                Named Properties<br> &#21629;&#21517;&#23646;&#24615;
               </p>
               </td>
 <td>
               <p>
                 Supported: the expression "[[:name:]]" or \N{name} matches
-                the named character "name".
-                <br />
-                支持:表达式 "[[:name:]]" 或 \N{name} 匹配命名字符 "name"。
+ the named character "name".<br> &#25903;&#25345;&#65306;&#34920;&#36798;&#24335; "[[:name:]]" + &#25110; \N{name} &#21305;&#37197;&#21629;&#21517;&#23383;&#31526; "name"&#12290;
               </p>
               </td>
 </tr>
@@ -387,12 +364,12 @@
               </td>
 <td>
               <p>
-                Wildcard properties
+ Wildcard properties<br> &#36890;&#37197;&#31526;&#23646;&#24615;
               </p>
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -409,7 +386,7 @@
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -426,7 +403,7 @@
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -443,7 +420,7 @@
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -461,9 +438,8 @@
 <td>
               <p>
Partial support: [[=c=]] matches characters with the same primary
-                equivalence class as "c".
-                <br />
-                部分支持:[[=c=]] 匹配同 "c" 有相同主等价分类的字符。
+ equivalence class as "c".<br> &#37096;&#20998;&#25903;&#25345;&#65306;[[=c=]] + &#21305;&#37197;&#21516; "c" &#26377;&#30456;&#21516;&#20027;&#31561;&#20215;&#20998;&#31867;&#30340;&#23383;&#31526;&#12290;
               </p>
               </td>
 </tr>
@@ -482,9 +458,8 @@
               <p>
Supported: [a-b] matches any character that collates in the range a to b, when the expression is constructed with the collate flag
-                set.
-                <br />
- 支持:[a-b] 匹配任意对应于范围 a 到 b 的字符,当表达式使用 collate 标签构造时。 + set.<br> &#25903;&#25345;&#65306;[a-b] &#21305;&#37197;&#20219;&#24847;&#23545;&#24212;&#20110;&#33539;&#22260; a &#21040; b &#30340;&#23383;&#31526;&#65292;&#24403;&#34920;&#36798;&#24335;&#20351;&#29992;
+                collate &#26631;&#31614;&#26500;&#36896;&#26102;&#12290;
               </p>
               </td>
 </tr>
@@ -496,12 +471,12 @@
               </td>
 <td>
               <p>
-                Context Matches
+ Context Matches<br> &#19978;&#19979;&#25991;&#21305;&#37197;
               </p>
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -513,15 +488,14 @@
               </td>
 <td>
               <p>
-                Incremental Matches
+                Incremental Matches<br> &#36882;&#22686;&#21305;&#37197;
               </p>
               </td>
 <td>
               <p>
Supported: pass the flag <code class="computeroutput"><span class="identifier">match_partial</span></code>
-                to the regex algorithms.
-                <br />
- 支持:将标签 <code class="computeroutput"><span class="identifier">match_partial</span></code> 传入正则表达式算法中。 + to the regex algorithms.<br> &#25903;&#25345;&#65306;&#23558;&#26631;&#31614; <code class="computeroutput"><span class="identifier">match_partial</span></code> + &#20256;&#20837;&#27491;&#21017;&#34920;&#36798;&#24335;&#31639;&#27861;&#20013;&#12290;
               </p>
               </td>
 </tr>
@@ -538,7 +512,7 @@
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -550,16 +524,14 @@
               </td>
 <td>
               <p>
-                Possible Match Sets
+ Possible Match Sets<br> &#25110;&#33021;&#30340;&#21305;&#37197;&#38598;
               </p>
               </td>
 <td>
               <p>
Not supported, however this information is used internally to optimise the matching of regular expressions, and return quickly if no match
-                is possible.
-                <br />
- 不支持,但这个信息在内部用于优化正则表达式的匹配,当不存在 匹配时快速返回。 + is possible.<br> &#19981;&#25903;&#25345;&#65292;&#20294;&#36825;&#20010;&#20449;&#24687;&#22312;&#20869;&#37096;&#29992;&#20110;&#20248;&#21270;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#65292;&#24403;&#19981;&#23384;&#22312;&#21305;&#37197;&#26102;&#24555;&#36895;&#36820;&#22238;&#12290;
               </p>
               </td>
 </tr>
@@ -577,9 +549,7 @@
 <td>
               <p>
Partial Support: It is possible to achieve a similar effect by using
-                a custom regular expression traits class.
-                <br />
-                部分支持:可以通过自定义正则表达式特性类来达到类似的效果。
+ a custom regular expression traits class.<br> &#37096;&#20998;&#25903;&#25345;&#65306;&#21487;&#20197;&#36890;&#36807;&#33258;&#23450;&#20041;&#27491;&#21017;&#34920;&#36798;&#24335;&#29305;&#24615;&#31867;&#26469;&#36798;&#21040;&#31867;&#20284;&#30340;&#25928;&#26524;&#12290;
               </p>
               </td>
 </tr>
@@ -596,7 +566,7 @@
               </td>
 <td>
               <p>
-                Not Supported.
+                Not Supported.<br> &#19981;&#25903;&#25345;
               </p>
               </td>
 </tr>
@@ -605,7 +575,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information/thread_safety.html Mon Oct 13 03:49:57 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information/thread_safety.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Thread Safety</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Thread Safety &#32447;&#31243;&#23433;&#20840;&#24615;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../background_information.html" title="Background Information">
-<link rel="prev" href="locale.html" title="Localization">
-<link rel="next" href="examples.html" title="Test and Example Programs">
+<link rel="up" href="../background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> +<link rel="prev" href="locale.html" title="Localization &#26412;&#22320;&#21270;"> +<link rel="next" href="examples.html" title="Test and Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,75 +24,68 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.background_information.thread_safety"></a><a href="thread_safety.html" title="Thread Safety"> Thread
-      Safety</a>
+<a name="boost_regex.background_information.thread_safety"></a><a class="link" href="thread_safety.html" title="Thread Safety &#32447;&#31243;&#23433;&#20840;&#24615;"> Thread
+      Safety &#32447;&#31243;&#23433;&#20840;&#24615;</a>
 </h3></div></div></div>
 <p>
The Boost.Regex library is thread safe when Boost is: you can verify that Boost is in thread safe mode by checking to see if <code class="computeroutput"><span class="identifier">BOOST_HAS_THREADS</span></code> is defined: this macro is set automatically by the config system when threading
-        support is turned on in your compiler.
-        <br />
-        如果 Boost 是线程安全的,那么 Boost.Regex 库也是:
- 你可以通过检查 <code class="computeroutput"><span class="identifier">BOOST_HAS_THREADS</span></code> 是否被定义来验证 Boost 是 否处于线程安全模式:
-        在编译器支持线程的情况下这个宏被配置系统自动地设置。
+ support is turned on in your compiler.<br> &#22914;&#26524; Boost &#26159;&#32447;&#31243;&#23433;&#20840;&#30340;&#65292;&#37027;&#20040; + Boost.Regex &#24211;&#20063;&#26159;&#65306;&#20320;&#21487;&#20197;&#36890;&#36807;&#26816;&#26597; <code class="computeroutput"><span class="identifier">BOOST_HAS_THREADS</span></code> + &#26159;&#21542;&#34987;&#23450;&#20041;&#26469;&#39564;&#35777; Boost &#26159;&#21542;&#22788;&#20110;&#32447;&#31243;&#23433;&#20840;&#27169;&#24335;&#65306; &#22312;&#32534;&#35793;&#22120;&#25903;&#25345;&#32447;&#31243;&#30340;&#24773;&#20917;&#19979;&#36825;&#20010;&#23439;&#34987;&#37197;&#32622;&#31995;&#32479;&#33258;&#21160;&#22320;&#35774;&#32622;&#12290;
       </p>
 <p>
- Class <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> + Class <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> and its typedefs regex and wregex are thread safe, in that compiled regular expressions can safely be shared between threads. The matching algorithms - <a href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, - <a href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, - and <a href="../ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> - are all re-entrant and thread safe. Class <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> is now thread safe, + <a class="link" href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, + <a class="link" href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, + and <a class="link" href="../ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> + are all re-entrant and thread safe. Class <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> 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 <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> instances onto a queue, + (for example one thread may find matches and push <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> instances onto a queue, while another thread pops them off the other end), otherwise use a separate - instance of <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>
-        per thread.
-        <br />
- 类 <a href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> 和其 typedef 的 regex 和 wregex 是线程安全的,也就是说已编译的正则表达式可以被不同线程安全地共享。 - 算法 <a href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>、<a href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> 和 <a href="../ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> 都是可重入,线程安全的。 - 类 <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> 现在是线程安全的,也就是 说匹配的结果可以从一个线程安全地拷贝到另一个线程 (例如一个线程找到匹配并将 <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> 实例放入队列中,而另一个 线程从另一端取出它们), - 否则每个线程使用 <a href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> 独立的实例。 + instance of <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + per thread.<br> &#31867; <a class="link" href="../ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> &#21450;&#20854; typedef &#30340; regex + &#21644; wregex &#26159;&#32447;&#31243;&#23433;&#20840;&#30340;&#65292;&#20063;&#23601;&#26159;&#35828;&#24050;&#32534;&#35793;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#21487;&#20197;&#34987;&#19981;&#21516;&#32447;&#31243;&#23433;&#20840;&#22320;&#20849;&#20139;&#12290; + &#31639;&#27861; <a class="link" href="../ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>&#12289; + <a class="link" href="../ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + &#21644; <a class="link" href="../ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> + &#37117;&#26159;&#21487;&#37325;&#20837;&#65292;&#32447;&#31243;&#23433;&#20840;&#30340;&#12290; &#31867; <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> &#29616;&#22312;&#26159;&#32447;&#31243;&#23433;&#20840;&#30340;&#65292;&#20063;&#23601;&#26159;&#35828;&#21305;&#37197;&#30340;&#32467;&#26524;&#21487;&#20197;&#20174;&#19968;&#20010;&#32447;&#31243;&#23433;&#20840;&#22320;&#25335;&#36125;&#21040;&#21478;&#19968;&#20010;&#32447;&#31243; + (&#20363;&#22914;&#19968;&#20010;&#32447;&#31243;&#25214;&#21040;&#21305;&#37197;&#24182;&#23558; <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> &#23454;&#20363;&#25918;&#20837;&#38431;&#21015;&#20013;&#65292;&#32780;&#21478;&#19968;&#20010;&#32447;&#31243;&#20174;&#21478;&#19968;&#31471;&#21462;&#20986;&#23427;&#20204;)&#65292;&#21542;&#21017;&#27599;&#20010;&#32447;&#31243;&#20351;&#29992; + <a class="link" href="../ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>
+        &#29420;&#31435;&#30340;&#23454;&#20363;&#12290;
       </p>
 <p>
- The <a href="../ref/posix.html" title="POSIX Compatible C API's">POSIX API functions</a> are + The <a class="link" href="../ref/posix.html" title="POSIX Compatible C API's POSIX&#20860;&#23481;&#30340;C API">POSIX API functions</a> are all re-entrant and thread safe, regular expressions compiled with regcomp
-        can also be shared between threads.
-        <br />
- <a href="../ref/posix.html" title="POSIX Compatible C API's">POSIX API 函数</a>都是可重入,线程安全的,
-        用 regcomp 编译的正则表达式也可以在线程间共享。
+ can also be shared between threads.<br> <a class="link" href="../ref/posix.html" title="POSIX Compatible C API's POSIX&#20860;&#23481;&#30340;C API">POSIX + API &#20989;&#25968;</a> &#37117;&#26159;&#21487;&#37325;&#20837;&#65292;&#32447;&#31243;&#23433;&#20840;&#30340;&#65292;&#29992; regcomp &#32534;&#35793;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#20063;&#21487;&#20197;&#22312;&#32447;&#31243;&#38388;&#20849;&#20139;&#12290;
       </p>
 <p>
- The <a href="../ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated)">class + The <a class="link" href="../ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated) &#39640;&#32423;&#31867;RegEx">class RegEx</a> 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.
-        <br />
- <a href="../ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated)">类 RegEx</a> - 只有当每个线程使用自己的 RegEx 实例 (apartment threading ???) 时才 是线程安全的
-        - 这是因为 RegEx 同时处理编译和匹配正则表达式。
+ and matching regular expressions.<br> <a class="link" href="../ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated) &#39640;&#32423;&#31867;RegEx">&#31867; + RegEx</a> &#21482;&#26377;&#24403;&#27599;&#20010;&#32447;&#31243;&#20351;&#29992;&#33258;&#24049;&#30340; RegEx &#23454;&#20363;(&#21333;&#20803;&#32447;&#31243;)&#26102;&#25165;&#26159;&#32447;&#31243;&#23433;&#20840;&#30340; + - &#36825;&#26159;&#22240;&#20026; RegEx &#21516;&#26102;&#22788;&#29702;&#32534;&#35793;&#21644;&#21305;&#37197;&#27491;&#21017;&#34920;&#36798;&#24335;&#12290;
       </p>
 <p>
Finally note that changing the global locale invalidates all compiled regular expressions, therefore calling <code class="computeroutput"><span class="identifier">set_locale</span></code> from one thread while another uses regular expressions will produce unpredictable
-        results.
-        <br />
-        最后注意改变全局区域设置会使所有已编译的正则表达式失效,
- 从某个线程调用 <code class="computeroutput"><span class="identifier">set_locale</span></code> 后会使其它线程使用的正则表达式产 生不可预测的结果。 + results.<br> &#26368;&#21518;&#27880;&#24847;&#25913;&#21464;&#20840;&#23616;&#21306;&#22495;&#35774;&#32622;&#20250;&#20351;&#25152;&#26377;&#24050;&#32534;&#35793;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#22833;&#25928;&#65292;&#20174;&#26576;&#20010;&#32447;&#31243;&#35843;&#29992; + <code class="computeroutput"><span class="identifier">set_locale</span></code> &#21518;&#20250;&#20351;&#20854;&#23427;&#32447;&#31243;&#20351;&#29992;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#20135;&#29983;&#19981;&#21487;&#39044;&#27979;&#30340;&#32467;&#26524;&#12290;
       </p>
 <p>
There is also a requirement that there is only one thread executing prior
-        to the start of main().
-        <br />
-        还有一个要求,在 main() 开始前只有一个执行线程。
+ to the start of main().<br> &#36824;&#26377;&#19968;&#20010;&#35201;&#27714;&#65292;&#22312; main() &#24320;&#22987;&#21069;&#21482;&#26377;&#19968;&#20010;&#25191;&#34892;&#32447;&#31243;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/background_information.html Thu Sep 4 19:42:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/background_information.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Background Information</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Background Information &#32972;&#26223;&#20449;&#24687;</title>
<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
-<link rel="prev" href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated)"> -<link rel="next" href="background_information/headers.html" title="Headers"> +<link rel="prev" href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated) &#39640;&#32423;&#31867;RegEx"> +<link rel="next" href="background_information/headers.html" title="Headers &#22836;&#25991;&#20214;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,30 +24,36 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.background_information"></a><a href="background_information.html" title="Background Information">Background Information</a> +<a name="boost_regex.background_information"></a><a class="link" href="background_information.html" title="Background Information &#32972;&#26223;&#20449;&#24687;"> Background Information
+    &#32972;&#26223;&#20449;&#24687;</a>
 </h2></div></div></div>
 <div class="toc"><dl>
-<dt><span class="section"><a href="background_information/headers.html"> Headers</a></span></dt> -<dt><span class="section"><a href="background_information/locale.html"> Localization</a></span></dt> +<dt><span class="section"><a href="background_information/headers.html"> Headers
+      &#22836;&#25991;&#20214;</a></span></dt>
+<dt><span class="section"><a href="background_information/locale.html"> Localization
+      &#26412;&#22320;&#21270;</a></span></dt>
<dt><span class="section"><a href="background_information/thread_safety.html"> Thread
-      Safety</a></span></dt>
+      Safety &#32447;&#31243;&#23433;&#20840;&#24615;</a></span></dt>
<dt><span class="section"><a href="background_information/examples.html"> Test and
-      Example Programs</a></span></dt>
+ Example Programs &#27979;&#35797;&#19982;&#31034;&#20363;&#31243;&#24207;</a></span></dt> <dt><span class="section"><a href="background_information/futher.html"> References
-      and Further Information</a></span></dt>
-<dt><span class="section"><a href="background_information/faq.html"> FAQ</a></span></dt> -<dt><span class="section"><a href="background_information/performance.html"> Performance</a></span></dt> + and Further Information &#21442;&#32771;&#36164;&#26009;&#21450;&#36827;&#19968;&#27493;&#30340;&#20449;&#24687;</a></span></dt> +<dt><span class="section"><a href="background_information/faq.html"> FAQ &#24120;&#35265;&#38382;&#39064;</a></span></dt> +<dt><span class="section"><a href="background_information/performance.html"> Performance
+      &#24615;&#33021;</a></span></dt>
<dt><span class="section"><a href="background_information/standards.html"> Standards
-      Conformance</a></span></dt>
-<dt><span class="section"><a href="background_information/redist.html"> Redistributables</a></span></dt>
+      Conformance &#26631;&#20934;&#31526;&#21512;&#24230;</a></span></dt>
+<dt><span class="section"><a href="background_information/redist.html"> Redistributables
+      &#37325;&#20998;&#21457;</a></span></dt>
<dt><span class="section"><a href="background_information/acknowledgements.html">
-      Acknowledgements</a></span></dt>
-<dt><span class="section"><a href="background_information/history.html"> History</a></span></dt>
+      Acknowledgements &#40483;&#35874;</a></span></dt>
+<dt><span class="section"><a href="background_information/history.html"> History
+      &#21382;&#21490;</a></span></dt>
 </dl></div>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/captures.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/captures.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Understanding Marked Sub-Expressions and Captures</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Understanding Marked Sub-Expressions and Captures &#29702;&#35299;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#21644;&#25429;&#25417;</title> <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
 <link rel="prev" href="unicode.html" title="Unicode and Boost.Regex">
-<link rel="next" href="partial_matches.html" title="Partial Matches">
+<link rel="next" href="partial_matches.html" title="Partial Matches &#37096;&#20998;&#21305;&#37197;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,29 +24,27 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.captures"></a><a href="captures.html" title="Understanding Marked Sub-Expressions and Captures"> Understanding Marked Sub-Expressions
-    and Captures</a>
+<a name="boost_regex.captures"></a><a class="link" href="captures.html" title="Understanding Marked Sub-Expressions and Captures &#29702;&#35299;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#21644;&#25429;&#25417;"> Understanding Marked Sub-Expressions + and Captures &#29702;&#35299;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#21644;&#25429;&#25417;</a>
 </h2></div></div></div>
 <p>
Captures are the iterator ranges that are "captured" by marked sub-expressions as a regular expression gets matched. Each marked sub-expression can result in more than one capture, if it is matched more than once. This document explains how captures and marked sub-expressions in Boost.Regex are represented and
-      accessed.
-      <br />
- 捕捉(capture)是当正则表达式匹配时由被标记的子表达式(marked sub-expression)"捕获"的迭代器范围。
-      每个被标记的子表达式可以导致一个或多个捕捉(如果匹配多次)。
-      本文档解释了捕捉和被标记子表达式在Boost.Regex中如何被表示和做到的。
+ accessed.<br> &#25429;&#25417;&#26159;&#24403;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#26102;&#30001;&#34987;&#26631;&#35760;&#30340;&#23376;&#34920;&#36798;&#24335;"&#25429;&#33719;"&#30340;&#36845;&#20195;&#22120;&#33539;&#22260;&#12290; + &#27599;&#20010;&#34987;&#26631;&#35760;&#30340;&#23376;&#34920;&#36798;&#24335;&#21487;&#20197;&#23548;&#33268;&#19968;&#20010;&#25110;&#22810;&#20010;&#25429;&#25417;(&#22914;&#26524;&#21305;&#37197;&#22810;&#27425;)&#12290; + &#26412;&#25991;&#26723;&#35299;&#37322;&#20102;&#25429;&#25417;&#21644;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#22312;Boost.Regex&#20013;&#22914;&#20309;&#34987;&#34920;&#31034;&#21644;&#20570;&#21040;&#30340;&#12290;
     </p>
-<a name="boost_regex.captures.marked_sub_expressions"></a><h5>
-<a name="id502903"></a>
- <a href="captures.html#boost_regex.captures.marked_sub_expressions">Marked sub-expressions</a> +<a name="boost_regex.captures.marked_sub_expressions______________________"></a><h5>
+<a name="id4862181"></a>
+ <a class="link" href="captures.html#boost_regex.captures.marked_sub_expressions______________________">Marked + sub-expressions &#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;</a>
     </h5>
 <p>
Every time a Perl regular expression contains a parenthesis group <code class="computeroutput"><span class="special">()</span></code>, it spits out an extra field, known as a
-      marked sub-expression, for example the expression:
-      <br />
- Perl正则表达式每包含一个括号组<code class="computeroutput"><span class="special">()</span></code>,就会分离出一部分区域,命名为被标记子表达式 (marked sub-expression),例如: + marked sub-expression, for example the expression:<br> Perl&#27491;&#21017;&#34920;&#36798;&#24335;&#27599;&#21253;&#21547;&#19968;&#20010;&#25324;&#21495;&#32452; + <code class="computeroutput"><span class="special">()</span></code>&#65292;&#23601;&#20250;&#20998;&#31163;&#20986;&#19968;&#37096;&#20998;&#21306;&#22495;&#65292;&#21629;&#21517;&#20026;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#65292;&#20363;&#22914;&#65306;
     </p>
 <pre class="programlisting">(\w+)\W+(\w+)</pre>
 <p>
@@ -54,10 +52,9 @@
the complete match is known as $&amp;, everything before the first match as $`, and everything after the match as $'. So if the above expression is searched for within <code class="computeroutput"><span class="string">"@abc def--"</span></code>,
-      then we obtain:
-      <br />
- 有两个标记子表达式(分别为$1和$2),全部的匹配被命名为$&amp;,第一个匹 配前的部分为$`,匹配后的部分为$'。 - 如果上面的表达式用来搜索<code class="computeroutput"><span class="string">"@abc def--"</span></code>,会有: + then we obtain:<br> &#26377;&#20004;&#20010;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;(&#20998;&#21035;&#20026;$1&#21644;$2)&#65292;&#20840;&#37096;&#30340;&#21305;&#37197;&#34987;&#21629;&#21517;&#20026;$&amp;&#65292;&#31532;&#19968;&#20010;&#21305;&#37197;&#21069;&#30340;&#37096;&#20998;&#20026;$`&#65292;&#21305;&#37197;&#21518;&#30340;&#37096;&#20998;&#20026;$'&#12290; + &#22914;&#26524;&#19978;&#38754;&#30340;&#34920;&#36798;&#24335;&#29992;&#26469;&#25628;&#32034; <code class="computeroutput"><span class="string">"@abc
+      def--"</span></code>&#65292;&#20250;&#26377;&#65306;
     </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -67,12 +64,12 @@
 <thead><tr>
 <th>
             <p>
-              Sub-expression
+              Sub-expression &#23376;&#34920;&#36798;&#24335;
             </p>
             </th>
 <th>
             <p>
-              Text found
+              Text found &#24471;&#21040;&#30340;&#25991;&#26412;
             </p>
             </th>
 </tr></thead>
@@ -140,17 +137,15 @@
 </tbody>
 </table></div>
 <p>
- In Boost.Regex all these are accessible via the <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> class that gets filled - in when calling one of the regular expression matching algorithms ( <a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, <a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, or <a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>). So given:
-      <br />
- 在Boost.Regex中上面所有都可以通过<a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>获得,这个类在以下某个正则 表达式匹配算法(<a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>、<a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>或<a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>)中被填充。如下: + In Boost.Regex all these are accessible via the <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> class that gets filled + in when calling one of the regular expression matching algorithms ( <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, or <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>). So given:<br> &#22312;Boost.Regex&#20013;&#19978;&#38754;&#25152;&#26377;&#37117;&#21487;&#20197;&#36890;&#36807; + <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + &#31867;&#33719;&#24471;&#65292; &#36825;&#20010;&#31867;&#22312;&#20197;&#19979;&#26576;&#20010;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#31639;&#27861;( <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, &#25110; <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>)&#20013;&#34987;&#22635;&#20805;&#12290;&#22914;&#19979;&#65306;
     </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">IteratorType</span><span class="special">&gt;</span> <span class="identifier">m</span><span class="special">;</span>
 </pre>
 <p>
-      The Perl and Boost.Regex equivalents are as follows:
-      <br />
-      Perl和Boost.Regex按照下面的方式对应:
+ The Perl and Boost.Regex equivalents are as follows:<br> Perl&#21644;Boost.Regex&#25353;&#29031;&#19979;&#38754;&#30340;&#26041;&#24335;&#23545;&#24212;&#65306;
     </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -221,74 +216,64 @@
 </tbody>
 </table></div>
 <p>
- In Boost.Regex each sub-expression match is represented by a <a href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> object, this is basically + In Boost.Regex each sub-expression match is represented by a <a class="link" href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> 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 <a href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> + type <a class="link" href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> behave a lot like a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>: for example they are implicitly convertible to a <code class="computeroutput"><span class="identifier">basic_string</span></code>, they can be compared to a string, added to a string, or streamed out to an
-      output stream.
-      <br />
- 在Boost.Regex中每个子表达式的匹配都用一个<a href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a>对象来表示,
-      最基本的只是一对迭代器用来标识子表达式匹配的起始和终止位置,
- 但还有一些额外的操作符,使得<a href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a>类的对象看起来像<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>: - 例如它们可以被隐式转换为<code class="computeroutput"><span class="identifier">basic_string</span></code>,
-      可以与字符串作比较,添加到字符中,或者流出到一个输出流中。
+ output stream.<br> &#22312;Boost.Regex&#20013;&#27599;&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#37117;&#29992;&#19968;&#20010; + <a class="link" href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> + &#23545;&#35937;&#26469;&#34920;&#31034;&#65292;&#26368;&#22522;&#26412;&#30340;&#21482;&#26159;&#19968;&#23545;&#36845;&#20195;&#22120;&#29992;&#26469;&#26631;&#35782;&#23376;&#34920;&#36798;&#24335;&#21305;&#37197;&#30340;&#36215;&#22987;&#21644;&#32456;&#27490;&#20301;&#32622;&#65292; + &#20294;&#36824;&#26377;&#19968;&#20123;&#39069;&#22806;&#30340;&#25805;&#20316;&#31526;&#65292;&#20351;&#24471; <a class="link" href="ref/sub_match.html" title="sub_match"><code class="computeroutput"><span class="identifier">sub_match</span></code></a> &#31867;&#30340;&#23545;&#35937;&#30475;&#36215;&#26469;&#20687; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>&#65306;&#20363;&#22914;&#23427;&#20204;&#21487;&#20197;&#34987;&#38544;&#24335;&#36716;&#25442;&#20026; + <code class="computeroutput"><span class="identifier">basic_string</span></code>&#65292; &#21487;&#20197;&#19982;&#23383;&#31526;&#20018;&#20316;&#27604;&#36739;&#65292;&#28155;&#21152;&#21040;&#23383;&#31526;&#20013;&#65292;&#25110;&#32773;&#27969;&#20986;&#21040;&#19968;&#20010;&#36755;&#20986;&#27969;&#20013;&#12290;
     </p>
-<a name="boost_regex.captures.unmatched_sub_expressions"></a><h5>
-<a name="id503526"></a>
- <a href="captures.html#boost_regex.captures.unmatched_sub_expressions">Unmatched Sub-Expressions</a> +<a name="boost_regex.captures.unmatched_sub_expressions_________________________"></a><h5>
+<a name="id4862873"></a>
+ <a class="link" href="captures.html#boost_regex.captures.unmatched_sub_expressions_________________________">Unmatched + Sub-Expressions &#19981;&#21305;&#37197;&#30340;&#23376;&#34920;&#36798;&#24335;</a>
     </h5>
 <p>
When a regular expression match is found there is no need for all of the marked - sub-expressions to have participated in the match, for example the expression:
-      <br />
- 当正则表达式找到一个匹配时,并不需要所有的标记子表达式都有匹配,例 如: + sub-expressions to have participated in the match, for example the expression:<br> + &#24403;&#27491;&#21017;&#34920;&#36798;&#24335;&#25214;&#21040;&#19968;&#20010;&#21305;&#37197;&#26102;&#65292;&#24182;&#19981;&#38656;&#35201;&#25152;&#26377;&#30340;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#37117;&#26377;&#21305;&#37197;&#65292;&#20363;&#22914;&#65306;
     </p>
 <pre class="programlisting">(abc)|(def)</pre>
 <p>
can match either $1 or $2, but never both at the same time. In Boost.Regex - you can determine which sub-expressions matched by accessing the <code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">matched</span></code> data member.
-      <br />
-      可以匹配$1或者$2,但绝不会同时。
- 在Boost.Regex中你可以通过访问<code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">matched</span></code>数据成员来知道哪个子表达式被匹配了。 + you can determine which sub-expressions matched by accessing the <code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">matched</span></code> data member.<br> &#21487;&#20197;&#21305;&#37197;$1&#25110;&#32773;$2&#65292;&#20294;&#32477;&#19981;&#20250;&#21516;&#26102;&#12290;&#22312;Boost.Regex&#20013;&#20320;&#21487;&#20197;&#36890;&#36807;&#35775;&#38382; + <code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">matched</span></code> &#25968;&#25454;&#25104;&#21592;&#26469;&#30693;&#36947;&#21738;&#20010;&#23376;&#34920;&#36798;&#24335;&#34987;&#21305;&#37197;&#20102;&#12290;
     </p>
-<a name="boost_regex.captures.repeated_captures"></a><h5>
-<a name="id503588"></a>
- <a href="captures.html#boost_regex.captures.repeated_captures">Repeated Captures</a>
+<a name="boost_regex.captures.repeated_captures_____________"></a><h5>
+<a name="id4862961"></a>
+ <a class="link" href="captures.html#boost_regex.captures.repeated_captures_____________">Repeated
+      Captures &#37325;&#22797;&#25429;&#25417;</a>
     </h5>
 <p>
When a marked sub-expression is repeated, then the sub-expression gets "captured" multiple times, however normally only the final capture is available, for example
-      if
-      <br />
- 标记子表达式被重复时,子表达式被"捕捉"多次,但通常只有最后一次捕捉可 得,例如 + if<br> &#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#34987;&#37325;&#22797;&#26102;&#65292;&#23376;&#34920;&#36798;&#24335;&#34987;"&#25429;&#25417;"&#22810;&#27425;&#65292;&#20294;&#36890;&#24120;&#21482;&#26377;&#26368;&#21518;&#19968;&#27425;&#25429;&#25417;&#21487;&#24471;&#65292;&#20363;&#22914;&#65292;&#22914;&#26524;
     </p>
 <pre class="programlisting">(?:(\w+)\W+)+</pre>
 <p>
-      is matched against
-      <br />
-      匹配
+      is matched against<br> &#29992;&#20110;&#21305;&#37197;
     </p>
 <pre class="programlisting">one fine day</pre>
 <p>
       Then $1 will contain the string "day", and all the previous captures
-      will have been forgotten.
-      <br />
-      $1包含字符串"day",前面所有的捕捉都被抛弃了。
+ will have been forgotten.<br> $1&#21253;&#21547;&#23383;&#31526;&#20018;"day"&#65292;&#21069;&#38754;&#25152;&#26377;&#30340;&#25429;&#25417;&#37117;&#34987;&#25243;&#24323;&#20102;&#12290;
     </p>
 <p>
However, Boost.Regex has an experimental feature that allows all the capture information to be retained - this is accessed either via the <code class="computeroutput"><span class="identifier">match_results</span><span class="special">::</span><span class="identifier">captures</span></code> member function or the <code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">captures</span></code> member function. These functions return a container that contains a sequence of all the captures obtained during the regular expression matching. The following example program shows how this
-      information may be used:
-      <br />
-      但是,Boost.Regex有一个实验性的特性使得所有捕获的信息都被保留
- - 这可以通过<code class="computeroutput"><span class="identifier">match_results</span><span class="special">::</span><span class="identifier">captures</span></code>成员函数或<code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">captures</span></code>成员 函数获取。
-      这些函数返回一个容器包含在正则表达式匹配过程中所有捕获信息的序列。
-      下面的例子展示了这个信息如何被使用:
+ information may be used:<br> &#20294;&#26159;&#65292;Boost.Regex&#26377;&#19968;&#20010;&#23454;&#39564;&#24615;&#30340;&#29305;&#24615;&#20351;&#24471;&#25152;&#26377;&#25429;&#33719;&#30340;&#20449;&#24687;&#37117;&#34987;&#20445;&#30041; + - &#36825;&#21487;&#20197;&#36890;&#36807; <code class="computeroutput"><span class="identifier">match_results</span><span class="special">::</span><span class="identifier">captures</span></code> + &#25104;&#21592;&#20989;&#25968;&#25110; <code class="computeroutput"><span class="identifier">sub_match</span><span class="special">::</span><span class="identifier">captures</span></code> &#25104;&#21592;&#20989;&#25968;&#33719;&#21462;&#12290;&#36825;&#20123;&#20989;&#25968;&#36820;&#22238;&#19968;&#20010;&#23481;&#22120;&#21253;&#21547;&#22312;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#36807;&#31243;&#20013;&#25152;&#26377;&#25429;&#33719;&#20449;&#24687;&#30340;&#24207;&#21015;&#12290; + &#19979;&#38754;&#30340;&#20363;&#23376;&#23637;&#31034;&#20102;&#36825;&#20010;&#20449;&#24687;&#22914;&#20309;&#34987;&#20351;&#29992;&#65306;
     </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
@@ -337,9 +322,7 @@
 <span class="special">}</span>
 </pre>
 <p>
-      Which produces the following output:
-      <br />
-      输出如下:
+ Which produces the following output:<br> &#36755;&#20986;&#22914;&#19979;&#65306;
     </p>
 <pre class="programlisting">Expression:  "(([[:lower:]]+)|([[:upper:]]+))+"
 Text:        "aBBcccDDDDDeeeeeeee"
@@ -390,30 +373,24 @@
 <p>
Unfortunately enabling this feature has an impact on performance (even if you don't use it), and a much bigger impact if you do use it, therefore to use
-      this feature you need to:
-      <br />
- 不幸的事,激活这个特性会造成性能影响(即使你不使用),如果你使用就会有 更大的影响,
-      因此为了使用这个特性你需要:
+ this feature you need to:<br> &#19981;&#24184;&#30340;&#26159;&#65292;&#28608;&#27963;&#36825;&#20010;&#29305;&#24615;&#20250;&#36896;&#25104;&#24615;&#33021;&#24433;&#21709;(&#21363;&#20351;&#20320;&#19981;&#20351;&#29992;)&#65292;&#22914;&#26524;&#20320;&#20351;&#29992;&#23601;&#20250;&#26377;&#26356;&#22823;&#30340;&#24433;&#21709;&#65292;&#22240;&#27492;&#20026;&#20102;&#20351;&#29992;&#36825;&#20010;&#29305;&#24615;&#20320;&#38656;&#35201;&#65306;
     </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
Define BOOST_REGEX_MATCH_EXTRA for all translation units including the library source (the best way to do this is to uncomment this define in boost/regex/user.hpp
-        and then rebuild everything.
-        <br />
- 在所有编译单元中定义BOOST_REGEX_MATCH_EXTRA,包括库源码(最好的方式 是在boost/regex/user.hpp中取消注释这行,然后重新生成所有的东西)。 + and then rebuild everything.<br> &#22312;&#25152;&#26377;&#32534;&#35793;&#21333;&#20803;&#20013;&#23450;&#20041;BOOST_REGEX_MATCH_EXTRA&#65292;&#21253;&#25324;&#24211;&#28304;&#30721;(&#26368;&#22909;&#30340;&#26041;&#24335;&#26159;&#22312;boost/regex/user.hpp&#20013;&#21462;&#28040;&#27880;&#37322;&#36825;&#34892;&#65292;&#28982;&#21518;&#37325;&#26032;&#29983;&#25104;&#25152;&#26377;&#30340;&#19996;&#35199;)&#12290;
       </li>
 <li>
Pass the match_extra flag to the particular algorithms where you actually - need the captures information (regex_search, regex_match, or regex_iterator).
-        <br />
- 将参数match_extra标记传入你想要使用这个捕获信息的特定算法 (regex_search、regex_match或regex_iterator)。 + need the captures information (regex_search, regex_match, or regex_iterator).<br> + &#23558;&#21442;&#25968;match_extra&#26631;&#35760;&#20256;&#20837;&#20320;&#24819;&#35201;&#20351;&#29992;&#36825;&#20010;&#25429;&#33719;&#20449;&#24687;&#30340;&#29305;&#23450;&#31639;&#27861;(regex_search&#12289;regex_match&#25110;regex_iterator)&#12290;
       </li>
 </ul></div>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration/algorithm.html Tue Sep 23 02:21:59 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration/algorithm.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Algorithm Selection</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Algorithm Selection &#31639;&#27861;&#36873;&#25321;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../configuration.html" title="Configuration">
-<link rel="prev" href="linkage.html" title="Linkage Options">
-<link rel="next" href="tuning.html" title="Algorithm Tuning">
+<link rel="up" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="prev" href="linkage.html" title="Linkage Options &#38142;&#25509;&#36873;&#39033;"> +<link rel="next" href="tuning.html" title="Algorithm Tuning &#31639;&#27861;&#35843;&#20248;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.configuration.algorithm"></a><a href="algorithm.html" title="Algorithm Selection"> Algorithm Selection</a> +<a name="boost_regex.configuration.algorithm"></a><a class="link" href="algorithm.html" title="Algorithm Selection &#31639;&#27861;&#36873;&#25321;"> Algorithm Selection
+      &#31639;&#27861;&#36873;&#25321;</a>
 </h3></div></div></div>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -34,12 +35,12 @@
 <thead><tr>
 <th>
               <p>
-                macro
+                macro &#23439;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -55,9 +56,9 @@
Tells Boost.Regex to use a stack-recursive matching algorithm. This is generally the fastest option (although there is very little in it), but can cause stack overflow in extreme cases, on Win32 this - can be handled safely, but this is not the case on other platforms.
-                <br />
- Boost.Regex将使用栈递归的匹配算法。通常这是最快的选项(改善 可能很小),但在极端情况下可能导致栈溢出,Win32平台上这可以被安全地处理,但在 其它平台上不能。 + can be handled safely, but this is not the case on other platforms.<br> + Boost.Regex&#23558;&#20351;&#29992;&#26632;&#36882;&#24402;&#30340;&#21305;&#37197;&#31639;&#27861;&#12290;&#36890;&#24120;&#36825;&#26159;&#26368;&#24555;&#30340;&#36873;&#39033;(&#25913;&#21892;&#21487;&#33021;&#24456;&#23567;)&#65292;&#20294;&#22312;&#26497;&#31471;&#24773;&#20917;&#19979;&#21487;&#33021;&#23548;&#33268;&#26632;&#28322;&#20986;&#65292;Win32&#24179;&#21488;&#19978;&#36825;&#21487;&#20197;&#34987;&#23433;&#20840;&#22320;&#22788;&#29702;&#65292; + &#20294;&#22312;&#20854;&#23427;&#24179;&#21488;&#19978;&#19981;&#33021;&#12290;
               </p>
               </td>
 </tr>
@@ -72,9 +73,7 @@
Tells Boost.Regex to use a non-stack recursive matching algorithm, this can be slightly slower than the alternative, but is always safe no matter how pathological the regular expression. This is the default
-                on non-Win32 platforms.
-                <br />
- Boost.Regex将使用非栈递归匹配算法,这可能会稍微慢一点,但无 论正则表达式如何病态这总是安全的。这是非Win32平台的默认选项。 + on non-Win32 platforms.<br> Boost.Regex&#23558;&#20351;&#29992;&#38750;&#26632;&#36882;&#24402;&#21305;&#37197;&#31639;&#27861;&#65292;&#36825;&#21487;&#33021;&#20250;&#31245;&#24494;&#24930;&#19968;&#28857;&#65292;&#20294;&#26080;&#35770;&#27491;&#21017;&#34920;&#36798;&#24335;&#22914;&#20309;&#21464;&#24577;&#37117;&#24635;&#26159;&#23433;&#20840;&#30340;&#12290;&#36825;&#26159;&#38750;Win32&#24179;&#21488;&#30340;&#40664;&#35748;&#36873;&#39033;&#12290;
               </p>
               </td>
 </tr>
@@ -83,7 +82,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration/compiler.html Tue Sep 23 02:21:59 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration/compiler.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Compiler Setup</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../configuration.html" title="Configuration">
-<link rel="prev" href="../configuration.html" title="Configuration">
-<link rel="next" href="locale.html" title="Locale and traits class selection"> +<link rel="up" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="prev" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="next" href="locale.html" title="Locale and traits class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,21 +24,22 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.configuration.compiler"></a><a href="compiler.html" title="Compiler Setup"> Compiler Setup</a> +<a name="boost_regex.configuration.compiler"></a><a class="link" href="compiler.html" title="Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;"> Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;</a>
 </h3></div></div></div>
 <p>
You shouldn't need to do anything special to configure Boost.Regex for use with your compiler - the <a href="../../../../../config/index.html" target="_top">Boost.Config subsystem</a> should already take care of it, if you do have problems (or you are using a particularly obscure compiler or platform) then <a href="../../../../../config/index.html" target="_top">Boost.Config</a> has a configure script
-        that you can run.
-        <br />
- 你不需要为了使用Boost.Regex做任何特殊的配置 - <a href="../../../../../config/index.html" target="_top">Boost.Config子系统 </a>已经做得足够了,如果你确实有问题(或者你使用了某个偏门的编译器或平台),那 么看这个<a href="../../../../../config/index.html" target="_top">Boost.Config</a>写一个配置脚本就可以了。 + that you can run.<br> &#20320;&#19981;&#38656;&#35201;&#20026;&#20102;&#20351;&#29992;Boost.Regex&#32780;&#23545;&#20320;&#30340;&#32534;&#35793;&#22120;&#20570;&#20219;&#20309;&#29305;&#27530;&#30340;&#37197;&#32622; + - <a href="../../../../../config/index.html" target="_top">Boost.Config&#23376;&#31995;&#32479;</a> &#20250;&#36127;&#36131;&#29031;&#31649;&#30340;&#65292; + &#22914;&#26524;&#20320;&#30830;&#23454;&#26377;&#38382;&#39064;(&#25110;&#32773;&#20320;&#20351;&#29992;&#20102;&#26576;&#20010;&#20559;&#38376;&#30340;&#32534;&#35793;&#22120;&#25110;&#24179;&#21488;)&#65292;&#37027;&#20040; + <a href="../../../../../config/index.html" target="_top">Boost.Config</a> &#26377;&#19968;&#20010;&#20320;&#21487;&#20197;&#29992;&#30340;&#37197;&#32622;&#33050;&#26412;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration/linkage.html Tue Sep 23 02:21:59 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration/linkage.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Linkage Options</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Linkage Options &#38142;&#25509;&#36873;&#39033;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../configuration.html" title="Configuration">
-<link rel="prev" href="locale.html" title="Locale and traits class selection">
-<link rel="next" href="algorithm.html" title="Algorithm Selection">
+<link rel="up" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="prev" href="locale.html" title="Locale and traits class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;"> +<link rel="next" href="algorithm.html" title="Algorithm Selection &#31639;&#27861;&#36873;&#25321;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,7 +24,7 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.configuration.linkage"></a><a href="linkage.html" title="Linkage Options"> Linkage Options</a> +<a name="boost_regex.configuration.linkage"></a><a class="link" href="linkage.html" title="Linkage Options &#38142;&#25509;&#36873;&#39033;"> Linkage Options &#38142;&#25509;&#36873;&#39033;</a>
 </h3></div></div></div>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -34,12 +34,12 @@
 <thead><tr>
 <th>
               <p>
-                macro
+                macro &#23439;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -55,9 +55,7 @@
For Microsoft and Borland C++ builds, this tells Boost.Regex that it should link to the dll build of the Boost.Regex. By default boost.regex will link to its static library build, even if the dynamic C runtime
-                library is in use.
-                <br />
- 对于Microsoft和Borland的C++编译器来说,这个宏告诉 Boost.Regex链接到dll版本。Boost.Regex默认链接到静态库,即使使用的是C动态运行 时库。 + library is in use.<br> &#23545;&#20110;Microsoft&#21644;Borland&#30340;C++&#32534;&#35793;&#22120;&#26469;&#35828;&#65292;&#36825;&#20010;&#23439;&#21578;&#35785;Boost.Regex&#38142;&#25509;&#21040;dll&#29256;&#26412;&#12290;Boost.Regex&#40664;&#35748;&#38142;&#25509;&#21040;&#38745;&#24577;&#24211;&#65292;&#21363;&#20351;&#20351;&#29992;&#30340;&#26159;C&#21160;&#24577;&#36816;&#34892;&#26102;&#24211;&#12290;
               </p>
               </td>
 </tr>
@@ -70,9 +68,8 @@
 <td>
               <p>
For Microsoft and Borland C++ builds, this tells Boost.Regex that
-                it should not automatically select the library to link to.
-                <br />
- 对于Microsoft和Borland的C++编译器来说,这个宏告诉 Boost.Regex不要自动选择链接的库。 + it should not automatically select the library to link to.<br> + &#23545;&#20110;Microsoft&#21644;Borland&#30340;C++&#32534;&#35793;&#22120;&#26469;&#35828;&#65292;&#36825;&#20010;&#23439;&#21578;&#35785;Boost.Regex&#19981;&#35201;&#33258;&#21160;&#36873;&#25321;&#38142;&#25509;&#30340;&#24211;&#12290;
               </p>
               </td>
 </tr>
@@ -81,7 +78,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration/locale.html Tue Sep 23 02:21:59 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration/locale.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Locale and traits class selection</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Locale and traits class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;</title> <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../configuration.html" title="Configuration">
-<link rel="prev" href="compiler.html" title="Compiler Setup">
-<link rel="next" href="linkage.html" title="Linkage Options">
+<link rel="up" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="prev" href="compiler.html" title="Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;"> +<link rel="next" href="linkage.html" title="Linkage Options &#38142;&#25509;&#36873;&#39033;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,14 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.configuration.locale"></a><a href="locale.html" title="Locale and traits class selection"> Locale and traits
-      class selection</a>
+<a name="boost_regex.configuration.locale"></a><a class="link" href="locale.html" title="Locale and traits class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;"> Locale and traits + class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;</a>
 </h3></div></div></div>
 <p>
The following macros (see <a href="../../../../../../boost/regex/user.hpp" target="_top">user.hpp</a>)
-        control how Boost.Regex interacts with the user's locale:
-        <br />
- 下面的宏(<a href="../../../../../../boost/regex/user.hpp" target="_top">user.hpp</a>)控制了Boost.Regex如果与用户的locale进行交互: + control how Boost.Regex interacts with the user's locale:<br> &#19979;&#38754;&#30340;&#23439;(&#35265; + <a href="../../../../../../boost/regex/user.hpp" target="_top">user.hpp</a>)&#25511;&#21046;&#20102;Boost.Regex&#22914;&#26524;&#19982;&#29992;&#25143;&#30340;locale&#36827;&#34892;&#20132;&#20114;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -41,12 +40,12 @@
 <thead><tr>
 <th>
               <p>
-                macro
+                macro &#23439;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -60,9 +59,8 @@
 <td>
               <p>
Forces Boost.Regex to use the global C locale in its traits class - support: this is now deprecated in favour of the C++ locale.
-                <br />
- 强迫Boost.Regex使用C的全局locale设置:现在已经不推荐使用 了,最好用C++的locale代替。 + support: this is now deprecated in favour of the C++ locale.<br> + &#24378;&#21046;Boost.Regex&#20351;&#29992;C&#30340;&#20840;&#23616;locale&#35774;&#32622;&#65306;&#29616;&#22312;&#24050;&#32463;&#19981;&#25512;&#33616;&#20351;&#29992;&#20102;&#65292;&#26368;&#22909;&#29992;C++&#30340;locale&#20195;&#26367;&#12290;
               </p>
               </td>
 </tr>
@@ -76,9 +74,8 @@
               <p>
Forces Boost.Regex to use std::locale in it's default traits class, regular expressions can then be imbued with an instance specific - locale. This is the default behaviour on non-Windows platforms.
-                <br />
- 强迫Boost.Regex使用std::locale和默认的特性类,正则表达式就 可以使用特定的locale了。这是非Windows平台的默认选项。 + locale. This is the default behaviour on non-Windows platforms.<br> + &#24378;&#21046;Boost.Regex&#20351;&#29992;std::locale&#21644;&#40664;&#35748;&#30340;&#29305;&#24615;&#31867;&#65292;&#27491;&#21017;&#34920;&#36798;&#24335;&#23601;&#21487;&#20197;&#20351;&#29992;&#29305;&#23450;&#30340;locale&#20102;&#12290;&#36825;&#26159;&#38750;Windows&#24179;&#21488;&#30340;&#40664;&#35748;&#36873;&#39033;&#12290;
               </p>
               </td>
 </tr>
@@ -92,9 +89,7 @@
               <p>
Tells Boost.Regex not to use any Win32 API's even when available (implies BOOST_REGEX_USE_CPP_LOCALE unless BOOST_REGEX_USE_C_LOCALE
-                is set).
-                <br />
- 告诉Boost.Regex不使用Win32的API,即使可以使用(默认为 BOOST_REGEX_USE_CPP_LOCALE除非定义了BOOST_REGEX_USE_C_LOCALE)。 + is set).<br> &#21578;&#35785;Boost.Regex&#19981;&#20351;&#29992;Win32&#30340;API&#65292;&#21363;&#20351;&#21487;&#20197;&#20351;&#29992;(&#40664;&#35748;&#20026;BOOST_REGEX_USE_CPP_LOCALE&#38500;&#38750;&#23450;&#20041;&#20102;BOOST_REGEX_USE_C_LOCALE)&#12290;
               </p>
               </td>
 </tr>
@@ -103,7 +98,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration/tuning.html Tue Sep 23 02:21:59 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration/tuning.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Algorithm Tuning</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Algorithm Tuning &#31639;&#27861;&#35843;&#20248;</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../configuration.html" title="Configuration">
-<link rel="prev" href="algorithm.html" title="Algorithm Selection">
-<link rel="next" href="../install.html" title="Building and Installing the Library"> +<link rel="up" href="../configuration.html" title="Configuration &#37197;&#32622;"> +<link rel="prev" href="algorithm.html" title="Algorithm Selection &#31639;&#27861;&#36873;&#25321;"> +<link rel="next" href="../install.html" title="Building and Installing the Library &#32534;&#35793;&#21644;&#23433;&#35013;&#24211;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,12 +24,11 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.configuration.tuning"></a><a href="tuning.html" title="Algorithm Tuning"> Algorithm Tuning</a> +<a name="boost_regex.configuration.tuning"></a><a class="link" href="tuning.html" title="Algorithm Tuning &#31639;&#27861;&#35843;&#20248;"> Algorithm Tuning &#31639;&#27861;&#35843;&#20248;</a>
 </h3></div></div></div>
 <p>
-        The following option applies only if BOOST_REGEX_RECURSIVE is set.
-        <br />
-        下面选项只有当BOOST_REGEX_RECURSIVE定义时才有效:
+ The following option applies only if BOOST_REGEX_RECURSIVE is set.<br> + &#19979;&#38754;&#36873;&#39033;&#21482;&#26377;&#24403;BOOST_REGEX_RECURSIVE&#23450;&#20041;&#26102;&#25165;&#26377;&#25928;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -39,12 +38,12 @@
 <thead><tr>
 <th>
               <p>
-                macro
+                macro &#23439;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -57,17 +56,15 @@
 <td>
               <p>
Tells Boost.Regex that Microsoft style __try - __except blocks are
-                supported, and can be used to safely trap stack overflow.
-                <br />
- 使Boost.Regex支持Microsoft的__try - __except块,能够安全地 处理栈溢出。 + supported, and can be used to safely trap stack overflow.<br> &#20351;Boost.Regex&#25903;&#25345;Microsoft&#30340;__try + - __except&#22359;&#65292;&#33021;&#22815;&#23433;&#20840;&#22320;&#22788;&#29702;&#26632;&#28322;&#20986;&#12290;
               </p>
               </td>
 </tr></tbody>
 </table></div>
 <p>
- The following options apply only if BOOST_REGEX_NON_RECURSIVE is set.
-        <br />
-        当BOOST_REGEX_NON_RECURSIVE被定义时下面选项有效:
+ The following options apply only if BOOST_REGEX_NON_RECURSIVE is set.<br> + &#24403;BOOST_REGEX_NON_RECURSIVE&#34987;&#23450;&#20041;&#26102;&#19979;&#38754;&#36873;&#39033;&#26377;&#25928;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -77,12 +74,12 @@
 <thead><tr>
 <th>
               <p>
-                macro
+                macro &#23439;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -100,10 +97,9 @@
then the fewer allocations that will take place. This defaults to 4096 bytes, which is large enough to match the vast majority of regular expressions without further allocations, however, you can choose - smaller or larger values depending upon your platforms characteristics.
-                <br />
- 在非递归模式下,Boost.Regex使用大块的内存作为状态机的栈,块 越大则分配行为越少。 - 默认为4096字符,对于大多数正则表达式来说不需要额外分配就足 够了,但是,你可以根据自己平台特性来选择更大或更小的数值。 + smaller or larger values depending upon your platforms characteristics.<br> + &#22312;&#38750;&#36882;&#24402;&#27169;&#24335;&#19979;&#65292;Boost.Regex&#20351;&#29992;&#22823;&#22359;&#30340;&#20869;&#23384;&#20316;&#20026;&#29366;&#24577;&#26426;&#30340;&#26632;&#65292;&#22359;&#36234;&#22823;&#21017;&#20998;&#37197;&#34892;&#20026;&#36234;&#23569;&#12290; + &#40664;&#35748;&#20026;4096&#23383;&#31526;&#65292;&#23545;&#20110;&#22823;&#22810;&#25968;&#27491;&#21017;&#34920;&#36798;&#24335;&#26469;&#35828;&#19981;&#38656;&#35201;&#39069;&#22806;&#20998;&#37197;&#23601;&#36275;&#22815;&#20102;&#65292;&#20294;&#26159;&#65292;&#20320;&#21487;&#20197;&#26681;&#25454;&#33258;&#24049;&#24179;&#21488;&#29305;&#24615;&#26469;&#36873;&#25321;&#26356;&#22823;&#25110;&#26356;&#23567;&#30340;&#25968;&#20540;&#12290;
               </p>
               </td>
 </tr>
@@ -119,11 +115,8 @@
is permitted to use. If this value is exceeded then Boost.Regex will stop trying to find a match and throw a std::runtime_error. Defaults to 1024, don't forget to tweek this value if you alter BOOST_REGEX_BLOCKSIZE
-                by much.
-                <br />
-                定义BOOST_REGEX_BLOCKSIZE大小的块最多可以有多少个。
- 如果这个值被超过了,那么Boost.Regex将停止匹配尝试并扔出 std::runtime_error。 - 默认为1024,如果你大幅度改动BOOST_REGEX_BLOCKSIZE,别忘了修 改这个值。 + by much.<br> &#23450;&#20041;BOOST_REGEX_BLOCKSIZE&#22823;&#23567;&#30340;&#22359;&#26368;&#22810;&#21487;&#20197;&#26377;&#22810;&#23569;&#20010;&#12290;&#22914;&#26524;&#36825;&#20010;&#20540;&#34987;&#36229;&#36807;&#20102;&#65292;&#37027;&#20040;Boost.Regex&#23558;&#20572;&#27490;&#21305;&#37197;&#23581;&#35797;&#24182;&#25172;&#20986;std::runtime_error&#12290; + &#40664;&#35748;&#20026;1024&#65292;&#22914;&#26524;&#20320;&#22823;&#24133;&#24230;&#25913;&#21160;BOOST_REGEX_BLOCKSIZE&#65292;&#21035;&#24536;&#20102;&#20462;&#25913;&#36825;&#20010;&#20540;&#12290;
               </p>
               </td>
 </tr>
@@ -144,12 +137,12 @@
size). If memory is tight then try defining this to 0 (disables all caching), or if that is too slow, then a value of 1 or 2, may be sufficient. On the other hand, on large multi-processor, multi-threaded
-                systems, you may find that a higher value is in order.
-                <br />
- 定义在内部缓存中存储多少内存块 - 内存块将优先从缓存中取得而 不是调用::operator new。 - 通常来说,这会比每次需要内存时都调用::operator new快上一个 数量级,但当Boost.Regex持有一大块缓存时会呈下降趋势(默认为16个 BOOST_REGEX_BLOCKSIZE大小的内存块)。 - 如果内存紧张可以尝试将其定义为0(禁用所有缓存),如果太慢,那 么1或2可能就足够了。 - 另一方面,对于一个大型的多处理器、多线程系统,你可能会觉得 一个更大的数值可能更好。 + systems, you may find that a higher value is in order.<br> &#23450;&#20041;&#22312;&#20869;&#37096;&#32531;&#23384;&#20013;&#23384;&#20648;&#22810;&#23569;&#20869;&#23384;&#22359; + - &#20869;&#23384;&#22359;&#23558;&#20248;&#20808;&#20174;&#32531;&#23384;&#20013;&#21462;&#24471;&#32780;&#19981;&#26159;&#35843;&#29992;::operator new&#12290; + &#36890;&#24120;&#26469;&#35828;&#65292;&#36825;&#20250;&#27604;&#27599;&#27425;&#38656;&#35201;&#20869;&#23384;&#26102;&#37117;&#35843;&#29992;::operator + new&#24555;&#19978;&#19968;&#20010;&#25968;&#37327;&#32423;&#65292; &#20294;&#24403;Boost.Regex&#25345;&#26377;&#19968;&#22823;&#22359;&#32531;&#23384;&#26102;&#20250;&#21576;&#19979;&#38477;&#36235;&#21183;(&#40664;&#35748;&#20026;16&#20010;BOOST_REGEX_BLOCKSIZE&#22823;&#23567;&#30340;&#20869;&#23384;&#22359;)&#12290; + &#22914;&#26524;&#20869;&#23384;&#32039;&#24352;&#21487;&#20197;&#23581;&#35797;&#23558;&#20854;&#23450;&#20041;&#20026;0(&#31105;&#29992;&#25152;&#26377;&#32531;&#23384;)&#65292;&#22914;&#26524;&#22826;&#24930;&#65292;&#37027;&#20040;1&#25110;2&#21487;&#33021;&#23601;&#36275;&#22815;&#20102;&#12290; + &#21478;&#19968;&#26041;&#38754;&#65292;&#23545;&#20110;&#19968;&#20010;&#22823;&#22411;&#30340;&#22810;&#22788;&#29702;&#22120;&#12289;&#22810;&#32447;&#31243;&#31995;&#32479;&#65292;&#20320;&#21487;&#33021;&#20250;&#35273;&#24471;&#19968;&#20010;&#26356;&#22823;&#30340;&#25968;&#20540;&#21487;&#33021;&#26356;&#22909;&#12290;
               </p>
               </td>
 </tr>
@@ -158,7 +151,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/configuration.html Thu Sep 4 19:42:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/configuration.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Configuration</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Configuration &#37197;&#32622;</title>
<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
 <link rel="prev" href="../index.html" title="Boost.Regex">
-<link rel="next" href="configuration/compiler.html" title="Compiler Setup">
+<link rel="next" href="configuration/compiler.html" title="Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,20 +24,21 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.configuration"></a><a href="configuration.html" title="Configuration"> Configuration</a> +<a name="boost_regex.configuration"></a><a class="link" href="configuration.html" title="Configuration &#37197;&#32622;"> Configuration &#37197;&#32622;</a>
 </h2></div></div></div>
 <div class="toc"><dl>
-<dt><span class="section"><a href="configuration/compiler.html"> Compiler Setup</a></span></dt> +<dt><span class="section"><a href="configuration/compiler.html"> Compiler Setup &#32534;&#35793;&#22120;&#35774;&#32622;</a></span></dt> <dt><span class="section"><a href="configuration/locale.html"> Locale and traits
-      class selection</a></span></dt>
-<dt><span class="section"><a href="configuration/linkage.html"> Linkage Options</a></span></dt> -<dt><span class="section"><a href="configuration/algorithm.html"> Algorithm Selection</a></span></dt> -<dt><span class="section"><a href="configuration/tuning.html"> Algorithm Tuning</a></span></dt> + class selection &#26412;&#22320;&#21270;&#21644;traits&#31867;&#30340;&#36873;&#25321;</a></span></dt> +<dt><span class="section"><a href="configuration/linkage.html"> Linkage Options &#38142;&#25509;&#36873;&#39033;</a></span></dt> +<dt><span class="section"><a href="configuration/algorithm.html"> Algorithm Selection
+      &#31639;&#27861;&#36873;&#25321;</a></span></dt>
+<dt><span class="section"><a href="configuration/tuning.html"> Algorithm Tuning &#31639;&#27861;&#35843;&#20248;</a></span></dt>
 </dl></div>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html Sat Sep 12 00:52:19 2009 +++ /trunk/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html Thu May 27 20:09:44 2010
@@ -1,108 +1,110 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-
-<title>Boost-Extended Format String Syntax</title><link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Boost-Extended Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../format.html" title="Search and Replace Format String Syntax">
-<link rel="prev" href="perl_format.html" title="Perl Format String Syntax">
-<link rel="next" href="../ref.html" title="Reference"></head>
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-<table cellpadding="2" width="100%"><tbody><tr>
-<td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td> +<link rel="up" href="../format.html" title="Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="prev" href="perl_format.html" title="Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="next" href="../ref.html" title="Reference &#21442;&#32771;&#25163;&#20876;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="perl_format.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../format.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.format.boost_format_syntax"></a><a href="boost_format_syntax.html" title="Boost-Extended Format String Syntax"> Boost-Extended
-      Format String Syntax</a>
+<a name="boost_regex.format.boost_format_syntax"></a><a class="link" href="boost_format_syntax.html" title="Boost-Extended Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> Boost-Extended + Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a>
 </h3></div></div></div>
 <p>
Boost-Extended format strings treat all characters as literals except for
-        '$', '\', '(', ')', '?', and ':'.
-        <br>
-        Boost扩展格式化字符串将'$'、'\'、'('、')'、'?'和':'特殊对待。
+ '$', '\', '(', ')', '?', and ':'.<br> Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#23558;'$'&#12289;'\'&#12289;'('&#12289;')'&#12289;'?'&#21644;':'&#29305;&#27530;&#23545;&#24453;&#12290;
       </p>
-<a name="boost_regex.format.boost_format_syntax.grouping"></a><h5>
-<a name="id525475"></a>
- <a href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.grouping">Grouping 分组</a>
+<a name="boost_regex.format.boost_format_syntax.grouping_______"></a><h5>
+<a name="id4887436"></a>
+ <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.grouping_______">Grouping
+        &#20998;&#32452;</a>
       </h5>
 <p>
The characters '(' and ')' perform lexical grouping, so use \( and \) if
-        you want a to output literal parenthesis.
-        <br>
-        字符'('和')'实现字面分组,使用\(和\)来输出字面的括号。
+ you want a to output literal parenthesis.<br> &#23383;&#31526;'('&#21644;')'&#23454;&#29616;&#23383;&#38754;&#20998;&#32452;&#65292;&#20351;&#29992;\(&#21644;\)&#26469;&#36755;&#20986;&#23383;&#38754;&#30340;&#25324;&#21495;&#12290;
       </p>
-<a name="boost_regex.format.boost_format_syntax.conditionals"></a><h5>
-<a name="id525505"></a>
- <a href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.conditionals">Conditionals 条件</a> +<a name="boost_regex.format.boost_format_syntax.conditionals_______"></a><h5>
+<a name="id4887469"></a>
+ <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.conditionals_______">Conditionals
+        &#26465;&#20214;</a>
       </h5>
 <p>
- The character '?' begins a conditional expression, the general form is:
-        <br>
-        字符'?'开始一个条件表达式,通用格式为:
+ The character '?' begins a conditional expression, the general form is:<br> + &#23383;&#31526;'?'&#24320;&#22987;&#19968;&#20010;&#26465;&#20214;&#34920;&#36798;&#24335;&#65292;&#36890;&#29992;&#26684;&#24335;&#20026;&#65306;
       </p>
 <p>
         ?Ntrue-expression:false-expression
       </p>
 <p>
-        where N is decimal digit.
-        <br>
-        其中N为数字。
+ where N is decimal digit.<br> &#20854;&#20013;N&#20026;&#25968;&#23383;&#12290;
       </p>
 <p>
If sub-expression N was matched, then true-expression is evaluated and sent - to output, otherwise false-expression is evaluated and sent to output.
-        <br>
- 如果子表达式N被匹配,那么true-expression被求值并送到输出,否则 false-expression被求值并送到输出。 + to output, otherwise false-expression is evaluated and sent to output.<br> + &#22914;&#26524;&#23376;&#34920;&#36798;&#24335;N&#34987;&#21305;&#37197;&#65292;&#37027;&#20040;true-expression&#34987;&#27714;&#20540;&#24182;&#36865;&#21040;&#36755;&#20986;&#65292;&#21542;&#21017;false-expression&#34987;&#27714;&#20540;&#24182;&#36865;&#21040;&#36755;&#20986;&#12290;
       </p>
 <p>
You will normally need to surround a conditional-expression with parenthesis
-        in order to prevent ambiguities.
-        <br>
-        通常都需要将条件表达式用括号围绕起来,以防止二义性。
+ in order to prevent ambiguities.<br> &#36890;&#24120;&#37117;&#38656;&#35201;&#23558;&#26465;&#20214;&#34920;&#36798;&#24335;&#29992;&#25324;&#21495;&#22260;&#32469;&#36215;&#26469;&#65292;&#20197;&#38450;&#27490;&#20108;&#20041;&#24615;&#12290;
       </p>
 <p>
         For example, the format string "(?1foo:bar)" will replace each
         match found with "foo" if the sub-expression $1 was matched, and
-        with "bar" otherwise.
-        <br>
- 例如,格式化字符串"(?1foo:bar)",如果子表达式$1匹配了,会将每个匹配 替换为"foo",否则为"bar"。</p><p>For sub-expressions with an index greater than 9, or for access to named -sub-expressions use:<br>对于索引数大于9的子表达式,或要访问命名的子表达 式,使用: </p>
-<p>?{INDEX}true-expression:false-expression </p>
-<p>or<br>或 </p>
-<p>?{NAME}true-expression:false-expression</p>
-<a name="boost_regex.format.boost_format_syntax.placeholder_sequences"></a><h5>
-<a name="id525562"></a>
- <a href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.placeholder_sequences">Placeholder
-        Sequences 占位符序列</a>
+ with "bar" otherwise.<br> &#20363;&#22914;&#65292;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;"(?1foo:bar)"&#65292;&#22914;&#26524;&#23376;&#34920;&#36798;&#24335;$1&#21305;&#37197;&#20102;&#65292;&#20250;&#23558;&#27599;&#20010;&#21305;&#37197;&#26367;&#25442;&#20026;"foo"&#65292;&#21542;&#21017;&#20026;"bar"&#12290;
+      </p>
+<p>
+ For sub-expressions with an index greater than 9, or for access to named + sub-expressions use:<br> &#23545;&#20110;&#32034;&#24341;&#25968;&#22823;&#20110;9&#30340;&#23376;&#34920;&#36798;&#24335;&#65292;&#25110;&#35201;&#35775;&#38382;&#21629;&#21517;&#30340;&#23376;&#34920;&#36798;&#24335;&#65292;&#20351;&#29992;&#65306;
+      </p>
+<p>
+        ?{INDEX}true-expression:false-expression
+      </p>
+<p>
+        or<br> &#25110;&#32773;
+      </p>
+<p>
+        ?{NAME}true-expression:false-expression
+      </p>
+<a name="boost_regex.format.boost_format_syntax.placeholder_sequences________________"></a><h5>
+<a name="id4887576"></a>
+ <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.placeholder_sequences________________">Placeholder
+        Sequences &#21344;&#20301;&#31526;&#24207;&#21015;</a>
       </h5>
 <p>
Placeholder sequences specify that some part of what matched the regular
-        expression should be sent to output as follows:
-        <br>
-        占位符序列指明了正则表达式匹配的哪部分将被输出:
+ expression should be sent to output as follows:<br> &#21344;&#20301;&#31526;&#24207;&#21015;&#25351;&#26126;&#20102;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#30340;&#21738;&#37096;&#20998;&#23558;&#34987;&#36755;&#20986;&#65306;
       </p>
 <div class="informaltable"><table class="table">
-<colgroup><col><col></colgroup>
+<colgroup>
+<col>
+<col>
+</colgroup>
 <thead><tr>
 <th>
               <p>
-                Placeholder
+                Placeholder &#21344;&#20301;&#31526;
               </p>
               </th>
 <th>
               <p>
-                Meaning
+                Meaning &#24847;&#20041;
               </p>
               </th>
 </tr></thead>
@@ -115,21 +117,37 @@
               </td>
 <td>
               <p>
-                Outputs what matched the whole expression.
-                <br>
-                输出整个表达式的匹配。
+ Outputs what matched the whole expression.<br> &#36755;&#20986;&#25972;&#20010;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
               </p>
               </td>
 </tr>
-<tr><td>
-<p>$MATCH </p></td>
+<tr>
 <td>
-<p>As $&amp;</p><p>同 $&amp; </p></td></tr><tr><td>
-<p>${^MATCH} </p></td>
+              <p>
+                $MATCH
+              </p>
+              </td>
 <td>
-<p>As $&amp;</p><p>同&nbsp;$&amp; </p></td></tr><tr>
+              <p>
+                As $&amp;
+              </p>
+              </td>
+</tr>
+<tr>
 <td>
               <p>
+                ${^MATCH}
+              </p>
+              </td>
+<td>
+              <p>
+                As $&amp;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
                 $`
               </p>
               </td>
@@ -137,63 +155,134 @@
               <p>
Outputs the text between the end of the last match found (or the start of the text if no previous match was found), and the start
-                of the current match.
-                <br>
- 输出从前一个匹配的终点(如果没有前一次匹配则为文本的开始 ),到当前匹配开始处之间的文本。 + of the current match.<br> &#36755;&#20986;&#20174;&#21069;&#19968;&#20010;&#21305;&#37197;&#30340;&#32456;&#28857;(&#22914;&#26524;&#27809;&#26377;&#21069;&#19968;&#27425;&#21305;&#37197;&#21017;&#20026;&#25991;&#26412;&#30340;&#24320;&#22987;)&#65292;&#21040;&#24403;&#21069;&#21305;&#37197;&#24320;&#22987;&#22788;&#20043;&#38388;&#30340;&#25991;&#26412;&#12290;
               </p>
               </td>
 </tr>
-<tr><td>
-<p>$PREMATCH </p></td>
+<tr>
 <td>
-<p>As $`<br>同&nbsp;$` </p></td></tr><tr><td>
-<p>${^PREMATCH} </p></td>
+              <p>
+                $PREMATCH
+              </p>
+              </td>
 <td>
-<p>As $`</p><p>同&nbsp;$` </p></td></tr><tr>
+              <p>
+                As $`
+              </p>
+              </td>
+</tr>
+<tr>
 <td>
               <p>
+                ${^PREMATCH}
+              </p>
+              </td>
+<td>
+              <p>
+                As $`
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
                 $'
               </p>
               </td>
 <td>
               <p>
- Outputs all the text following the end of the current match.
-                <br>
-                输出当前匹配终点之后的所有文本。
+ Outputs all the text following the end of the current match.<br> + &#36755;&#20986;&#24403;&#21069;&#21305;&#37197;&#32456;&#28857;&#20043;&#21518;&#30340;&#25152;&#26377;&#25991;&#26412;&#12290;
               </p>
               </td>
 </tr>
-<tr><td>
-<p>$POSTMATCH </p></td>
+<tr>
 <td>
-<p>As $'<br>同&nbsp;$' </p></td></tr><tr><td>
-<p>${^POSTMATCH} </p></td>
+              <p>
+                $POSTMATCH
+              </p>
+              </td>
 <td>
-<p>As $'</p><p>同&nbsp;$' </p></td></tr><tr><td>
-<p>$+ </p></td>
+              <p>
+                As $'
+              </p>
+              </td>
+</tr>
+<tr>
 <td>
-<p>Outputs what matched the last marked sub-expression in the regular
-expression.<br>输出与正则表达式中最后一个被标记的子表达式相匹配的文本。 </p></td></tr>
-<tr><td>
-<p>$LAST_PAREN_MATCH </p></td>
+              <p>
+                ${^POSTMATCH}
+              </p>
+              </td>
 <td>
-<p>As $+<br>同&nbsp;$+ </p></td></tr><tr><td>
-<p>$LAST_SUBMATCH_RESULT </p></td>
+              <p>
+                As $'
+              </p>
+              </td>
+</tr>
+<tr>
 <td>
-<p>Outputs what matched the last sub-expression to be actually matched.<br>输出被实际匹配的最后子表达式的结果。 </p></td></tr><tr><td>
-<p>$^N </p></td>
+              <p>
+                $+
+              </p>
+              </td>
 <td>
-<p>As $LAST_SUBMATCH_RESULT<br>同&nbsp;$LAST_SUBMATCH_RESULT </p></td></tr><tr><td>
+              <p>
+ Outputs what matched the last marked sub-expression in the regular + expression.<br> &#36755;&#20986;&#19982;&#27491;&#21017;&#34920;&#36798;&#24335;&#20013;&#26368;&#21518;&#19968;&#20010;&#34987;&#26631;&#35760;&#30340;&#23376;&#34920;&#36798;&#24335;&#30456;&#21305;&#37197;&#30340;&#25991;&#26412;&#12290;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
+                $LAST_PAREN_MATCH
+              </p>
+              </td>
+<td>
+              <p>
+                As $+
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
+                $LAST_SUBMATCH_RESULT
+              </p>
+              </td>
+<td>
+              <p>
+ Outputs what matched the last sub-expression to be actually matched.<br> + &#36755;&#20986;&#34987;&#23454;&#38469;&#21305;&#37197;&#30340;&#26368;&#21518;&#23376;&#34920;&#36798;&#24335;&#30340;&#32467;&#26524;&#12290;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
+                $^N
+              </p>
+              </td>
+<td>
+              <p>
+                As $LAST_SUBMATCH_RESULT
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
               <p>
                 $$
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
-                Outputs a literal '$'
-                <br>
-                输出字面符号'$'
+ Outputs a literal '$'<br> &#36755;&#20986;&#23383;&#38754;&#31526;&#21495;'$'
               </p>
-              </td></tr><tr>
+              </td>
+</tr>
+<tr>
 <td>
               <p>
                 $n
@@ -201,48 +290,64 @@
               </td>
 <td>
               <p>
-                Outputs what matched the n'th sub-expression.
-                <br>
-                输出第n个子表达式的匹配。
+ Outputs what matched the n'th sub-expression.<br> &#36755;&#20986;&#31532;n&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
               </p>
               </td>
-</tr><tr><td>
-<p>${n} </p></td>
+</tr>
+<tr>
 <td>
-<p>Outputs what matched the n'th sub-expression.<br>输出第n个子表达式的匹 配。 </p></td></tr><tr><td>
-<p>$+{NAME} </p></td>
+              <p>
+                ${n}
+              </p>
+              </td>
 <td>
-<p>Outputs whatever matched the sub-expression named "NAME".<br>输出名 为"NAME"的子表达式的匹配。 </p></td></tr>
+              <p>
+ Outputs what matched the n'th sub-expression.<br> &#36755;&#20986;&#31532;n&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
+                $+{NAME}
+              </p>
+              </td>
+<td>
+              <p>
+ Outputs whatever matched the sub-expression named "NAME".<br> + &#36755;&#20986;&#21517;&#20026;"NAME"&#30340;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
 </tbody>
 </table></div>
 <p>
Any $-placeholder sequence not listed above, results in '$' being treated
-        as a literal.
-        <br>
-        任何不在上面列出的$-placeholder序列,都将导致'$'被作为字面符号。
+ as a literal.<br> &#20219;&#20309;&#19981;&#22312;&#19978;&#38754;&#21015;&#20986;&#30340;$-&#21344;&#20301;&#31526;&#24207;&#21015;&#65292;&#37117;&#23558;&#23548;&#33268;'$'&#34987;&#20316;&#20026;&#23383;&#38754;&#31526;&#21495;&#12290;
       </p>
-<a name="boost_regex.format.boost_format_syntax.escape_sequences"></a><h5>
-<a name="id525734"></a>
- <a href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.escape_sequences">Escape
-        Sequences 转义序列</a>
+<a name="boost_regex.format.boost_format_syntax.escape_sequences_____________"></a><h5>
+<a name="id4887988"></a>
+ <a class="link" href="boost_format_syntax.html#boost_regex.format.boost_format_syntax.escape_sequences_____________">Escape
+        Sequences &#36716;&#20041;&#24207;&#21015;</a>
       </h5>
 <p>
An escape character followed by any character x, outputs that character unless
-        x is one of the escape sequences shown below.
-        <br>
-        一个转义符号后跟字符x,除非x是下面的转义序列之一,则输出字符x。
+ x is one of the escape sequences shown below.<br> &#19968;&#20010;&#36716;&#20041;&#31526;&#21495;&#21518;&#36319;&#23383;&#31526;x&#65292;&#38500;&#38750;x&#26159;&#19979;&#38754;&#30340;&#36716;&#20041;&#24207;&#21015;&#20043;&#19968;&#65292;&#21017;&#36755;&#20986;&#23383;&#31526;x&#12290;
       </p>
 <div class="informaltable"><table class="table">
-<colgroup><col><col></colgroup>
+<colgroup>
+<col>
+<col>
+</colgroup>
 <thead><tr>
 <th>
               <p>
-                Escape
+                Escape &#36716;&#20041;&#24207;&#21015;
               </p>
               </th>
 <th>
               <p>
-                Meaning
+                Meaning &#24847;&#20041;
               </p>
               </th>
 </tr></thead>
@@ -255,9 +360,7 @@
               </td>
 <td>
               <p>
-                Outputs the bell character: '\a'.
-                <br>
-                输出铃响字符:'\a'。
+ Outputs the bell character: '\a'.<br> &#36755;&#20986;&#38083;&#21709;&#23383;&#31526;&#65306;'\a'&#12290;
               </p>
               </td>
 </tr>
@@ -269,9 +372,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape character (code point 27).
-                <br>
-                输出ANSI转义字符(码点为27)。
+ Outputs the ANSI escape character (code point 27).<br> &#36755;&#20986;ANSI&#36716;&#20041;&#23383;&#31526;(&#30721;&#28857;&#20026;27)&#12290;
               </p>
               </td>
 </tr>
@@ -283,9 +384,7 @@
               </td>
 <td>
               <p>
-                Outputs a form feed character: '\f'
-                <br>
-                输出换页字符:'\f'。
+ Outputs a form feed character: '\f'<br> &#36755;&#20986;&#25442;&#39029;&#23383;&#31526;&#65306;'\f'&#12290;
               </p>
               </td>
 </tr>
@@ -297,9 +396,7 @@
               </td>
 <td>
               <p>
-                Outputs a newline character: '\n'.
-                <br>
-                输出换行字符:'\n'。
+ Outputs a newline character: '\n'.<br> &#36755;&#20986;&#25442;&#34892;&#23383;&#31526;&#65306;'\n'&#12290;
               </p>
               </td>
 </tr>
@@ -311,9 +408,7 @@
               </td>
 <td>
               <p>
-                Outputs a carriage return character: '\r'.
-                <br>
-                输出回车字符:'\r'。
+ Outputs a carriage return character: '\r'.<br> &#36755;&#20986;&#22238;&#36710;&#23383;&#31526;&#65306;'\r'&#12290;
               </p>
               </td>
 </tr>
@@ -325,9 +420,7 @@
               </td>
 <td>
               <p>
-                Outputs a tab character: '\t'.
-                <br>
-                输出制表符:'\t'。
+ Outputs a tab character: '\t'.<br> &#36755;&#20986;&#21046;&#34920;&#31526;&#65306;'\t'&#12290;
               </p>
               </td>
 </tr>
@@ -339,9 +432,7 @@
               </td>
 <td>
               <p>
-                Outputs a vertical tab character: '\v'.
-                <br>
-                输出垂直制表符:'\v'。
+ Outputs a vertical tab character: '\v'.<br> &#36755;&#20986;&#22402;&#30452;&#21046;&#34920;&#31526;&#65306;'\v'&#12290;
               </p>
               </td>
 </tr>
@@ -353,9 +444,8 @@
               </td>
 <td>
               <p>
-                Outputs the character whose hexadecimal code point is 0xDD
-                <br>
-                输出码点为0xDD的十六进制字符
+ Outputs the character whose hexadecimal code point is 0xDD<br> + &#36755;&#20986;&#30721;&#28857;&#20026;0xDD&#30340;&#21313;&#20845;&#36827;&#21046;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -367,9 +457,8 @@
               </td>
 <td>
               <p>
- Outputs the character whose hexadecimal code point is 0xDDDDD
-                <br>
-                输出码点为0xDDDD的十六进制字符
+ Outputs the character whose hexadecimal code point is 0xDDDDD<br> + &#36755;&#20986;&#30721;&#28857;&#20026;0xDDDD&#30340;&#21313;&#20845;&#36827;&#21046;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -381,9 +470,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape sequence "escape-X".
-                <br>
-                输出ANSI转义序列"escape-X"。
+ Outputs the ANSI escape sequence "escape-X".<br> &#36755;&#20986;ANSI&#36716;&#20041;&#24207;&#21015;"escape-X"&#12290;
               </p>
               </td>
 </tr>
@@ -396,9 +483,7 @@
 <td>
               <p>
If D is a decimal digit in the range 1-9, then outputs the text that
-                matched sub-expression D.
-                <br>
-                如果D是1-9范围内的数字,则输出子表达式D匹配的文本。
+ matched sub-expression D.<br> &#22914;&#26524;D&#26159;1-9&#33539;&#22260;&#20869;&#30340;&#25968;&#23383;&#65292;&#21017;&#36755;&#20986;&#23376;&#34920;&#36798;&#24335;D&#21305;&#37197;&#30340;&#25991;&#26412;&#12290;
               </p>
               </td>
 </tr>
@@ -411,9 +496,7 @@
 <td>
               <p>
Causes the next character to be outputted, to be output in lower
-                case.
-                <br>
-                使下一个被输出的字符输出为小写。
+ case.<br> &#20351;&#19979;&#19968;&#20010;&#34987;&#36755;&#20986;&#30340;&#23383;&#31526;&#36755;&#20986;&#20026;&#23567;&#20889;&#12290;
               </p>
               </td>
 </tr>
@@ -426,9 +509,7 @@
 <td>
               <p>
Causes the next character to be outputted, to be output in upper
-                case.
-                <br>
-                使下一个被输出的字符输出为大写。
+ case.<br> &#20351;&#19979;&#19968;&#20010;&#34987;&#36755;&#20986;&#30340;&#23383;&#31526;&#36755;&#20986;&#20026;&#22823;&#20889;&#12290;
               </p>
               </td>
 </tr>
@@ -441,9 +522,7 @@
 <td>
               <p>
Causes all subsequent characters to be output in lower case, until
-                a \E is found.
-                <br>
-                使后面所有的字符都输出为小写,直到碰到\E。
+ a \E is found.<br> &#20351;&#21518;&#38754;&#25152;&#26377;&#30340;&#23383;&#31526;&#37117;&#36755;&#20986;&#20026;&#23567;&#20889;&#65292;&#30452;&#21040;&#30896;&#21040;\E&#12290;
               </p>
               </td>
 </tr>
@@ -456,9 +535,7 @@
 <td>
               <p>
Causes all subsequent characters to be output in upper case, until
-                a \E is found.
-                <br>
-                使后面所有的字符都输出为大写,直到碰到\E。
+ a \E is found.<br> &#20351;&#21518;&#38754;&#25152;&#26377;&#30340;&#23383;&#31526;&#37117;&#36755;&#20986;&#20026;&#22823;&#20889;&#65292;&#30452;&#21040;&#30896;&#21040;\E&#12290;
               </p>
               </td>
 </tr>
@@ -470,25 +547,24 @@
               </td>
 <td>
               <p>
-                Terminates a \L or \U sequence.
-                <br>
-                结束\L或\U的序列。
+ Terminates a \L or \U sequence.<br> &#32467;&#26463;\L&#25110;\U&#30340;&#24207;&#21015;&#12290;
               </p>
               </td>
 </tr>
 </tbody>
 </table></div>
 </div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tbody><tr> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
 </div></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="perl_format.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../format.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/format/perl_format.html Sat Sep 12 00:52:19 2009 +++ /trunk/libs/regex/doc/html/boost_regex/format/perl_format.html Thu May 27 20:09:44 2010
@@ -1,189 +1,292 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-
-<title>Perl Format String Syntax</title><link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../format.html" title="Search and Replace Format String Syntax">
-<link rel="prev" href="sed_format.html" title="Sed Format String Syntax">
-<link rel="next" href="boost_format_syntax.html" title="Boost-Extended Format String Syntax"></head> -<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-<table cellpadding="2" width="100%"><tbody><tr>
-<td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td> +<link rel="up" href="../format.html" title="Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="prev" href="sed_format.html" title="Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="next" href="boost_format_syntax.html" title="Boost-Extended Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="sed_format.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../format.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="boost_format_syntax.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.format.perl_format"></a><a href="perl_format.html" title="Perl Format String Syntax"> Perl Format String Syntax</a> +<a name="boost_regex.format.perl_format"></a><a class="link" href="perl_format.html" title="Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> Perl Format String Syntax
+      Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a>
 </h3></div></div></div>
 <p>
Perl-style format strings treat all characters as literals except '$' and
-        '\' which start placeholder and escape sequences respectively.
-        <br>
- Perl风格格式化字符串将所有字符当作字面符号,除了'$'和'\',分别为占 位符和转义序列的开始。 + '\' which start placeholder and escape sequences respectively.<br> Perl&#39118;&#26684;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#23558;&#25152;&#26377;&#23383;&#31526;&#24403;&#20316;&#23383;&#38754;&#31526;&#21495;&#65292;&#38500;&#20102;'$'&#21644;'\'&#65292;&#20998;&#21035;&#20026;&#21344;&#20301;&#31526;&#21644;&#36716;&#20041;&#24207;&#21015;&#30340;&#24320;&#22987;&#12290;
       </p>
 <p>
Placeholder sequences specify that some part of what matched the regular
-        expression should be sent to output as follows:
-        <br>
- 占位符序列指明了正则表达式匹配的哪部分被送到输出中:</p><div class="informaltable">
-<table class="table">
-<colgroup><col><col></colgroup>
-<thead>
-<tr>
+ expression should be sent to output as follows:<br> &#21344;&#20301;&#31526;&#24207;&#21015;&#25351;&#26126;&#20102;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#30340;&#21738;&#37096;&#20998;&#34987;&#36865;&#21040;&#36755;&#20986;&#20013;&#65306;
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
 <th>
-<p>Placeholder </p></th>
+              <p>
+                Placeholder &#21344;&#20301;&#31526;
+              </p>
+              </th>
 <th>
-<p>Meaning </p></th></tr></thead>
+              <p>
+                Meaning &#24847;&#20041;
+              </p>
+              </th>
+</tr></thead>
 <tbody>
-<tr><td>
+<tr>
+<td>
               <p>
                 $&amp;
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
-                Outputs what matched the whole expression.
-                <br>
-                输出整个表达式的匹配。
+ Outputs what matched the whole expression.<br> &#36755;&#20986;&#25972;&#20010;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
               </p>
-              </td></tr>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$MATCH </p></td>
+              <p>
+                $MATCH
+              </p>
+              </td>
 <td>
-<p>As $&amp; </p></td></tr>
+              <p>
+                As $&amp;
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>${^MATCH} </p></td>
+              <p>
+                ${^MATCH}
+              </p>
+              </td>
 <td>
-<p>As $&amp; </p></td></tr>
-<tr><td>
+              <p>
+                As $&amp;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
               <p>
                 $`
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
Outputs the text between the end of the last match found (or the start of the text if no previous match was found), and the start
-                of the current match.
-                <br>
- 输出上次匹配结束(如果没有上次匹配则为文本的开始),到当前匹 配开始之间的文本。 + of the current match.<br> &#36755;&#20986;&#19978;&#27425;&#21305;&#37197;&#32467;&#26463;(&#22914;&#26524;&#27809;&#26377;&#19978;&#27425;&#21305;&#37197;&#21017;&#20026;&#25991;&#26412;&#30340;&#24320;&#22987;)&#65292;&#21040;&#24403;&#21069;&#21305;&#37197;&#24320;&#22987;&#20043;&#38388;&#30340;&#25991;&#26412;&#12290;
               </p>
-              </td></tr>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$PREMATCH </p></td>
+              <p>
+                $PREMATCH
+              </p>
+              </td>
 <td>
-<p>As $` </p></td></tr>
+              <p>
+                As $`
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>${^PREMATCH} </p></td>
+              <p>
+                ${^PREMATCH}
+              </p>
+              </td>
 <td>
-<p>As $` </p></td></tr>
-<tr><td>
+              <p>
+                As $`
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
               <p>
                 $'
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
- Outputs all the text following the end of the current match.
-                <br>
-                输出当前匹配结束之后的所有文本。
+ Outputs all the text following the end of the current match.<br> + &#36755;&#20986;&#24403;&#21069;&#21305;&#37197;&#32467;&#26463;&#20043;&#21518;&#30340;&#25152;&#26377;&#25991;&#26412;&#12290;
               </p>
-              </td></tr>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$POSTMATCH </p></td>
+              <p>
+                $POSTMATCH
+              </p>
+              </td>
 <td>
-<p>As $' </p></td></tr>
+              <p>
+                As $'
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>${^POSTMATCH} </p></td>
+              <p>
+                ${^POSTMATCH}
+              </p>
+              </td>
 <td>
-<p>As $' </p></td></tr>
+              <p>
+                As $'
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$+ </p></td>
+              <p>
+                $+
+              </p>
+              </td>
 <td>
-<p>Outputs what matched the last marked sub-expression in the regular
-expression.<br>输出与正则表达式最后一个被标记子表达式的匹配。 </p></td></tr>
+              <p>
+ Outputs what matched the last marked sub-expression in the regular + expression.<br> &#36755;&#20986;&#19982;&#27491;&#21017;&#34920;&#36798;&#24335;&#26368;&#21518;&#19968;&#20010;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$LAST_PAREN_MATCH </p></td>
+              <p>
+                $LAST_PAREN_MATCH
+              </p>
+              </td>
 <td>
-<p>As $+ </p></td></tr>
+              <p>
+                As $+
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$LAST_SUBMATCH_RESULT </p></td>
+              <p>
+                $LAST_SUBMATCH_RESULT
+              </p>
+              </td>
 <td>
-<p>Outputs what matched the last sub-expression to be actually matched.<br>输出实际匹配的最后一个子表达式的匹配。
-</p></td></tr>
+              <p>
+ Outputs what matched the last sub-expression to be actually matched.<br> + &#36755;&#20986;&#23454;&#38469;&#21305;&#37197;&#30340;&#26368;&#21518;&#19968;&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$^N </p></td>
+              <p>
+                $^N
+              </p>
+              </td>
 <td>
-<p>As $LAST_SUBMATCH_RESULT </p></td></tr>
-<tr><td>
+              <p>
+                As $LAST_SUBMATCH_RESULT
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
               <p>
                 $$
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
-                Outputs a literal '$'
-                <br>
-                输出字面字符'$'
+ Outputs a literal '$'<br> &#36755;&#20986;&#23383;&#38754;&#23383;&#31526;'$'
               </p>
-              </td></tr>
-<tr><td>
+              </td>
+</tr>
+<tr>
+<td>
               <p>
                 $n
               </p>
-              </td><td>
+              </td>
+<td>
               <p>
-                Outputs what matched the n'th sub-expression.
-                <br>
-                输出第n个子表达式的匹配。
+ Outputs what matched the n'th sub-expression.<br> &#36755;&#20986;&#31532;n&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
               </p>
-              </td></tr>
-<tr><td>
-<p>${n} </p></td><td>
-<p>Outputs what matched the n'th sub-expression.&nbsp;<br>输出第n个子表达式 的匹配。</p></td></tr>
+              </td>
+</tr>
 <tr>
 <td>
-<p>$+{NAME} </p></td>
+              <p>
+                ${n}
+              </p>
+              </td>
 <td>
-<p>Outputs whatever matched the sub-expression named "NAME".<br>输出名 为"NAME"的子表达式的匹配。 </p></td></tr></tbody></table></div><br><p>
+              <p>
+ Outputs what matched the n'th sub-expression.<br> &#36755;&#20986;&#31532;n&#20010;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
+<tr>
+<td>
+              <p>
+                $+{NAME}
+              </p>
+              </td>
+<td>
+              <p>
+ Outputs whatever matched the sub-expression named "NAME".<br> + &#36755;&#20986;&#21517;&#20026;"NAME"&#30340;&#23376;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#12290;
+              </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
Any $-placeholder sequence not listed above, results in '$' being treated
-        as a literal.
-        <br>
-        任何不在上面列出的$-placeholder序列,将'$'当作字面符号。
+ as a literal.<br> &#20219;&#20309;&#19981;&#22312;&#19978;&#38754;&#21015;&#20986;&#30340;$-&#21344;&#20301;&#31526;&#24207;&#21015;&#65292;&#23558;'$'&#24403;&#20316;&#23383;&#38754;&#31526;&#21495;&#12290;
       </p>
 <p>
An escape character followed by any character x, outputs that character unless
-        x is one of the escape sequences shown below.
-        <br>
- 一个转义字符后跟任意字符x,如果x不是下面列出的转义序列之一,则输出 字符x。 + x is one of the escape sequences shown below.<br> &#19968;&#20010;&#36716;&#20041;&#23383;&#31526;&#21518;&#36319;&#20219;&#24847;&#23383;&#31526;x&#65292;&#22914;&#26524;x&#19981;&#26159;&#19979;&#38754;&#21015;&#20986;&#30340;&#36716;&#20041;&#24207;&#21015;&#20043;&#19968;&#65292;&#21017;&#36755;&#20986;&#23383;&#31526;x&#12290;
       </p>
 <div class="informaltable"><table class="table">
-<colgroup><col><col></colgroup>
+<colgroup>
+<col>
+<col>
+</colgroup>
 <thead><tr>
 <th>
               <p>
-                Escape
+                Escape &#36716;&#20041;&#24207;&#21015;
               </p>
               </th>
 <th>
               <p>
-                Meaning
+                Meaning &#24847;&#20041;
               </p>
               </th>
 </tr></thead>
@@ -196,9 +299,7 @@
               </td>
 <td>
               <p>
-                Outputs the bell character: '\a'.
-                <br>
-                输出铃响字符:'\a'。
+ Outputs the bell character: '\a'.<br> &#36755;&#20986;&#38083;&#21709;&#23383;&#31526;&#65306;'\a'&#12290;
               </p>
               </td>
 </tr>
@@ -210,9 +311,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape character (code point 27).
-                <br>
-                输出ANSI转义字符(码点为27)。
+ Outputs the ANSI escape character (code point 27).<br> &#36755;&#20986;ANSI&#36716;&#20041;&#23383;&#31526;(&#30721;&#28857;&#20026;27)&#12290;
               </p>
               </td>
 </tr>
@@ -224,9 +323,7 @@
               </td>
 <td>
               <p>
-                Outputs a form feed character: '\f'
-                <br>
-                输出换页字符:'\f'。
+ Outputs a form feed character: '\f'<br> &#36755;&#20986;&#25442;&#39029;&#23383;&#31526;&#65306;'\f'&#12290;
               </p>
               </td>
 </tr>
@@ -238,9 +335,7 @@
               </td>
 <td>
               <p>
-                Outputs a newline character: '\n'.
-                <br>
-                输出换行字符:'\n'。
+ Outputs a newline character: '\n'.<br> &#36755;&#20986;&#25442;&#34892;&#23383;&#31526;&#65306;'\n'&#12290;
               </p>
               </td>
 </tr>
@@ -252,9 +347,7 @@
               </td>
 <td>
               <p>
-                Outputs a carriage return character: '\r'.
-                <br>
-                输出回车字符:'\r'。
+ Outputs a carriage return character: '\r'.<br> &#36755;&#20986;&#22238;&#36710;&#23383;&#31526;&#65306;'\r'&#12290;
               </p>
               </td>
 </tr>
@@ -266,9 +359,7 @@
               </td>
 <td>
               <p>
-                Outputs a tab character: '\t'.
-                <br>
-                输出制表符:'\t'。
+ Outputs a tab character: '\t'.<br> &#36755;&#20986;&#21046;&#34920;&#31526;&#65306;'\t'&#12290;
               </p>
               </td>
 </tr>
@@ -280,9 +371,7 @@
               </td>
 <td>
               <p>
-                Outputs a vertical tab character: '\v'.
-                <br>
-                输出垂直制表符:'\v'。
+ Outputs a vertical tab character: '\v'.<br> &#36755;&#20986;&#22402;&#30452;&#21046;&#34920;&#31526;&#65306;'\v'&#12290;
               </p>
               </td>
 </tr>
@@ -294,9 +383,8 @@
               </td>
 <td>
               <p>
-                Outputs the character whose hexadecimal code point is 0xDD
-                <br>
-                输出码点为0xDD的十六进制字符
+ Outputs the character whose hexadecimal code point is 0xDD<br> + &#36755;&#20986;&#30721;&#28857;&#20026;0xDD&#30340;&#21313;&#20845;&#36827;&#21046;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -308,9 +396,8 @@
               </td>
 <td>
               <p>
- Outputs the character whose hexadecimal code point is 0xDDDDD
-                <br>
-                输出码点为0xDDDD的十六进制字符
+ Outputs the character whose hexadecimal code point is 0xDDDDD<br> + &#36755;&#20986;&#30721;&#28857;&#20026;0xDDDD&#30340;&#21313;&#20845;&#36827;&#21046;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -322,9 +409,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape sequence "escape-X".
-                <br>
-                输出ANSI转义序列"escape-X"。
+ Outputs the ANSI escape sequence "escape-X".<br> &#36755;&#20986;ANSI&#36716;&#20041;&#24207;&#21015;"escape-X"&#12290;
               </p>
               </td>
 </tr>
@@ -337,9 +422,7 @@
 <td>
               <p>
If D is a decimal digit in the range 1-9, then outputs the text that
-                matched sub-expression D.
-                <br>
-                如果D是1-9范围内的数字,则输出子表达式D匹配的文本。
+ matched sub-expression D.<br> &#22914;&#26524;D&#26159;1-9&#33539;&#22260;&#20869;&#30340;&#25968;&#23383;&#65292;&#21017;&#36755;&#20986;&#23376;&#34920;&#36798;&#24335;D&#21305;&#37197;&#30340;&#25991;&#26412;&#12290;
               </p>
               </td>
 </tr>
@@ -352,9 +435,7 @@
 <td>
               <p>
Causes the next character to be outputted, to be output in lower
-                case.
-                <br>
-                使下一个被输出的字符输出为小写。
+ case.<br> &#20351;&#19979;&#19968;&#20010;&#34987;&#36755;&#20986;&#30340;&#23383;&#31526;&#36755;&#20986;&#20026;&#23567;&#20889;&#12290;
               </p>
               </td>
 </tr>
@@ -367,9 +448,7 @@
 <td>
               <p>
Causes the next character to be outputted, to be output in upper
-                case.
-                <br>
-                使下一个被输出的字符输出为大写。
+ case.<br> &#20351;&#19979;&#19968;&#20010;&#34987;&#36755;&#20986;&#30340;&#23383;&#31526;&#36755;&#20986;&#20026;&#22823;&#20889;&#12290;
               </p>
               </td>
 </tr>
@@ -382,9 +461,7 @@
 <td>
               <p>
Causes all subsequent characters to be output in lower case, until
-                a \E is found.
-                <br>
-                使后面所有的字符都输出为小写,直到碰到\E。
+ a \E is found.<br> &#20351;&#21518;&#38754;&#25152;&#26377;&#30340;&#23383;&#31526;&#37117;&#36755;&#20986;&#20026;&#23567;&#20889;&#65292;&#30452;&#21040;&#30896;&#21040;\E&#12290;
               </p>
               </td>
 </tr>
@@ -397,9 +474,7 @@
 <td>
               <p>
Causes all subsequent characters to be output in upper case, until
-                a \E is found.
-                <br>
-                使后面所有的字符都输出为大写,直到碰到\E。
+ a \E is found.<br> &#20351;&#21518;&#38754;&#25152;&#26377;&#30340;&#23383;&#31526;&#37117;&#36755;&#20986;&#20026;&#22823;&#20889;&#65292;&#30452;&#21040;&#30896;&#21040;\E&#12290;
               </p>
               </td>
 </tr>
@@ -411,25 +486,24 @@
               </td>
 <td>
               <p>
-                Terminates a \L or \U sequence.
-                <br>
-                结束\L或\U的序列。
+ Terminates a \L or \U sequence.<br> &#32467;&#26463;\L&#25110;\U&#30340;&#24207;&#21015;&#12290;
               </p>
               </td>
 </tr>
 </tbody>
 </table></div>
 </div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tbody><tr> +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
 </div></td>
-</tr></tbody></table>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="sed_format.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../format.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="boost_format_syntax.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/format/sed_format.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/format/sed_format.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Sed Format String Syntax</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</title> <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../format.html" title="Search and Replace Format String Syntax"> -<link rel="prev" href="../format.html" title="Search and Replace Format String Syntax">
-<link rel="next" href="perl_format.html" title="Perl Format String Syntax">
+<link rel="up" href="../format.html" title="Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="prev" href="../format.html" title="Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> +<link rel="next" href="perl_format.html" title="Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,12 +24,11 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.format.sed_format"></a><a href="sed_format.html" title="Sed Format String Syntax"> Sed Format String Syntax</a> +<a name="boost_regex.format.sed_format"></a><a class="link" href="sed_format.html" title="Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> Sed Format String Syntax
+      Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a>
 </h3></div></div></div>
 <p>
-        Sed-style format strings treat all characters as literals except:
-        <br />
-        Sed风格格式化字符串将所有字符字面对待,除了:
+ Sed-style format strings treat all characters as literals except:<br> Sed&#39118;&#26684;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#23558;&#25152;&#26377;&#23383;&#31526;&#23383;&#38754;&#23545;&#24453;&#65292;&#38500;&#20102;&#65306;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -39,12 +38,12 @@
 <thead><tr>
 <th>
               <p>
-                character
+                character &#23383;&#31526;
               </p>
               </th>
 <th>
               <p>
-                description
+                description &#35828;&#26126;
               </p>
               </th>
 </tr></thead>
@@ -59,9 +58,7 @@
               <p>
The ampersand character is replaced in the output stream by the the whole of what matched the regular expression. Use \&amp; to output
-                a literal '&amp;' character.
-                <br />
- &amp;字符在输出中被替换为正则表达式的整个匹配。使用\&amp;输 出字面的'&amp;'字符。 + a literal '&amp;' character.<br> &amp;&#23383;&#31526;&#22312;&#36755;&#20986;&#20013;&#34987;&#26367;&#25442;&#20026;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#25972;&#20010;&#21305;&#37197;&#12290;&#20351;&#29992;\&amp;&#36755;&#20986;&#23383;&#38754;&#30340;'&amp;'&#23383;&#31526;&#12290;
               </p>
               </td>
 </tr>
@@ -73,9 +70,7 @@
               </td>
 <td>
               <p>
-                Specifies an escape sequence.
-                <br />
-                指明一个转义序列。
+ Specifies an escape sequence.<br> &#25351;&#26126;&#19968;&#20010;&#36716;&#20041;&#24207;&#21015;&#12290;
               </p>
               </td>
 </tr>
@@ -83,9 +78,7 @@
 </table></div>
 <p>
An escape character followed by any character x, outputs that character unless
-        x is one of the escape sequences shown below.
-        <br />
-        转义字符后跟任意字符x,输出这个字符,除非x是下面显示的转义序列。
+ x is one of the escape sequences shown below.<br> &#36716;&#20041;&#23383;&#31526;&#21518;&#36319;&#20219;&#24847;&#23383;&#31526;x&#65292;&#36755;&#20986;&#36825;&#20010;&#23383;&#31526;&#65292;&#38500;&#38750;x&#26159;&#19979;&#38754;&#26174;&#31034;&#30340;&#36716;&#20041;&#24207;&#21015;&#12290;
       </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -95,12 +88,12 @@
 <thead><tr>
 <th>
               <p>
-                Escape
+                Escape &#36716;&#20041;&#24207;&#21015;
               </p>
               </th>
 <th>
               <p>
-                Meaning
+                Meaning &#24847;&#20041;
               </p>
               </th>
 </tr></thead>
@@ -113,9 +106,7 @@
               </td>
 <td>
               <p>
-                Outputs the bell character: '\a'.
-                <br />
-                输出铃响字符:'\a'。
+ Outputs the bell character: '\a'.<br> &#36755;&#20986;&#38083;&#21709;&#23383;&#31526;&#65306;'\a'&#12290;
               </p>
               </td>
 </tr>
@@ -127,9 +118,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape character (code point 27).
-                <br />
-                输出ANSI转义字符(码点为27)。
+ Outputs the ANSI escape character (code point 27).<br> &#36755;&#20986;ANSI&#36716;&#20041;&#23383;&#31526;(&#30721;&#28857;&#20026;27)&#12290;
               </p>
               </td>
 </tr>
@@ -141,9 +130,7 @@
               </td>
 <td>
               <p>
-                Outputs a form feed character: '\f'
-                <br />
-                输出换页字符:'\f'。
+ Outputs a form feed character: '\f'<br> &#36755;&#20986;&#25442;&#39029;&#23383;&#31526;&#65306;'\f'&#12290;
               </p>
               </td>
 </tr>
@@ -155,9 +142,7 @@
               </td>
 <td>
               <p>
-                Outputs a newline character: '\n'.
-                <br />
-                输出换行字符:'\n'。
+ Outputs a newline character: '\n'.<br> &#36755;&#20986;&#25442;&#34892;&#23383;&#31526;&#65306;'\n'&#12290;
               </p>
               </td>
 </tr>
@@ -169,9 +154,7 @@
               </td>
 <td>
               <p>
-                Outputs a carriage return character: '\r'.
-                <br />
-                输出回车字符:'\r'。
+ Outputs a carriage return character: '\r'.<br> &#36755;&#20986;&#22238;&#36710;&#23383;&#31526;&#65306;'\r'&#12290;
               </p>
               </td>
 </tr>
@@ -183,9 +166,7 @@
               </td>
 <td>
               <p>
-                Outputs a tab character: '\t'.
-                <br />
-                输出制表字符:'\t'。
+ Outputs a tab character: '\t'.<br> &#36755;&#20986;&#21046;&#34920;&#23383;&#31526;&#65306;'\t'&#12290;
               </p>
               </td>
 </tr>
@@ -197,9 +178,7 @@
               </td>
 <td>
               <p>
-                Outputs a vertical tab character: '\v'.
-                <br />
-                输出垂直制表符:'\v'。
+ Outputs a vertical tab character: '\v'.<br> &#36755;&#20986;&#22402;&#30452;&#21046;&#34920;&#31526;&#65306;'\v'&#12290;
               </p>
               </td>
 </tr>
@@ -211,9 +190,8 @@
               </td>
 <td>
               <p>
-                Outputs the character whose hexadecimal code point is 0xDD
-                <br />
-                输出十六进制码点为0xDD的字符
+ Outputs the character whose hexadecimal code point is 0xDD<br> + &#36755;&#20986;&#21313;&#20845;&#36827;&#21046;&#30721;&#28857;&#20026;0xDD&#30340;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -225,9 +203,8 @@
               </td>
 <td>
               <p>
- Outputs the character whose hexadecimal code point is 0xDDDDD
-                <br />
-                输出十六进制码点为0xDDDD的字符
+ Outputs the character whose hexadecimal code point is 0xDDDDD<br> + &#36755;&#20986;&#21313;&#20845;&#36827;&#21046;&#30721;&#28857;&#20026;0xDDDD&#30340;&#23383;&#31526;
               </p>
               </td>
 </tr>
@@ -239,9 +216,7 @@
               </td>
 <td>
               <p>
-                Outputs the ANSI escape sequence "escape-X".
-                <br />
-                输出ANSI转义序列"escape-X"。
+ Outputs the ANSI escape sequence "escape-X".<br> &#36755;&#20986;ANSI&#36716;&#20041;&#24207;&#21015;"escape-X"&#12290;
               </p>
               </td>
 </tr>
@@ -254,9 +229,7 @@
 <td>
               <p>
If D is a decimal digit in the range 1-9, then outputs the text that
-                matched sub-expression D.
-                <br />
-                如果D是1-9范围内的数字,那么输出子表达式D匹配的文本。
+ matched sub-expression D.<br> &#22914;&#26524;D&#26159;1-9&#33539;&#22260;&#20869;&#30340;&#25968;&#23383;&#65292;&#37027;&#20040;&#36755;&#20986;&#23376;&#34920;&#36798;&#24335;D&#21305;&#37197;&#30340;&#25991;&#26412;&#12290;
               </p>
               </td>
 </tr>
@@ -265,7 +238,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/format.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/format.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Search and Replace Format String Syntax</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</title> <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
-<link rel="prev" href="syntax/leftmost_longest_rule.html" title="The Leftmost Longest Rule"> -<link rel="next" href="format/sed_format.html" title="Sed Format String Syntax"> +<link rel="prev" href="syntax/leftmost_longest_rule.html" title="The Leftmost Longest Rule &#26368;&#24038;&#26368;&#38271;&#21407;&#21017;"> +<link rel="next" href="format/sed_format.html" title="Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,37 +24,37 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.format"></a><a href="format.html" title="Search and Replace Format String Syntax"> Search and Replace Format String Syntax</a> +<a name="boost_regex.format"></a><a class="link" href="format.html" title="Search and Replace Format String Syntax &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;"> Search and Replace Format String Syntax + &#26597;&#25214;&#19982;&#26367;&#25442;&#30340;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a>
 </h2></div></div></div>
 <div class="toc"><dl>
-<dt><span class="section"><a href="format/sed_format.html"> Sed Format String Syntax</a></span></dt> -<dt><span class="section"><a href="format/perl_format.html"> Perl Format String Syntax</a></span></dt> +<dt><span class="section"><a href="format/sed_format.html"> Sed Format String Syntax
+      Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a></span></dt>
+<dt><span class="section"><a href="format/perl_format.html"> Perl Format String Syntax
+      Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a></span></dt>
<dt><span class="section"><a href="format/boost_format_syntax.html"> Boost-Extended
-      Format String Syntax</a></span></dt>
+ Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;</a></span></dt>
 </dl></div>
 <p>
- Format strings are used by the algorithm <a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> and by <a href="ref/match_results.html#boost_regex.match_results_format"><code class="computeroutput"><span class="identifier">match_results</span><span class="special">&lt;&gt;::</span><span class="identifier">format</span></code></a>, and are used to transform
-      one string into another.
-      <br />
- 格式化字符被算法<a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>和<a href="ref/match_results.html#boost_regex.match_results_format"><code class="computeroutput"><span class="identifier">match_results</span><span class="special">&lt;&gt;::</span><span class="identifier">format</span></code></a>使用,用来将一个字符串转换为另外 一个。 + Format strings are used by the algorithm <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> and by <a class="link" href="ref/match_results.html#boost_regex.match_results_format"><code class="computeroutput"><span class="identifier">match_results</span><span class="special">&lt;&gt;::</span><span class="identifier">format</span></code></a>, and are used to transform + one string into another.<br> &#26684;&#24335;&#21270;&#20018;&#34987;&#31639;&#27861; <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> &#21644; <a class="link" href="ref/match_results.html#boost_regex.match_results_format"><code class="computeroutput"><span class="identifier">match_results</span><span class="special">&lt;&gt;::</span><span class="identifier">format</span></code></a> &#20351;&#29992;&#65292;&#29992;&#26469;&#23558;&#19968;&#20010;&#23383;&#31526;&#20018;&#36716;&#25442;&#20026;&#21478;&#22806;&#19968;&#20010;&#12290;
     </p>
 <p>
- There are three kind of format string: <a href="format/sed_format.html" title="Sed Format String Syntax">Sed</a>, - <a href="format/perl_format.html" title="Perl Format String Syntax">Perl</a> and <a href="format/boost_format_syntax.html" title="Boost-Extended Format String Syntax">Boost-Extended</a>.
-      <br />
- 有三种格式化字符串:<a href="format/sed_format.html" title="Sed Format String Syntax">Sed</a>、<a href="format/perl_format.html" title="Perl Format String Syntax">Perl</a>和<a href="format/boost_format_syntax.html" title="Boost-Extended Format String Syntax">Boost-Extended</a>。 + There are three kind of format string: <a class="link" href="format/sed_format.html" title="Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Sed</a>, + <a class="link" href="format/perl_format.html" title="Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Perl</a> and <a class="link" href="format/boost_format_syntax.html" title="Boost-Extended Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Boost-Extended</a>.<br> + &#26377;&#19977;&#31181;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#65306; <a class="link" href="format/sed_format.html" title="Sed Format String Syntax Sed&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Sed</a>, + <a class="link" href="format/perl_format.html" title="Perl Format String Syntax Perl&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Perl</a> &#21644; <a class="link" href="format/boost_format_syntax.html" title="Boost-Extended Format String Syntax Boost&#25193;&#23637;&#26684;&#24335;&#21270;&#20018;&#35821;&#27861;">Boost-Extended</a>&#12290;
     </p>
 <p>
Alternatively, when the flag <code class="computeroutput"><span class="identifier">format_literal</span></code> is passed to one of these functions, then the format string is treated as a
-      string literal, and is copied unchanged to the output.
-      <br />
- 另外,如果标签<code class="computeroutput"><span class="identifier">format_literal</span></code>被传入到这些函数,那么格式化 字符串就被当作字面字符串,被不变地拷贝到输出中。 + string literal, and is copied unchanged to the output.<br> &#21478;&#22806;&#65292;&#22914;&#26524;&#26631;&#31614; + <code class="computeroutput"><span class="identifier">format_literal</span></code> &#34987;&#20256;&#20837;&#21040;&#36825;&#20123;&#20989;&#25968;&#65292;&#37027;&#20040;&#26684;&#24335;&#21270;&#23383;&#31526;&#20018;&#23601;&#34987;&#24403;&#20316;&#23383;&#38754;&#23383;&#31526;&#20018;&#65292;&#34987;&#19981;&#21464;&#22320;&#25335;&#36125;&#21040;&#36755;&#20986;&#20013;&#12290;
     </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/install.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/install.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Building and Installing the Library</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Building and Installing the Library &#32534;&#35793;&#21644;&#23433;&#35013;&#24211;</title> <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
-<link rel="prev" href="configuration/tuning.html" title="Algorithm Tuning">
-<link rel="next" href="introduction_and_overview.html" title="Introduction and Overview"> +<link rel="prev" href="configuration/tuning.html" title="Algorithm Tuning &#31639;&#27861;&#35843;&#20248;"> +<link rel="next" href="introduction_and_overview.html" title="Introduction and Overview &#20171;&#32461;&#19982;&#25552;&#35201;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,84 +24,71 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.install"></a><a href="install.html" title="Building and Installing the Library"> Building and Installing the Library 编译安装库 </a> +<a name="boost_regex.install"></a><a class="link" href="install.html" title="Building and Installing the Library &#32534;&#35793;&#21644;&#23433;&#35013;&#24211;"> Building and Installing the Library
+    &#32534;&#35793;&#21644;&#23433;&#35013;&#24211;</a>
 </h2></div></div></div>
 <p>
When you extract the library from its zip file, you must preserve its internal directory structure (for example by using the -d option when extracting). If you didn't do that when extracting, then you'd better stop reading this, delete
-      the files you just extracted, and try again!
-      <br />
- 当你从zip文件中解压缩Boost.Regex库时,你必须保持其内部的目录结构(例如 解压缩时使用-d选项)。 - 如果你没有这样做,最后就停在这儿吧,删掉所有解压缩出来的文件,重新来 一遍好了! + the files you just extracted, and try again!<br> &#24403;&#20320;&#20174;zip&#25991;&#20214;&#20013;&#35299;&#21387;&#32553;Boost.Regex&#24211;&#26102;&#65292;&#20320;&#24517;&#39035;&#20445;&#25345;&#20854;&#20869;&#37096;&#30340;&#30446;&#24405;&#32467;&#26500;(&#20363;&#22914;&#35299;&#21387;&#32553;&#26102;&#20351;&#29992;-d&#36873;&#39033;)&#12290; + &#22914;&#26524;&#20320;&#27809;&#26377;&#36825;&#26679;&#20570;&#65292;&#26368;&#21518;&#23601;&#20572;&#22312;&#36825;&#20799;&#21543;&#65292;&#21024;&#25481;&#25152;&#26377;&#35299;&#21387;&#32553;&#20986;&#26469;&#30340;&#25991;&#20214;&#65292;&#37325;&#26032;&#26469;&#19968;&#36941;&#22909;&#20102;&#65281;
     </p>
 <p>
This library should not need configuring before use; most popular compilers/standard libraries/platforms are already supported "as is". If you do experience configuration problems, or just want to test the configuration with your compiler, then the process is the same as for all of boost; see the <a href="../../../../config/index.html" target="_top">configuration
-      library documentation</a>.
-      <br />
-      使用本库前不需要配置;大多数常见的编译器/标准库/平台都已经被支持了。
- 如果你确实遇到配置问题,或者想要对自己的编译器进行配置的测试,过程和 整个boost配置是相同的; - 请参考<a href="../../../../config/index.html" target="_top">库配置文 档(configuration library documentation)</a>。 + library documentation</a>.<br> &#20351;&#29992;&#26412;&#24211;&#21069;&#19981;&#38656;&#35201;&#37197;&#32622;&#65307;&#22823;&#22810;&#25968;&#24120;&#35265;&#30340;&#32534;&#35793;&#22120;/&#26631;&#20934;&#24211;/&#24179;&#21488;&#37117;&#24050;&#32463;&#34987;&#25903;&#25345;&#20102;&#12290; + &#22914;&#26524;&#20320;&#30830;&#23454;&#36935;&#21040;&#37197;&#32622;&#38382;&#39064;&#65292;&#25110;&#32773;&#24819;&#35201;&#23545;&#33258;&#24049;&#30340;&#32534;&#35793;&#22120;&#36827;&#34892;&#37197;&#32622;&#30340;&#27979;&#35797;&#65292;&#36807;&#31243;&#21644;&#25972;&#20010;boost&#37197;&#32622;&#26159;&#30456;&#21516;&#30340;&#65307; + &#35831;&#21442;&#32771; <a href="../../../../config/index.html" target="_top">&#24211;&#37197;&#32622;&#25991;&#26723;</a>&#12290;
     </p>
 <p>
-      The library will encase all code inside namespace boost.
-      <br />
-      本库的所有代码都在boost名字空间中。
+ The library will encase all code inside namespace boost.<br> &#26412;&#24211;&#30340;&#25152;&#26377;&#20195;&#30721;&#37117;&#22312;boost&#21517;&#23383;&#31354;&#38388;&#20013;&#12290;
     </p>
 <p>
Unlike some other template libraries, this library consists of a mixture of template code (in the headers) and static code and data (in cpp files). Consequently it is necessary to build the library's support code into a library or archive - file before you can use it, instructions for specific platforms are as follows:
-      <br />
- 与其它模板库不同,本库混合了模板代码(头文件中)和静态代码数据(cpp文件 中)。 - 所以,使用以前你需要将本库的代码编译为库(library)或档案文件(archive file),下面是特定平台的说明: + file before you can use it, instructions for specific platforms are as follows:<br> + &#19982;&#20854;&#23427;&#27169;&#26495;&#24211;&#19981;&#21516;&#65292;&#26412;&#24211;&#28151;&#21512;&#20102;&#27169;&#26495;&#20195;&#30721;(&#22836;&#25991;&#20214;&#20013;)&#21644;&#38745;&#24577;&#20195;&#30721;&#25968;&#25454;(cpp&#25991;&#20214;&#20013;)&#12290; + &#25152;&#20197;&#65292;&#22312;&#20351;&#29992;&#20043;&#21069;&#20320;&#38656;&#35201;&#23558;&#26412;&#24211;&#30340;&#20195;&#30721;&#32534;&#35793;&#20026;&#24211;&#25110;&#24402;&#26723;&#25991;&#20214;&#65292;&#19979;&#38754;&#26159;&#29305;&#23450;&#24179;&#21488;&#30340;&#35828;&#26126;&#65306;
     </p>
-<a name="boost_regex.install.building_with_bjam"></a><h5>
-<a name="id446088"></a>
- <a href="install.html#boost_regex.install.building_with_bjam">Building with bjam</a>
+<a name="boost_regex.install.building_with_bjam____bjam_________"></a><h5>
+<a name="id4809000"></a>
+ <a class="link" href="install.html#boost_regex.install.building_with_bjam____bjam_________">Building
+      with bjam &#29992;bjam&#26469;&#26500;&#24314;</a>
     </h5>
 <p>
This is now the preferred method for building and installing this library, please refer to the <a href="../../../../../more/getting_started.html" target="_top">getting
-      started guide</a> for more information.
-      <br />
- 这是编译安装本库的推荐方法,请参见<a href="../../../../../more/getting_started.html" target="_top">getting started guide</a>。 + started guide</a> for more information.<br> &#36825;&#26159;&#32534;&#35793;&#23433;&#35013;&#26412;&#24211;&#30340;&#25512;&#33616;&#26041;&#27861;&#65292;&#35831;&#21442;&#35265; + <a href="../../../../../more/getting_started.html" target="_top">&#20837;&#38376;&#25351;&#21335;</a>&#12290;
     </p>
-<a name="boost_regex.install.building_with_unicode_and_icu_support"></a><h5>
-<a name="id447706"></a>
- <a href="install.html#boost_regex.install.building_with_unicode_and_icu_support">Building
-      With Unicode and ICU Support</a>
+<a name="boost_regex.install.building_with_unicode_and_icu_support____unicode___icu_______________"></a><h5>
+<a name="id4809046"></a>
+ <a class="link" href="install.html#boost_regex.install.building_with_unicode_and_icu_support____unicode___icu_______________">Building + With Unicode and ICU Support &#24102;Unicode&#21644;ICU&#25903;&#25345;&#30340;&#26500;&#24314;</a>
     </h5>
 <p>
A default build of this library does not enable Unciode support via ICU. There is no need to enable this support if you don't need it, but if you use ICU for your Unicode support already, and want to work with Unicode-aware regular
-      expressions then read on.
-      <br />
-      本库默认的编译不启用使用ICU的Unicode支持。
- 如果你不需要的话也不需要启用它,但如果你已经使用ICU作为你的Unicode支 持,并希望使用Unicode相关的正则表达式,那就继续读下去了吧。 + expressions then read on.<br> &#26412;&#24211;&#40664;&#35748;&#30340;&#32534;&#35793;&#19981;&#21551;&#29992;&#20351;&#29992;ICU&#30340;Unicode&#25903;&#25345;&#12290;&#22914;&#26524;&#20320;&#19981;&#38656;&#35201;&#30340;&#35805;&#20063;&#19981;&#38656;&#35201;&#21551;&#29992;&#23427;&#65292; + &#20294;&#22914;&#26524;&#20320;&#24050;&#32463;&#20351;&#29992;ICU&#20316;&#20026;&#20320;&#30340;Unicode&#25903;&#25345;&#65292;&#24182;&#24076;&#26395;&#20351;&#29992;Unicode&#30456;&#20851;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#65292;&#37027;&#23601;&#32487;&#32493;&#35835;&#19979;&#21435;&#20102;&#21543;&#12290;
     </p>
 <p>
Most of the information you will need is in the getting started guide, the only additional step you need to take is to tell bjam that you want Boost.Regex
-      to use ICU and optionally to tell bjam where ICU is located.
-      <br />
- 大多数信息都在开始的向导(getting started guide)中,唯一的步骤是你需要 告诉bjam你需要Boost.Regex使用ICU,
-      然后可能还需要告诉bjam ICU在哪。
+ to use ICU and optionally to tell bjam where ICU is located.<br> &#22823;&#22810;&#25968;&#20449;&#24687;&#37117;&#22312;&#20837;&#38376;&#25351;&#21335;&#20013;&#65292;&#21807;&#19968;&#22686;&#21152;&#30340;&#27493;&#39588;&#26159;&#20320;&#35201;&#21578;&#35785;bjam&#20320;&#38656;&#35201;Boost.Regex&#20351;&#29992;ICU&#65292;&#28982;&#21518;&#21487;&#33021;&#36824;&#38656;&#35201;&#21578;&#35785;bjam
+      ICU&#22312;&#21738;&#12290;
     </p>
 <p>
If you're building on a Unix-like platform, and ICU is already installed in your compilers search path (with an install prefix of <code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span></code> or <code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span></code> for example), then set the environment variable <code class="computeroutput"><span class="identifier">HAVE_ICU</span></code> - to enable ICU support. For example you might build with the command line:
-      <br />
- 如果你在类Unix平台,并且ICU已经安装在编译器的搜索路径(例如安装前缀为 <code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span></code>或<code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span></code>), - 然后设置环境变量<code class="computeroutput"><span class="identifier">HAVE_ICU</span></code>来启用ICU支持。
-      例如,你编译的命令行可能是这样的:
+ to enable ICU support. For example you might build with the command line:<br> + &#22914;&#26524;&#20320;&#22312;&#31867;Unix&#24179;&#21488;&#65292;&#24182;&#19988;ICU&#24050;&#32463;&#23433;&#35013;&#22312;&#32534;&#35793;&#22120;&#30340;&#25628;&#32034;&#36335;&#24452;(&#20363;&#22914;&#23433;&#35013;&#21069;&#32512;&#20026;<code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span></code>&#25110;<code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span></code>)&#65292; &#28982;&#21518;&#35774;&#32622;&#29615;&#22659;&#21464;&#37327;<code class="computeroutput"><span class="identifier">HAVE_ICU</span></code>&#26469;&#21551;&#29992;ICU&#25903;&#25345;&#12290;&#20363;&#22914;&#65292;&#20320;&#32534;&#35793;&#30340;&#21629;&#20196;&#34892;&#21487;&#33021;&#26159;&#36825;&#26679;&#30340;&#65306;
     </p>
<pre class="programlisting">bjam -sHAVE_ICU=1 --toolset=toolset-name install</pre>
 <p>
@@ -109,10 +96,7 @@
variable <code class="computeroutput"><span class="identifier">ICU_PATH</span></code> to point to the root directory of your ICU installation, for example if ICU was installed to <code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span><span class="special">/</span><span class="identifier">icu</span><span class="special">/</span><span class="number">3.3</span></code>
-      you might use:
-      <br />
- 如果ICU不在你编译器的搜索路径,那么你就需要设置环境变量<code class="computeroutput"><span class="identifier">ICU_PATH</span></code>指向 ICU安装的根目录, - 例如ICU安装在<code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span><span class="special">/</span><span class="identifier">icu</span><span class="special">/</span><span class="number">3.3</span></code>,那么: + you might use:<br> &#22914;&#26524;ICU&#19981;&#22312;&#20320;&#32534;&#35793;&#22120;&#30340;&#25628;&#32034;&#36335;&#24452;&#65292;&#37027;&#20040;&#20320;&#23601;&#38656;&#35201;&#35774;&#32622;&#29615;&#22659;&#21464;&#37327;<code class="computeroutput"><span class="identifier">ICU_PATH</span></code>&#25351;&#21521;ICU&#23433;&#35013;&#30340;&#26681;&#30446;&#24405;&#65292; &#20363;&#22914;&#65292;&#22914;&#26524;ICU&#23433;&#35013;&#22312;<code class="computeroutput"><span class="special">/</span><span class="identifier">usr</span><span class="special">/</span><span class="identifier">local</span><span class="special">/</span><span class="identifier">icu</span><span class="special">/</span><span class="number">3.3</span></code>&#65292;&#37027;&#20040;&#65306;
     </p>
<pre class="programlisting">bjam -sICU_PATH=/usr/local/icu/3.3 --toolset=toolset-name install</pre>
 <p>
@@ -120,38 +104,35 @@
must have been built with the same C++ compiler (and compiler version) that you are using to build Boost. Boost.Regex will not work correctly unless you ensure that this is the case: it is up to you to ensure that the version of - ICU you are using is binary compatible with the toolset you use to build Boost.
-      <br />
- ICU也是一个C++的库,和Boost一样,你必须使用相同的C++编译器(包括编译器 版本)来编译Boost和ICU。 - 如果不这么做,Boost.Regex可能不能工作,除非你能确保ICU的版本和Boost编 译的版本是二进制兼容的。 + ICU you are using is binary compatible with the toolset you use to build Boost.<br> + ICU&#20063;&#26159;&#19968;&#20010;C++&#30340;&#24211;&#65292;&#21644;Boost&#19968;&#26679;&#65292;&#20320;&#24517;&#39035;&#20351;&#29992;&#30456;&#21516;&#30340;C++&#32534;&#35793;&#22120;(&#21253;&#25324;&#32534;&#35793;&#22120;&#29256;&#26412;)&#26469;&#32534;&#35793;Boost&#21644;ICU&#12290; + &#22914;&#26524;&#19981;&#36825;&#20040;&#20570;&#65292;Boost.Regex&#21487;&#33021;&#19981;&#33021;&#24037;&#20316;&#65292;&#38500;&#38750;&#20320;&#33021;&#30830;&#20445;ICU&#30340;&#29256;&#26412;&#21644;Boost&#32534;&#35793;&#30340;&#29256;&#26412;&#26159;&#20108;&#36827;&#21046;&#20860;&#23481;&#30340;&#12290;
     </p>
-<a name="boost_regex.install.building_via_makefiles"></a><h5>
-<a name="id445600"></a>
- <a href="install.html#boost_regex.install.building_via_makefiles">Building via makefiles</a> +<a name="boost_regex.install.building_via_makefiles_______makefile_________"></a><h5>
+<a name="id4809359"></a>
+ <a class="link" href="install.html#boost_regex.install.building_via_makefiles_______makefile_________">Building
+      via makefiles &#36890;&#36807;makefile&#26469;&#26500;&#24314;</a>
     </h5>
 <a name="boost_regex.install.borland_c___builder_"></a><h6>
-<a name="id445624"></a>
- <a href="install.html#boost_regex.install.borland_c___builder_">Borland C++ Builder:</a>
+<a name="id4809382"></a>
+ <a class="link" href="install.html#boost_regex.install.borland_c___builder_">Borland C++ Builder:</a>
     </h6>
 <div class="itemizedlist"><ul type="disc">
 <li>
Open up a console window and change to the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span></code>
-        directory.
-        <br />
- 打开一个控制台窗口,切换到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span></code>目录。 + directory.<br> &#25171;&#24320;&#19968;&#20010;&#25511;&#21046;&#21488;&#31383;&#21475;&#65292;&#20999;&#25442;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span></code>&#30446;&#24405;&#12290;
       </li>
 <li>
Select the appropriate makefile (bcb4.mak for C++ Builder 4, bcb5.mak for
-        C++ Builder 5, and bcb6.mak for C++ Builder 6).
-        <br />
- 选择适当的makefile(bcb4.mak for C++ Builder 4, bcb5.mak for C++ Builder 5, bcb6.mak for C++ Builder 6)。 + C++ Builder 5, and bcb6.mak for C++ Builder 6).<br> &#36873;&#25321;&#36866;&#24403;&#30340;makefile(bcb4.mak + for C++ Builder 4, bcb5.mak for C++ Builder 5, bcb6.mak for C++ Builder 6)&#12290;
       </li>
 <li>
Invoke the makefile (pass the full path to your version of make if you have more than one version installed, the makefile relies on the path to make - to obtain your C++ Builder installation directory and tools) for example:
-        <br />
- 调用makefile (如果你安装了多个版本,那么传入你要编译的完整路径,因 为makefile依赖于这个路径来获得C++ Builder的安装目录和工作)如下: + to obtain your C++ Builder installation directory and tools) for example:<br> + &#35843;&#29992;makefile (&#22914;&#26524;&#20320;&#23433;&#35013;&#20102;&#22810;&#20010;&#29256;&#26412;&#65292;&#37027;&#20040;&#20256;&#20837;&#20320;&#35201;&#32534;&#35793;&#30340;&#23436;&#25972;&#36335;&#24452;&#65292;&#22240;&#20026;makefile&#20381;&#36182;&#20110;&#36825;&#20010;&#36335;&#24452;&#26469;&#33719;&#24471;C++ + Builder&#30340;&#23433;&#35013;&#30446;&#24405;&#21644;&#24037;&#20316;)&#22914;&#19979;&#65306;
       </li>
 </ul></div>
 <pre class="programlisting">make -fbcb5.mak</pre>
@@ -159,24 +140,17 @@
The build process will build a variety of .lib and .dll files (the exact number depends upon the version of Borland's tools you are using) the .lib and dll files will be in a sub-directory called bcb4 or bcb5 depending upon the makefile
-      used. To install the libraries into your development system use:
-      <br />
- 编译程序会生成几个.lib和.dll文件(确切的数目取决于你使用的Borland工具 的版本)。 - .lib和.dll文件会放在名为bcb4或bcb5的子目录下,取决于哪个makefile被使 用。
-      要将生成的库安装到开发系统中,使用:
+ used. To install the libraries into your development system use:<br> &#32534;&#35793;&#31243;&#24207;&#20250;&#29983;&#25104;&#20960;&#20010;.lib&#21644;.dll&#25991;&#20214;(&#30830;&#20999;&#30340;&#25968;&#30446;&#21462;&#20915;&#20110;&#20320;&#20351;&#29992;&#30340;Borland&#24037;&#20855;&#30340;&#29256;&#26412;)&#12290;
+      
.lib&#21644;.dll&#25991;&#20214;&#20250;&#25918;&#22312;&#21517;&#20026;bcb4&#25110;bcb5&#30340;&#23376;&#30446;&#24405;&#19979;&#65292;&#21462;&#20915;&#20110;&#21738;&#20010;makefile&#34987;&#20351;&#29992;&#12290;&#35201;&#23558;&#29983;&#25104;&#30340;&#24211;&#23433;&#35013;&#21040;&#24320;&#21457;&#31995;&#32479;&#20013;&#65292;&#20351;&#29992;&#65306;
     </p>
 <pre class="programlisting">make -fbcb5.mak install</pre>
 <p>
library files will be copied to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">lib</span></code> and the dll's to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">bin</span></code>, where <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;</span></code>
-      corresponds to the install path of your Borland C++ tools.
-      <br />
- 库文件会被拷贝到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">lib</span></code>,dll文件会拷贝到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">bin</span></code>,其中<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;</span></code>指 Borland C++工具安装的路径。 + corresponds to the install path of your Borland C++ tools.<br> &#24211;&#25991;&#20214;&#20250;&#34987;&#25335;&#36125;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">lib</span></code>&#65292;dll&#25991;&#20214;&#20250;&#25335;&#36125;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;/</span><span class="identifier">bin</span></code>&#65292;&#20854;&#20013;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">BCROOT</span><span class="special">&gt;</span></code>&#25351;Borland C++&#24037;&#20855;&#23433;&#35013;&#30340;&#36335;&#24452;&#12290;
     </p>
 <p>
You may also remove temporary files created during the build process (excluding
-      lib and dll files) by using:
-      <br />
-      你还可以删除掉这样编译过程中创建的临时文件(不包括lib和dll文件):
+ lib and dll files) by using:<br> &#20320;&#36824;&#21487;&#20197;&#21024;&#38500;&#25481;&#36825;&#26679;&#32534;&#35793;&#36807;&#31243;&#20013;&#21019;&#24314;&#30340;&#20020;&#26102;&#25991;&#20214;(&#19981;&#21253;&#25324;lib&#21644;dll&#25991;&#20214;)&#65306;
     </p>
 <pre class="programlisting">make -fbcb5.mak clean</pre>
 <p>
@@ -190,123 +164,97 @@
symbol _NO_VCL in order to ensure that the correct link libraries are selected: the C++ Builder IDE normally sets this automatically. Hint, users of the 5.5 command line tools may want to add a -D_NO_VCL to bcc32.cfg in order to set
-      this option permanently.
-      <br />
- 最后,使用Boost.Regex,只需要将<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;</span></code>根目录加入到工程的包含路径中。
-    头文件会根据生成方式自动选择正确的.lib文件,告诉链接程序包含它。
-    但有一点要注意:在从命令行生成GUI程序时,库不能分辨VCL和非VCL,
- 所以如果使用5.5的命令行工具必须自己定义预定义符号_NO_VCL来确保正确的库 被链接:
-    C++ Builder IDE会自动定义这个符号。
-    提示,5.5命令行工具的用户可以在bcc32.cfg中加入-D_NO_VCL来设置这个选项。
+ this option permanently.<br> &#26368;&#21518;&#65292;&#20351;&#29992;Boost.Regex&#65292;&#21482;&#38656;&#35201;&#23558;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;</span></code>&#26681;&#30446;&#24405;&#21152;&#20837;&#21040;&#24037;&#31243;&#30340;&#21253;&#21547;&#36335;&#24452;&#20013;&#12290; + &#22836;&#25991;&#20214;&#20250;&#26681;&#25454;&#29983;&#25104;&#26041;&#24335;&#33258;&#21160;&#36873;&#25321;&#27491;&#30830;&#30340;.lib&#25991;&#20214;&#65292;&#21578;&#35785;&#38142;&#25509;&#31243;&#24207;&#21253;&#21547;&#23427;&#12290; + &#20294;&#26377;&#19968;&#28857;&#35201;&#27880;&#24847;&#65306;&#22312;&#20174;&#21629;&#20196;&#34892;&#29983;&#25104;GUI&#31243;&#24207;&#26102;&#65292;&#24211;&#19981;&#33021;&#20998;&#36776;VCL&#21644;&#38750;VCL&#65292; + &#25152;&#20197;&#22914;&#26524;&#20351;&#29992;5.5&#30340;&#21629;&#20196;&#34892;&#24037;&#20855;&#24517;&#39035;&#33258;&#24049;&#23450;&#20041;&#39044;&#23450;&#20041;&#31526;&#21495;_NO_VCL&#26469;&#30830;&#20445;&#27491;&#30830;&#30340;&#24211;&#34987;&#38142;&#25509;&#65306;C++ + Builder IDE&#20250;&#33258;&#21160;&#23450;&#20041;&#36825;&#20010;&#31526;&#21495;&#12290; &#25552;&#31034;&#65292;5.5&#21629;&#20196;&#34892;&#24037;&#20855;&#30340;&#29992;&#25143;&#21487;&#20197;&#22312;bcc32.cfg&#20013;&#21152;&#20837;-D_NO_VCL&#26469;&#35774;&#32622;&#36825;&#20010;&#36873;&#39033;&#12290;
     </p>
 <p>
If you would prefer to do a dynamic link to the regex libraries when using the dll runtime then define BOOST_REGEX_DYN_LINK (you must do this if you want to use Boost.Regex in multiple dll's), otherwise Boost.Regex will be statically
-      linked by default.
-      <br />
- 当使用动态运行时时,如果你想要用regex库的动态链接,那么定义 BOOST_REGEX_DYN_LINK (想要在多个dll中使用Boost.Regex必须这么做),否则 Boost.Regex会被默认为静态链接。 + linked by default. <br> &#24403;&#20351;&#29992;&#21160;&#24577;&#36816;&#34892;&#26102;&#26102;&#65292;&#22914;&#26524;&#20320;&#24819;&#35201;&#29992;regex&#24211;&#30340;&#21160;&#24577;&#38142;&#25509;&#65292;&#37027;&#20040;&#23450;&#20041;BOOST_REGEX_DYN_LINK + (&#24819;&#35201;&#22312;&#22810;&#20010;dll&#20013;&#20351;&#29992;Boost.Regex&#24517;&#39035;&#36825;&#20040;&#20570;)&#65292;&#21542;&#21017;Boost.Regex&#20250;&#34987;&#40664;&#35748;&#20026;&#38745;&#24577;&#38142;&#25509;&#12290;
     </p>
 <p>
If you want to suppress automatic linking altogether (and supply your own custom
-      build of the lib) then define BOOST_REGEX_NO_LIB.
-      <br />
- 如果你想要禁止自动链接(提供自己生成的lib),那么定义 BOOST_REGEX_NO_LIB。 + build of the lib) then define BOOST_REGEX_NO_LIB.<br> &#22914;&#26524;&#20320;&#24819;&#35201;&#31105;&#27490;&#33258;&#21160;&#38142;&#25509;(&#25552;&#20379;&#33258;&#24049;&#29983;&#25104;&#30340;lib)&#65292;&#37027;&#20040;&#23450;&#20041;BOOST_REGEX_NO_LIB&#12290;
     </p>
 <p>
If you are building with C++ Builder 6, you will find that <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> can not be used in a pre-compiled header (the actual problem is in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">locale</span><span class="special">&gt;</span></code> which gets included by <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>), if this causes problems for you, then try defining BOOST_NO_STD_LOCALE when building, this will disable some features throughout boost, but may save you
-      a lot in compile times!
-      <br />
- 如果你想要用C++ Builder 6生成,你会发现<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>不能被 应用在预编译的头文件中(真正的问题在于<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>中包含的<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">locale</span><span class="special">&gt;</span></code>), - 如果这对你造成影响,试一下定义BOOST_NO_STD_LOCALE,这个禁止一些 boost的特性,但可能会节省你的很多编译时间! + a lot in compile times!<br> &#22914;&#26524;&#20320;&#24819;&#35201;&#29992;C++ Builder 6&#29983;&#25104;&#65292;&#20320;&#20250;&#21457;&#29616;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>&#19981;&#33021;&#34987;&#24212;&#29992;&#22312;&#39044;&#32534;&#35793;&#30340;&#22836;&#25991;&#20214;&#20013; + (&#30495;&#27491;&#30340;&#38382;&#39064;&#22312;&#20110;&lt;boost/regex.hpp&gt;&#20013;&#21253;&#21547;&#30340;&lt;locale&gt;)&#65292;&#22914;&#26524;&#36825;&#23545;&#20320;&#36896;&#25104;&#24433;&#21709;&#65292;&#35797;&#19968;&#19979;&#23450;&#20041;BOOST_NO_STD_LOCALE&#65292; + &#36825;&#20010;&#31105;&#27490;&#19968;&#20123;boost&#30340;&#29305;&#24615;&#65292;&#20294;&#21487;&#33021;&#20250;&#33410;&#30465;&#20320;&#30340;&#24456;&#22810;&#32534;&#35793;&#26102;&#38388;&#65281;
     </p>
 <a name="boost_regex.install.microsoft_visual_c___6__7__7_1_and_8"></a><h5>
-<a name="id500138"></a>
- <a href="install.html#boost_regex.install.microsoft_visual_c___6__7__7_1_and_8">Microsoft
+<a name="id4806981"></a>
+ <a class="link" href="install.html#boost_regex.install.microsoft_visual_c___6__7__7_1_and_8">Microsoft
       Visual C++ 6, 7, 7.1 and 8</a>
     </h5>
 <p>
You need version 6 or later of MSVC to build this library. If you are using - VC5 then you may want to look at one of the previous releases of this library.
-      <br />
- 你需要用MSVC 6或以后的版本。如果你使用VC5,你可能需要去看本库之前的发 布版。 + VC5 then you may want to look at one of the previous releases of this library.<br> + &#20320;&#38656;&#35201;&#29992;MSVC 6&#25110;&#20197;&#21518;&#30340;&#29256;&#26412;&#12290;&#22914;&#26524;&#20320;&#20351;&#29992;VC5&#65292;&#20320;&#21487;&#33021;&#38656;&#35201;&#21435;&#30475;&#26412;&#24211;&#20043;&#21069;&#30340;&#21457;&#24067;&#29256;&#12290;
     </p>
 <p>
Open up a command prompt, which has the necessary MSVC environment variables defined (for example by using the batch file Vcvars32.bat installed by the - Visual Studio installation), and change to the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span> <span class="identifier">directory</span></code>.
-      <br />
- 打开一个定义有MSVC需要的环境变量的命令行提示符(例如Visual Studio安装 的批处理文件Vcvars32.bat), - 切换到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span>目录。 + Visual Studio installation), and change to the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span> <span class="identifier">directory</span></code>.<br> + &#25171;&#24320;&#19968;&#20010;&#23450;&#20041;&#26377;MSVC&#38656;&#35201;&#30340;&#29615;&#22659;&#21464;&#37327;&#30340;&#21629;&#20196;&#34892;&#25552;&#31034;&#31526;(&#20363;&#22914;Visual + Studio&#23433;&#35013;&#30340;&#25209;&#22788;&#29702;&#25991;&#20214;Vcvars32.bat)&#65292; &#20999;&#25442;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;\</span><span class="identifier">libs</span><span class="special">\</span><span class="identifier">regex</span><span class="special">\</span><span class="identifier">build</span></code>&#30446;&#24405;&#12290;
     </p>
 <p>
       Select the correct makefile - vc6.mak for "vanilla" Visual C++ 6
-      or vc6-stlport.mak if you are using STLPort.
-      <br />
- 选择正确的makefile - vc6.mak for "vanilla" Visual C++ 6,vc6-stlport.mak如果你使用STLPort。 + or vc6-stlport.mak if you are using STLPort.<br> &#36873;&#25321;&#27491;&#30830;&#30340;makefile + - vc6.mak for "vanilla" Visual C++ 6&#65292;vc6-stlport.mak&#22914;&#26524;&#20320;&#20351;&#29992;STLPort&#12290;
     </p>
 <p>
-      Invoke the makefile like this:
-      <br />
-      调用makefile:
+ Invoke the makefile like this:<br> &#22914;&#19979;&#35843;&#29992;makefile&#65306;
     </p>
 <pre class="programlisting">nmake -fvc6.mak</pre>
 <p>
You will now have a collection of lib and dll files in a "vc6" subdirectory,
-      to install these into your development system use:
-      <br />
-      现在在"vc6"子目录下会有一系列的lib和dll文件,然后安装到开发系统中:
+ to install these into your development system use:<br> &#29616;&#22312;&#22312;"vc6"&#23376;&#30446;&#24405;&#19979;&#20250;&#26377;&#19968;&#31995;&#21015;&#30340;lib&#21644;dll&#25991;&#20214;&#65292;&#28982;&#21518;&#23433;&#35013;&#21040;&#24320;&#21457;&#31995;&#32479;&#20013;&#65306;
     </p>
 <pre class="programlisting">nmake -fvc6.mak install</pre>
 <p>
The lib files will be copied to your <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">lib</span></code> directory and the dll files to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">bin</span></code>, where <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;</span></code> is
-      the root of your Visual C++ 6 installation.
-      <br />
- lib文件会被拷贝到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">lib</span></code>目 录,dll到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">bin</span></code>,其中 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;</span></code>是 Visual C++ 6安装的根目录。 + the root of your Visual C++ 6 installation.<br> lib&#25991;&#20214;&#20250;&#34987;&#25335;&#36125;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">lib</span></code>&#30446;&#24405;&#65292;dll&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;\</span><span class="identifier">bin</span></code>&#65292;&#20854;&#20013;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">VC6</span><span class="special">&gt;</span></code>&#26159;Visual
+      C++ 6&#23433;&#35013;&#30340;&#26681;&#30446;&#24405;&#12290;
     </p>
 <p>
You can delete all the temporary files created during the build (excluding
-      lib and dll files) using:
-      <br />
-      你可以删除编译过程中生成的临时文件(不包括lib和dll文件):
+ lib and dll files) using:<br> &#20320;&#21487;&#20197;&#21024;&#38500;&#32534;&#35793;&#36807;&#31243;&#20013;&#29983;&#25104;&#30340;&#20020;&#26102;&#25991;&#20214;(&#19981;&#21253;&#25324;lib&#21644;dll&#25991;&#20214;)&#65306;
     </p>
 <pre class="programlisting">nmake -fvc6.mak clean </pre>
 <p>
If you want to build with ICU support, then you need to pass the path to your
-      ICU directory to the makefile, for example with:
-      <br />
-      如果你想要ICU支持,你需要将ICU目录的路径传给makefile,例如:
+ ICU directory to the makefile, for example with:<br> &#22914;&#26524;&#20320;&#24819;&#35201;ICU&#25903;&#25345;&#65292;&#20320;&#38656;&#35201;&#23558;ICU&#30446;&#24405;&#30340;&#36335;&#24452;&#20256;&#32473;makefile&#65292;&#20363;&#22914;&#65306;
     </p>
<pre class="programlisting">nmake ICU_PATH=c:\open-source\icu -fvc71.mak install</pre>
 <p>
Finally when you use Boost.Regex it is only necessary for you to add the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;</span></code> root directory to your list of include directories for that project. It is not necessary for you to manually add a .lib file to the project; the headers will automatically select the correct
-      .lib file for your build mode and tell the linker to include it.
-      <br />
- 最后,使用Boost.Regex,只需要将<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;</span></code>根目录加入到工程的包含路径中。
-    头文件会根据生成方式自动选择正确的.lib文件,告诉链接程序包含它。
+ .lib file for your build mode and tell the linker to include it.<br> &#26368;&#21518;&#65292;&#20351;&#29992;Boost.Regex&#65292;&#21482;&#38656;&#35201;&#23558;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;</span></code>&#26681;&#30446;&#24405;&#21152;&#20837;&#21040;&#24037;&#31243;&#30340;&#21253;&#21547;&#36335;&#24452;&#20013;&#12290; + &#22836;&#25991;&#20214;&#20250;&#26681;&#25454;&#29983;&#25104;&#26041;&#24335;&#33258;&#21160;&#36873;&#25321;&#27491;&#30830;&#30340;.lib&#25991;&#20214;&#65292;&#21578;&#35785;&#38142;&#25509;&#31243;&#24207;&#21253;&#21547;&#23427;&#12290;
     </p>
 <p>
Note that if you want to dynamically link to the regex library when using the - dynamic C++ runtime, define BOOST_REGEX_DYN_LINK when building your project.
-      <br />
-      如果想要动态链接regex库,定义BOOST_REGEX_DYN_LINK。
+ dynamic C++ runtime, define BOOST_REGEX_DYN_LINK when building your project.<br> + &#22914;&#26524;&#24819;&#35201;&#21160;&#24577;&#38142;&#25509;regex&#24211;&#65292;&#23450;&#20041;BOOST_REGEX_DYN_LINK&#12290;
     </p>
 <p>
If you want to add the source directly to your project then define BOOST_REGEX_NO_LIB
-      to disable automatic library selection.
-      <br />
- 如果想要将源文件直接加入到你的工程中,定义BOOST_REGEX_NO_LIB来禁止编 译器自动选择库。 + to disable automatic library selection.<br> &#22914;&#26524;&#24819;&#35201;&#23558;&#28304;&#25991;&#20214;&#30452;&#25509;&#21152;&#20837;&#21040;&#20320;&#30340;&#24037;&#31243;&#20013;&#65292;&#23450;&#20041;BOOST_REGEX_NO_LIB&#26469;&#31105;&#27490;&#32534;&#35793;&#22120;&#33258;&#21160;&#36873;&#25321;&#24211;&#12290;
     </p>
 <p>
There are several important caveats to remember when using Boost.Regex with
-      Microsoft's Compiler:
-      <br />
-      用Microsoft的编译来使用Boost.Regex有几条重要的事项:
+ Microsoft's Compiler:<br> &#29992;Microsoft&#30340;&#32534;&#35793;&#26469;&#20351;&#29992;Boost.Regex&#26377;&#20960;&#26465;&#37325;&#35201;&#30340;&#20107;&#39033;&#65306;
     </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
@@ -316,49 +264,41 @@
optimization settings except /Oa. This problem is reported to affect some standard library code as well ( in fact I'm not sure if the problem is with the regex code or the underlying standard library), so it's probably worthwhile
-        applying this workaround in normal practice in any case.
-        <br />
- 有几个编译器优化的错误会影响本库,(尤其是VC6 service patch 5以前的 版本)工作区会使用/Oityb1而不是/O2来生成库。
-        也就是使用除/Oa之外的所有优化选项。
- 这个问题被认为同样会影响一些标准库(实际上我不确定到底是regex代码的 问题还是下面标准库的问题),
-        所以可能需要将工作区应用到各种情况。(???)
+ applying this workaround in normal practice in any case.<br> &#26377;&#20960;&#20010;&#32534;&#35793;&#22120;&#20248;&#21270;&#30340;&#38169;&#35823;&#20250;&#24433;&#21709;&#26412;&#24211;&#65292;(&#23588;&#20854;&#26159;VC6 + service patch 5&#20197;&#21069;&#30340;&#29256;&#26412;)&#21464;&#36890;&#30340;&#21150;&#27861;&#26159;&#20351;&#29992;/Oityb1&#32780;&#19981;&#26159;/O2&#26469;&#29983;&#25104;&#24211;&#12290; + &#20063;&#23601;&#26159;&#20351;&#29992;&#38500;/Oa&#20043;&#22806;&#30340;&#25152;&#26377;&#20248;&#21270;&#36873;&#39033;&#12290;&#36825;&#20010;&#38382;&#39064;&#34987;&#35748;&#20026;&#21516;&#26679;&#20250;&#24433;&#21709;&#19968;&#20123;&#26631;&#20934;&#24211;(&#23454;&#38469;&#19978;&#25105;&#19981;&#30830;&#23450;&#21040;&#24213;&#26159;regex&#20195;&#30721;&#30340;&#38382;&#39064;&#36824;&#26159;&#19979;&#38754;&#26631;&#20934;&#24211;&#30340;&#38382;&#39064;)&#65292; + &#25152;&#20197;&#21487;&#33021;&#38656;&#35201;&#23558;&#35813;&#21464;&#36890;&#26041;&#27861;&#24212;&#29992;&#21040;&#21508;&#31181;&#24773;&#20917;&#12290;
       </li>
 <li>
If you have replaced the C++ standard library that comes with VC6, then when you build the library you must ensure that the environment variables "INCLUDE"
         and "LIB" have been updated to reflect the include and library
paths for the new library - see vcvars32.bat (part of your Visual Studio
-        installation) for more details.
-        <br />
- 如果你替换了VC6的标准库,那么编译的时候你必须确保环 境"INCLUDE"和"LIB"同样被更新到新的include和library的路径 - 看vcvars32.bat来 得到更详细的信息。 + installation) for more details.<br> &#22914;&#26524;&#20320;&#26367;&#25442;&#20102;VC6&#30340;&#26631;&#20934;&#24211;&#65292;&#37027;&#20040;&#32534;&#35793;&#30340;&#26102;&#20505;&#20320;&#24517;&#39035;&#30830;&#20445;&#29615;&#22659;"INCLUDE"&#21644;"LIB"&#21516;&#26679;&#34987;&#26356;&#26032;&#21040;&#26032;&#30340;include&#21644;library&#30340;&#36335;&#24452; + - &#30475;vcvars32.bat&#26469;&#24471;&#21040;&#26356;&#35814;&#32454;&#30340;&#20449;&#24687;&#12290;
       </li>
 <li>
If you are building with the full STLPort v4.x, then use the vc6-stlport.mak file provided and set the environment variable STLPORT_PATH to point to the location of your STLPort installation (Note that the full STLPort libraries
-        appear not to support single-thread static builds).
-        <br />
- 如果使用完整的STLPort v4.x来生成,就使用vc6-stlport.mak文件,并设置 环境变量STLPORT_PATH指向STLPort的安装路径(注意完整的STLPort库貌似不支持单线 程静态生成)。 + appear not to support single-thread static builds).<br> &#22914;&#26524;&#20351;&#29992;&#23436;&#25972;&#30340;STLPort + v4.x&#26469;&#29983;&#25104;&#65292;&#23601;&#20351;&#29992;vc6-stlport.mak&#25991;&#20214;&#65292; &#24182;&#35774;&#32622;&#29615;&#22659;&#21464;&#37327;STLPORT_PATH&#25351;&#21521;STLPort&#30340;&#23433;&#35013;&#36335;&#24452;(&#27880;&#24847;&#23436;&#25972;&#30340;STLPort&#24211;&#35980;&#20284;&#19981;&#25903;&#25345;&#21333;&#32447;&#31243;&#38745;&#24577;&#29983;&#25104;)&#12290;
       </li>
 <li>
If you are building your application with /Zc:wchar_t then you will need - to modify the makefile to add /Zc:wchar_t before building the library.
-        <br />
- 如果使用/Zc:wchar_t来生成你的程序,你需要添加/Zc:wchar_t到 makefile来生成库。 + to modify the makefile to add /Zc:wchar_t before building the library.<br> + &#22914;&#26524;&#20351;&#29992;/Zc:wchar_t&#26469;&#29983;&#25104;&#20320;&#30340;&#31243;&#24207;&#65292;&#20320;&#38656;&#35201;&#28155;&#21152;/Zc:wchar_t&#21040;makefile&#26469;&#29983;&#25104;&#24211;&#12290;
       </li>
 </ul></div>
 <a name="boost_regex.install.gcc_2_95_and_later_"></a><h6>
-<a name="id500450"></a>
- <a href="install.html#boost_regex.install.gcc_2_95_and_later_">GCC(2.95 and later)</a>
+<a name="id4807499"></a>
+ <a class="link" href="install.html#boost_regex.install.gcc_2_95_and_later_">GCC(2.95 and later)</a>
     </h6>
 <p>
You can build with gcc using the normal boost Jamfile in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>, alternatively there is a conservative makefile for the g++ compiler. From the command prompt
-      change to the &lt;boost&gt;/libs/regex/build directory and type:
-      <br />
- 你可以使用<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>下的 Jamfile来启动gcc编译,
-      同样也有一个保守g++编译器的makefile文件。
-      从命令提示符下切换到&lt;boost&gt;/libs/regex/build目录敲入:
+ change to the &lt;boost&gt;/libs/regex/build directory and type:<br> &#20320;&#21487;&#20197;&#20351;&#29992;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>&#19979;&#30340;Jamfile&#26469;&#21551;&#21160;gcc&#32534;&#35793;&#65292;&#21516;&#26679;&#20063;&#26377;&#19968;&#20010;&#20445;&#23432;g++&#32534;&#35793;&#22120;&#30340;makefile&#25991;&#20214;&#12290; + &#20174;&#21629;&#20196;&#25552;&#31034;&#31526;&#19979;&#20999;&#25442;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>&#30446;&#24405;&#25970;&#20837;&#65306;
     </p>
 <pre class="programlisting">make -fgcc.mak </pre>
 <p>
@@ -366,72 +306,54 @@
release and debug versions of the library (libboost_regex.a and libboost_regex_debug.a). When you build projects that use regex++, you will need to add the boost install directory to your list of include paths and add &lt;boost&gt;/libs/regex/build/gcc/libboost_regex.a
-      to your list of library files.
-      <br />
- 生成过程的最后你会看到一个gcc的子目录包含release和debug版本的库 (libboost_regex.a和libboost_regex_debua.a)。 - 如果使用regex++编译工程,你需要添加boost安装路径到你的包含路径中,并 将&lt;boost&gt;/libs/regex/build/gcc/libboost_regex.a加入到库文件中。 + to your list of library files.<br> &#29983;&#25104;&#36807;&#31243;&#30340;&#26368;&#21518;&#20320;&#20250;&#30475;&#21040;&#19968;&#20010;gcc&#30340;&#23376;&#30446;&#24405;&#21253;&#21547;release&#21644;debug&#29256;&#26412;&#30340;&#24211;(libboost_regex.a&#21644;libboost_regex_debua.a)&#12290; + &#22914;&#26524;&#20351;&#29992;regex++&#32534;&#35793;&#24037;&#31243;&#65292;&#20320;&#38656;&#35201;&#28155;&#21152;boost&#23433;&#35013;&#36335;&#24452;&#21040;&#20320;&#30340;&#21253;&#21547;&#36335;&#24452;&#20013;&#65292;&#24182;&#23558;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span><span class="special">/</span><span class="identifier">gcc</span><span class="special">/</span><span class="identifier">libboost_regex</span><span class="special">.</span><span class="identifier">a</span></code>&#21152;&#20837;&#21040;&#24211;&#25991;&#20214;&#20013;&#12290;
     </p>
 <p>
-      There is also a makefile to build the library as a shared library:
-      <br />
-      同样有一个用来生成共享库的makefile文件:
+ There is also a makefile to build the library as a shared library:<br> &#21516;&#26679;&#26377;&#19968;&#20010;&#29992;&#26469;&#29983;&#25104;&#20849;&#20139;&#24211;&#30340;makefile&#25991;&#20214;&#65306;
     </p>
 <pre class="programlisting">make -fgcc-shared.mak</pre>
 <p>
-      which will build libboost_regex.so and libboost_regex_debug.so.
-      <br />
-      会生成libboost_regex.so和libboost_regex_debug.so。
+ which will build libboost_regex.so and libboost_regex_debug.so.<br> &#20250;&#29983;&#25104;libboost_regex.so&#21644;libboost_regex_debug.so&#12290;
     </p>
 <p>
- Both of the these makefiles support the following environment variables:
-      <br />
-      这些makefile都支持如下的环境变量:
+ Both of the these makefiles support the following environment variables:<br> + &#36825;&#20123;makefile&#37117;&#25903;&#25345;&#22914;&#19979;&#30340;&#29615;&#22659;&#21464;&#37327;&#65306;
     </p>
 <p>
ICU_PATH: tells the makefile to build with Unicode support, set to the path - where your ICU installation is located, for example with: make ICU_PATH=/usr/local
-      install -fgcc.mak
-      <br />
- ICU_PATH: 告诉makefile生成Unicode支持,将路径设为ICU安装路径,例 如:make ICU_PATH=/usr/local install -fgcc.mak + where your ICU installation is located, for example with: make ICU_PATH<code class="literal">/usr/local + install -fgcc.mak\n ICU_PATH: &#21578;&#35785;makefile&#29983;&#25104;Unicode&#25903;&#25345;&#65292;&#23558;&#36335;&#24452;&#35774;&#20026;ICU&#23433;&#35013;&#36335;&#24452;&#65292;&#20363;&#22914;&#65306;make
+      ICU_PATH</code>/usr/local install -fgcc.mak
     </p>
 <p>
CXXFLAGS: extra compiler options - note that this applies to both the debug
-      and release builds.
-      <br />
-      CXXFLAGS: 额外的编译选项 - 这会同时应用到debug和release版本中。
+ and release builds.<br> CXXFLAGS: &#39069;&#22806;&#30340;&#32534;&#35793;&#36873;&#39033; - &#36825;&#20250;&#21516;&#26102;&#24212;&#29992;&#21040;debug&#21644;release&#29256;&#26412;&#20013;&#12290;
     </p>
 <p>
-      INCLUDES: additional include directories.
-      <br />
-      INCLUDES: 额外的包含目录。
+ INCLUDES: additional include directories.<br> INCLUDES: &#39069;&#22806;&#30340;&#21253;&#21547;&#30446;&#24405;&#12290;
     </p>
 <p>
-      LDFLAGS: additional linker options.
-      <br />
-      LDFLAGS: 额外的链接选项。
+ LDFLAGS: additional linker options.<br> LDFLAGS: &#39069;&#22806;&#30340;&#38142;&#25509;&#36873;&#39033;&#12290;
     </p>
 <p>
-      LIBS: additional library files.
-      <br />
-      LIBS: 额外的库文件。
+ LIBS: additional library files.<br> LIBS: &#39069;&#22806;&#30340;&#24211;&#25991;&#20214;&#12290;
     </p>
 <p>
For the more adventurous there is a configure script in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span></code>; - see the <a href="../../../../config/index.html" target="_top">config library documentation</a>.
-      <br />
- 对于更喜欢冒险的人来说,<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span></code>有一个 配置脚本;请参见<a href="../../../../config/index.html" target="_top">config library documentation</a>。 + see the <a href="../../../../config/index.html" target="_top">config library documentation</a>.<br> + &#23545;&#20110;&#26356;&#21916;&#27426;&#25361;&#25112;&#30340;&#20154;&#26469;&#35828;&#65292;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">config</span></code>&#26377;&#19968;&#20010;&#37197;&#32622;&#33050;&#26412;&#65307;&#35831;&#21442;&#35265; + <a href="../../../../config/index.html" target="_top">config&#24211;&#30340;&#25991;&#26723;</a>&#12290;
     </p>
 <a name="boost_regex.install.sun_workshop_6_1"></a><h6>
-<a name="id500651"></a>
- <a href="install.html#boost_regex.install.sun_workshop_6_1">Sun Workshop 6.1</a>
+<a name="id4807928"></a>
+ <a class="link" href="install.html#boost_regex.install.sun_workshop_6_1">Sun Workshop 6.1</a>
     </h6>
 <p>
There is a makefile for the sun (6.1) compiler (C++ version 3.12). From the command prompt change to the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code> directory
-      and type:
-      <br />
-      对于sun (6.1)编译器(C++ version 3.12)有一个makefile。
- 从命令提示符下切换到<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>目录输 入: + and type:<br> &#23545;&#20110;sun (6.1)&#32534;&#35793;&#22120;(C++ version 3.12)&#26377;&#19968;&#20010;makefile&#12290; + &#20174;&#21629;&#20196;&#25552;&#31034;&#31526;&#19979;&#20999;&#25442;&#21040;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>&#30446;&#24405;&#36755;&#20837;&#65306;
     </p>
 <pre class="programlisting">dmake -f sunpro.mak </pre>
 <p>
@@ -440,69 +362,54 @@
libboost_regex_mt.a and libboost_regex_mt.so). When you build projects that use Boost.Regex, you will need to add the boost install directory to your list of include paths and add <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span><span class="special">/</span><span class="identifier">sunpro</span><span class="special">/</span></code> to
-      your library search path.
-      <br />
- 在生成过程的最后,你会看一个子目录包含单线程和多线程版本的库 (libboost_regex.a,libboost_regex.so,libboost_regex_mt.a,libboost_regex_mt.so)。 - 当使用Boost.Regex生成工程时,需要将boost安装路径加入到工程包含路径 中,将<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span><span class="special">/</span><span class="identifier">sunpro</span><span class="special">/</span></code>加入到 库搜索路径中。 + your library search path.<br> &#22312;&#29983;&#25104;&#36807;&#31243;&#30340;&#26368;&#21518;&#65292;&#20320;&#20250;&#30475;&#19968;&#20010;&#23376;&#30446;&#24405;&#21253;&#21547;&#21333;&#32447;&#31243;&#21644;&#22810;&#32447;&#31243;&#29256;&#26412;&#30340;&#24211;(libboost_regex.a&#65292;libboost_regex.so&#65292;libboost_regex_mt.a&#65292; + libboost_regex_mt.so)&#12290;&#24403;&#20351;&#29992;Boost.Regex&#29983;&#25104;&#24037;&#31243;&#26102;&#65292;&#38656;&#35201;&#23558;boost&#23433;&#35013;&#36335;&#24452;&#21152;&#20837;&#21040;&#24037;&#31243;&#21253;&#21547;&#36335;&#24452;&#20013;&#65292; + &#23558;<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span><span class="special">/</span><span class="identifier">sunpro</span><span class="special">/</span></code>&#21152;&#20837;&#21040;&#24211;&#25628;&#32034;&#36335;&#24452;&#20013;&#12290;
     </p>
 <p>
- Both of the these makefiles support the following environment variables:
-      <br />
-      这些makefile都支持如下环境变量:
+ Both of the these makefiles support the following environment variables:<br> + &#36825;&#20123;makefile&#37117;&#25903;&#25345;&#22914;&#19979;&#29615;&#22659;&#21464;&#37327;&#65306;
     </p>
 <p>
CXXFLAGS: extra compiler options - note that this applies to both the single
-      and multithreaded builds.
-      <br />
-      CXXFLAGS: 额外的编译器选项 - 注意这会以单线程和多线程中。
+ and multithreaded builds.<br> CXXFLAGS: &#39069;&#22806;&#30340;&#32534;&#35793;&#22120;&#36873;&#39033; - &#27880;&#24847;&#36825;&#20250;&#20197;&#21333;&#32447;&#31243;&#21644;&#22810;&#32447;&#31243;&#20013;&#12290;
     </p>
 <p>
-      INCLUDES: additional include directories.
-      <br />
-      INCLUDES: 额外的包含目录。
+ INCLUDES: additional include directories.<br> INCLUDES: &#39069;&#22806;&#30340;&#21253;&#21547;&#30446;&#24405;&#12290;
     </p>
 <p>
-      LDFLAGS: additional linker options.
-      <br />
-      LDFALGS: 额外的链接选项。
+ LDFLAGS: additional linker options.<br> LDFALGS: &#39069;&#22806;&#30340;&#38142;&#25509;&#36873;&#39033;&#12290;
     </p>
 <p>
-      LIBS: additional library files.
-      <br />
-      LIBS: 额外的库文件。
+ LIBS: additional library files.<br> LIBS: &#39069;&#22806;&#30340;&#24211;&#25991;&#20214;&#12290;
     </p>
 <p>
- LIBSUFFIX: a suffix to mangle the library name with (defaults to nothing).
-      <br />
-      LIBSUFFIX: 库名称的后缀重整(默认没有)。
+ LIBSUFFIX: a suffix to mangle the library name with (defaults to nothing).<br> + LIBSUFFIX: &#24211;&#21517;&#31216;&#30340;&#21518;&#32512;&#37325;&#25972;(&#40664;&#35748;&#27809;&#26377;)&#12290;
     </p>
 <p>
This makefile does not set any architecture specific options like -xarch=v9,
-      you can set these by defining the appropriate macros, for example:
-      <br />
- makefile不会设置任何架构选项如-xarch=v7,你可以自己定义适当的宏,例 如: + you can set these by defining the appropriate macros, for example:<br> makefile&#19981;&#20250;&#35774;&#32622;&#20219;&#20309;&#26550;&#26500;&#36873;&#39033;&#22914;-xarch=v9&#65292;&#20320;&#21487;&#20197;&#33258;&#24049;&#23450;&#20041;&#36866;&#24403;&#30340;&#23439;&#65292;&#20363;&#22914;&#65306;
     </p>
<pre class="programlisting">dmake CXXFLAGS="-xarch<code class="literal">v9" LDFLAGS</code>"-xarch<code class="literal">v9" LIBSUFFIX</code>"_v9" -f sunpro.mak</pre>
 <p>
- will build v9 variants of the regex library named libboost_regex_v9.a etc.
-      <br />
-      会生成v9相关的regex库名为libboost_regex_v9.a。
+ will build v9 variants of the regex library named libboost_regex_v9.a etc.<br> + &#20250;&#29983;&#25104;v9&#30456;&#20851;&#30340;regex&#24211;&#21517;&#20026;libboost_regex_v9.a&#12290;
     </p>
-<a name="boost_regex.install.makefiles_for_other_compilers"></a><h6>
-<a name="id500873"></a>
- <a href="install.html#boost_regex.install.makefiles_for_other_compilers">Makefiles
-      for Other compilers</a>
+<a name="boost_regex.install.makefiles_for_other_compilers_________________________makefile"></a><h6>
+<a name="id4859786"></a>
+ <a class="link" href="install.html#boost_regex.install.makefiles_for_other_compilers_________________________makefile">Makefiles + for Other compilers &#29992;&#20110;&#20854;&#23427;&#32534;&#35793;&#22120;&#30340;makefile</a>
     </h6>
 <p>
There is a generic makefile (generic.mak ) provided in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">-</span><span class="identifier">root</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code> - see that makefile for details of
-      environment variables that need to be set before use.
-      <br />
- 在 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">-</span><span class="identifier">root</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code>有一个通 常的makefile (generic.mak),请参见该makefile来取得其应用的详细信息。 + environment variables that need to be set before use. <br> &#22312; <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">-</span><span class="identifier">root</span><span class="special">&gt;/</span><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">build</span></code> &#26377;&#19968;&#20010;&#36890;&#29992;&#30340;makefile + (generic.mak)&#65292;&#35831;&#21442;&#35265;&#35813;makefile&#26469;&#21462;&#24471;&#20854;&#24212;&#29992;&#30340;&#35814;&#32454;&#20449;&#24687;&#12290;
     </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/introduction_and_overview.html Thu May 27 20:09:44 2010
@@ -1,12 +1,12 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Introduction and Overview</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Introduction and Overview &#20171;&#32461;&#19982;&#25552;&#35201;</title> <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
-<link rel="prev" href="install.html" title="Building and Installing the Library"> +<link rel="prev" href="install.html" title="Building and Installing the Library &#32534;&#35793;&#21644;&#23433;&#35013;&#24211;">
 <link rel="next" href="unicode.html" title="Unicode and Boost.Regex">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -24,8 +24,8 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.introduction_and_overview"></a><a href="introduction_and_overview.html" title="Introduction and Overview">Introduction and
-    Overview</a>
+<a name="boost_regex.introduction_and_overview"></a><a class="link" href="introduction_and_overview.html" title="Introduction and Overview &#20171;&#32461;&#19982;&#25552;&#35201;"> Introduction and
+    Overview &#20171;&#32461;&#19982;&#25552;&#35201;</a>
 </h2></div></div></div>
 <p>
Regular expressions are a form of pattern-matching that are often used in text
@@ -36,26 +36,21 @@
these API's, they do not represent the best way to use the library. For example Boost.Regex can cope with wide character strings, or search and replace operations (in a manner analogous to either sed or Perl), something that traditional C
-      libraries can not do.
-      <br />
-      正则表达式是一个在文本处理中经常用到的模式匹配的形式;
- 很多用户可能对Unix的工具grep、sed、awk和Perl编程语言有所熟悉,它们每 一个都有正则表达式的扩展使用。 - 过去C++用户被局限于POSIX C API来操作正则表达式,Boost.Regex同样提供这 些API,但这些API并不是使用本库最好的方式。 - 例如Boost.Regex能够同宽字符字符串,或者搜索和替换操作(与sed或Perl类似 的方式)有效结构,
-      这些用传统的C库并不能做到。
+ libraries can not do.<br> &#27491;&#21017;&#34920;&#36798;&#24335;&#26159;&#19968;&#20010;&#22312;&#25991;&#26412;&#22788;&#29702;&#20013;&#32463;&#24120;&#29992;&#21040;&#30340;&#27169;&#24335;&#21305;&#37197;&#30340;&#24418;&#24335;&#65307;&#24456;&#22810;&#29992;&#25143;&#21487;&#33021;&#23545;Unix&#30340;&#24037;&#20855;grep&#12289;sed&#12289;awk&#21644;Perl&#32534;&#31243;&#35821;&#35328;&#26377;&#25152;&#29087;&#24713;&#65292; + &#23427;&#20204;&#27599;&#19968;&#20010;&#37117;&#26377;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#25193;&#23637;&#20351;&#29992;&#12290;&#36807;&#21435;C++&#29992;&#25143;&#34987;&#23616;&#38480;&#20110;POSIX + C API&#26469;&#25805;&#20316;&#27491;&#21017;&#34920;&#36798;&#24335;&#65292;Boost.Regex&#21516;&#26679;&#25552;&#20379;&#36825;&#20123;API&#65292; &#20294;&#36825;&#20123;API&#24182;&#19981;&#26159;&#20351;&#29992;&#26412;&#24211;&#26368;&#22909;&#30340;&#26041;&#24335;&#12290;&#20363;&#22914;Boost.Regex&#33021;&#22815;&#21516;&#23485;&#23383;&#31526;&#23383;&#31526;&#20018;&#65292;&#25110;&#32773;&#25628;&#32034;&#21644;&#26367;&#25442;&#25805;&#20316;(&#19982;sed&#25110;Perl&#31867;&#20284;&#30340;&#26041;&#24335;)&#26377;&#25928;&#32467;&#26500;&#65292; + &#36825;&#20123;&#29992;&#20256;&#32479;&#30340;C&#24211;&#24182;&#19981;&#33021;&#20570;&#21040;&#12290;
     </p>
 <p>
- The class <a href="ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a> + The class <a class="link" href="ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>
       is the key class in this library; it represents a "machine readable"
regular expression, and is very closely modeled on <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>, think of it as a string plus the actual state-machine required by the regular expression algorithms. Like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code> there are two typedefs that are almost always the means by which this class
-      is referenced:
-      <br />
- <a href="ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>类是库的关键字;它表示一 个"机器可读的"正则表达式,并且非常紧密地建模于<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>,
-    可以认为是一个字符串加上正则表达式算法需要的实际状态机。
- 类似于Like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>有两个typedef经常被使用: + is referenced:<br> <a class="link" href="ref/basic_regex.html" title="basic_regex"><code class="computeroutput"><span class="identifier">basic_regex</span></code></a>&#31867;&#26159;&#26412;&#24211;&#30340;&#20851;&#38190;&#31867;&#65307;&#23427;&#34920;&#31034;&#19968;&#20010;"&#26426;&#22120;&#21487;&#35835;&#30340;"&#27491;&#21017;&#34920;&#36798;&#24335;&#65292;&#24182;&#19988;&#38750;&#24120;&#32039;&#23494;&#22320;&#24314;&#27169;&#20110; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code>&#65292; &#21487;&#20197;&#35748;&#20026;&#26159;&#19968;&#20010;&#23383;&#31526;&#20018;&#21152;&#19978;&#27491;&#21017;&#34920;&#36798;&#24335;&#31639;&#27861;&#38656;&#35201;&#30340;&#23454;&#38469;&#29366;&#24577;&#26426;&#12290;&#19982; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code> &#30456;&#20284;&#65292;&#26377;&#20004;&#20010;typedef&#32463;&#24120;&#20250;&#34987;&#29992;&#21040;&#65306;
     </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>

@@ -80,14 +75,13 @@
and Perl shorthand for this \d (note that many older libraries tended to be hard-coded to the C-locale, consequently this was not an issue for them). That leaves us with the following regular expression to validate credit card number
-      formats:
-      <br />
-      为了展示本库如何被使用,假设我们正在开发一个信用卡处理程序。
-      信用卡号通常是16位数字的字符串,4个数字一组,用空格或连字符分隔。
- 在将卡号存入数据库之前(不是必须的,但你的客户会很高兴),我们可能需要 验证数字是正确的格式。 - 匹配任意数字,我们可以使用正则表达式[0-9],但这样的字符范围实际上是 locale相关的。 - 相反我们应该使用POSIX标准模式[[:digit:]],或者Boost.Regex和Perl的速记 \d(注意很多旧版的库是硬编码到C-locale的,所以这并不是它们的问题)。
-      下面就是我们用来验证信用卡号码格式的正则表达式:
+ formats:<br> &#20026;&#20102;&#23637;&#31034;&#26412;&#24211;&#22914;&#20309;&#34987;&#20351;&#29992;&#65292;&#20551;&#35774;&#25105;&#20204;&#27491;&#22312;&#24320;&#21457;&#19968;&#20010;&#20449;&#29992;&#21345;&#22788;&#29702;&#31243;&#24207;&#12290; + &#20449;&#29992;&#21345;&#21495;&#36890;&#24120;&#26159;16&#20301;&#25968;&#23383;&#30340;&#23383;&#31526;&#20018;&#65292;4&#20010;&#25968;&#23383;&#19968;&#32452;&#65292;&#29992;&#31354;&#26684;&#25110;&#36830;&#23383;&#31526;&#20998;&#38548;&#12290; + &#22312;&#23558;&#21345;&#21495;&#23384;&#20837;&#25968;&#25454;&#24211;&#20043;&#21069;(&#19981;&#26159;&#24517;&#39035;&#30340;&#65292;&#20294;&#20320;&#30340;&#23458;&#25143;&#20250;&#24456;&#39640;&#20852;)&#65292;&#25105;&#20204;&#21487;&#33021;&#38656;&#35201;&#39564;&#35777;&#25968;&#23383;&#26159;&#27491;&#30830;&#30340;&#26684;&#24335;&#12290; + &#21305;&#37197;&#20219;&#24847;&#25968;&#23383;&#65292;&#25105;&#20204;&#21487;&#20197;&#20351;&#29992;&#27491;&#21017;&#34920;&#36798;&#24335;[0-9]&#65292;&#20294;&#36825;&#26679;&#30340;&#23383;&#31526;&#33539;&#22260;&#23454;&#38469;&#19978;&#26159;locale&#30456;&#20851;&#30340;&#12290; + &#30456;&#21453;&#25105;&#20204;&#24212;&#35813;&#20351;&#29992;POSIX&#26631;&#20934;&#27169;&#24335;[[:digit:]]&#65292;&#25110;&#32773;Boost.Regex&#21644;Perl&#30340;&#32553;&#20889; + \d (&#27880;&#24847;&#24456;&#22810;&#26087;&#29256;&#30340;&#24211;&#26159;&#30828;&#32534;&#30721;&#21040;C-locale&#30340;&#65292;&#25152;&#20197;&#36825;&#24182;&#19981;&#26159;&#23427;&#20204;&#30340;&#38382;&#39064;)&#12290; + &#19979;&#38754;&#23601;&#26159;&#25105;&#20204;&#29992;&#26469;&#39564;&#35777;&#20449;&#29992;&#21345;&#21495;&#30721;&#26684;&#24335;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#65306;
     </p>
<pre class="programlisting">(\d{4}<span class="strikethrough"></span>){3}\d{4}</pre>
 <p>
@@ -96,17 +90,12 @@
the extended regular expression syntax used by Perl, awk and egrep. Boost.Regex
       also supports the older "basic" syntax used by sed and grep, but
this is generally less useful, unless you already have some basic regular expressions
-      that you need to reuse.
-      <br />
-      括号用来成组(为后面的引用作标记)子表达式,{4}意味着"精确重复4次"。
-      这是Perl、awk和egrep使用的扩展正则表达式语法。
- Boost.Regex同样支持sed和grep使用的旧的"基础的"语法,但这通常是用处不 大的,除非你已经有一些基础正则表达式要重用。 + that you need to reuse.<br> &#25324;&#21495;&#29992;&#26469;&#25104;&#32452;(&#20026;&#21518;&#38754;&#30340;&#24341;&#29992;&#20316;&#26631;&#35760;)&#23376;&#34920;&#36798;&#24335;&#65292;{4}&#24847;&#21619;&#30528;"&#31934;&#30830;&#37325;&#22797;4&#27425;"&#12290;&#36825;&#26159;Perl&#12289;awk&#21644;egrep&#20351;&#29992;&#30340;&#25193;&#23637;&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#12290; + Boost.Regex&#21516;&#26679;&#25903;&#25345;sed&#21644;grep&#20351;&#29992;&#30340;&#26087;&#30340;"&#22522;&#30784;&#30340;"&#35821;&#27861;&#65292;&#20294;&#36825;&#36890;&#24120;&#26159;&#29992;&#22788;&#19981;&#22823;&#30340;&#65292;&#38500;&#38750;&#20320;&#24050;&#32463;&#26377;&#19968;&#20123;&#22522;&#30784;&#27491;&#21017;&#34920;&#36798;&#24335;&#35201;&#37325;&#29992;&#12290;
     </p>
 <p>
Now let's take that expression and place it in some C++ code to validate the
-      format of a credit card number:
-      <br />
-      现在我们把这个表达式放到C++代码中来验证信用卡号码的格式:
+ format of a credit card number:<br> &#29616;&#22312;&#25105;&#20204;&#25226;&#36825;&#20010;&#34920;&#36798;&#24335;&#25918;&#21040;C++&#20195;&#30721;&#20013;&#26469;&#39564;&#35777;&#20449;&#29992;&#21345;&#21495;&#30721;&#30340;&#26684;&#24335;&#65306;
     </p>
<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">validate_card_format</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">)</span>
 <span class="special">{</span>
@@ -121,11 +110,11 @@
to be doubled up when embedding them in C/C++ code. Also note that all the examples assume that your compiler supports argument-dependent-lookup lookup, if yours doesn't (for example VC6), then you will have to add some <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span></code> prefixes
-      to some of the function calls in the examples.
-      <br />
- 注意我们需要在表达式中添加一些额外的转义字符:记住,在被正则表达式引 擎看到之前,这些转义符已经被C++编译器看到了,所以在C/C++代码中我们必须写两个 转义符。 - 同样注意所有的例子都假设你的编译器支持参数相关查找 (argument-dependent-lookup), - 如果没有(例如VC6),你需要给例子中的函数调用添加<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span></code>前缀。 + to some of the function calls in the examples.<br> &#27880;&#24847;&#25105;&#20204;&#38656;&#35201;&#22312;&#34920;&#36798;&#24335;&#20013;&#28155;&#21152;&#19968;&#20123;&#39069;&#22806;&#30340;&#36716;&#20041;&#23383;&#31526;&#65306;&#35760;&#20303;&#65292;&#22312;&#34987;&#27491;&#21017;&#34920;&#36798;&#24335;&#24341;&#25806;&#30475;&#21040;&#20043;&#21069;&#65292; + &#36825;&#20123;&#36716;&#20041;&#31526;&#24050;&#32463;&#34987;C++&#32534;&#35793;&#22120;&#30475;&#21040;&#20102;&#65292;&#25152;&#20197;&#22312;C/C++&#20195;&#30721;&#20013;&#25105;&#20204;&#24517;&#39035;&#20889;&#20004;&#20010;&#36716;&#20041;&#31526;&#12290; + &#21516;&#26679;&#27880;&#24847;&#25152;&#26377;&#30340;&#20363;&#23376;&#37117;&#20551;&#35774;&#20320;&#30340;&#32534;&#35793;&#22120;&#25903;&#25345;&#21442;&#25968;&#30456;&#20851;&#26597;&#25214;&#65292;&#22914;&#26524;&#27809;&#26377;(&#20363;&#22914;VC6)&#65292;&#20320;&#38656;&#35201;&#32473;&#20363;&#23376;&#20013;&#30340;&#20989;&#25968;&#35843;&#29992;&#28155;&#21152; + <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span></code>
+      &#21069;&#32512;&#12290;
     </p>
 <p>
Those of you who are familiar with credit card processing, will have realized
@@ -137,16 +126,14 @@
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 <a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>, for our credit card - example we can write two algorithms like this to provide the format conversions:
-      <br />
- 已经在信用卡处理程序熟悉的人们,可能会意识到上面用到的格式是适合人读 的,但并不适用于在线信息号系统用的格式;
-      那需要一个16(或15)个数字的字符串,中间没有任何空格。
-      我们需要做的是在两种格式之间轻松转换,这就是搜索和替换做的事情。
-      熟悉sed和Perl的人可能已经做到了;
- 我们需要两个字符串 - 一个正则表达式 - 另一个"格式字符串"提供要替换的 字符串。 - 在Boost.Regex中搜索和替换是通过算法<a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>实现的,
-      对于我们的信用卡例子来说,我们提供两个格式转换的算法如下:
+ and replace operation is performed with the algorithm <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>, for our credit card + example we can write two algorithms like this to provide the format conversions:<br> + &#24050;&#32463;&#22312;&#20449;&#29992;&#21345;&#22788;&#29702;&#31243;&#24207;&#29087;&#24713;&#30340;&#20154;&#20204;&#65292;&#21487;&#33021;&#20250;&#24847;&#35782;&#21040;&#19978;&#38754;&#29992;&#21040;&#30340;&#26684;&#24335;&#26159;&#36866;&#21512;&#20154;&#35835;&#30340;&#65292;&#20294;&#24182;&#19981;&#36866;&#29992;&#20110;&#22312;&#32447;&#20449;&#24687;&#21495;&#31995;&#32479;&#29992;&#30340;&#26684;&#24335;&#65307; + &#37027;&#38656;&#35201;&#19968;&#20010;16(&#25110;15)&#20010;&#25968;&#23383;&#30340;&#23383;&#31526;&#20018;&#65292;&#20013;&#38388;&#27809;&#26377;&#20219;&#20309;&#31354;&#26684;&#12290; + &#25105;&#20204;&#38656;&#35201;&#20570;&#30340;&#26159;&#22312;&#20004;&#31181;&#26684;&#24335;&#20043;&#38388;&#36731;&#26494;&#36716;&#25442;&#65292;&#36825;&#23601;&#26159;&#25628;&#32034;&#21644;&#26367;&#25442;&#20570;&#30340;&#20107;&#24773;&#12290; + &#29087;&#24713;sed&#21644;Perl&#30340;&#20154;&#21487;&#33021;&#24050;&#32463;&#20570;&#21040;&#20102;&#65307; &#25105;&#20204;&#38656;&#35201;&#20004;&#20010;&#23383;&#31526;&#20018; + - &#19968;&#20010;&#27491;&#21017;&#34920;&#36798;&#24335; - &#21478;&#19968;&#20010;"&#26684;&#24335;&#23383;&#31526;&#20018;"&#25552;&#20379;&#35201;&#26367;&#25442;&#30340;&#23383;&#31526;&#20018;&#12290; + &#22312;Boost.Regex&#20013;&#25628;&#32034;&#21644;&#26367;&#25442;&#26159;&#36890;&#36807;&#31639;&#27861; <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> &#23454;&#29616;&#30340;&#65292;&#23545;&#20110;&#25105;&#20204;&#30340;&#20449;&#29992;&#21345;&#20363;&#23376;&#26469;&#35828;&#65292;&#25105;&#20204;&#25552;&#20379;&#20004;&#20010;&#26684;&#24335;&#36716;&#25442;&#30340;&#31639;&#27861;&#22914;&#19979;&#65306;
     </p>
<pre class="programlisting"><span class="comment">// match any format with the regular expression: </span><span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex</span> <span class="identifier">e</span><span class="special">(</span><span class="string">"\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z"</span><span class="special">);</span>
@@ -166,20 +153,19 @@
 <p>
Here we've used marked sub-expressions in the regular expression to split out the four parts of the card number as separate fields, the format string then - uses the sed-like syntax to replace the matched text with the reformatted version.
-      <br />
- 这里我们通过正则表达式中被标记的子表达式来将卡号分成四部分,然后格式 字符串使用类sed语法将匹配的文本替换为新的。 + uses the sed-like syntax to replace the matched text with the reformatted version.<br> + &#36825;&#37324;&#25105;&#20204;&#36890;&#36807;&#27491;&#21017;&#34920;&#36798;&#24335;&#20013;&#34987;&#26631;&#35760;&#30340;&#23376;&#34920;&#36798;&#24335;&#26469;&#23558;&#21345;&#21495;&#20998;&#25104;&#22235;&#37096;&#20998;&#65292;&#28982;&#21518;&#26684;&#24335;&#23383;&#31526;&#20018;&#20351;&#29992;&#31867;sed&#35821;&#27861;&#23558;&#21305;&#37197;&#30340;&#25991;&#26412;&#26367;&#25442;&#20026;&#26032;&#30340;&#12290;
     </p>
 <p>
In the examples above, we haven't directly manipulated the results of a regular 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 <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>,
-      as before there are typedefs of this class for the most common cases:
-      <br />
- 在上面的例子中,我们没有直接操纵正则表达式匹配的结果,但一般来讲,匹 配结果除了包含整个匹配,还包含匹配的子表达式的数量。 - 本库用类<a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>的实例来报告正则表达式的匹 配,就像之前一样,我们也定义最常用情况的typedef: + the class <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>, + as before there are typedefs of this class for the most common cases:<br> + &#22312;&#19978;&#38754;&#30340;&#20363;&#23376;&#20013;&#65292;&#25105;&#20204;&#27809;&#26377;&#30452;&#25509;&#25805;&#32437;&#27491;&#21017;&#34920;&#36798;&#24335;&#21305;&#37197;&#30340;&#32467;&#26524;&#65292;&#20294;&#19968;&#33324;&#26469;&#35762;&#65292;&#21305;&#37197;&#32467;&#26524;&#38500;&#20102;&#21253;&#21547;&#25972;&#20010;&#21305;&#37197;&#65292;&#36824;&#21253;&#21547;&#21305;&#37197;&#30340;&#23376;&#34920;&#36798;&#24335;&#30340;&#25968;&#37327;&#12290; + &#26412;&#24211;&#29992;&#31867; <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + &#30340;&#23454;&#20363;&#26469;&#25253;&#21578;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#21305;&#37197;&#65292;&#23601;&#20687;&#20043;&#21069;&#19968;&#26679;&#65292;&#25105;&#20204;&#20063;&#23450;&#20041;&#26368;&#24120;&#29992;&#24773;&#20917;&#30340;typedef&#65306;
     </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>

@@ -191,79 +177,75 @@
 <span class="special">}</span>
 </pre>
 <p>
- The algorithms <a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> - and <a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> - make use of <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> - to report what matched; the difference between these algorithms is that <a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> + The algorithms <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + and <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> + make use of <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + to report what matched; the difference between these algorithms is that <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> will only find matches that consume <span class="emphasis"><em>all</em></span> of the input text, - where as <a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>
-      will search for a match anywhere within the text being matched.
-      <br />
- 算法<a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>和<a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>使用<a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>来报告匹配了什么; - 这两个算法的差别在于<a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>只匹配消费了<span class="emphasis"><em>所有</em></span>输出文本的情况, - 而<a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>搜索文本任何被匹配的地方。 + where as <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + will search for a match anywhere within the text being matched.<br> &#31639;&#27861; + <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + &#21644; <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> + &#20351;&#29992; <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + &#26469;&#25253;&#21578;&#21305;&#37197;&#20102;&#20160;&#20040;&#65307; &#36825;&#20004;&#20010;&#31639;&#27861;&#30340;&#24046;&#21035;&#22312;&#20110; <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> &#21482;&#21305;&#37197;&#28040;&#36153;&#20102;&#25152;&#26377;&#36755;&#20986;&#25991;&#26412;&#30340;&#24773;&#20917;&#65292;&#32780; + <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + &#25628;&#32034;&#25991;&#26412;&#20219;&#20309;&#34987;&#21305;&#37197;&#30340;&#22320;&#26041;&#12290;
     </p>
 <p>
Note that these algorithms are not restricted to searching regular C-strings, any bidirectional iterator type can be searched, allowing for the possibility
-      of seamlessly searching almost any kind of data.
-      <br />
- 注意这些算法并不只局限于正常的C-字符串,任意双向迭代器类型都可以被搜 索,提供了对任意类型数据进行无缝搜索的可能性。 + of seamlessly searching almost any kind of data.<br> &#27880;&#24847;&#36825;&#20123;&#31639;&#27861;&#24182;&#19981;&#21482;&#23616;&#38480;&#20110;&#27491;&#24120;&#30340;C-&#23383;&#31526;&#20018;&#65292;&#20219;&#24847;&#21452;&#21521;&#36845;&#20195;&#22120;&#31867;&#22411;&#37117;&#21487;&#20197;&#34987;&#25628;&#32034;&#65292;&#25552;&#20379;&#20102;&#23545;&#20219;&#24847;&#31867;&#22411;&#25968;&#25454;&#36827;&#34892;&#26080;&#32541;&#25628;&#32034;&#30340;&#21487;&#33021;&#24615;&#12290;
     </p>
 <p>
- For search and replace operations, in addition to the algorithm <a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> that we have already - seen, the <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + For search and replace operations, in addition to the algorithm <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> that we have already + seen, the <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> class has a <code class="computeroutput"><span class="identifier">format</span></code> member that takes the result of a match and a format string, and produces a new string
-      by merging the two.
-      <br />
- 对于搜索和替换操作,对于我们已经看到的<a href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>算法,类<a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>有一个成员<code class="computeroutput"><span class="identifier">format</span></code>,包含了 一个匹配结果和格式字符串,并通过合并这两者生成一个新的字符串。 + by merging the two.<br> &#23545;&#20110;&#25628;&#32034;&#21644;&#26367;&#25442;&#25805;&#20316;&#65292;&#23545;&#20110;&#25105;&#20204;&#24050;&#32463;&#30475;&#21040;&#30340; + <a class="link" href="ref/regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> + &#31639;&#27861;&#65292;&#31867; <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + &#26377;&#19968;&#20010;&#25104;&#21592; <code class="computeroutput"><span class="identifier">format</span></code>&#65292; &#21253;&#21547;&#20102;&#19968;&#20010;&#21305;&#37197;&#32467;&#26524;&#21644;&#26684;&#24335;&#23383;&#31526;&#20018;&#65292;&#24182;&#36890;&#36807;&#21512;&#24182;&#36825;&#20004;&#32773;&#29983;&#25104;&#19968;&#20010;&#26032;&#30340;&#23383;&#31526;&#20018;&#12290;
     </p>
 <p>
For iterating through all occurences of an expression within a text, there - are two iterator types: <a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a> will enumerate over - the <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> - objects found, while <a href="ref/regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a> will enumerate
-      a series of strings (similar to perl style split operations).
-      <br />
- 如果要迭代一个文本内对于一个表达式的所有出现(occurrence),有两种迭代 器类型: - <a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>会枚举所有找到的 <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>对象, - <a href="ref/regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a>会枚举一系列字符串 (类似于perl风格的split操作)。 + are two iterator types: <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a> will enumerate over + the <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> + objects found, while <a class="link" href="ref/regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a> will enumerate + a series of strings (similar to perl style split operations).<br> &#22914;&#26524;&#35201;&#36845;&#20195;&#19968;&#20010;&#25991;&#26412;&#20869;&#23545;&#20110;&#19968;&#20010;&#34920;&#36798;&#24335;&#30340;&#25152;&#26377;&#20986;&#29616;&#65292;&#26377;&#20004;&#31181;&#36845;&#20195;&#22120;&#31867;&#22411;&#65306; + <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a> + &#20250;&#26522;&#20030;&#25152;&#26377;&#25214;&#21040;&#30340; match_results&#23545;&#35937;&#65292;&#32780; <a class="link" href="ref/regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a> &#20250;&#26522;&#20030;&#19968;&#31995;&#21015;&#23383;&#31526;&#20018;(&#31867;&#20284;&#20110;perl&#39118;&#26684;&#30340;split&#25805;&#20316;)&#12290;
     </p>
 <p>
- For those that dislike templates, there is a high level wrapper class <a href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated)"><code class="computeroutput"><span class="identifier">RegEx</span></code></a> + For those that dislike templates, there is a high level wrapper class <a class="link" href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated) &#39640;&#32423;&#31867;RegEx"><code class="computeroutput"><span class="identifier">RegEx</span></code></a> 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.
This class is now deprecated as it does not form part of the regular expressions
-      C++ standard library proposal.
-      <br />
- 对于不喜欢模板的,有一个高层次的外覆类<a href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated)"><code class="computeroutput"><span class="identifier">RegEx</span></code></a>封装了低层次的模板代码 - - 它为不需要本库全部功能的人提供了一个简化的接口,并只支持窄字符和"扩 展的"正则表达式语法。 - 这个类现在已经不被赞成使用了,并且它也不是C++标准库正则表达式提议的一 部分。 + C++ standard library proposal.<br> &#23545;&#20110;&#19981;&#21916;&#27426;&#27169;&#26495;&#30340;&#65292;&#26377;&#19968;&#20010;&#39640;&#23618;&#27425;&#30340;&#22806;&#35206;&#31867; + <a class="link" href="ref/deprecated_interfaces/old_regex.html" title="High Level Class RegEx (Deprecated) &#39640;&#32423;&#31867;RegEx"><code class="computeroutput"><span class="identifier">RegEx</span></code></a> &#23553;&#35013;&#20102;&#20302;&#23618;&#27425;&#30340;&#27169;&#26495;&#20195;&#30721; + - &#23427;&#20026;&#19981;&#38656;&#35201;&#26412;&#24211;&#20840;&#37096;&#21151;&#33021;&#30340;&#20154;&#25552;&#20379;&#20102;&#19968;&#20010;&#31616;&#21270;&#30340;&#25509;&#21475;&#65292;&#24182;&#21482;&#25903;&#25345;&#31364;&#23383;&#31526;&#21644;"&#25193;&#23637;&#30340;"&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;&#12290; + &#36825;&#20010;&#31867;&#29616;&#22312;&#24050;&#32463;&#19981;&#34987;&#36190;&#25104;&#20351;&#29992;&#20102;&#65292;&#24182;&#19988;&#23427;&#20063;&#19981;&#26159;C++&#26631;&#20934;&#24211;&#27491;&#21017;&#34920;&#36798;&#24335;&#25552;&#35758;&#30340;&#19968;&#37096;&#20998;&#12290;
     </p>
 <p>
- The POSIX API functions: <a href="ref/posix.html#boost_regex.ref.posix.regcomp"><code class="computeroutput"><span class="identifier">regcomp</span></code></a>, <a href="ref/posix.html#boost_regex.ref.posix.regexec"><code class="computeroutput"><span class="identifier">regexec</span></code></a>, <a href="ref/posix.html#boost_regex.ref.posix.regfree"><code class="computeroutput"><span class="identifier">regfree</span></code></a> and [regerr], are available + The POSIX API functions: <a class="link" href="ref/posix.html#boost_regex.ref.posix.regcomp"><code class="computeroutput"><span class="identifier">regcomp</span></code></a>, <a class="link" href="ref/posix.html#boost_regex.ref.posix.regexec"><code class="computeroutput"><span class="identifier">regexec</span></code></a>, <a class="link" href="ref/posix.html#boost_regex.ref.posix.regfree"><code class="computeroutput"><span class="identifier">regfree</span></code></a> and [regerr], are available in both narrow character and Unicode versions, and are provided for those who
-      need compatibility with these API's.
-      <br />
- POSIX API函数:<a href="ref/posix.html#boost_regex.ref.posix.regcomp"><code class="computeroutput"><span class="identifier">regcomp</span></code></a>, <a href="ref/posix.html#boost_regex.ref.posix.regexec"><code class="computeroutput"><span class="identifier">regexec</span></code></a>, <a href="ref/posix.html#boost_regex.ref.posix.regfree"><code class="computeroutput"><span class="identifier">regfree</span></code></a>和 [regerr]同时支持窄字符和Unicode,并且与这些API兼容。 + need compatibility with these API's.<br> POSIX API&#20989;&#25968;&#65306; <a class="link" href="ref/posix.html#boost_regex.ref.posix.regcomp"><code class="computeroutput"><span class="identifier">regcomp</span></code></a>, <a class="link" href="ref/posix.html#boost_regex.ref.posix.regexec"><code class="computeroutput"><span class="identifier">regexec</span></code></a>, <a class="link" href="ref/posix.html#boost_regex.ref.posix.regfree"><code class="computeroutput"><span class="identifier">regfree</span></code></a> &#21644; [regerr] &#21516;&#26102;&#25903;&#25345;&#31364;&#23383;&#31526;&#21644;Unicode&#65292;&#24182;&#19988;&#19982;&#36825;&#20123;API&#20860;&#23481;&#12290;
     </p>
 <p>
- Finally, note that the library now has <a href="background_information/locale.html" title="Localization">run-time + Finally, note that the library now has <a class="link" href="background_information/locale.html" title="Localization &#26412;&#22320;&#21270;">run-time localization support</a>, 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 expression libraries including GNU and BSD4 regex packages, PCRE and Perl 5.
-      <br />
- 注意,本库现在有<a href="background_information/locale.html" title="Localization">运行时本地化支持(run-time localization support)</a>,并 且识别全部POSIX正则表达式语法 - - 包括像多字符的对照元素(collating element)和等价类(equivalence classes)这样的高级特性 - - 并提供与其它正则表达式库如GNU、BSD4 regex packages、PCRE、Perl 5的 兼容性。 + <br> &#27880;&#24847;&#65292;&#26412;&#24211;&#29616;&#22312;&#26377; <a class="link" href="background_information/locale.html" title="Localization &#26412;&#22320;&#21270;">&#36816;&#34892;&#26102;&#26412;&#22320;&#21270;&#25903;&#25345;</a>&#65292; + &#24182;&#19988;&#35782;&#21035;&#20840;&#37096;POSIX&#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861; - &#21253;&#25324;&#20687;&#22810;&#23383;&#31526;&#30340;&#23545;&#29031;&#20803;&#32032;(collating + element)&#21644;&#31561;&#20215;&#31867;(equivalence classes)&#36825;&#26679;&#30340;&#39640;&#32423;&#29305;&#24615; - &#24182;&#25552;&#20379;&#19982;&#20854;&#23427;&#27491;&#21017;&#34920;&#36798;&#24335;&#24211;&#22914;GNU&#12289;BSD4 + regex packages&#12289;PCRE&#12289;Perl 5&#30340;&#20860;&#23481;&#24615;&#12290;
     </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/partial_matches.html Sun Oct 5 19:30:35 2008 +++ /trunk/libs/regex/doc/html/boost_regex/partial_matches.html Thu May 27 20:09:44 2010
@@ -1,13 +1,13 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Partial Matches</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Partial Matches &#37096;&#20998;&#21305;&#37197;</title>
<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../index.html" title="Boost.Regex">
 <link rel="up" href="../index.html" title="Boost.Regex">
-<link rel="prev" href="captures.html" title="Understanding Marked Sub-Expressions and Captures">
-<link rel="next" href="syntax.html" title="Regular Expression Syntax">
+<link rel="prev" href="captures.html" title="Understanding Marked Sub-Expressions and Captures &#29702;&#35299;&#34987;&#26631;&#35760;&#23376;&#34920;&#36798;&#24335;&#21644;&#25429;&#25417;"> +<link rel="next" href="syntax.html" title="Regular Expression Syntax &#27491;&#21017;&#34920;&#36798;&#24335;&#35821;&#27861;">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -24,13 +24,13 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_regex.partial_matches"></a><a href="partial_matches.html" title="Partial Matches"> Partial Matches</a> +<a name="boost_regex.partial_matches"></a><a class="link" href="partial_matches.html" title="Partial Matches &#37096;&#20998;&#21305;&#37197;"> Partial Matches &#37096;&#20998;&#21305;&#37197;</a>
 </h2></div></div></div>
 <p>
- The <a href="ref/match_flag_type.html" title="match_flag_type"><code class="computeroutput"><span class="identifier">match_flag_type</span></code></a> + The <a class="link" href="ref/match_flag_type.html" title="match_flag_type"><code class="computeroutput"><span class="identifier">match_flag_type</span></code></a> <code class="computeroutput"><span class="identifier">match_partial</span></code> can be passed - to the following algorithms: <a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, <a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, and <a href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>, and used with the iterator - <a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>. + to the following algorithms: <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, and <a class="link" href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>, and used with the iterator + <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>. 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,16 +40,14 @@
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 <a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> as filled in by <a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, - <a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> - or <a href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>):
-      <br />
- <a href="ref/match_flag_type.html" title="match_flag_type"><code class="computeroutput"><span class="identifier">match_flag_type</span></code></a> <code class="computeroutput"><span class="identifier">match_partial</span></code>可以被传入如下算法:<a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>、<a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>和<a href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>还有迭代器<a href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>。
-      这意味着部分匹配和完全匹配同样被寻找。
- 部分匹配是指在输出文本的结尾时匹配一个或多个字符,但并不匹配完整的正 则表达式(可能有更多输入时可以做到)。
-      部分匹配典型地被应用于验证数据输入(当从键盘键入时检查每个字符),
- 或在过长(不能调入内存,甚至映射文件)或不定长(例如socket源或类似)的文 本中搜索。 - 部分匹配和完全匹配的差别在下面的表格中显示(变量M代表在<a href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>、<a href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>或<a href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>中填充的<a href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a>实例): + an instance of <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> as filled in by <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, + <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> + or <a class="link" href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a>):<br> <a class="link" href="ref/match_flag_type.html" title="match_flag_type"><code class="computeroutput"><span class="identifier">match_flag_type</span></code></a> <code class="computeroutput"><span class="identifier">match_partial</span></code> + &#21487;&#20197;&#34987;&#20256;&#20837;&#22914;&#19979;&#31639;&#27861;&#65306; <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, &#21644; <a class="link" href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a> &#36824;&#26377;&#36845;&#20195;&#22120; <a class="link" href="ref/regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a>&#12290; &#36825;&#24847;&#21619;&#30528;&#37096;&#20998;&#21305;&#37197;&#21644;&#23436;&#20840;&#21305;&#37197;&#21516;&#26679;&#34987;&#23547;&#25214;&#12290; + &#37096;&#20998;&#21305;&#37197;&#26159;&#25351;&#22312;&#36755;&#20986;&#25991;&#26412;&#30340;&#32467;&#23614;&#26102;&#21305;&#37197;&#19968;&#20010;&#25110;&#22810;&#20010;&#23383;&#31526;&#65292;&#20294;&#24182;&#19981;&#21305;&#37197;&#23436;&#25972;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;(&#21487;&#33021;&#26377;&#26356;&#22810;&#36755;&#20837;&#26102;&#21487;&#20197;&#20570;&#21040;)&#12290; + &#37096;&#20998;&#21305;&#37197;&#20856;&#22411;&#22320;&#34987;&#24212;&#29992;&#20110;&#39564;&#35777;&#25968;&#25454;&#36755;&#20837;(&#24403;&#20174;&#38190;&#30424;&#38190;&#20837;&#26102;&#26816;&#26597;&#27599;&#20010;&#23383;&#31526;)&#65292;&#25110;&#22312;&#36807;&#38271;(&#19981;&#33021;&#35843;&#20837;&#20869;&#23384;&#65292;&#29978;&#33267;&#26144;&#23556;&#25991;&#20214;) + &#25110;&#19981;&#23450;&#38271;(&#20363;&#22914;socket&#28304;&#25110;&#31867;&#20284;)&#30340;&#25991;&#26412;&#20013;&#25628;&#32034;&#12290;&#37096;&#20998;&#21305;&#37197;&#21644;&#23436;&#20840;&#21305;&#37197;&#30340;&#24046;&#21035;&#22312;&#19979;&#38754;&#30340;&#34920;&#26684;&#20013;&#26174;&#31034; + (&#21464;&#37327;M&#20195;&#34920;&#22312; <a class="link" href="ref/regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, <a class="link" href="ref/regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> &#25110; <a class="link" href="ref/deprecated_interfaces/regex_grep.html" title="regex_grep (Deprecated)"><code class="computeroutput"><span class="identifier">regex_grep</span></code></a> &#20013;&#22635;&#20805;&#30340; <a class="link" href="ref/match_results.html" title="match_results"><code class="computeroutput"><span class="identifier">match_results</span></code></a> &#23454;&#20363;)&#65306;
     </p>
 <div class="informaltable"><table class="table">
 <colgroup>
@@ -66,7 +64,7 @@
             </th>
 <th>
             <p>
-              Result
+              Result &#32467;&#26524;
             </p>
             </th>
 <th>
@@ -89,7 +87,7 @@
 <tr>
 <td>
             <p>
-              No match
+              No match<br> &#19981;&#21305;&#37197;
             </p>
             </td>
 <td>
@@ -99,24 +97,24 @@
             </td>
 <td>
             <p>
-              Undefined
+              Undefined<br> &#26080;&#23450;&#20041;
             </p>
             </td>
 <td>
             <p>
-              Undefined
+              Undefined<br> &#26080;&#23450;&#20041;
             </p>
             </td>
 <td>
             <p>
-              Undefined
+              Undefined<br> &#26080;&#23450;&#20041;
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
-              Partial match
+              Partial match<br> &#37096;&#20998;&#21305;&#37197;
             </p>
             </td>
 <td>
@@ -131,19 +129,19 @@
             </td>
 <td>
             <p>
-              Start of partial match.
+ Start of partial match.<br> &#37096;&#20998;&#21305;&#37197;&#30340;&#24320;&#22987;&#12290;
             </p>
             </td>
 <td>
             <p>
-              End of partial match (end of text).
+ End of partial match (end of text).<br> &#37096;&#20998;&#21305;&#37197;&#30340;&#32467;&#26463;&#12290;
             </p>
             </td>
 </tr>
 <tr>
 <td>
             <p>
-              Full match
+              Full match<br> &#20840;&#21305;&#37197;
             </p>
             </td>
 <td>
@@ -158,12 +156,12 @@
             </td>
 <td>
             <p>
-              Start of full match.
+ Start of full match.<br> &#20840;&#21305;&#37197;&#30340;&#24320;&#22987;&#12290;
             </p>
             </td>
 <td>
             <p>
-              End of full match.
+ End of full match.<br> &#20840;&#21305;&#37197;&#30340;&#32467;&#26463;&#12290;
             </p>
             </td>
 </tr>
@@ -171,30 +169,25 @@
 </table></div>
 <p>
Be aware that using partial matches can sometimes result in somewhat imperfect
-      behavior:
-      <br />
-      注意使用部分匹配有时会导致不完美的行为:
+ behavior:<br> &#27880;&#24847;&#20351;&#29992;&#37096;&#20998;&#21305;&#37197;&#26377;&#26102;&#20250;&#23548;&#33268;&#19981;&#23436;&#32654;&#30340;&#34892;&#20026;&#65306;
     </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
There are some expressions, such as ".*abc" that will always produce a partial match. This problem can be reduced by careful construction of the regular expressions used, or by setting flags like match_not_dot_newline
-        so that expressions like .* can't match past line boundaries.
-        <br />
-        有一些表达式,例如".*abc"总会生成部分匹配。
- 这个问题可以通过小心地构造使用的正则表达式,或者设置如 match_not_dot_newline的标记使得.*这样的表达式不会匹配超过行边界,来解决。 + so that expressions like .* can't match past line boundaries.<br> &#26377;&#19968;&#20123;&#34920;&#36798;&#24335;&#65292;&#20363;&#22914;".*abc"&#24635;&#20250;&#29983;&#25104;&#37096;&#20998;&#21305;&#37197;&#12290; + &#36825;&#20010;&#38382;&#39064;&#21487;&#20197;&#36890;&#36807;&#23567;&#24515;&#22320;&#26500;&#36896;&#20351;&#29992;&#30340;&#27491;&#21017;&#34920;&#36798;&#24335;&#65292; &#25110;&#32773;&#35774;&#32622;&#22914; + match_not_dot_newline &#30340;&#26631;&#35760;&#20351;&#24471;.*&#36825;&#26679;&#30340;&#34920;&#36798;&#24335;&#19981;&#20250;&#21305;&#37197;&#36229;&#36807;&#34892;&#36793;&#30028;&#65292;&#26469;&#35299;&#20915;&#12290;
       </li>
 <li>
Boost.Regex currently prefers leftmost matches to full matches, so for example
         matching "abc|b" against "ab" produces a partial match
         against the "ab" rather than a full match against "b".
It's more efficient to work this way, but may not be the behavior you want
-        in all situations.
-        <br />
-        Boost.Regex对于完全匹配总是使用最左匹配(leftmost match),
-        所以对于如"abc|b"应用于"ab"会导致部分匹配"ab"而不是完全匹配"b"。
-        这种方式工作很有效,但可能不是所有情况都适用。
+ in all situations.<br> Boost.Regex&#23545;&#20110;&#23436;&#20840;&#21305;&#37197;&#24635;&#26159;&#20351;&#29992;&#26368;&#24038;&#21305;&#37197;(leftmost + match)&#65292;&#25152;&#20197;&#23545;&#20110;&#22914;"abc| b"&#24212;&#29992;&#20110;"ab"&#20250;&#23548;&#33268;&#37096;&#20998;&#21305;&#37197;"ab"&#32780;&#19981;&#26159;&#23436;&#20840;&#21305;&#37197;"b"&#12290; + &#36825;&#31181;&#26041;&#24335;&#24037;&#20316;&#24456;&#26377;&#25928;&#65292;&#20294;&#21487;&#33021;&#19981;&#26159;&#25152;&#26377;&#24773;&#20917;&#37117;&#36866;&#29992;&#12290;
       </li>
 </ul></div>
 <p>
@@ -206,13 +199,12 @@
yet a valid card number, but could be with more input, so the user interface would disable the OK button. Finally, if the procedure throws an exception the input could never become a valid number, and the inputted character must
-      be discarded, and a suitable error indication displayed to the user.
-      <br />
-      下面的例子用来测试文本是否是有效的信用卡号码,当用户按键时,
- 键入的字符被加入到生成的字符串中,并传入<code class="computeroutput"><span class="identifier">is_possible_card_number</span></code>。
-      如果返回true说明文本是有效的卡号,这样用户界面的OK按钮可以被按下。
- 如果返回false说明不是有效的卡号,但可以有更多输入,那么用户界面的OK按 钮就被禁用。 - 最后,如果过程扔出异常,输出不可能成为一个有效的卡号,并且输入的字符 将被扔掉,并且适当的错误提示会显示给用户。 + be discarded, and a suitable error indication displayed to the user.<br> + &#19979;&#38754;&#30340;&#20363;&#23376;&#29992;&#26469;&#27979;&#35797;&#25991;&#26412;&#26159;&#21542;&#26159;&#26377;&#25928;&#30340;&#20449;&#29992;&#21345;&#21495;&#30721;&#65292;&#24403;&#29992;&#25143;&#25353;&#38190;&#26102;&#65292;&#38190;&#20837;&#30340;&#23383;&#31526;&#34987;&#21152;&#20837;&#21040;&#29983;&#25104;&#30340;&#23383;&#31526;&#20018;&#20013;&#65292;&#24182;&#20256;&#20837; + <code class="computeroutput"><span class="identifier">is_possible_card_number</span></code>&#12290; + &#22914;&#26524;&#36820;&#22238;true&#35828;&#26126;&#25991;&#26412;&#26159;&#26377;&#25928;&#30340;&#21345;&#21495;&#65292;&#36825;&#26679;&#29992;&#25143;&#30028;&#38754;&#30340;OK&#25353;&#38062;&#21487;&#20197;&#34987;&#25353;&#19979;&#12290; + &#22914;&#26524;&#36820;&#22238;false&#35828;&#26126;&#19981;&#26159;&#26377;&#25928;&#30340;&#21345;&#21495;&#65292;&#20294;&#21487;&#20197;&#26377;&#26356;&#22810;&#36755;&#20837;&#65292;&#37027;&#20040;&#29992;&#25143;&#30028;&#38754;&#30340;OK&#25353;&#38062;&#23601;&#34987;&#31105;&#29992;&#12290; + &#26368;&#21518;&#65292;&#22914;&#26524;&#36807;&#31243;&#25172;&#20986;&#24322;&#24120;&#65292;&#36755;&#20986;&#19981;&#21487;&#33021;&#25104;&#20026;&#19968;&#20010;&#26377;&#25928;&#30340;&#21345;&#21495;&#65292;&#24182;&#19988;&#36755;&#20837;&#30340;&#23383;&#31526;&#23558;&#34987;&#25172;&#25481;&#65292;&#24182;&#19988;&#36866;&#24403;&#30340;&#38169;&#35823;&#25552;&#31034;&#20250;&#26174;&#31034;&#32473;&#29992;&#25143;&#12290;
     </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
@@ -247,10 +239,8 @@
amount of text; this example simply counts the number of html tags encountered in the stream. The text is loaded into a buffer and searched a part at a time, if a partial match was encountered, then the partial match gets searched a
-      second time as the start of the next batch of text:
-      <br />
- 在下面的例子中,文本从流中输入,大小未知;这个例子简单地记录流中遇到 html标签的次数。 - 文本被调入缓存,每次搜索一部分,如果遇到一个部分匹配,那么在下一批文 本的开始处进行第2次部分匹配: + second time as the start of the next batch of text:<br> &#22312;&#19979;&#38754;&#30340;&#20363;&#23376;&#20013;&#65292;&#25991;&#26412;&#20174;&#27969;&#20013;&#36755;&#20837;&#65292;&#22823;&#23567;&#26410;&#30693;&#65307;&#36825;&#20010;&#20363;&#23376;&#31616;&#21333;&#22320;&#35760;&#24405;&#27969;&#20013;&#36935;&#21040;html&#26631;&#31614;&#30340;&#27425;&#25968;&#12290; + &#25991;&#26412;&#34987;&#35843;&#20837;&#32531;&#23384;&#65292;&#27599;&#27425;&#25628;&#32034;&#19968;&#37096;&#20998;&#65292;&#22914;&#26524;&#36935;&#21040;&#19968;&#20010;&#37096;&#20998;&#21305;&#37197;&#65292;&#37027;&#20040;&#22312;&#19979;&#19968;&#25209;&#25991;&#26412;&#30340;&#24320;&#22987;&#22788;&#36827;&#34892;&#31532;2&#27425;&#37096;&#20998;&#21305;&#37197;&#65306;
     </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">fstream</span><span class="special">&gt;</span>
@@ -318,7 +308,7 @@
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html Sun Oct 12 23:27:05 2008 +++ /trunk/libs/regex/doc/html/boost_regex/ref/bad_expression.html Thu May 27 20:09:44 2010
@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>bad_expression</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../ref.html" title="Reference">
+<link rel="up" href="../ref.html" title="Reference &#21442;&#32771;&#25163;&#20876;"> <link rel="prev" href="regex_token_iterator.html" title="regex_token_iterator">
 <link rel="next" href="syntax_option_type.html" title="syntax_option_type">
 </head>
@@ -24,11 +24,11 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.ref.bad_expression"></a><a href="bad_expression.html" title="bad_expression"> bad_expression</a> +<a name="boost_regex.ref.bad_expression"></a><a class="link" href="bad_expression.html" title="bad_expression"> bad_expression</a>
 </h3></div></div></div>
-<a name="boost_regex.ref.bad_expression.synopsis"></a><h5>
-<a name="id606153"></a>
- <a href="bad_expression.html#boost_regex.ref.bad_expression.synopsis">Synopsis</a>
+<a name="boost_regex.ref.bad_expression.synopsis_______"></a><h5>
+<a name="id4978489"></a>
+ <a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.synopsis_______">Synopsis &#27010;&#35201;</a>
       </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">pattern_except</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 </pre>
@@ -36,8 +36,7 @@
The class <code class="computeroutput"><span class="identifier">regex_error</span></code> 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.
-        <br />
- 类<code class="computeroutput"><span class="identifier">regex_error</span></code>定义了在将正则表达式字符串转换到 有限状态机过程中出现错误时扔出的异常类型。 + <br> &#31867; <code class="computeroutput"><span class="identifier">regex_error</span></code> &#23450;&#20041;&#20102;&#22312;&#23558;&#27491;&#21017;&#34920;&#36798;&#24335;&#23383;&#31526;&#20018;&#36716;&#25442;&#21040;&#26377;&#38480;&#29366;&#24577;&#26426;&#36807;&#31243;&#20013;&#20986;&#29616;&#38169;&#35823;&#26102;&#25172;&#20986;&#30340;&#24322;&#24120;&#31867;&#22411;&#12290;
       </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>

@@ -55,27 +54,30 @@
 </span>
 <span class="special">}</span> <span class="comment">// namespace boost
 </span></pre>
-<a name="boost_regex.ref.bad_expression.description"></a><h5>
-<a name="id606656"></a>
- <a href="bad_expression.html#boost_regex.ref.bad_expression.description">Description</a>
+<a name="boost_regex.ref.bad_expression.description_______"></a><h5>
+<a name="id4978960"></a>
+ <a class="link" href="bad_expression.html#boost_regex.ref.bad_expression.description_______">Description
+        &#35828;&#26126;</a>
       </h5>
<pre class="programlisting"><span class="identifier">regex_error</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">error_type</span> <span class="identifier">err</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">pos</span><span class="special">);</span> <span class="identifier">regex_error</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">error_type</span> <span class="identifier">err</span><span class="special">);</span>
 </pre>
 <p>
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of class regex_error. + <span class="bold"><strong>Effects:</strong></span> Constructs an object of class regex_error.<br> + <span class="bold"><strong>&#25928;&#26524;</strong></span>&#65306;&#26500;&#36896;&#19968;&#20010; <code class="computeroutput"><span class="identifier">regex_error</span></code>
+        &#31867;&#30340;&#23545;&#35937;&#12290;
       </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">error_type</span> <span class="identifier">code</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
 </pre>
 <p>
<span class="bold"><strong>Effects:</strong></span> returns the error code that represents
-        parsing error that occurred.
+ parsing error that occurred.<br> <span class="bold"><strong>&#25928;&#26524;</strong></span>&#65306;&#36820;&#22238;&#34920;&#31034;&#25152;&#21457;&#29983;&#30340;&#20998;&#26512;&#38169;&#35823;&#30340;&#38169;&#35823;&#20195;&#30721;&#12290;
       </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">position</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
 </pre>
 <p>
<span class="bold"><strong>Effects:</strong></span> returns the location in the expression
-        where parsing stopped.
+ where parsing stopped.<br> <span class="bold"><strong>&#25928;&#26524;</strong></span>&#65306;&#36820;&#22238;&#34920;&#36798;&#24335;&#20013;&#20572;&#27490;&#20998;&#26512;&#30340;&#20301;&#32622;&#12290;
       </p>
 <p>
Footnotes: the choice of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
@@ -86,18 +88,19 @@
and <code class="computeroutput"><span class="identifier">bad_expression</span></code> for errors, these have been replaced by the single class <code class="computeroutput"><span class="identifier">regex_error</span></code> to keep the library in synchronization with the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical
-        Report on C++ Library Extensions</a>.
-        <br />
- 脚注:将<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>作为<code class="computeroutput"><span class="identifier">regex_error</span></code>的 基类是无实际意义的; - 依赖于库如何被使用,异常可能是逻辑错误(程序员提供的表达式)或运行时 错误(用户提供的表达式)。 - 库之前使用<code class="computeroutput"><span class="identifier">bad_pattern</span></code>和<code class="computeroutput"><span class="identifier">bad_expression</span></code>用于错误, - 现在已经被替换为单个类<code class="computeroutput"><span class="identifier">regex_error</span></code>, - 保持与<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical Report on C++ Library Extensions</a>的库一致。 + Report on C++ Library Extensions</a>.<br> &#33050;&#27880;&#65306;&#23558; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> + &#20316;&#20026; <code class="computeroutput"><span class="identifier">regex_error</span></code> &#30340;&#22522;&#31867;&#26159;&#26080;&#23454;&#38469;&#24847;&#20041;&#30340;&#65307; + &#20381;&#36182;&#20110;&#24211;&#22914;&#20309;&#34987;&#20351;&#29992;&#65292;&#24322;&#24120;&#21487;&#33021;&#26159;&#36923;&#36753;&#38169;&#35823;(&#31243;&#24207;&#21592;&#25552;&#20379;&#30340;&#34920;&#36798;&#24335;)&#25110;&#36816;&#34892;&#26102;&#38169;&#35823;(&#29992;&#25143;&#25552;&#20379;&#30340;&#34920;&#36798;&#24335;)&#12290; + &#24211;&#20043;&#21069;&#20351;&#29992; <code class="computeroutput"><span class="identifier">bad_pattern</span></code> + &#21644; <code class="computeroutput"><span class="identifier">bad_expression</span></code> &#29992;&#20110;&#38169;&#35823;&#65292;&#29616;&#22312;&#24050;&#32463;&#34987;&#26367;&#25442;&#20026;&#21333;&#20010;&#31867; + <code class="computeroutput"><span class="identifier">regex_error</span></code>&#65292; &#20445;&#25345;&#26412;&#24211;&#19982; + <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf"; target="_top">Technical
+        Report on C++ Library Extensions</a> &#21516;&#27493;&#12290;
       </p>
 </div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 1998 -2007 John Maddock<p> +<td align="right"><div class="copyright-footer">Copyright &#169; 1998 -2007 John Maddock<p> Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
=======================================
--- /trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html Sun Oct 12 23:27:05 2008 +++ /trunk/libs/regex/doc/html/boost_regex/ref/basic_regex.html Thu May 27 20:09:44 2010
@@ -1,12 +1,12 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>basic_regex</title>
<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css"> -<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
 <link rel="start" href="../../index.html" title="Boost.Regex">
-<link rel="up" href="../ref.html" title="Reference">
-<link rel="prev" href="../ref.html" title="Reference">
+<link rel="up" href="../ref.html" title="Reference &#21442;&#32771;&#25163;&#20876;"> +<link rel="prev" href="../ref.html" title="Reference &#21442;&#32771;&#25163;&#20876;">
 <link rel="next" href="match_results.html" title="match_results">
 </head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -24,51 +24,45 @@
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="boost_regex.ref.basic_regex"></a><a href="basic_regex.html" title="basic_regex"> basic_regex</a> +<a name="boost_regex.ref.basic_regex"></a><a class="link" href="basic_regex.html" title="basic_regex"> basic_regex</a>
 </h3></div></div></div>
-<a name="boost_regex.ref.basic_regex.synopsis"></a><h5>
-<a name="id526147"></a>
- <a href="basic_regex.html#boost_regex.ref.basic_regex.synopsis">Synopsis</a>
+<a name="boost_regex.ref.basic_regex.synopsis_______"></a><h5>
+<a name="id4888431"></a>
+ <a class="link" href="basic_regex.html#boost_regex.ref.basic_regex.synopsis_______">Synopsis &#25688;&#35201;</a>
       </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 </pre>
 <p>
The template class <code class="computeroutput"><span class="identifier">basic_regex</span></code> encapsulates regular expression parsing and compilation. The class takes
-        two template parameters:
-        <br />
- 模板类<code class="computeroutput"><span class="identifier">basic_regex</span></code>封装了正则表达式的解析和编译。
-        这个类接受两个模板参数:
+ two template parameters:<br> &#27169;&#26495;&#31867; <code class="computeroutput"><span class="identifier">basic_regex</span></code> + &#23553;&#35013;&#20102;&#27491;&#21017;&#34920;&#36798;&#24335;&#30340;&#35299;&#26512;&#21644;&#32534;&#35793;&#12290;&#36825;&#20010;&#31867;&#25509;&#21463;&#20004;&#20010;&#27169;&#26495;&#21442;&#25968;&#65306;
       </p>
 <div class="itemizedlist"><ul type="disc">
 <li>
<code class="computeroutput"><span class="identifier">charT</span></code>: determines the character type, i.e. either <code class="computeroutput"><span class="keyword">char</span></code> or - <code class="computeroutput"><span class="keyword">wchar_t</span></code>; see <a href="concepts/charT_concept.html" title="charT Requirements">charT
-          concept</a>.
-          <br />
- <code class="computeroutput"><span class="identifier">charT</span></code>:决定字符类型,如<code class="computeroutput"><span class="keyword">char</span></code>或<code class="computeroutput"><span class="keyword">wchar_t</span></code>;见<a href="concepts/charT_concept.html" title="charT Requirements">charT concept</a>。 + <code class="computeroutput"><span class="keyword">wchar_t</span></code>; see <a class="link" href="concepts/charT_concept.html" title="charT Requirements charT&#30340;&#35201;&#27714;">charT + concept</a>.<br><code class="computeroutput"><span class="identifier">charT</span></code>&#65306;&#20915;&#23450;&#23383;&#31526;&#31867;&#22411;&#65292;&#22914; + <code class="computeroutput"><span class="keyword">char</span></code> &#25110; <code class="computeroutput"><span class="keyword">wchar_t</span></code>&#65307;&#35265; + <a class="link" href="concepts/charT_concept.html" title="charT Requirements charT&#30340;&#35201;&#27714;">charT&#27010;&#24565;</a>&#12290;
         </li>
 <li>
<code class="computeroutput"><span class="identifier">traits</span></code>: determines the behavior of the character type, for example which character class names - are recognized. A default traits class is provided: <code class="computeroutput"><span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span></code>. See also <a href="concepts/traits_concept.html" title="Traits Class Requirements">traits
-          concept</a>.
-          <br />
- <code class="computeroutput"><span class="identifier">traits</span></code>:决定字符类型的行为,例如哪些字符类 名称可以被识别。 - 默认的特性类:<code class="computeroutput"><span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span></code>。 - 见<a href="concepts/traits_concept.html" title="Traits Class Requirements">traits concept</a>。 + are recognized. A default traits class is provided: <code class="computeroutput"><span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span></code>. See also <a class="link" href="concepts/traits_concept.html" title="Traits Class Requirements Traits&#31867;&#30340;&#35201;&#27714;">traits + concept</a>.<br><code class="computeroutput"><span class="identifier">traits</span></code>: + &#20915;&#23450;&#23383;&#31526;&#31867;&#22411;&#30340;&#34892;&#20026;&#65292;&#20363;&#22914;&#21738;&#20123;&#23383;&#31526;&#31867;&#21517;&#31216;&#21487;&#20197;&#34987;&#35782;&#21035;&#12290;&#40664;&#35748;&#30340;&#29305;&#24615;&#31867;&#65306;<code class="computeroutput"><span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span></code>&#12290; + &#35265; <a class="link" href="concepts/traits_concept.html" title="Traits Class Requirements Traits&#31867;&#30340;&#35201;&#27714;">traits &#27010;&#24565;</a>&#12290;
         </li>
 </ul></div>
 <p>
For ease of use there are two typedefs that define the two standard <code class="computeroutput"><span class="identifier">basic_regex</span></code> instances, unless you want to use custom traits classes or non-standard character types (for example - see <a href="non_std_strings/icu.html" title="Working With Unicode and ICU String Types">unicode support</a>),
-        you won't need to use anything other than these:
-        <br />
- 为了使用简单,有两个typedef定义了两个标准的<code class="computeroutput"><span class="identifier">basic_regex</span></code>实 例, - 除非你想要使用自定义特性类或非标准的字符类型(例如<a href="non_std_strings/icu.html" title="Working With Unicode and ICU String Types">unicode support</a>),
-        你不需要使用另外的定义:
+ see <a class="link" href="non_std_strings/icu.html" title="Working With Unicode and ICU String Types &#19982;Unicode&#21450;ICU&#23383;&#31526;&#20018;&#31867;&#22411;&#19968;&#36215;&#20351;&#29992;">unicode support</a>), + you won't need to use anything other than these:<br> &#20026;&#20102;&#20351;&#29992;&#31616;&#21333;&#65292;&#26377;&#20004;&#20010;typedef&#23450;&#20041;&#20102;&#20004;&#20010;&#26631;&#20934;&#30340; + <code class="computeroutput"><span class="identifier">basic_regex</span></code> &#23454;&#20363;&#65292;&#38500;&#38750;&#20320;&#24819;&#35201;&#20351;&#29992;&#33258;&#23450;&#20041;&#29305;&#24615;&#31867;&#25110;&#38750;&#26631;&#20934;&#30340;&#23383;&#31526;&#31867;&#22411;(&#20363;&#22914; + <a class="link" href="non_std_strings/icu.html" title="Working With Unicode and ICU String Types &#19982;Unicode&#21450;ICU&#23383;&#31526;&#20018;&#31867;&#22411;&#19968;&#36215;&#20351;&#29992;">&#23545;unicode&#30340;&#25903;&#25345;</a>)&#65292;&#21542;&#21017;&#20320;&#19981;&#38656;&#35201;&#20351;&#29992;&#21478;&#22806;&#30340;&#23450;&#20041;&#65306;
       </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>

@@ -83,11 +77,10 @@
 <p>
The definition of <code class="computeroutput"><span class="identifier">basic_regex</span></code> follows: it is based very closely on class <code class="computeroutput"><span class="identifier">basic_string</span></code>, - and fulfils the requirements for a constant-container of <code class="computeroutput"><span class="identifier">charT</span></code>.
-        <br />
- <code class="computeroutput"><span class="identifier">basic_regex</span></code>定义如下: - 这紧密依赖于类<code class="computeroutput"><span class="identifier">basic_string</span></code>, - 并且达到<code class="computeroutput"><span class="identifier">charT</span></code>的常量容器的需求。 + and fulfils the requirements for a constant-container of <code class="computeroutput"><span class="identifier">charT</span></code>.<br> + <code class="computeroutput"><span class="identifier">basic_regex</span></code> &#23450;&#20041;&#22914;&#19979;&#65306;&#20854;&#22522;&#30784;&#38750;&#24120;&#25509;&#36817;&#20110;&#31867; + <code class="computeroutput"><span class="identifier">basic_string</span></code>&#65292;&#24182;&#19988;&#28385;&#36275;&#20316;&#20026; + <code class="computeroutput"><span class="identifier">charT</span></code> &#30340;&#24120;&#37327;&#23481;&#22120;&#30340;&#38656;&#27714;&#12290;
       </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span>

@@ -102,156 +95,157 @@
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&amp;</span> <span class="identifier">const_reference</span><span class="special">;</span> <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span> <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size_type</span><span class="special">;</span> - <span class="keyword">typedef</span> <span class="identifier">regex_constants</span><span class="special">::</span> <a href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput"><span class="identifier">syntax_option_type</span></code></a> <span class="identifier">flag_type</span><span class="special">;</span> + <span class="keyword">typedef</span> <span class="identifier">regex_constants</span><span class="special">::</span> <a class="link" href="syntax_option_type.html" title="syntax_option_type"><code class="computeroutput"><span class="identifier">syntax_option_type</span></code></a> <span class="identifier">flag_type</span><span class="special">;</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">traits</span><span class="special">::</span><span class="identifier">locale_type</span> <span class="identifier">locale_type</span><span class="special">;</span>

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

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

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

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

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

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

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

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

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SA</span><span class="special">&gt;</span> - <a href="basic_regex.html#boost_regex.basic_regex.opeq3">basic_regex&amp; operator=</a> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;&amp;</span> <span class="identifier">p</span><span class="special">);</span> + <a class="link" href="basic_regex.html#boost_regex.basic_regex.opeq3">basic_regex&amp; operator=</a> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="specia