[boost-doc-zh] r335 committed - Spirit库译文，由青菜肉丝提供，第二批

From: codesite-noreply@xxxxxxxxxx
To: boost-doc-zh-notify@xxxxxxxxxxxxx
Date: Mon, 21 Sep 2009 07:38:27 +0000

Revision: 335
Author: alai04
Date: Sun Sep 20 23:13:57 2009
Log: Spirit库译文，由 青菜肉丝 提供，第二批
http://code.google.com/p/boost-doc-zh/source/detail?r=335

Modified:
 /trunk/libs/spirit/classic/doc/character_sets.html
 /trunk/libs/spirit/classic/doc/closures.html
 /trunk/libs/spirit/classic/doc/confix.html
 /trunk/libs/spirit/classic/doc/distinct.html
 /trunk/libs/spirit/classic/doc/dynamic_parsers.html
 /trunk/libs/spirit/classic/doc/escape_char_parser.html
 /trunk/libs/spirit/classic/doc/functional.html
 /trunk/libs/spirit/classic/doc/functor_parser.html
 /trunk/libs/spirit/classic/doc/list_parsers.html
 /trunk/libs/spirit/classic/doc/loops.html
 /trunk/libs/spirit/classic/doc/parametric_parsers.html
 /trunk/libs/spirit/classic/doc/phoenix.html
 /trunk/libs/spirit/classic/doc/predefined_actors.html
 /trunk/libs/spirit/classic/doc/refactoring.html
 /trunk/libs/spirit/classic/doc/regular_expression_parser.html
 /trunk/libs/spirit/classic/doc/scoped_lock.html
 /trunk/libs/spirit/classic/doc/select_parser.html
 /trunk/libs/spirit/classic/doc/stored_rule.html
 /trunk/libs/spirit/classic/doc/switch_parser.html
 /trunk/libs/spirit/classic/doc/the_lazy_parser.html
 /trunk/libs/spirit/classic/index.html

=======================================

--- /trunk/libs/spirit/classic/doc/character_sets.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/character_sets.html Sun Sep 20 23:13:572009

@@ -1,133 +1,126 @@
-<html>
-<head>
-<title>Character Sets</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Character Sets</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>
     <td width="85%">

- Character Sets+ Character Sets 字符集

     </td>

- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="loops.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="confix.html"><img src="theme/r_arr.gif"border="0"></a></td>

    </tr>
-</table>
+</tbody></table>

The character set <tt>chset</tt> matches a set of characters over afiniterange bounded by the limits of its template parameter <tt>CharT</tt>.This classis an optimization of a parser that acts on a set of single characters.Thetemplate class is parameterized by the character type <tt>CharT</tt> andcan

-  work efficiently with 8, 16 and 32 and even 64 bit characters.</p>

-<pre> template<typenameCharT =char>- class <spanclass=identifier>chset;</pre>+ work efficiently with 8, 16 and 32 and even 64 bit characters. 字符集分析器 <tt>chset</tt><spanstyle="font-family: Courier New;"> 匹配由它的模板参数<tt>CharT</tt> 所限制的范围内的有限字符子集。这个分析器针对单个字符的集合的分析而优化。这个模板类由字符类<tt>CharT</tt> 参数化并且可以使用8、16和32甚至64位的字符。+<pre> template<typenameCharT =char> class <spanclass="identifier">chset;</pre>The <tt>chset</tt> is constructed from literals (e.g. <tt>'x'</tt>),<tt>ch_p</tt>or <tt>chlit<></tt>, <tt>range_p</tt> or <tt>range<></tt>,<tt>anychar_p</tt>and <tt>nothing_p</tt> (see <a href="primitives.html">primitives</a>) orcopy-constructedfrom another <tt>chset</tt>. The <tt>chset</tt> class uses acopy-on-write scheme

-  that enables instances to be passed along easily by value.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/lens.gif" width="15" height="16">Sparse

-      bit vectors</b><br>

+ that enables instances to be passed along easily byvalue. <tt>chset</tt> 构造自字符分析器 (如 <tt>'x'</tt>)，<tt>ch_p</tt>或 <tt>chlit<></tt>, <tt>range_p</tt> 或 <tt>range<></tt>,<tt>anychar_p</tt> 和 <tt>nothing_p</tt>(见<a href="primitives.html">元素</a>)或者拷贝构造自其他 <tt>chset</tt>。<tt>chset</tt> 类使用"延迟拷贝"技术，使其可以轻松传值使用。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/lens.gif" height="16" width="15">Sparse

+      bit vectors 稀疏的bit vector</b><br>
       <br>
       To accomodate 16/32 and 64 bit characters, the <tt>chset</tt> class

statically switches from a <tt>std::bitset</tt> implementation whenthecharacter type is not greater than 8 bits, to a sparse bit/booleanset whichuses a sorted vector of disjoint ranges (<tt>range_run</tt>). Theset is- constructed from ranges such that adjacent or overlapping ranges arecoalesced. + constructed from ranges such that adjacent or overlapping ranges arecoalesced. 为了容纳16/32和64位字符，当字符类长度小于8位时，<tt>chset</tt> 类的实现从 <tt>std::bitset</tt> 类切换到一个使用不连续范围+(<tt>range_run</tt>)的有序向量(vector)的位/布尔集合。这个集合使用区间，使得那些相邻的或重叠的范围得以链接。 

       <br>

range_runs are very space-economical in situations where there arelotsof ranges and a few individual disjoint values. Searching is O(logn) where

-      n is the number of ranges.</td>

+ n is the number of ranges. range_run 在有大批间续的值和少量离散值的情况下是非常节省空间的。搜索时间为 O(log n)，n 是区间的大小。</td>

   </tr>
-</table>
-<p> Examples:<br>
+</tbody></table>
+<p> Examples:<br>例如：<br>
 </p>

-<pre> <spanclass=identifier>chset<> <spanclass=identifier>s1(<spanclass=literal>'x');- chset<>s2(<spanclass=identifier>anychar_p - <spanclass=identifier>s1);</pre>+<pre> <spanclass="identifier">chset<> <spanclass="identifier">s1(<spanclass="literal">'x'); <spanclass="identifier">chset<> <spanclass="identifier">s2(<spanclass="identifier">anychar_p - <spanclass="identifier">s1);</pre>Optionally, character sets may also be constructed using a definitionstringfollowing a syntax that resembles posix style regular expressioncharacter sets,except that double quotes delimit the set elements instead of squarebrackets

-  and there is no special negation <tt>^</tt> character.</p>

-<pre> range =anychar_p >>'-' >>anychar_p;- set =*(range_p |anychar_p<spanclass=special>);</pre>+ and there is no special negation <tt>^</tt> character. 此外，字符集可以由一个根据类似于posix风格正则表达式（除了用双引号代替方括号且没有特殊的反^字符）的字符串定义。

+</p>

+<pre> range =anychar_p <spanclass="special">>> '-' <spanclass="special">>> <spanclass="identifier">anychar_p; set =*(range_p |anychar_p<spanclass="special">);</pre>Since we are defining the set using a C string, the usual C/C++ literalstring

-  syntax rules apply. Examples:<br>

+ syntax rules apply. Examples: 由于我们用C字符串定义，因此通常的C/C++字符串语法同样适用。例子：

 </p>

-<pre> chset<>s1(<spanclass=string>"a-zA-Z");// alphabetic characters- chset<>s2(<spanclass=string>"0-9a-fA-F");// hexadecimal characters- chset<>s3(<spanclass=string>"actgACTG");// DNA identifiers- chset<>s4(<spanclass=string>"\x7f\x7e");// Hexadecimal 0x7F and 0x7E</pre>+<pre> chset<spanclass="special"><> s1<spanclass="special">("a-zA-Z"<spanclass="special">); // alphabeticcharacters chset<spanclass="special"><> s2<spanclass="special">("0-9a-fA-F"<spanclass="special">); // hexadecimalcharacters chset<spanclass="special"><> s3<spanclass="special">("actgACTG"<spanclass="special">); // DNAidentifiers chset<spanclass="special"><> s4<spanclass="special">("\x7f\x7e"<spanclass="special">); // Hexadecimal 0x7F and0x7E</pre>The standard Spirit set operators apply (see <ahref="operators.html">operators</a>)- plus an additional character-set-specific inverse (negation <tt>~</tt>)operator:

-
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="2">Character set operators</td>

+ plus an additional character-set-specific inverse (negation <tt>~</tt>)operator: 标准的Spirit集合操作符（见<a href="operators.html">操作符</a>）还添加了一个字符集专属的补集（求反~）操作符：

+
+
+
+<span class="comment"></span></p>
+
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td class="table_title" colspan="2">Character set operators 字符集操作符</td>

   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>~a</b></td>
-    <td class="table_cells" width="72%">Set inverse</td>
+    <td class="table_cells" width="72%">Set inverse 补集</td>
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>a | b</b></td>
-    <td class="table_cells" width="72%">Set union</td>
+    <td class="table_cells" width="72%">Set union 并集</td>
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>a &amp; </b></td>
-    <td class="table_cells" width="72%">Set intersection</td>
+    <td class="table_cells" width="72%">Set intersection 交集</td>
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>a - b</b></td>
-    <td class="table_cells" width="72%">Set difference</td>
+    <td class="table_cells" width="72%">Set difference 差集</td>
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>a ^ b</b></td>
-    <td class="table_cells" width="72%">Set xor</td>
+    <td class="table_cells" width="72%">Set xor 集合异或</td>
   </tr>
-</table>
-<p></p>
-<p></p>
-<p></p>
-<p></p>
-<p></p>
-<p></p>
-<p></p>
-<p></p>
+</tbody></table>

where operands a and b are both <tt>chsets</tt> or one of the operandis eithera literal character, <tt>ch_p</tt> or <tt>chlit</tt>, <tt>range_p</tt>or <tt>range</tt>,<tt>anychar_p</tt> or <tt>nothing_p</tt>. Special optimized overloadsare providedfor <tt>anychar_p</tt> and <tt>nothing_p</tt> operands. A<tt>nothing_p</tt>- operand is converted to an empty set, while an <tt>anychar_p</tt>operand is

+  operand is converted to an empty set, while an&nbsp;anychar_p operand is

converted to a set having elements of the full range of the charactertype used

-  (e.g. 0-255 for unsigned 8 bit chars).</p>

+ (e.g. 0-255 for unsigned 8 bit chars). 这里算子 a 和 b 都是<tt>chsets</tt> 或者其中一个是字面字符，<tt>ch_p</tt> 或<tt>chlit</tt>, <tt>range_p</tt> 或 <tt>range</tt>,+ <tt>anychar_p</tt> 或 <tt>nothing_p</tt>。为 <tt>anychar_p</tt> 和 <tt>nothing_p</tt> 算子提供了特别优化的算符重载。<tt>nothing_p</tt> 算子被转化为一个空集而+anychar_p 算子则被转化为一个所使用的字符的全集（比如8位的字符就是0-255）。A special case is <tt>~anychar_p</tt> which yields <tt>nothing_p</tt>,but<tt>~nothing_p</tt> is illegal. Inversion of <tt>anychar_p</tt> isasymmetrical,- a one-way trip comparable to converting <tt>T*</tt> to a<tt>void*.</tt>

-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="2">Special conversions</td>

+ a one-way trip comparable to converting <tt>T*</tt> to a<tt>void*.</tt> 一个特例是，<tt>~anychar_p</tt> 会产生<tt>nothing_p</tt>，而+ <tt>~nothing_p</tt> 是非法的。<tt>anychar_p</tt> 的求反是不对称的、单向的，类似于从 <tt>T*</tt> 到 <tt>void*.</tt>

+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="2">Special conversions 特殊的转换</td>
   </tr>
   <tr>

<td class="table_cells"width="28%">chset<CharT>(nothing_p)</td>

-    <td class="table_cells" width="72%">empty set</td>
+    <td class="table_cells" width="72%">empty set 空集</td>
   </tr>
   <tr>

<td class="table_cells"width="28%">chset<CharT>(anychar_p)</td><td class="table_cells" width="72%">full range of CharT (e.g. 0-255for unsigned

-      8 bit chars)</td>
+      8 bit chars)<br>CharT的全范围（比如8位的字符就是0-255）</td>
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>~anychar_p</b></td>
@@ -135,24 +128,23 @@
   </tr>
   <tr>
     <td class="table_cells" width="28%"><b>~nothing_p</b></td>
-    <td class="table_cells" width="72%">illegal</td>
+    <td class="table_cells" width="72%">illegal 非法</td>
   </tr>
-</table>
+</tbody></table>

 <p></p><table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/closures.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/closures.html        Sun Sep 20 23:13:57 2009
@@ -1,50 +1,54 @@
-<html>
-<head>
-<title>Closures</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Closures</title><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">

 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <style type="text/css">
 <!--
 .style1 {font-family: "Courier New", Courier, mono}
 -->
-</style>
-</head>
-
+</style></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>
     <td width="85%">

- Closures+ Closures 闭包

     </td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="phoenix.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="dynamic_parsers.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

   </tr>
-</table>
-<h2>Overview</h2>

-Using phoenix, in the previous chapter, we've seen how we can get datafrom our parsers using <tt>var</tt>:-<pre><code> <spanclass=keyword>int i<spanclass=special>;- integer =int_p[<spanclass="identifier">var(<spanclass=identifier>i) = <spanclass="identifier">arg1<spanclass=special>];</code></pre>

+</tbody></table>
+<h2>Overview 概览</h2>

+Using phoenix, in the previous chapter, we've seen how we can get datafrom our parsers using <tt>var</tt>: 在上一章中，通过使用Phoenix，我们已经看到了如何用 <tt>var</tt> 从分析器中取得数据：+<pre><code> <spanclass="keyword">int i<spanclass="special">; integer= <spanclass="identifier">int_p[<spanclass="identifier">var(<spanclass="identifier">i) = <spanclass="identifier">arg1<spanclass="special">];</code></pre>Nifty! Our rule <tt>integer</tt>, if successful, passes the parsedintegerto the variable <tt>i</tt>. Everytime we need to parse an integer, wecan callour rule <tt>integer</tt> and simply extract the parsed number from thevariable<tt>i</tt>. There's something you should be aware of though. In theviewpointof the grammar, the variable <tt>i</tt> is global. When the grammar getsmorecomplex, it's hard to keep track of the current state of <tt>i</tt>.And, with

-  recursive rules, global variables simply won't be adequate. </p>

-Closures are needed if you need your rules (or grammars) to bereentrant. For example, a rule (or grammar) might be called recursivelyindirectly or directly by itself. The calculator is a good example. Theexpression rule recursively calls itself indirectly when it invokes thefactor rule. -Closures provide named (lazy) variables associated with each parse ruleinvocation. A closure variable is addressed using member syntax:-<pre><code>rulename.varname</code></pre>-A closure variable <tt>R.x</tt> may be addressed in the semantic actionof any other rule invoked by <tt>R</tt>; it refers to the innermostenclosing invocation of <tt>R</tt>. If no such invocation exists, anassertion occurs at runtime. + recursive rules, global variables simply won't be adequate. 好极了！我们的规则 <tt>integer</tt>，如果成功匹配，将把所分析出的整数传递给变量<tt>i</tt>。每次我们需要分析一个整数，都可以调用 <tt>integer</tt> 规则，并简单地+从变量 <tt>i</tt> 提取分析出的整数。但这里还是有些事情要注意。从语法的视角来看，<tt>i</tt> 是全局的。当语法变得越来越复杂时，是很难掌握<tt>i</tt> 的当前状态的。并且，在递归

+规则的情况下，全局变量通常并不适用。</p>
+<p>Closures are needed if you need your rules (or grammars) to be
+reentrant. For example, a rule (or grammar) might be called recursively
+indirectly or directly by itself. The calculator is a good example. The
+expression rule recursively calls itself indirectly when it invokes the

+factor rule. 如果你想让你的规则（或者语法）变成可再入的，那闭包就是必须的了。比如，一个规则（或语法）可能被自身直接或间接地递归调用。caculator是一个好例子。expression规则在调用factor规则时，间接地调用自身。

+<p>Closures provide named (lazy) variables associated with each parse

+rule invocation. A closure variable is addressed using member syntax: 闭包提供了与每次规则调用相关联的命名（惰性）变量。一个闭包变量用成员语法表示：+<pre><code>rulename.varname</code></pre>+A closure variable <tt>R.x</tt> may be addressed in the semantic actionof any other rule invoked by <tt>R</tt>; it refers to the innermostenclosing invocation of <tt>R</tt>. If no such invocation exists, anassertion occurs at runtime. 一个闭包变量 <tt>R.x</tt> 可以在关联于由 <tt>R</tt> 所调用的任何规则的语义动作中出现；它关联到 <tt>R</tt> 的最深一层的调用。如果这样的调用不存在，将产生一个运行时断言错误。

 <p>Closures provide an environment, a stack frame, for local variables.

Most importantly, the closure variables are accessible from the EBNFgrammarspecification and can be used to pass parser information upstream ordownstream

@@ -52,287 +56,193 @@
   Closures facilitate dynamic scoping in C++.

Spirit's closure implementation is based on Todd Veldhuizen'sDynamicscoping in C++ technique that he presented in his paper <ahref="ftp://ftp.cs.indiana.edu/pub/techreports/TR542.pdf";>Techniques

-  for Scientic C++</a>. </p>

+ for Scientic C++</a>. 闭包为本地变量提供了一个环境，一个栈框架。最重要的是，闭包变量可以在EBNF语法定义中访问且可以在自顶向下递归下降中顺流或逆流传递分析器信息。闭包完善了C++的动态作用范围。Spirit的闭包实现基于ToddVeldhuizen的 Dynamic scoping in C++ 技术，见于他的文章 <a href="ftp://ftp.cs.indiana.edu/pub/techreports/TR542.pdf";>Techniquesfor Scientic C++</a>。When a rule is given a closure, the closure's local variables arecreated priorto entering the parse function and destructed after exiting the parsefunction.- These local variables are true local variables that exist on thehardware stack.

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16"> Closures

-      <strong>and Phoenix</strong><br> <br>

+ These local variables are true local variables that exist on thehardware stack. 当一个规则被给定一个闭包，闭包的本地变量在进入parse函数前创建，在退出parse函数后析构。这些本地变量都是真实存在于硬件栈上的本地变量。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> Closures

+      <strong>and Phoenix </strong><strong>闭包和Phoenix</strong><br> <br>

Spirit v1.8 closure support requires <ahref="../phoenix/index.html">Phoenix</a>.In the future, Spirit will fully support <ahref="../../../../libs/lambda/index.html">BLL</a>.- Currently, work is underway to merge the features of bothlibraries.</td>+ Currently, work is underway to merge the features of bothlibraries. Spirit1.8闭包需要 <a href="../phoenix/index.html">Phoenix</a>的支持。在将来，Spirit将完全支持 <ahref="../../../lambda/index.html">BLL</a><ahref="http://www.boost.org/libs/lambda/index.html";></a>。目前正在进行合并这两个库的功能的工作。</td>

   </tr>
-</table>
-<h2>Example</h2>

-Let's go back to the calculator grammar introduced in the <ahref="functional.html">Functional</a> chapter. Here's the full grammaragain, plus the closure declarations:-<pre> structcalc_closure :boost<spanclass=special>::spirit<spanclass=special>::closure<spanclass=special><calc_closure<spanclass=special>, double<spanclass=special>>

-    </span><span class=special>{

- member1 <spanclass=identifier>val;

-    </span><span class=special>};
-

- struct <spanclass=identifier>calculator : <spanclass=keyword>public grammar<spanclass=special><calculator<spanclass=special>, calc_closure<spanclass=special>::context_t<spanclass=special>>

-    </span><span class=special>{

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- struct <spanclass=identifier>definition

-        </span><span class=special>{

- definition<spanclass=special>(calculator <spanclass=keyword>const& <spanclass=identifier>self)

-            </span><span class=special>{

- top <spanclass=special>= expression<spanclass=special>[self<spanclass=special>.val <spanclass=special>= arg1<spanclass=special>];

-
-                </span><span class=identifier>expression

- = <spanclass=identifier>term[<spanclass=identifier>expression.<spanclass=identifier>val = <spanclass=identifier>arg1]- >> <spanclass=special>*( (<spanclass=literal>'+' >> <spanclass=identifier>term[<spanclass=identifier>expression.<spanclass=identifier>val += <spanclass=identifier>arg1])- | <spanclass=special>('-' <spanclass=special>>> term<spanclass=special>[expression<spanclass=special>.val <spanclass=special>-= arg1<spanclass=special>])

-                            </span><span class=special>)
-                    </span><span class=special>;
-
-                </span><span class=identifier>term

- = <spanclass=identifier>factor[<spanclass=identifier>term.<spanclass=identifier>val = <spanclass=identifier>arg1]- >> <spanclass=special>*( (<spanclass=literal>'*' >> <spanclass=identifier>factor[<spanclass=identifier>term.<spanclass=identifier>val *= <spanclass=identifier>arg1])- | <spanclass=special>('/' <spanclass=special>>> factor<spanclass=special>[term<spanclass=special>.val <spanclass=special>/= arg1<spanclass=special>])

-                            </span><span class=special>)
-                    </span><span class=special>;
-
-                </span><span class=identifier>factor

- = <spanclass=identifier>ureal_p[<spanclass=identifier>factor.<spanclass=identifier>val = <spanclass=identifier>arg1]- | <spanclass=literal>'(' >> <spanclass=identifier>expression[<spanclass=identifier>factor.<spanclass=identifier>val = <spanclass=identifier>arg1] <spanclass=special>>> ')'- | <spanclass=special>('-' <spanclass=special>>> factor<spanclass=special>[factor<spanclass=special>.val <spanclass=special>= -<spanclass=identifier>arg1])- | <spanclass=special>('+' <spanclass=special>>> factor<spanclass=special>[factor<spanclass=special>.val <spanclass=special>= arg1<spanclass=special>])

-                    </span><span class=special>;
-            </span><span class=special>}
-

- typedef <spanclass=identifier>rule<<spanclass=identifier>ScannerT, <spanclass=identifier>calc_closure::<spanclass=identifier>context_t> <spanclass=identifier>rule_t;- rule_t <spanclass=identifier>expression, <spanclass=identifier>term, <spanclass=identifier>factor;- rule<spanclass=special><ScannerT<spanclass=special>> top<spanclass=special>;

- rule<spanclass=special><ScannerT<spanclass=special>> const<spanclass=special>&- start<spanclass=special>() const <spanclass=special>{ return <spanclass=identifier>top; <spanclass=special>}

-        </span><span class=special>};
-    </span><span class=special>};</span></pre>

- <img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/phoenix_calc.cpp">viewed here</a>.This is part of the Spirit distribution.-Surely, we've come a long way from the original version of thiscalculator. With inline <a href="phoenix.html#lambda">lambdaexpressions</a>, we were able to write self contained grammars completewith semantic actions. -The first thing to notice is the declaration of <tt>calc_closure</tt>.

-<p> <strong>Declaring closures</strong></p>
-<p> The general closure declaration syntax is:</p>

-<pre><code> struct <spanclass=identifier>name <spanclass=special>: spirit<spanclass=special>::closure<spanclass=special><name<spanclass=special>, type1, type2, type3,...typeN>

-    {

- member1 m_name1<spanclass=special>;- member2 m_name2<spanclass=special>;- member3 m_name3<spanclass=special>;

-        ...

- memberN m_nameN<spanclass=special>;

-    };</span></code></pre>

- <tt>member1</tt>... <tt>memberN</tt> are indirect links to the actualclosure variables. Their indirect types correspond to<code><tt>type1</tt></code>... <code><tt>typeN</tt></code>. In our example,we declared <tt>calc_closure</tt>:-<pre> struct <spanclass=identifier>calc_closure : <spanclass=identifier>boost::<spanclass=identifier>spirit::<spanclass=identifier>closure<<spanclass=identifier>calc_closure, <spanclass=keyword>double>

-    </span><span class=special>{

- member1 <spanclass=identifier>val;

-    </span><span class=special>};</span></pre>

-<tt>calc_closure</tt> has a single variable <tt>val</tt> of type <spanclass=keyword>double.

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16"> <tt>BOOST_SPIRIT_CLOSURE_LIMIT</tt> 

+</tbody></table>
+<h2>Example 例子</h2>

+Let's go back to the calculator grammar introduced in the <ahref="functional.html">Functional</a> chapter. Here's the full grammaragain, plus the closure declarations: 让我们回到在<ahref="functional.html">函数式</a>一章中介绍的计算器语法。这次又是一个完整的语法，附带闭包声明：+<pre> structcalc_closure :boost<spanclass="special">::spirit<spanclass="special">::closure<spanclass="special"><<spanclass="identifier">calc_closure, <spanclass="keyword">double> <spanclass="special">{ member1val; }; <spanclass="keyword">struct calculator: publicgrammar<spanclass="special"><calculator<spanclass="special">, calc_closure<spanclass="special">::context_t<spanclass="special">> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">definition(<spanclass="identifier">calculator <spanclass="keyword">const& <spanclass="identifier">self) { <spanclass="identifier">top = <spanclass="identifier">expression[<spanclass="identifier">self.<spanclass="identifier">val = <spanclass="identifier">arg1<spanclass="special">]; <spanclass="identifier">expression <spanclass="special">= term<spanclass="special">[expression<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">] <spanclass="special">>> *( <spanclass="special">('+' <spanclass="special">>> term<spanclass="special">[expression<spanclass="special">.val <spanclass="special">+= arg1<spanclass="special">]) <spanclass="special">| (<spanclass="literal">'-' >> <spanclass="identifier">term[<spanclass="identifier">expression.<spanclass="identifier">val -= <spanclass="identifier">arg1<spanclass="special">]) <spanclass="special">) <spanclass="special">; <spanclass="identifier">term <spanclass="special">= factor<spanclass="special">[term<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">] <spanclass="special">>> *( <spanclass="special">('*' <spanclass="special">>> factor<spanclass="special">[term<spanclass="special">.val <spanclass="special">*= arg1<spanclass="special">]) <spanclass="special">| (<spanclass="literal">'/' >> <spanclass="identifier">factor[<spanclass="identifier">term.<spanclass="identifier">val /= <spanclass="identifier">arg1<spanclass="special">]) <spanclass="special">) <spanclass="special">; <spanclass="identifier">factor <spanclass="special">= ureal_p<spanclass="special">[factor<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">] |'(' >>expression<spanclass="special">[factor<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">] >> <spanclass="literal">')' |('-' <spanclass="special">>> factor<spanclass="special">[factor<spanclass="special">.val <spanclass="special">= -<spanclass="identifier">arg1<spanclass="special">]) |('+' <spanclass="special">>> factor<spanclass="special">[factor<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">]) <spanclass="special">; <spanclass="special">} typedefrule<spanclass="special"><ScannerT<spanclass="special">, calc_closure<spanclass="special">::context_t<spanclass="special">> rule_t<spanclass="special">; rule_texpression,term,factor<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">top; rule<spanclass="special"><ScannerT<spanclass="special">> const<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return top<spanclass="special">; } <spanclass="special">}; };</pre>

+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/phoenix_calc.cpp">viewed here</a>.This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15"> 完整的源码<ahref="../example/fundamental/phoenix_calc.cpp">在此查阅</a>。这是Spirit发布包的组成部分。Surely, we've come a long way from the originalversion of this calculator. With inline <ahref="phoenix.html#lambda">lambda expressions</a>, we were able to writeself contained grammars complete with semantic actions. 当然，我们离最初版本的计算器已经很远了。借助内联<a href="phoenix.html#lambda">λ表达式</a>，我们可以写出完全自持的带语义动作的语法。+The first thing to notice is the declaration of<tt>calc_closure</tt>. 首先要注意的是 <tt>calc_closure</tt><spanstyle="font-family: Courier New;"> 的生命。

+<p> <strong>Declaring closures 声明闭包</strong></p>

+ The general closure declaration syntax is: 一般的闭包声明语法为：+<pre><code> struct <spanclass="identifier">name <spanclass="special">: spirit<spanclass="special">::closure<spanclass="special"><name<spanclass="special">, type1, type2, type3,...typeN> { <spanclass="identifier">member1 m_name1; member2 m_name2<spanclass="special">; member3m_name3; ... memberN m_nameN<spanclass="special">; };</code></pre>+ <tt>member1</tt>... <tt>memberN</tt> are indirect links to the actualclosure variables. Their indirect types correspond to<code><tt>type1</tt></code>... <code><tt>typeN</tt></code>. In our example,we declared <tt>calc_closure</tt>: <tt>member1</tt>... <tt>memberN</tt>间接地链接到真正的本地变量。它们的间接类型对应于<code><tt>type1</tt></code>... <code><tt>typeN</tt></code>。在我们的例子中，我们如下声明 <tt>calc_closure</tt>:+<pre> structcalc_closure :boost<spanclass="special">::spirit<spanclass="special">::closure<spanclass="special"><<spanclass="identifier">calc_closure, <spanclass="keyword">double> <spanclass="special">{ member1val; };</pre>+<tt>calc_closure</tt> has a single variable <tt>val</tt> of type <spanclass="keyword">double<spanclass="special">. <tt>calc_closure</tt> 有一个类型为 <spanclass="keyword">double 的变量<tt>val</tt>。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> <tt>BOOST_SPIRIT_CLOSURE_LIMIT</tt> 

         <br>

- Spirit predefined maximum closure limit. This limit defines themaximum number of elements a closure can hold. This number defaults to 3.The actual maximum is rounded up in multiples of 3. Thus, if this value is4, the actual limit is 6. The ultimate maximum limit in this implementationis 15. It should NOT be greater than<tt>PHOENIX_LIMIT</tt> (see <a href="../phoenix/index.html">phoenix</a>).Example: 

+Spirit predefined maximum closure limit. This limit defines the maximum
+number of elements a closure can hold. This number defaults to 3. The
+actual maximum is rounded up in multiples of 3. Thus, if this value is
+4, the actual limit is 6. The ultimate maximum limit in this

+implementation is 15. It should NOT be greater than<tt>PHOENIX_LIMIT</tt> (see <a href="../phoenix/index.html">phoenix</a>).Example: Spirit预定义了闭包的最大限制。它限制了一个闭包所能持有的元素的最大数目。默认值为3。实际上最大值可以是3的整数倍。因此，如果该值为4，那么实际的最大值为6。这个版本的实现所允许的极大值为15。这个值不能大于<tt>PHOENIX_LIMIT</tt> (见 <a href="../phoenix/index.html">phoenix</a>)。例子：

       <br>

- // Define these before includinganything else + // Define these before including anything else #define<spanclass="style1"> PHOENIX_LIMIT 10 #define<spanclass="style1"> BOOST_SPIRIT_CLOSURE_LIMIT 10 </td>

   </tr>
-</table>
-<p><strong>Attaching closures</strong></p>
+</tbody></table>
+<p><strong>Attaching closures 关联闭包</strong></p>

Closures can be applied to rules, subrules and grammars(non-terminals). The closure has aspecial <a href="indepth_the_parser_context.html">parser context</a>that can be used with these non-terminals. The closure's- context is its means to hook into the non-terminal. The context of theclosure <tt>C</tt> is <tt>C::context_t</tt>. -We can see in the example that we attached <tt>calc_closure</tt> to the<tt>expression</tt>, <tt>term</tt> and <tt>factor</tt> rules in ourgrammar:-<pre> typedefrule<spanclass=special><ScannerT<spanclass=special>, calc_closure<spanclass=special>::context_t<spanclass=special>> rule_t<spanclass=special>;- rule_t <spanclass=identifier>expression, <spanclass=identifier>term, <spanclass=identifier>factor; </pre>

-<p>as well as the grammar itself:</p>

-<pre> structcalculator :public <spanclass=identifier>grammar<<spanclass=identifier>calculator, <spanclass=identifier>calc_closure::<spanclass=identifier>context_t></pre>

-<p><strong>Closure return value</strong></p>

-The closure <tt>member1</tt> is the closure's return value. This returnvalue, like the one returned by <tt>anychar_p</tt>, for example, can beused to propagate data up the parser hierarchy or passed to semanticactions. Thus, <tt>expression</tt>, <tt>term</tt> and <tt>factor</tt>, aswell as the <tt>calculator</tt> grammar itself, all return a<tt>double</tt>. 

-<p><strong>Accessing closure variables</strong></p>

+ context is its means to hook into the non-terminal. The context of theclosure <tt>C</tt> is <tt>C::context_t</tt>. 闭包可应用于规则、子规则和语法（非终结符）。配合这些非终结符使用的闭包有一个特殊的<ahref="indepth_the_parser_context.html">分析器语境</a>。这个语境用来把闭包与非终结符挂钩。闭包的语境是它与非终结符挂钩的方法。闭包 <tt>C</tt> 的语境是<tt>C::context_t</tt>+We can see in the example that we attached <tt>calc_closure</tt> to the<tt>expression</tt>, <tt>term</tt> and <tt>factor</tt> rules in ourgrammar: 在例子中可以看到，在语法中我们把 <tt>calc_closure</tt> 关联到<tt>expression</tt>, <tt>term</tt> 和 <tt>factor</tt> ：<spanstyle="font-family: Courier New;"><tt></tt>+<pre> typedefrule<spanclass="special"><ScannerT<spanclass="special">, calc_closure<spanclass="special">::context_t<spanclass="special">> rule_t<spanclass="special">; rule_texpression,term,factor;</pre>

+<p>as well as the grammar itself:<br>以及语法本身：</p>

+<pre> structcalculator :public <spanclass="identifier">grammar<<spanclass="identifier">calculator, <spanclass="identifier">calc_closure::<spanclass="identifier">context_t></pre>

+<p><strong>Closure return value 闭包的返回值</strong></p>

+The closure <tt>member1</tt> is the closure's return value. This returnvalue, like the one returned by <tt>anychar_p</tt>, for example, can beused to propagate data up the parser hierarchy or passed to semanticactions. Thus, <tt>expression</tt>, <tt>term</tt> and <tt>factor</tt>, aswell as the <tt>calculator</tt> grammar itself, all return a<tt>double</tt>. 闭包成员 <tt>member1</tt> 是闭包的返回值。这个返回值，类似于<tt>anychar_p</tt> 的返回值，例如，可用于在分析器层次中传递数据或传递给语义动作。因此， <tt>expression</tt>, <tt>term</tt> 和 <tt>factor</tt>, 以及<tt>calculator</tt> 语法本身，都返回一个 <tt>double</tt>。

+<p><strong>Accessing closure variables 访问闭包变量</strong></p>

Closure variables can be accessed from within semantic actions justlike youwould struct members: by qualifying the member name with its owner rule,subrule- or grammar. In our example above, notice how we referred to the closuremember val. Example:-<pre class="identifier"><code> expression<spanclass=special>.val // refer to expression'sclosure member val</code></pre>

-<p><strong>Initializing closure variables </strong></p>
-<p>We didn't use this feature in the example, yet, for completeness... </p>

-Sometimes, we need to initialize our closure variables upon entering anon-terminal (rule, subrule or grammar). Closure enabled non-terminals, bydefault, default-construct variables upon entering the parse memberfunction.- If this is not desirable, we can pass constructor arguments to thenon-terminal. The syntax mimics a

-  function call. </p>

+ or grammar. In our example above, notice how we referred to the closuremember val. Example: 闭包变量可以在语义动作中访问，就用你组织成员变量的方式：指定它所属的规则、子规则或语法以及闭包变量的名字。在上面的例子中，要注意我们是如何引用闭包变量的。例子：+<pre class="identifier"><code> expression<spanclass="special">.val // refer to expression'sclosure member val 引向expression的闭包成员val</code></pre>

+<p><strong>Initializing closure variables 初始化闭包变量 </strong></p>

+We didn't use this feature in the example, yet, forcompleteness... 虽然我们的例子并未使用这个功能，但为了完整性……

+<p>Sometimes, we need to initialize our closure variables upon entering
+a non-terminal (rule, subrule or grammar). Closure enabled
+non-terminals, by default, default-construct variables upon entering
+the parse member function. If this is not desirable, we can pass
+constructor arguments to the non-terminal. The syntax mimics a function

+call. 有时，我们在进入一个非终结符（规则、子规则或语法）前需要初始化闭包变量。默认的，闭包允许非终结符在进入parse成员函数前初始化有默认构造函数的变量。如果这不是我们想要的，我们可以把构造函数的参数传给非终结符。这个语法模仿了函数调用。For (a contrived) example, if you wish to construct<tt>calc_closure</tt>'s variables- to <tt>3.6</tt>, when we invoke the rule <tt>expression</tt>, wewrite:-<pre class="identifier"><code> expression<spanclass="special">(3.6<spanclass="special">) // invoke rule expressionand set its closure variable to 3.6</code></pre>+ to <tt>3.6</tt>, when we invoke the rule <tt>expression</tt>, wewrite: （特意的）例如，如果你想把 <tt>calc_closure</tt> <spanstyle="font-family: Courier New;">的变量初始化为 <tt>3.6</tt><spanstyle="font-family: Courier New;">，当我们调用<tt>expression</tt>，这么写：+<pre class="identifier"><code> expression<spanclass="special">(3.6<spanclass="special">) // invoke rule expressionand set its closure variable to 3.6 调用规则expression并设置其闭包变量为3.6</code></pre>The constructor arguments are actually Phoenix lambda expressions, soyou can- use arbitrarily complex expressions. Here's another contrivedexample: -<pre class="identifier"><code> // call rulefactor and set its closure variable to (expression.x / 8) * factor.y- <code>factor</code><spanclass="special">((expression.x<spanclass="keyword"> /<spanclass="keyword"> 8) *<spanclass="keyword"> term.y<spanclass="special">)</code></pre>-<img src="theme/lens.gif" width="15" height="16"> We can pass lessarguments than the actual number of variables in the closure.+ use arbitrarily complex expressions. Here's another contrivedexample: 构造函数参数实际上是Phoenix的λ表达式，因此你可以使用任意复杂的表达式。这里是另一个特意的例子：+<pre class="identifier"><code> // call rulefactor and set its closure variable to (expression.x / 8) * factor.y // 调用规则factor并设置其闭包变量为 (expression.x / 8) *factor.y <code>factor</code><spanclass="special">((expression.x<spanclass="keyword"> /<spanclass="keyword"> 8) *<spanclass="keyword"> term.y<spanclass="special">)</code></pre>+<img src="theme/lens.gif" height="16" width="15"> We can pass lessarguments than the actual number of variables in the closure.The variables at the right with no corresponding constructor argumentsare default- constructed. Passing more arguments than there are closure variables isan error.-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/intermediate/parameters.cpp">parameters.cpp</a> for acompilable example. This is part of the Spirit distribution.

-<h2>Closures and Dynamic parsing</h2>

-Let's write a very simple parser for an XML/HTML like language witharbitrarily nested tags. The typical approach to this type of nested tagparsing is to delegate the actual tag matching to semantic actions, perhapsusing a symbol table. For example, the semantic actions are responsible forensuring that the tags are nested (e.g. this code:<tt><table></table></tt> is erroneous).-Spirit allows us to dynamically modify the parser at runtime. Theability to guide parser behavior through semantic actions makes it possibleto ensure the nesting of tags directly in the parser. We shall see how thisis possible. here's the grammar in its simplest form:-<pre> element =start_tag >>*element>> <spanclass=identifier>end_tag;+ constructed. Passing more arguments than there are closure variables isan error. <img src="theme/lens.gif" height="16" width="15"> 我们可以传递少于实际的闭包变量数目的参数。右边那些没有对应的构造函数参数的变量将被默认构造。传递多余变量数目的参数将产生一个错误。+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/intermediate/parameters.cpp">parameters.cpp</a> for acompilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译例子见 <ahref="../example/intermediate/parameters.cpp">parameters.cpp</a> 。这是Spirit分发包的组成部分。

+<h2>Closures and Dynamic parsing 闭包与动态分析</h2>
+<p>Let's write a very simple parser for an XML/HTML like language with
+arbitrarily nested tags. The typical approach to this type of nested
+tag parsing is to delegate the actual tag matching to semantic actions,
+perhaps using a symbol table. For example, the semantic actions are

+responsible for ensuring that the tags are nested (e.g. this code:<tt><table></table></tt> is erroneous). 让我们来写一个类似于XML/HTML的任意的标记语言的分析器。对这种嵌套标记语言典型的方法是在语义动作中进行真正的标记匹配，也许是通过一个符号表。例如，由语义动作负责保证这些标记是嵌套的（比如类似这样的代码是错误的：<tt><table></table></tt>)<tt></tt>

+<p>Spirit allows us to dynamically modify the parser at runtime. The
+ability to guide parser behavior through semantic actions makes it
+possible to ensure the nesting of tags directly in the parser. We shall

+see how this is possible. here's the grammar in its simplestform: Spirit允许我们在运行时动态地修改分析器。通过语义动作引导分析器行为的能力使得可以直接使用分析器保证标签的嵌套。我们将看到这是如何成为可能的。这是最简形式的语法：+<pre> element =start_tag <spanclass="special">>> *<spanclass="identifier">element >>end_tag;

 </pre>

-An element is a <tt>start_tag</tt> (e.g. <tt></tt>) folowedby zero or more elements, and ended by an <tt>end_tag</tt> (e.g.<tt></tt>). Now, here's a first shot at our<tt>start_tag</tt>:-<pre> start_tag= '<' <spanclass=special>>> lexeme_d<spanclass=special>[(+<spanclass=identifier>alpha_p)<spanclass=special>] >> <spanclass=literal>'>';</pre>-Notice that the <tt>end_tag</tt> is just the same as <tt>start_tag</tt>with the addition of a slash:-<pre> end_tag= "</">> what_we_got_in_the_start_tag>> <spanclass=literal>'>';+An element is a <tt>start_tag</tt> (e.g. <tt></tt>) folowedby zero or more elements, and ended by an <tt>end_tag</tt> (e.g.<tt></tt>). Now, here's a first shot at our<tt>start_tag</tt>: 一个元素即一个 <tt>start_tag</tt> (如<tt></tt>)跟随零个或更多元素，且以<tt>end_tag</tt> (如<tt></tt>)结尾。那么，下面就是我们的<tt>start_tag</tt> 的首次定义：+<pre> start_tag= '<'>> <spanclass="identifier">lexeme_d[<spanclass="special">(+alpha_p<spanclass="special">)] <spanclass="special">>> '>'<spanclass="special">;</pre>+Notice that the <tt>end_tag</tt> is just the same as <tt>start_tag</tt>with the addition of a slash: 注意 <tt>end_tag</tt> 和<tt>start_tag</tt> 类似，只是多了一个斜线：+<pre> end_tag= "</">> what_we_got_in_the_start_tag>> <spanclass="literal">'>';

 </pre>

-What we need to do is to temporarily store what we got in our<tt>start_tag</tt> and use that later to parse our <tt>end_tag</tt>. Nifty,we can use the <a href="parametric_parsers.html">parametric parser</a>primitives to parse our <tt>end_tag</tt>: -<pre> end_tag= "</">> <spanclass=identifier>f_str_p(tag<spanclass=special>) >> <spanclass=literal>'>';</pre>

-<p>where we parameterize <tt>f_str_p</tt> with what we stored (tag). </p>

-Be reminded though that our grammar is recursive. The element rulecalls itself. Hence, we can't just use a variable and use<tt>phoenix::var</tt> or <tt>boost::ref</tt>. Nested recursion will simplygobble up the variable. Each invocation of element must have a closurevariable <tt>tag</tt>. Here now is the complete grammar:-<pre> struct <spanclass=identifier>tags_closure : <spanclass=identifier>boost::<spanclass=identifier>spirit::<spanclass=identifier>closure<<spanclass=identifier>tags_closure, <spanclass=identifier>string> <spanclass=special>

-    {

- member1 <spanclass=identifier>tag;

-    </span><span class=special>};
-

- struct tags: public <spanclass=identifier>grammar<<spanclass=identifier>tags>

-    </span><span class=special>{

- definition<spanclass=special>(tags <spanclass=keyword>const& <spanclass=comment>/*self*/)

-            </span><span class=special>{

- element <spanclass=special>= start_tag <spanclass=special>>> *<spanclass=identifier>element >> <spanclass=identifier>end_tag;

- start_tag <spanclass=special>=

-                        </span><span class=literal>'&lt;'

- >> <spanclass=identifier>lexeme_d

-                        </span><span class=special>[

- (+<spanclass=identifier>alpha_p)

-                            </span><span class=special>[

- // constructstring from arg1 and arg2 lazily- // and assignto element.tag

- <spanclass=identifier>element.<spanclass=identifier>tag = <spanclass=identifier>construct_<<spanclass=identifier>string>(<spanclass=identifier>arg1, <spanclass=identifier>arg2)

-                            </span><span class=special>]
-                        </span><span class=special>]

- >> <spanclass=literal>'>';

- end_tag <spanclass=special>= "</" <spanclass=special>>> f_str_p<spanclass=special>(element<spanclass=special>.tag<spanclass=special>) >> <spanclass=literal>'>';

-            </span><span class=special>}
-

- rule<spanclass=special><ScannerT<spanclass=special>, tags_closure<spanclass=special>::context_t<spanclass=special>> element<spanclass=special>;- rule<spanclass=special><ScannerT<spanclass=special>> start_tag<spanclass=special>, end_tag<spanclass=special>;

- rule<spanclass=special><ScannerT<spanclass=special>, tags_closure<spanclass=special>::context_t<spanclass=special>> const<spanclass=special>&- start<spanclass=special>() const <spanclass=special>{ return <spanclass=identifier>element; <spanclass=special>}

-        </span><span class=special>};
-    </span><span class=special>};</span></pre>

-We attached a semantic action to the <tt>(+alpha_p)</tt> part of thestart_tag. There, we stored the parsed tag in the <tt>element</tt>'sclosure variable <tt>tag</tt>. Later, in the <tt>end_tag</tt>, we simplyused the <tt>element</tt>'s closure variable <tt>tag</tt> to parameterizeour <tt>f_str_p</tt> parser. Simple and elegant. If some of the detailsbegin to look like greek (e.g. what is <tt>construct_</tt>?), pleaseconsult the <a href="phoenix.html">Phoenix</a> chapter. -<img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/matching_tags.cpp">viewed here</a>.This is part of the Spirit distribution.-<h2><img src="theme/lens.gif" width="15" height="16"> Closuresin-depth</h2>

-<p><strong>What are Closures?</strong></p>

-The closure is an object that <spanclass="quotes">"closes"+What we need to do is to temporarily store what we got in our<tt>start_tag</tt> and use that later to parse our <tt>end_tag</tt>. Nifty,we can use the <a href="parametric_parsers.html">parametric parser</a>primitives to parse our <tt>end_tag</tt>: 我们所需要做的是临时储存<tt>start_tag</tt> 并且在随后分析 <tt>end_tag</tt> 中使用它。很好，我们可以用<a href="parametric_parsers.html">参数化</a>的元素分析器来解析<tt>end_tag</tt>：+<pre> end_tag= "</">> <spanclass="identifier">f_str_p(tag<spanclass="special">) >> <spanclass="literal">'>';</pre>+where we parameterize <tt>f_str_p</tt> with what we stored (tag). 这里我们用我们所储存的tag来参数化 <tt>f_str_p</tt>。+Be reminded though that our grammar is recursive. The element rulecalls itself. Hence, we can't just use a variable and use<tt>phoenix::var</tt> or <tt>boost::ref</tt>. Nested recursion will simplygobble up the variable. Each invocation of element must have a closurevariable <tt>tag</tt>. Here now is the complete grammar: 注意我们的语法是递归的。element 规则调用自身。因此，我们不能只用一个变量和<tt>phoenix::var</tt> 或 <tt>boost::ref</tt>。嵌套的递归将更改变量。每次对element 的调用都必须有一个闭包变量 <tt>tag</tt>。下面是完整的语法：+<pre> structtags_closure :boost<spanclass="special">::spirit<spanclass="special">::closure<spanclass="special"><<spanclass="identifier">tags_closure, <spanclass="identifier">string> <spanclass="special">

+    {

+ member1 <spanclass="identifier">tag; <spanclass="special">}; structtags :public <spanclass="identifier">grammar<<spanclass="identifier">tags> { <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">definition(<spanclass="identifier">tags const<spanclass="special">& /*self*/<spanclass="special">) <spanclass="special">{ <spanclass="identifier">element = <spanclass="identifier">start_tag >>*element>> <spanclass="identifier">end_tag<spanclass="special">; <spanclass="identifier">start_tag <spanclass="special">= <spanclass="literal">'<' <spanclass="special">>> <spanclass="identifier">lexeme_d <spanclass="special">[ <spanclass="special">(+alpha_p<spanclass="special">) <spanclass="special">[ <spanclass="comment">// construct string from arg1 and arg2 lazily 从arg1和arg2惰性地构造字符串 <spanclass="comment">// and assign to element.tag 并赋值给element.tag <spanclass="identifier">element.<spanclass="identifier">tag = <spanclass="identifier">construct_<<spanclass="identifier">string>(<spanclass="identifier">arg1, <spanclass="identifier">arg2<spanclass="special">) <spanclass="special">] <spanclass="special">] <spanclass="special">>> '>'<spanclass="special">; <spanclass="identifier">end_tag = <spanclass="string">"</" >> <spanclass="identifier">f_str_p(<spanclass="identifier">element.<spanclass="identifier">tag) <spanclass="special">>> '>'<spanclass="special">; <spanclass="special">} <spanclass="identifier">rule<<spanclass="identifier">ScannerT, <spanclass="identifier">tags_closure::<spanclass="identifier">context_t> <spanclass="identifier">element; rule<spanclass="special"><ScannerT<spanclass="special">> start_tag<spanclass="special">, end_tag<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">ScannerT, <spanclass="identifier">tags_closure::<spanclass="identifier">context_t> <spanclass="keyword">const& start()const {return <spanclass="identifier">element; <spanclass="special">} }; };</pre>+We attached a semantic action to the <tt>(+alpha_p)</tt> part of thestart_tag. There, we stored the parsed tag in the <tt>element</tt>'sclosure variable <tt>tag</tt>. Later, in the <tt>end_tag</tt>, we simplyused the <tt>element</tt>'s closure variable <tt>tag</tt> to parameterizeour <tt>f_str_p</tt> parser. Simple and elegant. If some of the detailsbegin to look like greek (e.g. what is <tt>construct_</tt>?), pleaseconsult the <a href="phoenix.html">Phoenix</a> chapter. 我们把语义动作关联到 start_tag 的 <tt>(+alpha_p)</tt> 部分上。在那里，我们把分析出的标记储存在这个 <tt>element</tt> 的闭包变量　<tt>tag</tt>　里。随+后，在 <tt>end_tag</tt>　中，我们简单地用　<tt>element</tt>　的闭包变量　<tt>tag</tt>　来参数化我们的 <tt>f_str_p</tt> 分析器。简单而优雅。如果某些细节看起来有点晦涩（比如， <tt>construct_</tt>　是干嘛的？），请见<ahref="phoenix.html">Phoenix</a>章节。+<img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/matching_tags.cpp">viewed here</a>.This is part of the Spirit distribution.<img src="theme/lens.gif"height="16" width="15"> 完整的源码<ahref="../example/fundamental/matching_tags.cpp">在此查阅</a>，这是Spirit分发包的组成部分。+<h2><img src="theme/lens.gif" height="16" width="15"> Closures in-depth 深入闭包</h2>

+<p><strong>What are Closures? 闭包是什么？</strong></p>
+<p>The closure is an object that <span class="quotes">"closes"</span>

over the local variables of a function making them visible andaccessible outsidethe function. What is more interesting is that the closure actuallypackagesa local context (stack frame where some variables reside) and makes itavailableoutside the scope in which they actually exist. The information isessentially- "captured" by the closure allowingit

+  <span class="quotes">"captured"</span> by the closure allowing it

to be referred to anywhere and anytime, even prior to the actualcreation of

-  the variables. </p>

+ the variables. 闭包指"包裹"函数的本地变量，使其在函数外可见及可访问的对象。更有趣的是闭包实际上包裹了一个本地语境（变量所处的栈框架）并使其在他们实际的可见范围之外可见。这些信息本质上被闭包所"捕捉"以使其在任一时刻任意地点都可以被引用，甚至在变量被实际创建之前。The following diagram depicts the situation where a function <tt>A</tt>(orrule) exposes its closure and another function <tt>B</tt> references<tt>A</tt>'s

-  variables through its closure.</p>
-<table width="40%" border="0" align="center">
-  <tr>

+ variables through its closure. 下图描绘了一个函数 <tt>A</tt>（或者规则）暴露其闭包且另一个函数 <tt>B</tt> 通过这个闭包引用 <tt>A</tt> 的变量。

+<table align="center" border="0" width="40%">
+  <tbody><tr>
     <td><img src="theme/closure1.png"></td>
   </tr>
   <tr>

- <td> <div align="center">The- closure as an object that "closes" over the localvariables- of a function making them visible and accessible outside thefunction</div></td>+ <td> <div align="center">The

+        closure as an object that <i>"closes"</i> over the local variables

+ of a function making them visible and accessible outside thefunction 闭包就象一个"包裹"着一个函数的某个局部变量的对象，使之可以在函数以外可见并被访问</div></td>

   </tr>
-</table>
+</tbody></table>

Of course, function <tt>A</tt> should be active when <tt>A.x</tt> isreferenced.What this means is that function <tt>B</tt> is reliant on function<tt>A</tt>(If <tt>B</tt> is a nested function of <tt>A</tt>, this will always bethe case).The free form nature of Spirit rules allows access to a closure variableanytime,anywhere. Accessing <tt>A.x</tt> is equivalent to referring to thetopmost stackvariable <tt>x</tt> of function <tt>A</tt>. If function <tt>A</tt> isnot active

-  when <tt>A.x</tt> is referenced, a runtime exception will be thrown.</p>
-<p><strong>Nested Functions</strong></p>

+ when <tt>A.x</tt> is referenced, a runtime exception will bethrown. 当然，在 <tt>A.x</tt> 被引用时，函数 <tt>A</tt> 应当是活动的。这意味着函数 <tt>B</tt> 依赖于函数 <tt>A</tt>（如果 <tt>B</tt> 嵌套于 <tt>A</tt> 内，那么这永远成立）。Spirit拥有的自由形式允+许在任何时刻任何地点引用闭包变量。访问 <tt>A.x</tt> 等价于访问函数<tt>A</tt> 栈内最顶层的变量 <tt>x</tt>。如果在 <tt>A.x</tt> 被引用时<tt>A</tt> 并不是活动的，将抛出一个运行时异常。

+<p><strong>Nested Functions 嵌套函数</strong></p>

To fully understand the importance of closures, it is best to look at alanguagesuch as Pascal which allows nested functions. Since we are dealing withC++,lets us assume for the moment that C++ allows nested functions. Considerthe

-  following <b><i>pseudo</i></b> C++ code:</p>

-<pre> voida()

-    </span><span class=special>{

- int <spanclass=identifier>va;- void <spanclass=identifier>b()

-        </span><span class=special>{

- int <spanclass=identifier>vb;- void <spanclass=identifier>c()

-            </span><span class=special>{

- int <spanclass=identifier>vc;

-            </span><span class=special>}
-

- c<spanclass=special>();

-        </span><span class=special>}
-
-        </span><span class=identifier>b</span><span class=special>();
-    </span><span class=special>}</span></pre>

+ following pseudo C++ code: 要完全明白闭包的重要性，最好看看诸如Pascal这样允许嵌套函数的语言。由于我们是在和C++打交道，让我们假设C++允许嵌套函数。考虑下面的C++伪代码：+<pre> voida() { intva; void <spanclass="identifier">b() <spanclass="special">{ intvb<spanclass="special">; voidc<spanclass="special">() <spanclass="special">{ intvc<spanclass="special">; <spanclass="special">} <spanclass="identifier">c()<spanclass="special">; } b(); }</pre>We have three functions <tt>a</tt>, <tt>b</tt> and <tt>c</tt> where<tt>c</tt>is nested in <tt>b</tt> and <tt>b</tt> is nested in <tt>a</tt>. We alsohavethree variables <tt>va</tt>, <tt>vb</tt> and <tt>vc</tt>. The lifetimeof eachof these local variables starts when the function where it is declaredis enteredand ends when the function exits. The scope of a local variable spansall nested- functions inside the enclosing function where the variable isdeclared.+ functions inside the enclosing function where the variable isdeclared. 我们有三个函数 <tt>a</tt>, <tt>b</tt> 和 <tt>c</tt>。这里<tt>c</tt> 嵌套于 <tt>b</tt>，<tt>b</tt> 嵌套于 <tt>a</tt>。我们也有三个变量 <tt>va</tt>, <tt>vb</tt> 和 <tt>vc</tt>。这三个局部变量的生命周期从函数中他们声明的位置开始，结束于函数退出之时。局部变量的周期跨越所有在变量声明之后的嵌套函数。Going downstream from function <tt>a</tt> to function <tt>c</tt>, whenfunctiona is entered, the variable <tt>va</tt> will be created in the stack.When function<tt>b</tt> is entered (called by <tt>a</tt>), <tt>va</tt> is very wellin scopeand is visble in <tt>b</tt>. At which point a fresh variable,<tt>vb</tt>, iscreated on the stack. When function <tt>c</tt> is entered, both<tt>va</tt>and <tt>vb</tt> are visibly in scope, and a fresh local variable<tt>vc</tt>

-  is created. </p>

+ is created. 从函数 <tt>a </tt>顺流来到函数 <tt>c</tt>，当进入<tt>a</tt> 函数时，变量 <tt>va</tt> 将被在栈上创建。当进入函数<tt>b</tt>（由 <tt>a</tt> 调用），<tt>va</tt> 处于它的周期之内并在<tt>b</tt> 中可见。此时一个新的变量，<tt>vb</tt> 在栈上创建。当进入函数<tt>c</tt>，<tt>va</tt> 和 <tt>vb</tt> 都在可见范围内，同时新的局部变量 <tt>vc</tt> 被创建。Going upstream, <tt>vc</tt> is not and cannot be visible outside thefunction<tt>c</tt>. <tt>vc</tt>'s life has already expired once <tt>c</tt>exits. Thesame is true with <tt>vb</tt>; vb is accessible in function <tt>c</tt>but not

-  in function <tt>a</tt>. </p>
-<strong>Nested Mutually Recursive Rules</strong>
-<p>Now consider that <tt>a</tt>, <tt>b</tt> and <tt>c</tt> are rules:</p>

-<pre> a= b <spanclass=special>>> *((<spanclass=literal>'+' >> <spanclass=identifier>b) |('-' <spanclass=special>>> b<spanclass=special>));- b =c >>*(('*' <spanclass=special>>> c<spanclass=special>) | <spanclass=special>('/' <spanclass=special>>> c<spanclass=special>));- c =int_p |'(' >>a >>')' | <spanclass=special>('-' <spanclass=special>>> c<spanclass=special>) | <spanclass=special>('+' <spanclass=special>>> c<spanclass=special>);</pre>+ in function <tt>a</tt>. 由底而上，<tt>vc</tt> 不是且不能在函数 <tt>c</tt> 外可见。<tt>vc</tt> 的生命在退出 <tt>c</tt> 时已经结束了。这同样适用于 <tt>vb</tt>；<tt>vb</tt> 在函数 <tt>c</tt> 内是可访问的，但在函数 <tt>a</tt> 内不是。+Nested Mutually Recursive Rules 嵌套交叉递归规则+Now consider that <tt>a</tt>, <tt>b</tt> and <tt>c</tt> are rules: 下面考虑规则 <tt>a</tt>, <tt>b</tt> 和 <tt>c</tt>:+<pre> a= b>> <spanclass="special">*(('+' <spanclass="special">>> b<spanclass="special">) | <spanclass="special">('-' <spanclass="special">>> b<spanclass="special">)); b <spanclass="special">= c <spanclass="special">>> *((<spanclass="literal">'*' >> <spanclass="identifier">c) <spanclass="special">| (<spanclass="literal">'/' >> <spanclass="identifier">c)); <spanclass="identifier">c = <spanclass="identifier">int_p | <spanclass="literal">'(' >> <spanclass="identifier">a >> <spanclass="literal">')' | <spanclass="special">('-' <spanclass="special">>> c<spanclass="special">) | <spanclass="special">('+' <spanclass="special">>> c<spanclass="special">);</pre>We can visualize <tt>a</tt>, <tt>b</tt> and <tt>c</tt> as mutuallyrecursivefunctions where <tt>a</tt> calls <tt>b</tt>, <tt>b</tt> calls <tt>c</tt>and<tt>c</tt> recursively calls <tt>a</tt>. Now, imagine if <tt>a</tt>,<tt>b</tt>and <tt>c</tt> each has a local variable named <tt>value</tt> that canbe referred

-  to in our grammar by explicit qualification:</p>

-<pre> a<spanclass=special>.value <spanclass=comment>// refer to a's value local variable- b<spanclass=special>.value <spanclass=comment>// refer to b's value local variable- c<spanclass=special>.value <spanclass=comment>// refer to c's value local variable+ to in our grammar by explicit qualification: 我们可以看到 <tt>a</tt>,<tt>b</tt> 和 <tt>c</tt> 是交叉引用的，<tt>a</tt> 调用<tt>b</tt>，<tt>b</tt> 调用 <tt>c</tt> 而 <tt>c</tt> 又回过头来调用 <tt>a</tt>。现在，想像 <tt>a</tt>、<tt>b</tt> 和 <tt>c</tt> 都有一个局部变量，名为 <tt>value</tt>，可以在我们的语法中通过显式指定来引用：+<pre> <spanclass="identifier">a.<spanclass="identifier">value // refer to a's valuelocal variable 引用a的局部变量value <spanclass="identifier">b.<spanclass="identifier">value // refer to b's valuelocal variable 引用b的局部变量value <spanclass="identifier">c.<spanclass="identifier">value // refer to c's valuelocal variable 引用c的局部变量value 

 </pre>

Like above, when <tt>a</tt> is entered, a local variable <tt>value</tt>iscreated on the stack. This variable can be referred to by both<tt>b</tt> and<tt>c</tt>. Again, when <tt>b</tt> is called by <tt>a</tt>, <tt>b</tt>createsa local variable <tt>value</tt>. This variable is accessible by<tt>c</tt> but

-  not by <tt>a</tt>. </p>

+ not by <tt>a</tt>. 就像上面一样，当进入 <tt>a</tt> 时，一个本地变量 <tt>value</tt> 在栈上创建。这个变量可以由 <tt>b</tt> 和 <tt>c</tt>引用。同样，当 <tt>b</tt> 被 <tt>a</tt> 调用，<tt>b</tt> 创建一个本地变量 <tt>value</tt>。这个变量可以由 <tt>c</tt> 引用，但<tt>a</tt> 不行。Here now is where the analogy with nested functions end: when<tt>c</tt> iscalled, a fresh variable <tt>value</tt> is created which, as usual,lasts thewhole lifetime of <tt>c</tt>. Pay close attention however that<tt>c</tt> maycall <tt>a</tt> recursively. When this happens, <tt>a</tt> may now referto- the local variable of <tt>c</tt><code><spanclass=special>.</code>+ the local variable of <tt>c</tt><code><spanclass="special">. </code>现在这里有了一个类似于嵌套函数的结局：当<tt>c</tt> 被调用时，一个新的变量 <tt>value</tt> 被创建，持续于 <tt>c</tt>的整个生命周期。请密切注意，<tt>c</tt> 可能会递归调用 <tt>a</tt>。如果发生了这种情况，那么 <tt>a</tt> 也可以引用 <tt>c</tt> 的局部变量。<tt></tt><code></code>

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/confix.html  Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/confix.html  Sun Sep 20 23:13:57 2009
@@ -1,185 +1,175 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>Confix Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
+<html><head>
+

+<title>Confix Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>

 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>

- <td width="10">  </td>- <td width="85%"> Confix Parsers</td>- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>

+ <td width="10">  </td>+ <td width="85%"> Confix Parsers 片段分析器</td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="character_sets.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="list_parsers.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
-<p><a name="confix_parser"></a><b>Confix Parsers</b></p>
+</tbody></table>
+<p><a name="confix_parser"></a><b>Confix Parsers 片段分析器</b></p>

Confix Parsers recognize a sequence out of three independent elements:an

-       opening, an expression and a closing. A simple example is a C comment:

+ opening, an expression and a closing. A simple example is a Ccomment: 片段分析器识别一个包含三个元素的序列：一个开头、一个表达式和一个结尾。简单的例子就是C的注释：

 </p>
 <pre><code class="comment">    /* This is a C comment */</code></pre>

-which could be parsed through the following rule definition:<code><fontcolor="#000000">+which could be parsed through the following rule definition: 它可以用下面定义的规则来分析：<code>

   </font></code> </p>

-<pre> <spanclass=identifier>rule<> <spanclass=identifier>c_comment_rule- = <spanclass=identifier>confix_p(<spanclass=literal>"/*", <spanclass=special>*anychar_p<spanclass=special>, "*/")

-        </span><span class=special>;</span></pre>

+<pre> <spanclass="identifier">rule<> <spanclass="identifier">c_comment_rule <spanclass="special">= confix_p<spanclass="special">("/*"<spanclass="special">, *<spanclass="identifier">anychar_p, <spanclass="literal">"*/") <spanclass="special">;</pre>

 <p>The <tt>confix_p</tt> parser generator
   should be used for generating the required Confix Parser. The
   three parameters to <tt>confix_p</tt> can be single

characters (as above), strings or, if more complex parsing logic isrequired,auxiliary parsers, each of which is automatically converted to thecorresponding

-  parser type needed for successful parsing.</p>
-<p>The generated parser is equivalent to the following rule: </p>

-<pre><code> open <spanclass=special>>> (expr <spanclass=special>- close<spanclass=special>) >> <spanclass=identifier>close</code></pre>+ parser type needed for successful parsing. <tt>confix_p</tt> 分析器生成器用于生成所要求的片段分析器。<tt>confix_p</tt> 的三个参数可以是单个字符(如上)、字符串或是任意的分析器，如果需要更复杂的分析逻辑，三者都被自动转化为成功分析所需的恰当的分析器类型。+The generated parser is equivalent to the following rule: 所生成的分析器等价于下面的规则： +<pre><code> open <spanclass="special">>> (expr <spanclass="special">- close<spanclass="special">) >> <spanclass="identifier">close</code></pre>If the expr parser is an <tt>action_parser_category</tt> type parser (aparserwith an attached semantic action) we have to do something special. Thishappens,

-  if the user wrote something like:</p>

-<pre><code> confix_p<spanclass=special>(open<spanclass=special>, expr<spanclass=special>[func<spanclass=special>], close<spanclass=special>)</code></pre>+ if the user wrote something like: 如果 expr 分析器是一个<tt>action_parser_category</tt> 类型的分析器(可挂接语义动作的分析器)，我们就需要进行特别处理。这是在用户写出类似下面的代码时会发生的：+<pre><code> confix_p<spanclass="special">(open<spanclass="special">, expr<spanclass="special">[func<spanclass="special">], close<spanclass="special">)</code></pre>where <code>expr</code> is the parser matching the expr of the confixsequenceand <code>func</code> is a functor to be called after matching the<code>expr</code>.- If we would do nothing, the resulting code would parse the sequence asfollows:-<pre><code> open <spanclass=special>>> (expr<spanclass=special>[func<spanclass=special>] - close<spanclass=special>) >> <spanclass=identifier>close</code></pre>+ If we would do nothing, the resulting code would parse the sequence asfollows: 其中 <code>expr</code> 是匹配片段中的 expr 部分，而<code>func</code> 则是在匹配 <code>expr</code> 之后所调用的仿函数。如果我们不做任何事情，则产生的代码就会进行类似于如下的分析：+<pre><code> open <spanclass="special">>> (expr<spanclass="special">[func<spanclass="special">] - close<spanclass="special">) >> <spanclass="identifier">close</code></pre>which in most cases is not what the user expects. (If this iswhat you've

   expected, then please use the <tt>confix_p</tt> generator

function <tt>direct()</tt>, which will inhibit the parser refactoring).To make

-  the confix parser behave as expected:</p>

-<pre><code> open <spanclass=special>>> (expr <spanclass=special>- close<spanclass=special>)[func<spanclass=special>] >> <spanclass=identifier>close</code></pre>+ the confix parser behave as expected: 而这不是大多数用户所要的(如果这就是你想要的，那么请使用 <tt>confix_p</tt> 生成器函数<tt>direct()</tt>，它将返回所重构的分析器)。为了让片段分析器按照如下所预期的方式工作：+<pre><code> open <spanclass="special">>> (expr <spanclass="special">- close<spanclass="special">)[func<spanclass="special">] >> <spanclass="identifier">close</code></pre>the actor attached to the <code>expr</code> parser has to bere-attached tothe <code>(expr - close)</code> parser construct, which will make theresultingconfix parser 'do the right thing'. This refactoring is done by the helpofthe <a href="refactoring.html">Refactoring Parsers</a>. Additionallyspecialcare must be taken, if the expr parser is a<tt>unary_parser_category</tt> type

-  parser as </p>

-<pre><code> confix_p<spanclass=special>(open<spanclass=special>, *anychar_p<spanclass=special>, close<spanclass=special>)</code></pre>

-<p>which without any refactoring would result in </p>

-<pre><code> open <spanclass=special>>> (*anychar_p- <spanclass=identifier>close) >> <spanclass=identifier>close</code></pre>+ parser as 挂接于 <code>expr</code> 分析器之上的动作器必须重挂接到 <code>(expr - close)</code> 分析器上，才能使得所产生的片段分析器"行为得当"。这一重构借由<a href="refactoring.html">重构分析器</a>完成。还有必须要注意的是，如果 expr 分析器属于<tt>unary_parser_category</tt> 类型的分析器，比如：+<pre><code> confix_p<spanclass="special">(open<spanclass="special">, *anychar_p<spanclass="special">, close<spanclass="special">)</code></pre>+which without any refactoring would result in 以上如果不经重构则变成：+<pre><code> open <spanclass="special">>> (*anychar_p- <spanclass="identifier">close) >>close</code></pre>and will not give the expected result (*anychar_p will eat up all theinput up

-to the end of the input stream). So we have to refactor this into:

-<pre><code> open <spanclass=special>>> *(anychar_p- <spanclass=identifier>close) >> <spanclass=identifier>close</code></pre>

-<p>what will give the correct result. </p>

+to the end of the input stream). So we have to refactor this into: 而这将无法得出所期望的结果（*anychar_p 将接受任意字符，直到输入耗尽）。因此我们必须把这个重构为：<pre><code> open>> *(<spanclass="identifier">anychar_p - <spanclass="identifier">close) >>close</code></pre>

+<p>what will give the correct result.<br>从而得出正确的结果。</p>

The case, where the expr parser is a combination of the two mentionedproblems(i.e. the expr parser is a unary parser with an attached action), ishandled

-  accordingly too, so: </p>

-<pre><code> confix_p<spanclass=special>(open<spanclass=special>, (*anychar_p<spanclass=special>)[func<spanclass=special>], close)</code></pre>

-<p>will be parsed as expected: </p>

-<pre><code> open <spanclass=special>>> (*(anychar_p- end<spanclass=special>))[func<spanclass=special>] >> close</code></pre>+ accordingly too, so: expr 分析器揉杂了以上两个问题的情况（比如 expr 分析器是一个一元的且挂接了语义动作），也是通过同样的方法处理，因此：+<pre><code> confix_p<spanclass="special">(open<spanclass="special">, (*anychar_p<spanclass="special">)[func<spanclass="special">], close)</code></pre>

+<p>will be parsed as expected:<br>将会像下面所期望地那样分析：</p>

+<pre><code> open <spanclass="special">>> (*(anychar_p- <spanclass="identifier">end))[<spanclass="identifier">func] >>close</code></pre>The required refactoring is implemented here with the help of the <ahref="refactoring.html">Refactoring

-  Parsers</a> too.</p>
-<table width="90%" border="0" align="center">
-  <tr>

- <td colspan="2" class="table_title">Summary of Confix Parserrefactorings</td>+ Parsers</a> too. 必要的重构也是借由<a href="refactoring.html">重构分析器</a>来完成的。

+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td colspan="2" class="table_title">Summary of Confix Parserrefactorings 片段分析器重构概览</td>

   </tr>
   <tr class="table_title">
-    <td width="40%"><b>You write it as:</b></td>
+    <td width="40%"><b>You write it as: 源代码：</b></td>

<td width="60%"><code>It

-      is refactored to:</font></code></td>
+      is refactored to: 重构为：</font></code></td>
   </tr>
   <tr>

-        </font><span class=special>&gt;&gt;</span> close</code></p>

+ <td class="table_cells" width="60%"> <code>open <spanclass="special">>>+ (expr - close<spanclass="special">)

+        </font><span class="special">&gt;&gt;</span> close</code></p>
     </td>
   </tr>
   <tr>

- <td width="40%" class="table_cells"><code>confix_p<spanclass="special">(open<spanclass="special">,+ <td class="table_cells" width="40%"><code>confix_p<spanclass="special">(open<spanclass="special">,expr[func<spanclass="special">], close)</code></td>- <td width="60%" class="table_cells"> <code>open <spanclass=special>>>- (expr - close<spanclass="special">)[func]- >>close</code>+ <td class="table_cells" width="60%"> <code>open <spanclass="special">>>+ (expr - close<spanclass="special">)[func]+ >>close</code>

     </td>
   </tr>
   <tr>

- <td width="40%" class="table_cells" height="9"><code>confix_p<spanclass="special">(open<spanclass="special">,+ <td class="table_cells" height="9" width="40%"><code>confix_p<spanclass="special">(open<spanclass="special">,*expr, close<spanclass="special">)</code></td>- <td width="60%" class="table_cells" height="9"> <code>open <fontcolor="#0000FF">>>- *(expr- - close<spanclass="special">)- >>close</code>+ <td class="table_cells" height="9" width="60%"> <code>open <fontcolor="#0000ff">>>+ *(expr+ - close<spanclass="special">)+ >>close</code>

     </td>
   </tr>
   <tr>

- <td width="40%" class="table_cells"><code>confix_p<spanclass="special">(open<spanclass="special">,+ <td class="table_cells" width="40%"><code>confix_p<spanclass="special">(open<spanclass="special">,(*expr)[func<spanclass="special">],

       close</span><span class="special">)</span></code></td>

- <td width="60%" class="table_cells"> <code>open <fontcolor="#0000FF">>><spanclass="special">- (*(expr <fontcolor="#0000FF" class="special">-- close))[func]>>+ <td class="table_cells" width="60%"> <code>open <fontcolor="#0000ff">>><spanclass="special">+ (*(expr <fontclass="special" color="#0000ff">-+ close))[func]>>

         close</code></p>
     </td>
   </tr>
-</table>
-<p><a name="comment_parsers"></a><b>Comment Parsers</b></p>
+</tbody></table>
+<p><a name="comment_parsers"></a><b>Comment Parsers 注释分析器</b></p>
 <p>The Comment Parser generator template <tt>comment_p</tt>

is helper for generating a correct <a href="#confix_parser">ConfixParser</a>- from auxiliary parameters, which is able to parse comment constructs asfollows:+ from auxiliary parameters, which is able to parse comment constructs asfollows: 注释分析器生成器模板 <tt>comment_p</tt> 是一个用于从附加的参数生成正确的<a href="#confix_parser">片段分析器</a>的辅助生成器，它可以正确分析类似下面结构的注释：

 </p>

<pre><code> StartCommentToken >>Comment text >>EndCommentToken</code></pre>

 <p>There are the following types supported as parameters: parsers, single
   characters and strings (see as_parser). If it

is used with one parameter, a comment starting with the given firstparserparameter up to the end of the line is matched. So for instance thefollowing

-  parser matches C++ style comments:</p>
-

-<pre><code> comment_p<spanclass=special>("//"<spanclass=special>)</code></pre>+ parser matches C++ style comments: 参数可以是如下类型：分析器、单个字符和字符串（见as_parser)。如果只有一个参数，那么就认为一个注释就从给定的参数开始直到一行的结束。所以，例如下面的分析器就匹配C++风格的注释：

+<pre><code> comment_p<spanclass="special">("//"<spanclass="special">)</code></pre>If it is used with two parameters, a comment starting with the firstparserparameter up to the second parser parameter is matched. For instance a Cstyle

-  comment parser could be constrcuted as:</p>

-<pre><code> comment_p<spanclass=special>("/*","*/"<spanclass=special>)</code></pre>+ comment parser could be constrcuted as: 如果使用两个参数，则一个注释从第一个参数开始，直到匹配了第二个参数才结束。比如C风格的注释就可以构造如下：+<pre><code> comment_p<spanclass="special">("/*"<spanclass="special">, "*/"<spanclass="special">)</code></pre>The <tt>comment_p</tt> parser generator allows to generate parsers formatchingnon-nested comments (as for C/C++ comments). Sometimes it is necessaryto parse

-  nested comments as for instance allowed in Pascal.</p>

+ nested comments as for instance allowed inPascal. <tt>comment_p</tt> 生成器允许生成非嵌套的注释（就像C/C++的注释）。有时需要分析嵌套的注释，就像下面给出的Pascal里的：<pre><code class="comment"> { This is a { nested } PASCAL-comment}</code></pre>

 <p>Such nested comments are

parseable through parsers generated by the <tt>comment_nest_p</tt>generatortemplate functor. The following example shows a parser, which can beused for

-  parsing the two different (nestable) Pascal comment styles:</p>

-<pre><code> rule<spanclass=special><> pascal_comment- = <spanclass=identifier>comment_nest_p(<spanclass=string>"(*", <spanclass=string>"*)")- | comment_nest_p<spanclass=special>('{','}')

-        ;</span></code></pre>

+ parsing the two different (nestable) Pascal comment styles: 这样的嵌套注释可以用生成器模板仿函数 <tt>comment_nest_p</tt><spanstyle="font-family: Courier New;"> 所生成的分析器分析。下面的例子给出了一个分析器，它可以用于分析两种不同风格（可嵌套）的Pascal注释：+<pre><code> rule<spanclass="special"><> <spanclass="identifier">pascal_comment <spanclass="special">= <spanclass="identifier">comment_nest_p(<spanclass="string">"(*", <spanclass="string">"*)") |comment_nest_p<spanclass="special">('{'<spanclass="special">, '}'<spanclass="special">) ;</code></pre>Please note, that a comment is parsed implicitly as if the whole<tt>comment_p(...)</tt>statement were embedded into a <tt>lexeme_d[]</tt> directive, i.e.during parsingof a comment no token skipping will occur, even if you've defined a skipparser

-for your whole parsing process.</p>

- <img height="16" width="15" src="theme/lens.gif"> <ahref="../example/fundamental/comments.cpp">comments.cpp</a> demonstratesvarious comment parsing schemes: +for your whole parsing process. 请注意，这样分析的注释暗示着类似把整个<tt>comment_p(...)</tt> 语句放到一个 <tt>lexeme_d[]</tt> 里面，举例而言，在整个分析注释的过程中，将不会有忽略符号的情况发生，即使你已经为你的整个分析过程指定了忽略分析器。+ <img src="theme/lens.gif" height="16" width="15"> <ahref="../example/fundamental/comments.cpp">comments.cpp</a> demonstratesvarious comment parsing schemes: <img src="theme/lens.gif" height="16"width="15"> <ahref="../example/fundamental/comments.cpp">comments.cpp</a> 给出了各种各样的注释分析方案：

 <ol>
-  <li>Parsing of different comment styles  </li>
+  <li>Parsing of different comment styles<br>分析不同风格的注释  </li>
   <ul>
-    <li>parsing C/C++-style comment</li>
-    <li>parsing C++-style comment</li>
-    <li>parsing PASCAL-style comment</li>
+    <li>parsing C/C++-style comment<br>分析C/C++风格的注释</li>
+    <li>parsing C++-style comment<br>分析C++风格的注释</li>
+    <li>parsing PASCAL-style comment<br>分析PASCAL风格的注释</li>
   </ul>
-  <li>Parsing tagged data with the help of the confix_parser</li>

- <li>Parsing tagged data with the help of the confix_parser but thesemantic 

-  action is directly attached to the body sequence parser</li>

+ <li>Parsing tagged data with the help of the confix_parser 借助confix_parser 分析标记语言的数据</li>+ <li>Parsing tagged data with the help of the confix_parser but thesemantic action is directly attached to the body sequence parser 借助confix_parser分析标记语言的数据，但语义动作直接挂接到片段的内容上</li>

 </ol>
-<p>This is part of the Spirit distribution.</p>

+This is part of the Spirit distribution. 这是Spirit发布包的组成部分。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2002 Hartmut Kaiser<br>
+<p class="copyright">Copyright © 2001-2002 Hartmut Kaiser<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/distinct.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/distinct.html        Sun Sep 20 23:13:57 2009
@@ -1,122 +1,98 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>Distinct Parser</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

+<html><head><meta content="text/html; charset=UTF-8"http-equiv="content-type">

+
+

+<title>Distinct Parser</title><link rel="stylesheet"href="theme/style.css" type="text/css"></head>

 <body>

-<table width="100%" height="48" border="0" background="theme/bkd2.gif"cellspacing="2">

-  <tr>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" height="48"width="100%">

+  <tbody><tr>
     <td width="10">
     </td>
     <td width="85%">

- Distinct Parser </td>+ Distinct Parser 区分分析器 </td><td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="scoped_lock.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="symbols.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
-<h3>Distinct Parsers</h3><p>
+</tbody></table>
+<h3>Distinct Parsers 区分分析器</h3><p>
 The distinct parsers are utility parsers which ensure that matched input is
 not immediately followed by a forbidden pattern. Their typical usage is to
-distinguish keywords from identifiers.</p>

+distinguish keywords from identifiers. 区分分析器是一个工具分析器，它确保被匹配的输入没有被一个禁止的模式所跟随。它们的典型用途是区分关键字和标识符。

 <h3>distinct_parser</h3>
 <p>

The basic usage of the <tt>distinct_parser</tt> is to replace the<tt>str_p</tt> parser. For

-example the <tt>declaration_rule</tt> in the following example:</p>
-<pre>

- <code>rule<spanclass=special><ScannerT<spanclass=special>> declaration_rule= <spanclass=identifier>str_p(<spanclass=string>"declare") >>lexeme_d<spanclass=special>[+alpha_p<spanclass=special>];

-</span></code></pre>

+example the <tt>declaration_rule</tt> in the followingexample: <tt>distinct_parser</tt> 的基本用途是替换 <tt>str_p</tt> 分析器。例如，以下例子中的 <tt>declaration_rule</tt> :+<pre> <code>rule<spanclass="special"><ScannerT<spanclass="special">> declaration_rule= <spanclass="identifier">str_p(<spanclass="string">"declare") >>lexeme_d<spanclass="special">[+alpha_p<spanclass="special">]; </code></pre>

<p>

-would correctly match an input "declare abc", but as well aninput"declareabc" what is usually not intended. In order to avoidthis, we can

-use <tt>distinct_parser</tt>:</p>
+would correctly match an input "declare abc", but as well an
+input"declareabc" what is usually not intended. In order to avoid this,
+we can

+use <tt>distinct_parser</tt>: 可以正确地匹配输入 "declare abc"，也可能匹配 "declareabc"，但这通常不是想要的。为了避免这种情况，我们可以使用 <tt>distinct_parser</tt>:

 <code>
-<pre>
-    <span class=comment>// keyword_p may be defined in the global scope

- distinct_parser<spanclass=special><> keyword_p<spanclass=special>("a-zA-Z0-9_"<spanclass=special>);

- rule<spanclass=special><ScannerT<spanclass=special>> declaration_rule= <spanclass=identifier>keyword_p(<spanclass=string>"declare") >>lexeme_d<spanclass=special>[+alpha_p<spanclass=special>];

-</span></pre>
-</code>

+</code><pre> // keyword_p may be defined in theglobal scope keyword_p可以在全局范围内定义 <spanclass="identifier">distinct_parser<>keyword_p<spanclass="special">("a-zA-Z0-9_"<spanclass="special">); <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">declaration_rule =keyword_p<spanclass="special">("declare"<spanclass="special">) >> <spanclass="identifier">lexeme_d[+<spanclass="identifier">alpha_p]; </pre>

+
 <p>

The <tt>keyword_p</tt> works in the same way as the <tt>str_p</tt> parserbut matches only

 when the matched input is not immediately followed by one of the characters

from the set passed to the constructor of <tt>keyword_p</tt>. In theexample the-"declare" can't be immediately followed by any alphabeticcharacter, any

-number or an underscore.</p>
+"declare" can't be immediately followed by any alphabetic character, any

+number or an underscore. <tt>keyword_p</tt> 的用法与 <tt>str_p</tt> 分析器相同，但仅当被匹配的输入不是被传给 <tt>keyword_p</tt> 的构造函数的字符集中的某个字符所紧随时，才匹配成功。在本例中，"declare" 不能被任何字母、数字或下划线所紧随。

<p>

-See the full <ahref="../example/fundamental/distinct/distinct_parser.cpp">example here</a>.+See the full <ahref="../example/fundamental/distinct/distinct_parser.cpp">example here</a>. 完整的<ahref="../example/fundamental/distinct/distinct_parser.cpp">例子在此</a>。

 <h3>distinct_directive</h3><p>
 For more sophisticated cases, for example when keywords are stored in a
-symbol table, we can use <tt>distinct_directive</tt>.</p>
-<pre>

- <code>distinct_directive<spanclass=special><> keyword_d<spanclass=special>("a-zA-Z0-9_"<spanclass=special>);

- symbol<spanclass=special><> keywords <spanclass=special>= "declare"<spanclass=special>, "begin"<spanclass=special>, "end"<spanclass=special>;- rule<spanclass=special><ScannerT<spanclass=special>> keyword <spanclass=special>= keyword_d<spanclass=special>[keywords<spanclass=special>];

-</span></code></pre>

+symbol table, we can use <tt>distinct_directive</tt>. 对于更复杂的情况，例如当关键字被保存在一个符号表中时，我们可以使用<tt>distinct_directive</tt>。+<pre> <code>distinct_directive<spanclass="special"><> <spanclass="identifier">keyword_d(<spanclass="string">"a-zA-Z0-9_"); symbol<>keywords ="declare","begin","end"; rule<spanclass="special"><ScannerT<spanclass="special">> keyword <spanclass="special">= keyword_d<spanclass="special">[keywords<spanclass="special">]; </code></pre>

 <h3>dynamic_distinct_parser and dynamic_distinct_directive</h3><p>
 In some cases a set of forbidden follow-up characters is not sufficient.
 For example ASN.1 naming conventions allows identifiers to contain dashes,
 but not double dashes (which marks the beginning of a comment).
 Furthermore, identifiers can't end with a dash. So, a matched keyword can't
 be followed by any alphanumeric character or exactly one dash, but can be
-followed by two dashes.</p>

+followed by two dashes. 有些情况下，只有一组被禁用的跟随字符是不够的。例如，ASN.1 命名约定允许标识符带有破折号，但不允许双划线(这标志着一个注释的开始)。此外，标识符不能以破折号结束。所以，一个被匹配的关键字不能后随任何字母数字和单一个破折号，但可以后随两个破折号。

<p>

This is when <tt>dynamic_distinct_parser</tt> and the<tt>dynamic_distinct_directive </tt>come into play. The constructor of the<tt>dynamic_distinct_parser</tt> accepts a-parser which matches any input that must NOT follow thekeyword.

-<pre>

- <code>// Alphanumeric characters and a dashfollowed by a non-dash

-    // may not follow an ASN.1 identifier.

- dynamic_distinct_parser<spanclass=special><> keyword_p<spanclass=special>(alnum_p <spanclass=special>| ('-' <spanclass=special>>> ~ch_p<spanclass=special>('-')));

-</span></code></pre>

+parser which matches any input that must NOT follow thekeyword. 这就是 <tt>dynamic_distinct_parser</tt> 和<tt>dynamic_distinct_directive </tt>大显身手的时候了。<tt>dynamic_distinct_parser</tt> 的构造函数接受一个分析器，用于匹配不能跟在该关键字之后的任意输入。+<pre> <code>// Alphanumeric characters and a dashfollowed by a non-dash // may not follow an ASN.1 identifier. dynamic_distinct_parser<spanclass="special"><> <spanclass="identifier">keyword_p(<spanclass="identifier">alnum_p | (<spanclass="literal">'-' >> ~<spanclass="identifier">ch_p(<spanclass="literal">'-'))); rule<spanclass="special"><ScannerT<spanclass="special">> declaration_rule= <spanclass="identifier">keyword_p(<spanclass="string">"declare") >>lexeme_d<spanclass="special">[+alpha_p<spanclass="special">]; </code></pre>

<p>

Since the <tt>dynamic_distinct_parser</tt> internally uses a rule, itstype isdependent on the scanner type. So, the <tt>keyword_p</tt> shouldn't bedefined

-globally, but rather within the grammar.</p>

+globally, but rather within the grammar. 由于<tt>dynamic_distinct_parser</tt> 在内部使用了一个规则，所以它的类型依赖于扫描器的类型。因此，<tt>keyword_p</tt> 不能在全局被定义，而应在语法内部。

<p>

-See the full <ahref="../example/fundamental/distinct/distinct_parser_dynamic.cpp">examplehere</a>.

-<h3>How it works</h3><p>

-When the <tt>keyword_p_1</tt> and the <tt>keyword_p_2</tt> are definedas

-<code><pre>

- distinct_parser<spanclass=special><> keyword_p<spanclass=special>(forbidden_chars<spanclass=special>);- distinct_parser_dynamic<spanclass=special><> keyword_p<spanclass=special>(<spanclass=identifier>forbidden_tail_parser);

-</span></pre></code>

+See the full <ahref="../example/fundamental/distinct/distinct_parser_dynamic.cpp">examplehere</a>. 完整的<ahref="../example/fundamental/distinct/distinct_parser_dynamic.cpp">例子在此</a>。

+<h3>How it works 它是如何工作的</h3><p>

+When the <tt>keyword_p_1</tt> and the <tt>keyword_p_2</tt> are definedas 当 <tt>keyword_p_1</tt> 和 <tt>keyword_p_2</tt> 被定义为+<code></code><pre> distinct_parser<spanclass="special"><> <spanclass="identifier">keyword_p(<spanclass="identifier">forbidden_chars); distinct_parser_dynamic<spanclass="special"><> <spanclass="identifier">keyword_p(<spanclass="identifier">forbidden_tail_parser<spanclass="special">); </pre>

 <p>
-the parsers</p>
-<code><pre>

- keyword_p_1<spanclass=special>(str)- keyword_p_2<spanclass=special>(str)

-</span></pre></code>
+the parsers<br>分析器</p>

+<code></code><pre> keyword_p_1<spanclass="special">(str<spanclass="special">) <spanclass="identifier">keyword_p_2(<spanclass="identifier">str) </pre>

 <p>
-are equivalent to the rules</p>
-<code><pre>

- lexeme_d<spanclass=special>[chseq_p<spanclass=special>(str<spanclass=special>) >> ~<spanclass=identifier>epsilon_p(<spanclass=identifier>chset_p(<spanclass=identifier>forbidden_chars))]- lexeme_d<spanclass=special>[chseq_p<spanclass=special>(str<spanclass=special>) >> ~<spanclass=identifier>epsilon_p(<spanclass=identifier>forbidden_tail_parser)]

-</span></pre></code>
+are equivalent to the rules<br>相当于规则</p>

+<code></code><pre> lexeme_d<spanclass="special">[chseq_p<spanclass="special">(str<spanclass="special">) >> ~<spanclass="identifier">epsilon_p(<spanclass="identifier">chset_p(<spanclass="identifier">forbidden_chars))] lexeme_d<spanclass="special">[chseq_p<spanclass="special">(str<spanclass="special">) >> ~<spanclass="identifier">epsilon_p(<spanclass="identifier">forbidden_tail_parser<spanclass="special">)] </pre>

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2003-2004
+<p class="copyright">Copyright © 2003-2004


  Vaclav Vesely<br><br>

- Use, modification and distribution is subject to the BoostSoftware License, Version 1.0. (See accompanying file LICENSE_1_0.txt orcopy at http://www.boost.org/LICENSE_1_0.txt) 

-</body>
-</html>
+ <font size="2">Use,
+modification and distribution is subject to the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt) </font>  </p>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/dynamic_parsers.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/dynamic_parsers.html Sun Sep 20 23:13:572009

@@ -1,95 +1,102 @@
-<html>
-<head>
-<title>Dynamic Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Dynamic Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Dynamic

-      Parsers </b></font></td>

- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>+ <td width="85%"> Dynamic

+      Parsers 动态分析器 </b></font></td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="closures.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="stored_rule.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>

-We see dynamic parsing everywhere in Spirit. A special group ofparsers, aptly named dynamic parsers, form the most basic building blocksto dynamic parsing. This chapter focuses on these critters. You'll noticethe similarity of these parsers with C++'s control structures. Thesimilarity is not a coincidence. These parsers give an imperative flavor toparsing, and, since imperative constructs are not native to declarativeEBNF, mimicking the host language, C++, should make their use immediatelyfamiliar. 

+</tbody></table>
+<p>We see dynamic parsing everywhere in Spirit. A special group of
+parsers, aptly named dynamic parsers, form the most basic building
+blocks to dynamic parsing. This chapter focuses on these critters.
+You'll notice the similarity of these parsers with C++'s control
+structures. The similarity is not a coincidence. These parsers give an
+imperative flavor to parsing, and, since imperative constructs are not
+native to declarative EBNF, mimicking the host language, C++, should

+make their use immediately familiar. 在Spirit中动态分析随处可见。有一组特别的分析器，被恰当地命名为动态分析器，组成了动态分析中最基本的成分。这章的焦点集中于这些关键要素+上。你将看到这些分析器和C++控制结构的相似性。但相似性并非一致性。这些分析器带来了指令式分析，并且，由于指令式结构并非声明式的EBNF的特征，而是

+模仿宿主语言C++，将使这些分析器的使用方法能够被迅速熟悉。</p>

Dynamic parsers modify the parsing behavior according to conditions.Constructingdynamic parsers requires a condition argument and a body parserargument. Additional

-    arguments are required by some parsers.</p>
-<h2>Conditions</h2>

+ arguments are required by some parsers. 动态分析器通过条件改变分析行为。构造动态分析器需要一个条件参数和一个分析器体参数。某些分析器需要更多的参数。

+<h2>Conditions 条件</h2>

Functions or functors returning values convertable to bool can be usedas conditions.When the evaluation of the function/functor yields true it will beconsidered

-  as meeting the condition.</p>

+ as meeting the condition. 其返回值可以转换为bool型的函数或仿函数可以被用作条件。当函数/仿函数的演算值为真时，则认为条件被符合。

+</p>

Parsers can be used as conditions, as well. When the parser matches theconditionis met. Parsers used as conditions work in an all-or-nothing manner: thescanner

-  will not be advanced when they don't match.</p>
-<p>A failure to meet the condition will not result in a parse error.</p>

+ will not be advanced when they don't match.  分析器也可以作为条件使用。当分析器匹配时，认为条件被符合。被当成条件使用的分析器以一种"零或全部"的行为工作：当不匹配时，扫描器不会前进。+A failure to meet the condition will not result in a parse error. 失败的条件匹配不会引起分析错误。

 <h2>if_p</h2>

-<tt>if_p</tt> can be used with or without an else-part. The syntaxis:-<pre> if_p<spanclass=special>(condition<spanclass=special>)[then<spanclass=special>-parser<spanclass=special>]</pre>

-<p><span class=special></span>or</p>

-<pre> if_p<spanclass=special>(condition<spanclass=special>)[then<spanclass=special>-parser<spanclass=special>].else_p<spanclass=special>[else<spanclass=special>-parser<spanclass=special>]</pre>+<tt>if_p</tt> can be used with or without an else-part. The syntaxis: <tt>if_p</tt> 的 else 部分可有可无。它的语法为：+<pre> if_p<spanclass="special">(condition<spanclass="special">)[then<spanclass="special">-parser<spanclass="special">]</pre>

+<p><span class="special"></span>or<br>或</p>

+<pre> if_p<spanclass="special">(condition<spanclass="special">)[then<spanclass="special">-parser<spanclass="special">].else_p<spanclass="special">[else<spanclass="special">-parser<spanclass="special">]</pre>When the condition is met the then-parser is used next in the parsingprocess.When the condition is not met and an else-parser is available theelse-parseris used next. When the condition isn't met and no else-parser isavailable then- the whole parser matches the empty sequence. (<img src="theme/alert.gif"width="16" height="16">+ the whole parser matches the empty sequence. (<img src="theme/alert.gif"height="16" width="16">Note: older versions of <tt>if_p</tt> report a failure when thecondition isn't

-  met and no else-parser is available.)</p>
-<p>Example:</p>

-<pre> <spanclass=identifier>if_p(<spanclass=string>"0x")[<spanclass=identifier>hex_p].<spanclass=identifier>else_p[<spanclass=identifier>uint_p]</pre>+ met and no else-parser is available.) 当条件匹配时，then-分析器将被用于下一步的分析过程。当条件不匹配且else-分析器存在时，else-分析器被接着调用。当条件不匹配而else-分析器也不存在时，那么整个分析器将匹配空序列（<imgsrc="theme/alert.gif" height="16" width="16">注意：老版本的<tt>if_p</tt> 在条件不匹配且没有else-分析器时会报告一个失败）。

+<p>Example:<br>例如：</p>

+<pre> <spanclass="identifier">if_p(<spanclass="string">"0x")[<spanclass="identifier">hex_p].<spanclass="identifier">else_p[<spanclass="identifier">uint_p]</pre>

 <h2>while_p, do_p</h2>
-<p><tt>while_p</tt>/<tt>do_p</tt> syntax is:</p>

-<pre> while_p<spanclass=special>(condition<spanclass=special>)[body<spanclass=special>-parser<spanclass=special>]- do_p<spanclass=special>[body<spanclass=special>-parser<spanclass=special>].while_p<spanclass=special>(condition<spanclass=special>)</pre>+<tt>while_p</tt>/<tt>do_p</tt> syntaxis: <tt>while_p</tt>/<tt>do_p</tt> 的语法为：+<pre> while_p<spanclass="special">(condition<spanclass="special">)[body<spanclass="special">-parser<spanclass="special">] do_p<spanclass="special">[body<spanclass="special">-parser<spanclass="special">].while_p<spanclass="special">(condition<spanclass="special">)</pre>As long as the condition is met the dynamic parser constructed by<tt>while_p</tt>will try to match the body-parser. <tt>do_p</tt> returns a parser thattriesto match the body-parser and then behaves just like the parser returnedby <tt>while_p</tt>.A failure to match the body-parser will cause a failure to be reportedby the

-  while/do-parser.</p>
-<p>Example:</p>

-<pre> <spanclass=identifier>uint_p[<spanclass=identifier>assign_a(<spanclass=identifier>sum)] >> <spanclass=identifier>while_p(<spanclass=literal>'+')[<spanclass=identifier>uint_p(<spanclass=identifier>add(<spanclass=identifier>sum)]- '"' <spanclass=special>>> while_p<spanclass=special>(~eps_p<spanclass=special>('"'<spanclass=special>))[c_escape_ch_p<spanclass=special>[push_back_a<spanclass=special>(result<spanclass=special>)]] >> '"'+ while/do-parser. 只要条件匹配，由 <tt>while_p</tt> 构造的动态分析器将一直尝试匹配body-分析器。<tt>do_p</tt> 则返回一个首先尝试匹配body-分析器，接着就干和<spanstyle="font-family: Courier New;"><tt>while_p</tt> <spanstyle="font-family: Courier New;">一样的事情的分析器。body-分析器的匹配失败将导致while/do-分析器报告一个失败。

+<p>Example:<br>例如：</p>

+<pre> <spanclass="identifier">uint_p[<spanclass="identifier">assign_a(<spanclass="identifier">sum)] >> <spanclass="identifier">while_p(<spanclass="literal">'+')[<spanclass="identifier">uint_p(<spanclass="identifier">add(<spanclass="identifier">sum)] <spanclass="literal">'"' >> <spanclass="identifier">while_p(~<spanclass="identifier">eps_p(<spanclass="literal">'"'))[<spanclass="identifier">c_escape_ch_p[<spanclass="identifier">push_back_a(<spanclass="identifier">result)]] >>'"'

 </pre>
 <h2>for_p</h2>
-<p><tt>for_p</tt> requires four arguments. The syntax is:</p>

-<pre> <spanclass=identifier>for_p(<spanclass=identifier>init, <spanclass=identifier>condition, <spanclass=identifier>step)[<spanclass=identifier>body-<spanclass=identifier>parser]</pre>+<tt>for_p</tt> requires four arguments. The syntaxis: <tt>for_p</tt> 需要四个参数。其语法为：+<pre> <spanclass="identifier">for_p(<spanclass="identifier">init, <spanclass="identifier">condition, <spanclass="identifier">step)[<spanclass="identifier">body-<spanclass="identifier">parser]</pre>init and step have to be 0-ary functions/functors. for_p returns aparser that

-  will:</p>
+  will:<br>init 和 step 必须是无参数函数/仿函数。for_p 返回的分析器将：</p>
 <ol>
-  <li> call init</li>

- <li>check the condition, if the condition isn't met then a match isreturned. The match will cover everything that has been matchedsuccessfully up to this point.</li>- <li> tries to match the body-parser. A failure to match the body-parserwill cause a failure to be reported by the for-parser</li>

-  <li> calls step</li>
-  <li> goes to 2.</li>
+  <li> call init<br>调用 init</li>
+  <li>check the condition, if the
+condition isn't met then a match is returned. The match will cover

+everything that has been matched successfully up to this point. 检查条件，如果条件不符合则返回一个匹配，这个匹配覆盖着到目前为止所匹配的所有东西。 </li>+ <li> tries to match the body-parser. A failure to match the body-parserwill cause a failure to be reported by the for-parser 尝试匹配body-分析器，body-分析器匹配失败会使for-分析器报告失败。</li>

+  <li> calls step<br>调用 step</li>
+  <li> goes to 2.<br>转至步骤2。</li>
 </ol>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2002-2003 Joel de Guzman<br>
-  Copyright &copy; 2002-2003 Martin Wille<br>
+<p class="copyright">Copyright © 2002-2003 Joel de Guzman<br>
+  Copyright © 2002-2003 Martin Wille<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/escape_char_parser.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/escape_char_parser.html Sun Sep 2023:13:57 2009

@@ -1,58 +1,57 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>Escape Character Parser</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
-</head>
+<html><head>
+

+<title>Escape Character Parser</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link href="theme/style.css" rel="stylesheet" type="text/css"></head>

 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>

- <td width="10" height="49">  </td>- <td width="85%" height="49"> Escape Character Parser</td>- <td width="112" height="49"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>

+ <td height="49" width="10">  </td>+ <td height="49" width="85%"> Escape Character Parser 转义字符分析器</td>+ <td height="49" width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td>- <td width="30"><a href="switch_parser.html"><img src="theme/l_arr.gif"width="20" height="19" border="0"></a></td>+ <td width="30"><a href="switch_parser.html"><img src="theme/l_arr.gif"border="0" height="19" width="20"></a></td><td width="30"><a href="loops.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>

-<a name="escape_char_parser"></a>The Escape Character Parser is autility

-  parser, which parses escaped character sequences used in C/C++,

- LEX or Perl regular expressions. Combined with the confix_p utilityparser, it is useful for parsing C/C++ strings containing double quotes andother escaped

-  characters:</p>
+</tbody></table>
+<p><a name="escape_char_parser"></a>The Escape Character Parser is a
+utility parser, which parses escaped character sequences used in C/C++,
+LEX or Perl regular expressions. Combined with the confix_p utility
+parser, it is useful for parsing C/C++ strings containing double quotes

+and other escaped characters: 转义字符分析器属于工具分析器，用于分析C/C++、LEX 或 Perl 正则表达式中的转义字符串。将之与 confix_p 工具分析器共同使用，在分析 C/C++ 中由引号引起的字符串方面很有用。<pre> confix_p(<emclass="literal">'"', <spanclass="special">*c_escape_ch_p,'"<spanclass="literal">')</pre>

 <p>There are two different types of the Escape Character Parser:

<tt>c_escape_ch_p</tt>, which parses C/C++ escaped character sequencesand<tt>lex_escape_ch_p</tt>, which parses LEX style escaped charactersequences.The following table shows the valid character sequences understood bythese

-  utility parsers.</p>
-<table width="90%" border="0" align="center">
-  <tr>

+ utility parsers. 有两种不同的转义字符分析器：<tt>c_escape_ch_p</tt>，分析C/C++ 转移字符串，和 <tt>lex_escape_ch_p</tt><spanstyle="font-family: Courier New;">，分析 LEX 风格的转移字符串。下面的表格说明了这些工具分析器所能有效识别的转移字符串。

+<table align="center" border="0" width="90%">
+  <tbody><tr>

<td colspan="2" class="table_title">Summary of valid escapedcharacter

-      sequences</b></td>
+      sequences 有效转义字符序列概览</b></td>
   </tr>
   <tr>

- <td width="29%" height="27"class="table_cells">c_escape_ch_p</td>- <td width="71%" class="table_cells"><code>\b, \t, \n, \f, \r, \\,\",+ <td class="table_cells" height="27"width="29%">c_escape_ch_p</td>+ <td class="table_cells" width="71%"><code>\b, \t, \n, \f, \r, \\,\",

         \', \xHH, \OOO</code><br>

where: H is some hexadecimal digit (0..9, a..f, A..F) and O issome octal

-        digit (0..7)</p></td>

+ digit (0..7)其中：H 是十六进制数字(0..9, a..f, A..F) 而 O 是八进制数字(0..7)</td>

   </tr>
   <tr>

- <td height="27"class="table_cells">lex_escape_ch_p</td>+ <td class="table_cells"height="27">lex_escape_ch_p</td>

     <td class="table_cells">

all C/C++ escaped character sequences as described above andadditionally

-        any other character, which follows a backslash</p>

+ any other character, which follows a backslash 上面的所有C/C++转移字符串，以及紧随反斜线的任意字符

     </td>
   </tr>
-</table>
+</tbody></table>

If there is a semantic action attached directly to the Escape CharacterParser,

   all valid escaped characters are converted to their character equivalent
   (i.e. a backslash followed by a 'r' is converted to '\r'), which is
@@ -61,28 +60,32 @@
   overflow will be detected and will generate a non-match.  lex_escape_ch_p
   will strip the leading backslash for all character

sequences which are not listed as valid C/C++ escape sequences whenpassing

-  the unescaped character to an attached action.</p>
+  the unescaped character to an attached action.<br>如

+果有语义动作挂接在转移字符分析器上，被传递给挂接的动作器的所有的有效转义字符将被转换成与之等价的实际字符（比如一个反斜线后面跟着一个'r'将被转+换为'\r'）。所分析出的十六进制或者八进制数值的个数将取决于输入字符的尺寸。而溢出将被检测到并且引发一个匹配失败。

+lex_escape_ch_p

+在分析尚未分析的字符并传递给语义动作时，对所有带反斜线但不是C/C++中有效的转移字符串的字符串，将忽略开头的反斜

+线。</p>
 <p>Please note though, that if there is a semantic action attached to an

outermost parser (for instance as in<tt>(*c_escape_ch_p)[some_actor]</tt>,where the action is attached to the kleene star generated parser) noconversiontakes place at the moment, but nevertheless the escaped characters areparsed- correctly. This limitation will be removed in a future version of thelibrary.+ correctly. This limitation will be removed in a future version of thelibrary. 请注意，如果语义动作挂接在最外围的分析器上（比如类似<tt>(*c_escape_ch_p)[some_actor]</tt>，语义动作挂接在克林星分析器上）将不会产生字符的转换，取而代之的是直接把字符串传递给语义动作。这个限制在以后的版本中将被清除。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>

 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2002 Daniel C. Nuffer<br>
-Copyright &copy; 2003 Hartmut Kaiser <br>
+<p class="copyright">Copyright © 2001-2002 Daniel C. Nuffer<br>
+Copyright © 2003 Hartmut Kaiser <br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/functional.html      Sat Sep 12 00:52:19 2009
+++ /trunk/libs/spirit/classic/doc/functional.html      Sun Sep 20 23:13:57 2009
@@ -1,265 +1,242 @@
-<html>
-<head>
-<title>Functional</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><title>Functional</title>
+
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
-    <td width="10">
-    </td>

- <td width="85%"> Functional

-    </td>

- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

-  </tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+<tbody>
+<tr>
+<td width="10"> </td>

+<td width="85%"> Functional

+函数式</b></font> </td>

+<td width="112"><a href="http://spirit.sf.net";><img src="theme/spirit.gif"align="right" border="0" height="48" width="112"></a></td>

+</tr>
+</tbody>
 </table>
 <br>
 <table border="0">
-  <tr>
-    <td width="10"></td>

- <td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td>- <td width="30"><a href="parametric_parsers.html"><imgsrc="theme/l_arr.gif" border="0"></a></td>- <td width="30"><a href="phoenix.html"><img src="theme/r_arr.gif"border="0"></a></td>

-  </tr>
+<tbody>
+<tr>
+<td width="10"></td>

+<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td>+<td width="30"><a href="parametric_parsers.html"><imgsrc="theme/l_arr.gif" border="0"></a></td>+<td width="30"><a href="phoenix.html"><img src="theme/r_arr.gif"border="0"></a></td>

+</tr>
+</tbody>
 </table>

-If you look more closely, you'll notice that Spirit is all aboutcomposition- of parser functions. A parser is just a function that accepts ascanner- and returns a match. Parser functions are composed to formincreasingly- complex higher order forms. Notice too that the parser, albeit anobject,- is immutable and constant. All primitive and composite parser objectsare <tt>const</tt>.

-  The parse member function is even declared as <tt>const</tt>:</p>
-<pre>

- <code>template <spanclass=special><typename <spanclass=identifier>ScannerT>- typename <spanclass=identifier>parser_result<<spanclass=identifier>self_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse<spanclass=special>(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan) <spanclass=keyword>const;</code></pre>- In all accounts, this looks and feels a lot like FunctionalProgramming.- And indeed it is. Spirit is by all means an application of Functionalprogramming- in the imperative C++ domain. In Haskell, for example, there is what arecalled- <a href="references.html#combinators">parser combinators</a> which arestrikingly- similar to the approach taken by Spirit- parser functions which arecomposed- using various operators to create higher order parser functions thatmodel a- top-down recursive descent parser. Those smart Haskell folks have beendoing

-  this way before Spirit.</p>

- Functional style programming (or FP) libraries are gaining momentum inthe- C++ community. Certainly, we'll see more of FP in Spirit now and in thefuture.- Actually, if one looks more closely, even the C++ standard library hasan FP- flavor. Stealthily beneath the core of the standard C++ library, acloser look- into STL gives us a glimpse of a truly FP paradigm already in place. Itis obvious

-  that the authors of STL know and practice FP.</p>
-
-<h2>Semantic Actions in the FP Perspective</h2>
-
-<h3>STL style FP</h3>

- A more obvious application of STL-style FP in Spirit is the semanticaction.- What is STL-style FP? It is primarily the use of functors that can becomposed

-  to form higher order functors.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/note.gif" width="16"height="16"> Functors 

-      <br>

- A Function Object, or Functor is simply any object that can becalled as- if it is a function. An ordinary function is a function object, andso is- a function pointer; more generally, so is an object of a class thatdefines

-      operator(). </td>
-  </tr>
+<p>If you look more closely, you'll notice that Spirit is all
+about composition of <i>parser functions</i>. A parser is

+just a function that accepts a scanner and returns a match. Parserfunctions

+are composed to form increasingly complex <i>higher order forms</i>.
+Notice too that the parser, albeit an object, is immutable and
+constant. All primitive and composite parser objects are <tt>const</tt>.
+The parse member function is even declared as <tt>const</tt>:<br>

+如果凑近些看，你会发现Spirit全是分析器函数的组合。一个分析器不过是一个接受扫描器并返回匹配的函+数。分析器函数被组合起来以构成更高层次的形式。同时注意，对分+析器而言，任意一个对象都是常量或者不变量。所有的元素或合成分析器对象都是<tt>const</tt>。甚至parse

+成员函数也同样被声明成 <tt>const</tt> 的：</p>

+<pre> <code>template <spanclass="special"><typename <spanclass="identifier">ScannerT> typename <spanclass="identifier">parser_result<spanclass="special"><self_t<spanclass="special">, ScannerT<spanclass="special">>::type <spanclass="identifier">parse(<spanclass="identifier">ScannerT const<spanclass="special">& scan<spanclass="special">) const<spanclass="special">;</code></pre>

+<p> In all accounts, this looks and feels a lot like <b>Functional
+Programming</b>. And indeed it is. Spirit is by all means an
+application of Functional programming in the imperative C++ domain. In

+Haskell, for example, there is what are called <ahref="references.html#combinators">parser combinators</a>

+which are strikingly similar to the approach taken by Spirit- parser
+functions which are composed using various operators to create higher
+order parser functions that model a top-down recursive descent parser.
+Those smart Haskell folks have been doing this way before Spirit.<br>

+就方方面面而言，这看起来像，感觉也像函数式编程。而且的确就是。Spirit就是一个想尽+一切办法在命令式的C++领域里实现函数式编程的应用。比如，在Haskell里面，有一个叫<a href="references.html#combinators">分析器连接器</a>的玩意，和+Spirit里使用不同的操作符来组合分析器函数以构成更高层次的分析函数，从而形成一个自顶向下递归下降分析器的方法非常相似。Haskell聪明的作

+者们在Spirit之前已经这么干了。</p>
+<p> Functional style programming (or FP) libraries are gaining
+momentum in the C++ community. Certainly, we'll see more of FP in
+Spirit now and in the future. Actually, if one looks more closely, even
+the C++ standard library has an FP flavor. Stealthily beneath the core
+of the standard C++ library, a closer look into STL gives us a glimpse
+of a truly FP paradigm already in place. It is obvious that the authors
+of STL know and practice FP.<br>

+函数式编程（FP）库正在C++社区中获得越来越多的能量。可以确定的是，从现在到将来，我们将在Spirit里看到更多的FP。实际上，如果看得+更仔细些，会发现甚至C++标准库都有某些FP的特征。在标准库隐秘的核心之下，更仔细地观察，我们会看到一个真正的FP范式早已经在那儿了。很明

+显，STL的作者们了解并实践了FP。</p>
+<h2>Semantic Actions in the FP Perspective &nbsp;FP视角下的语义动作</h2>
+<h3>STL style FP &nbsp;STL风格的FP</h3>
+<p> A more obvious application of STL-style FP in Spirit is the
+semantic action. What is STL-style FP? It is primarily the use of
+functors that can be composed to form higher order functors.<br>

+Spirit中一个更明显的STL风格的FP应用即语义动作。什么是STL风格的FP？主要是指使用仿函数来构成更高阶的仿函数。

+<table align="center" border="0" width="80%">
+<tbody>
+<tr>

+<td class="note_box"> <img src="theme/note.gif" height="16" width="16">Functors 仿函数 

+<br>
+A Function Object, or Functor is simply any object that can be called
+as if it is a function. An ordinary function is a function object, and
+so is a function pointer; more generally, so is an object of a class
+that defines operator().

+ 一个函数对象，或者说仿函数简单的说就是任意可以像函数那样被调用的对象。一个普通函数是一个函数对象，函数指针也是，更

+广泛的说，一个定义了operator()的类的对象也是如此。<p></p>
+</td>
+</tr>
+</tbody>
 </table>

- This STL-style FP can be seen everywhere these days. The followingexample- is taken from <a href="http://www.sgi.com/tech/stl/";>SGI's StandardTemplate

-  Library Programmer's Guide</a>:</p>
-<pre>

- <code>// Computes sin(x)/(x + DBL_MIN) for eachelement of a range.

- transform<spanclass=special>(first<spanclass=special>, last<spanclass=special>, first<spanclass=special>,- compose2<spanclass=special>(divides<spanclass=special><double<spanclass=special>>(),- ptr_fun<spanclass=special>(sin<spanclass=special>),- bind2nd<spanclass=special>(plus<spanclass=special><double<spanclass=special>>(), DBL_MIN<spanclass=special>)));</code></pre>- Really, this is just currying in FPterminology.

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16"> Currying 

-      <br>
-      What is &quot;currying&quot;, and where does it come from?<br>
-      <br>

- Currying has its origins in the mathematical study of functions. Itwas- observed by Frege in 1893 that it suffices to restrict attention tofunctions- of a single argument. For example, for any two parameter function<tt>f(x,y)</tt>,- there is a one parameter function <tt>f'</tt> such that<tt>f'(x)</tt> is- a function that can be applied to y to give <tt>(f'(x))(y) = f(x,y)</tt>.- This corresponds to the well known fact that the sets <tt>(AxB ->C)</tt>- and <tt>(A -> (B -> C))</tt> are isomorphic, where<tt>"x"</tt>- is cartesian product and <tt>"->"</tt> is functionspace. In- functional programming, function application is denoted byjuxtaposition,- and assumed to associate to the left, so that the equation abovebecomes

-      <tt>f' x y = f(x,y)</tt>. </td>
-  </tr>
+<p> This STL-style FP can be seen everywhere these days. The

+following example is taken from <ahref="http://www.sgi.com/tech/stl/";>SGI's Standard Template+Library Programmer's Guide</a>: 这种STL风格的FP在今天已经随处可见。下面的例子来自于<a href="http://www.sgi.com/tech/stl/";>SGI的标准模板库程序员指南</a>：+<pre> <code>// Computes sin(x)/(x + DBL_MIN) foreach element of a range. 对一个区间内的各个元素计算</code><code>sin(x)/(x +DBL_MIN) </code><code> <spanclass="identifier">transform(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">first, <spanclass="identifier">compose2(<spanclass="identifier">divides<<spanclass="keyword">double>(), <spanclass="identifier">ptr_fun(<spanclass="identifier">sin), <spanclass="identifier">bind2nd(<spanclass="identifier">plus<<spanclass="keyword">double>(), <spanclass="identifier">DBL_MIN<spanclass="special">)));</code></pre>

+<p style="text-align: left;"> Really, this is just <i>currying</i>

+in FP terminology. 其实，这只是FP术语中所谓的 currying 罢了。

+<table align="center" border="0" width="80%">
+<tbody>
+<tr>

+<td class="note_box"> <img src="theme/lens.gif" height="16" width="15">Currying 

+<br>

+What is "currying", and where does it come from? 什么是"currying"，它又是从哪儿来的？ 

+<br>
+Currying has its origins in the mathematical study of functions. It was
+observed by Frege in 1893 that it suffices to restrict attention to
+functions of a single argument. For example, for any two parameter
+function <tt>f(x,y)</tt>, there is a one parameter
+function <tt>f'</tt> such that <tt>f'(x)</tt>
+is a function that can be applied to y to give <tt>(f'(x))(y) =
+f (x,y)</tt>. This corresponds to the well known fact that the
+sets <tt>(AxB -&gt; C)</tt> and <tt>(A
+-&gt; (B -&gt; C))</tt> are isomorphic, where <tt>"x"</tt>
+is cartesian product and <tt>"-&gt;"</tt> is function
+space. In functional programming, function application is denoted by
+juxtaposition, and assumed to associate to the left, so that the

+equation above becomes <tt>f' x y = f(x,y)</tt>. currying来自于对函数的数学研究。1893年Frege发现可以把注意力严格集中到只有一个参数的函数上。比如，对任意有两个参数的函数 <tt>f(x)</tt>，存在一个单参数函数<tt>f'</tt> 比如 <tt>f'(x)</tt> 使得 <tt>(f'(x))(y) =+f (x,y)</tt> 成立。这对应于众所周知的事实：集合 <tt>(AxB -> C)</tt> 和 <tt>(A+-> (B -> C))</tt> 等价。这里 <tt>"x"</tt> 是笛卡尔乘积且 <tt>"->"</tt> 是函数空间。在函数式编程中，函数的使用写成并置的形式，并且认为是左关联的，因此上面的等式变成了 <spanstyle="font-family: Courier New;"><tt>f' x y = f(x,y)</tt>。 </td>

+</tr>
+</tbody>
 </table>

- In the context of Spirit, the same FP style functor composition may beapplied- to semantic actions. <ahref="../example/fundamental/full_calc.cpp">full_calc.cpp</a> is a goodexample. Here's a snippet from that sample:

-<pre>
-    <code><span class=identifier>expression </span><span class=special>=
-        </span><span class=identifier>term

- >> <spanclass=special>*( (<spanclass=literal>'+' >> <spanclass=identifier>term)[<spanclass=identifier>make_op(<spanclass=identifier>plus<<spanclass=keyword>long>(), <spanclass=identifier>self.<spanclass=identifier>eval)]- | <spanclass=special>('-' <spanclass=special>>> term<spanclass=special>)[make_op<spanclass=special>(minus<spanclass=special><long<spanclass=special>>(), self<spanclass=special>.eval<spanclass=special>)]

-            </span><span class=special>)
-            </span><span class=special>;</span></code></pre>
-

- <img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/full_calc.cpp">viewed here</a>. Thisis part of the Spirit distribution.

-<h3>Boost style FP</h3>

- Boost takes the FP paradigm further. There are libraries in boost thatfocus

-  specifically on Function objects and higher-order programming.</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="14"> Boost FP libraries </td>
-  </tr>
-  <tr>

- <td class="table_cells"><ahref="http://www.boost.org/libs/bind/bind.html";>bind</a>- and <ahref="http://www.boost.org/libs/bind/mem_fn.html";>mem_fn</a></td>- <td class="table_cells">Generalized binders forfunction/object/pointers and

-      member functions, from Peter Dimov</td>
-  </tr>

- <td class="table_cells"><ahref="http://www.boost.org/libs/function/index.html";>function</a></td>- <td class="table_cells">Function object wrappers for deferred calls orcallbacks,

-    from Doug Gregor</td>
-  </tr>

- <td class="table_cells"><ahref="http://www.boost.org/libs/functional/index.html";>functional</a></td>- <td class="table_cells">Enhanced function object adaptors, from MarkRodgers</td>

-  </tr>

- <td class="table_cells"><ahref="http://www.boost.org/libs/lambda/index.html";>lambda</a></td>- <td class="table_cells">Define small unnamed function objects at theactual

-    call site, and more, from Jaakko Järvi and Gary Powell</td>
-  </tr>

- <td class="table_cells"><ahref="http://www.boost.org/libs/bind/ref.html";>ref</a></td>- <td class="table_cells">A utility library for passing references togeneric- functions, from Jaako Järvi, Peter Dimov, Doug Gregor, and DaveAbrahams</td>

-  </tr>
+<p> In the context of Spirit, the same FP style functor

+composition may be applied to semantic actions. <ahref="../example/fundamental/full_calc.cpp">full_calc.cpp</a>+is a good example. Here's a snippet from that sample: 在Spirit的语境里，同样FP风格的仿函数可以应用于语义动作，<ahref="../example/fundamental/full_calc.cpp">full_calc.cpp</a>是一个很好的例子。这里是例子里的片段：+<pre> <code>expression <spanclass="special">= term <spanclass="special">>> *( <spanclass="special">('+' <spanclass="special">>> term<spanclass="special">)[make_op<spanclass="special">(plus<spanclass="special"><long<spanclass="special">>(), self<spanclass="special">.eval<spanclass="special">)] | <spanclass="special">('-' <spanclass="special">>> term<spanclass="special">)[make_op<spanclass="special">(minus<spanclass="special"><long<spanclass="special">>(), self<spanclass="special">.eval<spanclass="special">)] ) <spanclass="special">;</code></pre>+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/full_calc.cpp">viewed here</a>.+This is part of the Spirit distribution.<img src="theme/lens.gif"height="16" width="15">可以在 <ahref="../example/fundamental/full_calc.cpp">这里</a> 查看完整代码，这是Spirit发布包的一部分。

+<h3>Boost style FP &nbsp;Boost风格的FP</h3>
+<p> Boost takes the FP paradigm further. There are libraries in
+boost that focus specifically on Function objects and higher-order

+programming. Boost在FP范式上走得更远。在boost里有不少专注于仿函数和高阶编程的库。

+<table align="center" border="0" width="90%">
+<tbody>
+<tr>
+<td class="table_title" colspan="14"> Boost
+FP libraries &nbsp;Boost中的FP库 </td>
+</tr>
+<tr>

+<td class="table_cells"><ahref="http://www.boost.org/libs/bind/bind.html";>bind</a>

+and <a href="http://www.boost.org/libs/bind/mem_fn.html";>mem_fn</a></td>
+<td class="table_cells">Generalized binders for

+function/object/pointers and member functions, from Peter Dimov 为函数/对象/指针和成员函数生成绑定器。来自Peter Dimov</td>

+</tr>
+<tr>

+<td class="table_cells"><ahref="http://www.boost.org/libs/function/index.html";>function</a></td>

+<td class="table_cells">Function object wrappers for

+deferred calls or callbacks, from Doug Gregor 函数对象封装器，针对解引用调用或者回调，来自于Doug Gregor</td>

+</tr>
+<tr>

+<td class="table_cells"><ahref="http://www.boost.org/libs/functional/index.html";>functional</a></td>

+<td class="table_cells">Enhanced function object

+adaptors, from Mark Rodgers 增强的函数对象适配器，来自于MarkRodgers</td>

+</tr>
+<tr>

+<td class="table_cells"><ahref="http://www.boost.org/libs/lambda/index.html";>lambda</a></td>

+<td class="table_cells">Define small unnamed
+function objects at the actual call site, and more, from Jaakko Järvi

+and Gary Powell 在调用点定义小型的匿名函数对象，以及更多，来自于JaakkoJärvi 和Gary Powell</td>

+</tr>
+<tr>

+<td class="table_cells"><ahref="http://www.boost.org/libs/bind/ref.html";>ref</a></td>

+<td class="table_cells">A utility library for
+passing references to generic functions, from Jaako Järvi, Peter Dimov,

+Doug Gregor, and Dave Abrahams 把一个对象的引用传递给一般函数的工具库，来自于Jaako Järvi, Peter Dimov, Doug Gregor, 以及 Dave Abrahams</td>

+</tr>
+</tbody>
 </table>

- The following is an example that uses boost Bind touse a- member function as a Spirit semantic action. You can see this example infull

-  in the file<a href="../example/fundamental/bind.cpp"> bind.cpp</a>.</p>
-<pre>

- <code>class <spanclass=identifier>list_parser

-    </span><span class=special>{
-    </span><span class=keyword>public</span><span class=special>:
-

- typedef <spanclass=identifier>list_parser <spanclass=identifier>self_t;

-
-        </span><span class=keyword>bool

- parse<spanclass=special>(char <spanclass=keyword>const* <spanclass=identifier>str)

-        </span><span class=special>{

- return <spanclass=identifier>spirit::<spanclass=identifier>parse(<spanclass=identifier>str,

-
-                </span><span class=comment>//  Begin grammar
-                </span><span class=special>(
-                    </span><span class=identifier>real_p
-                    </span><span class=special>[

- bind<spanclass=special>(&self_t<spanclass=special>::add<spanclass=special>, this,_1)

-                    </span><span class=special>]
-

- >> <spanclass=special>*( ','- >>real_p

-                                </span><span class=special>[

- <spanclass=identifier>bind(&<spanclass=identifier>self_t::<spanclass=identifier>add, <spanclass=keyword>this, <spanclass=identifier>_1)

-                                </span><span class=special>]
-                        </span><span class=special>)
-                </span><span class=special>)
-                </span><span class=special>,
-                </span><span class=comment>//  End grammar
-

- space_p<spanclass=special>).full<spanclass=special>;

-        </span><span class=special>}
-
-        </span><span class=keyword>void

- add<spanclass=special>(double <spanclass=identifier>n)

-        </span><span class=special>{

- v<spanclass=special>.push_back<spanclass=special>(n);

-        </span><span class=special>}
-

- vector<spanclass=special><double<spanclass=special>> v<spanclass=special>;

-    </span><span class=special>};
-</span></code></pre>

- <img height="16" width="15" src="theme/lens.gif"> The full sourcecode can be <a href="../example/fundamental/bind.cpp">viewed here</a>. Thisis part of the Spirit distribution.-This parser parses a comma separated list of real numbers and storesthem- in a vector<double>. Boost.bind creates a Spirit conformingsemantic action

-  from the <tt>list_parser</tt>'s member function <tt>add</tt>.</p>
+<p> The following is an example that uses boost <strong>Bind</strong>
+to use a member function as a Spirit semantic action. You can see this
+example in full in the file<a href="../example/fundamental/bind.cpp">

+bind.cpp</a>. 下面是一个如何使用boost Bind 来把一个成员函数变成语义动作的例子。可以在<ahref="../example/fundamental/bind.cpp">bind.cpp</a>看到完整的例子。+<pre> <code>class <spanclass="identifier">list_parser { public: typedef <spanclass="identifier">list_parser <spanclass="identifier">self_t; bool <spanclass="identifier">parse(<spanclass="keyword">char const<spanclass="special">* str<spanclass="special">) { <spanclass="keyword">return spirit<spanclass="special">::parse<spanclass="special">(str<spanclass="special">, // Begin grammar ( <spanclass="identifier">real_p [ bind<spanclass="special">(&self_t<spanclass="special">::add<spanclass="special">, this<spanclass="special">, _1<spanclass="special">) ] <spanclass="special">>> *( <spanclass="literal">',' >> <spanclass="identifier">real_p [ bind<spanclass="special">(&self_t<spanclass="special">::add<spanclass="special">, this<spanclass="special">, _1<spanclass="special">) ] <spanclass="special">) ) <spanclass="special">, // End grammar space_p<spanclass="special">).full<spanclass="special">; } <spanclass="keyword">void add<spanclass="special">(double <spanclass="identifier">n) <spanclass="special">{ v<spanclass="special">.push_back<spanclass="special">(n<spanclass="special">); } <spanclass="identifier">vector<<spanclass="keyword">double> <spanclass="identifier">v; <spanclass="special">}; </code></pre>+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/bind.cpp">viewed here</a>.+This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15">可以在 <a href="../example/fundamental/bind.cpp">这里</a> 查看完整代码，这是Spirit发布包的一部分。

+<p>This parser parses a comma separated list of real numbers and
+stores them in a vector&lt;double&gt;. Boost.bind creates a
+Spirit conforming semantic action from the <tt>list_parser</tt>'s

+member function <tt>add</tt>. 这个分析器分析一个由逗号分隔的实数列表并把它们储存到一个 vector<double>。Boost.bind 从 <tt>list_parser</tt> 的成员函数 <tt>add</tt> 创建了一个符合Spirt标准的语义动作。

 <h3>Lambda and Phoenix</h3>

- There's a library, authored by yours truly, named <ahref="../phoenix/index.html">Phoenix</a>.- While this is not officially part of the Spirit distribution, thislibrary has- been used extensively to experiment on advanced FP techniques in C++.This library- is highly influenced by <ahref="http://www.cc.gatech.edu/%7Eyannis/fc%2B%2B/";>FC++</a>- and boost Lambda (<ahref="http://www.boost.org/libs/lambda/index.html";>BLL</a>).

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16">

-      BLL</b><br>
-      <br>

- In as much as Phoenix is influenced by boost Lambda (<ahref="http://www.boost.org/libs/lambda/index.html";>BLL</a>),- Phoenix innovations such as local variables, local functions andadaptable- closures, in turn influenced BLL. Currently, BLL is very similar toPhoenix.- Most importantly, BLL incorporated Phoenix's adaptable closures. Inthe

-      future, Spirit will fully support BLL. </td>
-  </tr>

+ There's a library, authored by yours truly, named <ahref="../phoenix/index.html">Phoenix</a>. While this

+is not officially part of the Spirit distribution, this library has
+been used extensively to experiment on advanced FP techniques in C++.

+This library is highly influenced by <ahref="http://www.cc.gatech.edu/%7Eyannis/fc%2B%2B/";>FC++</a>+and boost Lambda (<ahref="http://www.boost.org/libs/lambda/index.html";>BLL</a>). 有一个库，由诚挚的本人写成的，名叫<ahref="http://www.boost.org/libs/spirit/phoenix/index.html";>Phoenix</a>。虽然还不是Spirit发布版的正式组成部分，但这个库已经被广泛地用来实验C++中的高级FP技术。这个库受到 <ahref="http://www.cc.gatech.edu/%7Eyannis/fc%2B%2B/";>FC++</a>和boost Lambda(<a href="http://www.boost.org/libs/lambda/index.html";>BLL</a>)的深刻影响。

+<table align="center" border="0" width="80%">
+<tbody>
+<tr>
+<td class="note_box"> <b><img src="theme/lens.gif" height="16" width="15">
+BLL</b><br>
+<br>

+In as much as Phoenix is influenced by boost Lambda (<ahref="http://www.boost.org/libs/lambda/index.html";>BLL</a>),

+Phoenix innovations such as local variables, local functions and
+adaptable closures, in turn influenced BLL. Currently, BLL is very
+similar to Phoenix. Most importantly, BLL incorporated Phoenix's

+adaptable closures. In the future, Spirit will fully support BLL. 由于Phoenix受到boost Lambda(<ahref="http://www.boost.org/libs/lambda/index.html";>BLL</a>)的影响，Phoenix变革了诸如本地变量，本地函数和可适配闭包等受到BLL影响的概念。目前，BLL和Phoenix非常详细。最重要的是，BLL能与Phoenix的可适配闭包配合。将来，Spirit将对BLL提供完备的支持。 </td>

+</tr>
+</tbody>
 </table>

- Phoenix allows one to write semantic actions inline in C++ throughlambda- (an unnamed function) expressions. Here's a snippet from the <ahref="../example/fundamental/phoenix_calc.cpp">phoenix_calc.cpp</a>example:

-<pre>
-    <code><span class=identifier>expression

-                </span><span class=special>)
-        </span><span class=special>;
-
-    </span><span class=identifier>term

-                </span><span class=special>)
-        </span><span class=special>;
-
-    </span><span class=identifier>factor

- = <spanclass=identifier>ureal_p[<spanclass=identifier>factor.<spanclass=identifier>val = <spanclass=identifier>arg1]- | '('>> <spanclass=identifier>expression[<spanclass=identifier>factor.<spanclass=identifier>val = <spanclass=identifier>arg1] <spanclass=special>>> ')'- | <spanclass=special>('-' <spanclass=special>>> factor<spanclass=special>[factor<spanclass=special>.val <spanclass=special>= -<spanclass=identifier>arg1])- | <spanclass=special>('+' <spanclass=special>>> factor<spanclass=special>[factor<spanclass=special>.val <spanclass=special>= arg1<spanclass=special>])

-        </span><span class=special>;</span></code></pre>

- <img height="16" width="15" src="theme/lens.gif"> The full sourcecode can be <a href="../example/fundamental/phoenix_calc.cpp">viewedhere</a>. This is part of the Spirit distribution.-You do not have to worry about the details for now. There is a lotgoing on here that needs to be explained. The succeeding chapters will beenlightening.

-<p>Notice the use of lambda expressions such as:</p>
-<pre>

- <code>expression<spanclass=special>.val <spanclass=special>+= arg1</code></pre>

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16">

-        <a name="lambda"></a>Lambda Expressions?</b><br>
-        <br>

- Lambda expressions are actually unnamed partially applied functionswhere- placeholders (e.g. arg1, arg2) are provided in place of some of thearguments.- The reason this is called a lambda expression is that traditionally,such- placeholders are written using the Greek letter lambda <imgsrc="theme/lambda.png" width="15" height="22">.</td>

-  </tr>
+<p> Phoenix allows one to write semantic actions inline in C++
+through lambda (an unnamed function) expressions. Here's a snippet from
+the <a href="../example/fundamental/phoenix_calc.cpp">phoenix_calc.cpp</a>

+example: Phoenix允许在C++中通过λ（lambda，匿名函数）表达式写出内联的语义动作。这里是取自 <ahref="../example/fundamental/phoenix_calc.cpp">phoenix_calc.cpp</a> 中例子的一个片段：

+</p>

+<pre> <code>expression <spanclass="special">= term<spanclass="special">[expression<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">] >> <spanclass="special">*( (<spanclass="literal">'+' >> <spanclass="identifier">term[<spanclass="identifier">expression.<spanclass="identifier">val += <spanclass="identifier">arg1]) <spanclass="special">| (<spanclass="literal">'-' >> <spanclass="identifier">term[<spanclass="identifier">expression.<spanclass="identifier">val -= <spanclass="identifier">arg1]) <spanclass="special">) ; <spanclass="identifier">term = <spanclass="identifier">factor[<spanclass="identifier">term.<spanclass="identifier">val = <spanclass="identifier">arg1] <spanclass="special">>> *( <spanclass="special">('*' <spanclass="special">>> factor<spanclass="special">[term<spanclass="special">.val <spanclass="special">*= arg1<spanclass="special">]) | <spanclass="special">('/' <spanclass="special">>> factor<spanclass="special">[term<spanclass="special">.val <spanclass="special">/= arg1<spanclass="special">]) ) <spanclass="special">; factor = <spanclass="identifier">ureal_p[<spanclass="identifier">factor.<spanclass="identifier">val = <spanclass="identifier">arg1] <spanclass="special">| '(' <spanclass="special">>> <spanclass="identifier">expression[<spanclass="identifier">factor.<spanclass="identifier">val = <spanclass="identifier">arg1] <spanclass="special">>> ')' <spanclass="special">| (<spanclass="literal">'-' >> <spanclass="identifier">factor[<spanclass="identifier">factor.<spanclass="identifier">val = <spanclass="special">-arg1<spanclass="special">]) | <spanclass="special">('+' <spanclass="special">>> factor<spanclass="special">[factor<spanclass="special">.val <spanclass="special">= arg1<spanclass="special">]) ;</code></pre>+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/phoenix_calc.cpp">viewed here</a>.+This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15">完整的代码可<ahref="../example/fundamental/phoenix_calc.cpp">在此查阅</a>。这是Spirit发布包的一部分。

+<p>You do not have to worry about the details for now. There is a
+lot going on here that needs to be explained. The succeeding chapters

+will be enlightening. 目前你不必为细节烦神。接下来还有很多东西要解释。紧接着的章节将有详细的讨论。

+<p>Notice the use of lambda expressions such as:<br>注意下面的λ表达式：</p>

+<pre> <code>expression<spanclass="special">.val <spanclass="special">+= arg1</code></pre>

+<table align="center" border="0" width="80%">
+<tbody>
+<tr>

+<td class="note_box"> <img src="theme/lens.gif" height="16" width="15"><a name="lambda"></a>Lambda Expressions? λ表达式？ 

+<br>
+Lambda expressions are actually unnamed partially applied functions
+where placeholders (e.g. arg1, arg2) are provided in place of some of
+the arguments. The reason this is called a lambda expression is that
+traditionally, such placeholders are written using the Greek letter

+lambda <img src="theme/lambda.png" height="22" width="15">. Lambda 表达式实际上是匿名的部分已应用的函数，其中某些参数被占位符(如 arg1, arg2)替代。之所以把它称为 lambda 表达式，是由于在传统上，这样的占位符被写为希腊字母

+lambda <img src="theme/lambda.png" height="22" width="15">.</td>
+</tr>
+</tbody>
 </table>

-where <tt>expression.val</tt> is a closure variable of the expressionrule- (see <a href="closures.html">Closures</a>). <code><spanclass=identifier><tt>arg1</tt></code>- is a placeholder for the first argument that the semantic action willreceive- (see <a href="../phoenix/doc/place_holders.html">PhoenixPlace-holders</a>).

-  In Boost.Lambda (BLL), this corresponds to <tt>_1</tt>. </p>
+<p>where <tt>expression.val</tt> is a closure
+variable of the expression rule (see <a href="closures.html">Closures</a>).
+<code><span class="identifier"><tt>arg1</tt></span></code>
+is a placeholder for the first argument that the semantic action will
+receive (see <a href="../phoenix/doc/place_holders.html">Phoenix

+Place-holders</a>). In Boost.Lambda (BLL), this corresponds to<tt>_1</tt>. <tt>expression.val</tt> 是表达式规则的一个闭包（见<ahref="closures.html">闭包</a>）变量。<code><spanclass="identifier"><tt>arg1</tt></code> 是语义动作将要接收的第一个参数的占位符（见<a href="../phoenix/doc/place_holders.html">Phoenix占位符</a>）。在Boost.Lambda（BLL），对应的占位符为 <tt>_1</tt>。

 <table border="0">
-  <tr>
-    <td width="10"></td>

-  </tr>
+<tbody>
+<tr>
+<td width="10"></td>

+</tr>
+</tbody>
 </table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
-  <br>

-Use, modification and distribution is subject to the BoostSoftware

-    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-    http://www.boost.org/LICENSE_1_0.txt)</font></p>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
+<br>
+<font size="2">Use, modification and distribution is
+subject to the Boost Software License, Version 1.0. (See accompanying

+file LICENSE_1_0.txt or copy athttp://www.boost.org/LICENSE_1_0.txt)

 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/functor_parser.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/functor_parser.html Sun Sep 20 23:13:572009

@@ -1,108 +1,63 @@
-<html>
-<head>
-<title>Functor Parser</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Functor Parser</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Functor

-      Parser</b></font> </td>

+      Parser 仿函数分析器</b></font> </td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="list_parsers.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="refactoring.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

The simplest way to write your hand coded parser that works well withthe rest

-  of the Spirit library is to simply write a functor parser.</p>
-<p> A functor parser is expected to have the interface:</p>
-<pre>
-    <code><span class=keyword>struct </span><span class=identifier>functor
-    </span><span class=special>{

- typedef Tresult_t;

- template <spanclass=special><typename <spanclass=identifier>ScannerT>

-        </span><span class=keyword>std::ptrdiff_t

- operator<spanclass=special>()(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan, <spanclass=identifier>result_t& <spanclass=identifier>result) <spanclass=keyword>const;

-    </span><span class=special>};
-</span></code></pre>

+ of the Spirit library is to simply write a functor parser. 使得你所写的代码能和Spirit其他部分合作愉快的最简单的方法就是简单地写一个仿函数分析器。+ A functor parser is expected to have the interface: 一个仿函数分析器应该有如下接口：+<pre> <code>struct <spanclass="identifier">functor { typedef Tresult_t<spanclass="special">; template<typenameScannerT<spanclass="special">> <spanclass="keyword">std::ptrdiff_t <spanclass="keyword">operator()(<spanclass="identifier">ScannerT const<spanclass="special">& scan<spanclass="special">, result_t<spanclass="special">& result<spanclass="special">) const<spanclass="special">; <spanclass="special">}; </code></pre> where typedef T result_t; is the attribute type of the parser thatwill bepassed back to the match result (see <ahref="indepth_the_parser.html">In-depth:The Parser</a>). If the parser does not need to return an attribute,this can- simply be nil_t. The <tt>std::ptrdiff_t</tt>result+ simply be nil_t. The <spanclass="keyword"><tt>std::ptrdiff_t</tt> resultis the number of matching characters matched by your parser. A negativevalue

-  flags an unsucessful match.</p>

+ flags an unsucessful match. 这里 typedef T result_t; 是分析器的属性类，将会传回给匹配结果（见<a href="indepth_the_parser.html">深入：分析器</a>）。如果分析器不需要返回一个属性，这一类型可以是nil_t。<spanclass="keyword"><tt>std::ptrdiff_t</tt> 作为结果反映了你的分析器所匹配的字符数量。负数表明匹配失败。 A conforming functor parser can transformed into a well formed Spiritparser

-  by wrapping it in the functor_parser template:</p>
-<pre>

- <code>functor_parser<spanclass=special><functor<spanclass=special>> functor_p<spanclass=special>;

-</span></code></pre>
-
-<h2>Example</h2>
-<p> The following example puts the functor_parser into action:</p>
-<pre>

- <code>struct <spanclass=identifier>number_parser

-    </span><span class=special>{

- typedef intresult_t;- template <spanclass=special><typename <spanclass=identifier>ScannerT>

-        </span><span class=keyword>std::ptrdiff_t</span>

- operator<spanclass=special>()(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan, <spanclass=identifier>result_t& <spanclass=identifier>result) <spanclass=keyword>const

-        </span><span class=special>{

- if <spanclass=special>(scan<spanclass=special>.at_end<spanclass=special>())- return <spanclass=special>-1;

- char <spanclass=identifier>ch = <spanclass=special>*scan<spanclass=special>;- if <spanclass=special>(ch <spanclass=special>< '0' <spanclass=special>|| ch <spanclass=special>> '9'<spanclass=special>)- return <spanclass=special>-1;

- result <spanclass=special>= 0;- std::ptrdiff_t <spanclass=identifier>len = <spanclass=number>0;

-
-            </span><span class=keyword>do
-            </span><span class=special>{

- result <spanclass=special>= result<spanclass=special>*10 +int(<spanclass=identifier>ch - <spanclass=literal>'0');- ++<spanclass=identifier>len;- ++<spanclass=identifier>scan;- } while(!scan<spanclass=special>.at_end<spanclass=special>() && <spanclass=special>(ch <spanclass=special>= *<spanclass=identifier>scan, <spanclass=identifier>ch >= <spanclass=literal>'0' && <spanclass=identifier>ch <= <spanclass=literal>'9'));

- return <spanclass=identifier>len;

-        </span><span class=special>}
-    </span><span class=special>};
-

- functor_parser<spanclass=special><number_parser<spanclass=special>> <spanclass=identifier>number_parser_p;

-</span></code></pre>

- <img src="theme/lens.gif" width="15" height="16"> The full sourcecode can be <a href="../example/fundamental/functor_parser.cpp">viewedhere</a>. This is part of the Spirit distribution. + by wrapping it in the functor_parser template: 一个符合要求的仿函数分析器可以转变为格式良好的Spirit分析器，通过把它封装在 functor_parser 模板中：+<pre> <code>functor_parser<spanclass="special"><functor<spanclass="special">> functor_p<spanclass="special">; </code></pre>

+
+<h2>Example 例子</h2>

+ The following example puts the functor_parser into action: 下面的例子用上了 functor_parser：+<pre> <code>struct <spanclass="identifier">number_parser <spanclass="special">{ typedefint <spanclass="identifier">result_t; template <spanclass="special"><typename <spanclass="identifier">ScannerT> std::ptrdiff_t+ operator<spanclass="special">()(ScannerT <spanclass="keyword">const& <spanclass="identifier">scan, <spanclass="identifier">result_t& <spanclass="identifier">result) <spanclass="keyword">const <spanclass="special">{ if(<spanclass="identifier">scan.<spanclass="identifier">at_end<spanclass="special">()) return-1<spanclass="special">; charch =*<spanclass="identifier">scan; if (<spanclass="identifier">ch < <spanclass="literal">'0' || <spanclass="identifier">ch > <spanclass="literal">'9') return <spanclass="special">-1<spanclass="special">; result= 0<spanclass="special">; <spanclass="keyword">std::ptrdiff_t len= 0<spanclass="special">; <spanclass="keyword">do <spanclass="special">{ result= <spanclass="identifier">result*<spanclass="number">10 + <spanclass="keyword">int(<spanclass="identifier">ch - <spanclass="literal">'0'); ++<spanclass="identifier">len; ++<spanclass="identifier">scan; } while(!<spanclass="identifier">scan.<spanclass="identifier">at_end() <spanclass="special">&& (<spanclass="identifier">ch = <spanclass="special">*scan<spanclass="special">, ch <spanclass="special">>= '0' <spanclass="special">&& ch <spanclass="special"><= '9'<spanclass="special">)); returnlen<spanclass="special">; } }; <spanclass="identifier">functor_parser<spanclass="special"><<spanclass="identifier">number_parser>number_parser_p<spanclass="special">; </code></pre>+ <img src="theme/lens.gif" height="16" width="15"> The full sourcecode can be <a href="../example/fundamental/functor_parser.cpp">viewedhere</a>. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 完整代码<ahref="../example/fundamental/functor_parser.cpp">在此查阅</a>。这是Spirit发布包的组成部分。To further understand the implementation, see <ahref="indepth_the_scanner.html">In-depth:- The Scanner</a> for the scanner API details. We now have a parser<tt>number_parser_p</tt> that we can use just like any other Spirit parser.Example:

-<pre>

- <code>r =number_parser_p <spanclass=special>>> *(<spanclass=literal>',' >> <spanclass=identifier>number_parser_p);

-</span></code></pre>

+ The Scanner</a> for the scanner API details. We now have a parser<tt>number_parser_p</tt> that we can use just like any other Spirit parser.Example: 要进一步了解实现，可参考<a href="indepth_the_scanner.html">深入：扫描器</a>中扫描器API的细节。我们现在有了 <tt>number_parser_p</tt><spanstyle="font-family: Courier New;">，可以像使用其他Spirit分析那样使用它。例子：+<pre> <code>r =number_parser_p <spanclass="special">>> *(<spanclass="literal">',' >> <spanclass="identifier">number_parser_p<spanclass="special">); </code></pre>

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/list_parsers.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/list_parsers.html Sun Sep 20 23:13:572009

@@ -1,187 +1,186 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>List Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
-</head>
+<html><head>
+

+<title>List Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link href="theme/style.css" rel="stylesheet" type="text/css"></head>

 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>

- <td width="10">  </td>- <td width="85%"> List Parsers</td>- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>

+ <td width="10">  </td>+ <td width="85%"> List Parsers 列表分析器</td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="confix.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="functor_parser.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

List Parsers are generated by the special predefined parser generatorobject

   <tt>list_p</tt>, which generates parsers recognizing list structures
-  of the type </p>

-<pre> item >>*(delimiter>> <spanclass=identifier>item) <spanclass=special>>> !<spanclass=identifier>end</pre>

+  of the type<br>列表分析器生成自特殊的预定义分析器生成器对象

+ <tt>list_p</tt>，所生成的分析器识别如下类型的列表 +<pre> item <spanclass="special">>> *(<spanclass="identifier">delimiter >>item)>> <spanclass="special">!end</pre>where <tt>item</tt> is an expression, delimiter is a delimiter and endis anoptional closing expression. As you can see, the <tt>list_p</tt>generated parserdoes not recognize empty lists, i.e. the parser must find at least oneitemin the input stream to return a successful match. If you wish to alsomatchan empty list, you can make your list_p optional with operator! Anexample wherethis utility parser is helpful is parsing comma separated C/C++ strings,which

-  can be easily formulated as:</p>

-<pre> <spanclass=identifier>rule<> <spanclass=identifier>list_of_c_strings_rule- = <spanclass=identifier>list_p(<spanclass=identifier>confix_p(<spanclass=literal>'\"', <spanclass=special>*c_escape_char_p<spanclass=special>, '\"'<spanclass=special>), ',')

-        </span><span class=special>;</span></pre>

+ can be easily formulated as: 这里 <tt>item</tt> 是一个表达式，delimiter 是一个分隔符而 end 是一个可选的结尾表达式。正如你所见，<tt>list_p</tt>

+所

+生成的分析器并不识别空列表，比如，只有在输入中匹配了至少一项，分析器才会返回成功匹配。如果希望能同时识别空列表，可以为 list_p+加上!（可选）操作符。下面的例子是这一工具分析器对分析逗号分隔的C/C++字符串助益良多的例子，可以很轻易的列出这个表达式：+<pre> <spanclass="identifier">rule<> <spanclass="identifier">list_of_c_strings_rule <spanclass="special">= list_p<spanclass="special">(confix_p<spanclass="special">('\"'<spanclass="special">, *<spanclass="identifier">c_escape_char_p,'\"'),',') ;</pre>

 <p>The <tt>confix_p</tt> and <tt>c_escape_char_p</tt> parser generators

- are described <a href="confix.html">here</a> and <ahref="escape_char_parser.html">here</a>.+ are described <a href="confix.html">here</a> and <ahref="escape_char_parser.html">here</a>. <tt>confix_p</tt> 和<tt>c_escape_char_p</tt> 分析器可以在  <a href="confix.html">这里</a>and <a href="escape_char_parser.html">这里</a> 查阅。The <tt>list_p</tt> parser generator object can be used to generate thefollowing

-  different types of List Parsers:</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title"><b>List Parsers</b></td>

+ different types of List Parsers: <tt>list_p</tt><spanstyle="font-family: Courier New;"> 分析器生成器对象可用于生成下列类型的列表分析器：

+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td colspan="2" class="table_title"><b>List Parsers 列表分析器</b></td>
   </tr>
   <tr>
-    <td width="29%" height="27" class="table_cells"><b>list_p</b></td>

- <td width="71%" class="table_cells"><tt>list_p</tt> used by itselfparses

+    <td class="table_cells" height="27" width="29%"><b>list_p</b></td>

+ <td class="table_cells" width="71%"><tt>list_p</tt> used by itselfparsescomma separated lists without special item formatting, i.e.everythingin between two commas is matched as an <tt>item</tt>, no<tt>end</tt>

-        of list token is matched</p></td>

+ of list token is matched<tt>list_p</tt><spanstyle="font-family: Courier New;"> 这一形式用于识别没有特殊格式的列表项的逗号分隔列表，比如，两个逗号之间的所有东西都被匹配为一个<tt>item</tt>，而列表标记的 <tt>end</tt> 则不会匹配</td>

   </tr>
   <tr>

- <td height="27"class="table_cells">list_p(delimiter)</td>+ <td class="table_cells"height="27">list_p(delimiter)</td><td class="table_cells">generates a list parser, which recognizeslistswith the given <tt>delimiter</tt> and matches everything inbetween them- as an <tt>item</tt>, no <tt>end</tt> of list token ismatched</td>+ as an <tt>item</tt>, no <tt>end</tt> of list token ismatched生成一个列表分析器，它识别以给定的 <tt>delimiter</tt> 作为分隔符的列表，且把两个分隔符之间的任意内容识别为一个 <tt>item</tt>，而列表标记的 <tt>end</tt> 则不会匹配</td>

   </tr>
   <tr>

- <td height="27" class="table_cells">list_p(item,delimiter)</td>+ <td class="table_cells" height="27">list_p(item,delimiter)</td><td class="table_cells">generates a list parser, which recognizeslistswith the given <tt>delimiter</tt> and matches items based on thegiven

-        item parser, no <tt>end</tt> of list token is matched</p></td>

+ item parser, no <tt>end</tt> of list token is matched生成一个列表分析器，它识别拥有给定的 <tt>delimiter</tt> 作为分隔符，且把给定的item分析器的匹配作为列表项，而列表标记的 <tt>end</tt> 则不会匹配。</td>

   </tr>
   <tr>

- <td height="27" class="table_cells">list_p(item, delimiter,end)</td>+ <td class="table_cells" height="27">list_p(item, delimiter,end)</td><td class="table_cells">generates a list parser, which recognizeslistswith the given <tt>delimiter</tt> and matches items based on thegiven<tt>item</tt> parser and additionally recognizes an optional<tt>end</tt>

-        expression</p></td>

+ expression生成一个列表分析器，它识别拥有给定的<tt>delimiter</tt> 作为分隔符，且把给定的 <tt>item</tt> 分析器的匹配作为列表项，最后，它还以一个可选的 <tt>end</tt> 表达式作为列表的结尾</td>

   </tr>
-</table>
+</tbody></table>
 <p>All of the parameters to list_p can be single characters, strings

or, if more complex parsing logic is required, auxiliary parsers, eachof whichis automatically converted to the corresponding parser type needed forsuccessful

-  parsing.</p>

+ parsing. list_p 的所有参数可以是单独的字符、字符串、或者，如果需要更复杂的分析逻辑的话，任意的分析器，这些东西都被自动的转化为成功分析所需要的分析器的类型。If the <tt>item</tt> parser is an <tt>action_parser_category</tt> type(parserwith an attached semantic action) we have to do something special. Thishappens,

-  if the user wrote something like:</p>

-<pre> <spanclass=identifier>list_p(<spanclass=identifier>item[<spanclass=identifier>func], <spanclass=identifier>delim)</pre>+ if the user wrote something like: 如果 <tt>item</tt> 分析器属于<tt>action_parser_category</tt> 类型（挂接语义动作的分析器），则需要特殊处理。这发生在用户写出类似如下的代码：+<pre> <spanclass="identifier">list_p(<spanclass="identifier">item[<spanclass="identifier">func], <spanclass="identifier">delim)</pre> where <tt>item</tt> is the parser matching one item of the listsequence and<tt>func</tt> is a functor to be called after matching one item. If wewould

-  do nothing, the resulting code would parse the sequence as follows:</p>

-<pre> (<spanclass=identifier>item[<spanclass=identifier>func] <spanclass=special>- delim<spanclass=special>) >> <spanclass=special>*(delim <spanclass=special>>> (<spanclass=identifier>item[<spanclass=identifier>func] <spanclass=special>- delim<spanclass=special>))</pre>+ do nothing, the resulting code would parse the sequence as follows: 这里 <tt>item</tt> 列表项分析器而 <tt>func</tt> 是在匹配列表项之后被调用的仿函数。如果我们什么都不做，所产生的代码就会以如下的方式进行分析：+<pre> (<spanclass="identifier">item[<spanclass="identifier">func] <spanclass="special">- delim<spanclass="special">) >> <spanclass="special">*(delim <spanclass="special">>> (<spanclass="identifier">item[<spanclass="identifier">func] <spanclass="special">- delim<spanclass="special">))</pre> what in most cases is not what the user expects. (If this iswhat you've

   expected, then please use one of the <tt>list_p</tt> generator

functions <tt>direct()</tt>, which will inhibit refactoring of the<tt>item</tt>

-  parser). To make the list parser behave as expected:</p>

-<pre> (<spanclass=identifier>item - <spanclass=identifier>delim)[<spanclass=identifier>func] <spanclass=special>>> *(<spanclass=identifier>delim >> <spanclass=special>(item <spanclass=special>- delim<spanclass=special>)[func<spanclass=special>])</pre>+ parser). To make the list parser behave as expected: 大多数情况下这并未所期望的。（如果这的确是你想要的，那么请用 <tt>list_p</tt> 生成器函数 <tt>direct()</tt>,它会集成 <tt>item</tt> 分析器的重构后的产物）。要使列表分析器的行为如你所愿：+<pre> (<spanclass="identifier">item - <spanclass="identifier">delim)[<spanclass="identifier">func] <spanclass="special">>> *(<spanclass="identifier">delim >> <spanclass="special">(item <spanclass="special">- delim<spanclass="special">)[func<spanclass="special">])</pre> the actor attached to the item parser has to be re-attached to the<tt>(item- delim)</tt> parser construct, which will make the resulting listparser 'dothe right thing'. This refactoring is done by the help of the <ahref="refactoring.html">RefactoringParsers</a>. Additionally special care must be taken, if the item parseris

-  a <tt>unary_parser_category</tt> type parser as for instance:</p>

-<pre> <spanclass=identifier>list_p(*<spanclass=identifier>anychar_p, <spanclass=literal>',')</pre>

-<p> which without any refactoring would result in </p>

-<pre> (*<spanclass=identifier>anychar_p - <spanclass=identifier>ch_p(<spanclass=literal>','))- >> *(ch_p(<spanclass=literal>',') <spanclass=special>>> (*<spanclass=identifier>anychar_p - <spanclass=identifier>ch_p(<spanclass=literal>',')) <spanclass=special>)</pre>+ a <tt>unary_parser_category</tt> type parser as for instance: 挂接到item 分析器上的动作器必须重新挂接到 <tt>(item+ - delim)</tt> 分析器结构上，才能使得所产生的分析器"行为正确"。这一重构在<a href="refactoring.html">重构分析器</a>的帮助下完成。需要额外注意的是，如果列表项分析器是一个 <tt>unary_parser_category</tt> <spanstyle="font-family: Courier New;">类型的分析器，就像下面的：+<pre> <spanclass="identifier">list_p(*<spanclass="identifier">anychar_p, <spanclass="literal">',')</pre>+ which without any refactoring would result in 这如果不重构就变成+<pre> <spanclass="special">(*anychar_p <spanclass="special">- ch_p<spanclass="special">(','<spanclass="special">)) >>*( <spanclass="identifier">ch_p(<spanclass="literal">',') <spanclass="special">>> (*<spanclass="identifier">anychar_p - <spanclass="identifier">ch_p(<spanclass="literal">',')) <spanclass="special">)</pre> and will not give the expected result (the first <tt>*anychar_p</tt>willeat up all the input up to the end of the input stream). So we have torefactor

-  this into:</p>

-<pre> *(<spanclass=identifier>anychar_p - <spanclass=identifier>ch_p(<spanclass=literal>','))- >> *(ch_p(<spanclass=literal>',') <spanclass=special>>> *(<spanclass=identifier>anychar_p - <spanclass=identifier>ch_p(<spanclass=literal>',')) <spanclass=special>)</pre>

-<p> what will give the correct result.</p>

+ this into: 而这将不会得到所期望的结果（第一个 <tt>*anychar_p</tt>将把输入流里的直到末尾的输入全部吃掉）。所以我们需要把它重构为：+<pre> <spanclass="special">*(anychar_p <spanclass="special">- ch_p<spanclass="special">(','<spanclass="special">)) >>*( <spanclass="identifier">ch_p(<spanclass="literal">',') <spanclass="special">>> *(<spanclass="identifier">anychar_p - <spanclass="identifier">ch_p(<spanclass="literal">',')) <spanclass="special">)</pre>

+<p> what will give the correct result.<br>这将得到正确的结果</p>

 The case, where the item parser is a combination of the two mentionedproblems(i.e. the item parser is a unary parser with an attached action), ishandled

-  accordingly too:</p>

-<pre> <spanclass=identifier>list_p((*<spanclass=identifier>anychar_p)[<spanclass=identifier>func], <spanclass=literal>',')</pre>

-<p> will be parsed as expected:</p>

-<pre> <spanclass=special>(*(anychar_p <spanclass=special>- ch_p<spanclass=special>(','<spanclass=special>)))[func<spanclass=special>]- >> *(ch_p(<spanclass=literal>',') <spanclass=special>>> (*(<spanclass=identifier>anychar_p - <spanclass=identifier>ch_p(<spanclass=literal>',')))[<spanclass=identifier>func] <spanclass=special>)</pre>+ accordingly too: 列表分析器混合了上面提到的两个问题的情况（比如列表分析器是一个带着语义动作的一元分析器），也将以一致的方式被处理：+<pre> <spanclass="identifier">list_p((*<spanclass="identifier">anychar_p)[<spanclass="identifier">func], <spanclass="literal">',')</pre>

+<p> will be parsed as expected:<br>将会被如所期望的那样变为：</p>

+<pre> <spanclass="special">(*(anychar_p <spanclass="special">- ch_p<spanclass="special">(','<spanclass="special">)))[func<spanclass="special">] >> <spanclass="special">*( ch_p<spanclass="special">(','<spanclass="special">) >> <spanclass="special">(*(anychar_p <spanclass="special">- ch_p<spanclass="special">(','<spanclass="special">)))[func<spanclass="special">] )</pre>The required refactoring is implemented with the help of the <ahref="refactoring.html">Refactoring

-  Parsers</a>.</p>
-<table width="90%" border="0" align="center">
-  <tr>

- <td colspan="2" class="table_title">Summary of List Parserrefactorings</td>+ Parsers</a>. 所需要的重构都是借由<a href="refactoring.html">重构分析器</a>的帮助来实现的。

+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td colspan="2" class="table_title">Summary of List Parserrefactorings 列表分析器重构概览</td>

   </tr>
   <tr class="table_title">
-    <td width="34%"><b>You write it as:</b></td>
+    <td width="34%"><b>You write it as: 源代码：</b></td>

<td width="66%"><code>It

-      is refactored to:</font></code></td>
+      is refactored to: 重构为：</font></code></td>
   </tr>
   <tr>

- <td width="34%" class="table_cells"><code><spanclass=identifier>list_p(<spanclass=identifier>item,- delimiter<spanclass=special>)</code></td>- <td width="66%" class="table_cells"> <code>(item- - <spanclass=identifier>delimiter)+ <td class="table_cells" width="34%"><code><spanclass="identifier">list_p(<spanclass="identifier">item,+ delimiter<spanclass="special">)</code></td>+ <td class="table_cells" width="66%"> <code>(item+ - <spanclass="identifier">delimiter)

       <br>

- >> *(delimiter <spanclass=special>- >> (item <spanclass=special>-- delimiter<spanclass=special>))</code></td>+ >> *(delimiter <spanclass="special">+ >> (item <spanclass="special">-+ delimiter<spanclass="special">))</code></td>

   </tr>
   <tr>

- <td width="34%" class="table_cells"><code><spanclass=identifier>list_p(<spanclass=identifier>item[<spanclass=identifier>func],- delimiter<spanclass=special>)</code></td>- <td width="66%" class="table_cells"> <code>(item- - <spanclass=identifier>delimiter)[<spanclass=identifier>func]+ <td class="table_cells" width="34%"><code><spanclass="identifier">list_p(<spanclass="identifier">item[<spanclass="identifier">func],+ delimiter<spanclass="special">)</code></td>+ <td class="table_cells" width="66%"> <code>(item+ - <spanclass="identifier">delimiter)[<spanclass="identifier">func]

       <br>

- >> *(delimiter <spanclass=special>>>- (item -delimiter<spanclass=special>)[func<spanclass=special>])</code></td>+ >> *(delimiter <spanclass="special">>>+ (item -delimiter<spanclass="special">)[func<spanclass="special">])</code></td>

   </tr>
   <tr>

- <td width="34%" class="table_cells"><code><spanclass=identifier>list_p(*<spanclass=identifier>item,- delimiter<spanclass=special>)</code></td>- <td width="66%" class="table_cells"> <code><spanclass=special>*(item- - <spanclass=identifier>delimiter)+ <td class="table_cells" width="34%"><code><spanclass="identifier">list_p(*<spanclass="identifier">item,+ delimiter<spanclass="special">)</code></td>+ <td class="table_cells" width="66%"> <code><spanclass="special">*(item+ - <spanclass="identifier">delimiter)

       <br>

- >> *(delimiter <spanclass=special>>>- *(item -delimiter<spanclass=special>))</code></td>+ >> *(delimiter <spanclass="special">>>+ *(item <spanclass="special">- delimiter<spanclass="special">))</code></td>

   </tr>
   <tr>

- <td width="34%" class="table_cells"><code><spanclass=identifier>list_p((*<spanclass=identifier>item)[<spanclass=identifier>func],- delimiter<spanclass=special>)</code></td>- <td width="66%" class="table_cells"> <code><spanclass=special>(*(item- - <spanclass=identifier>delimiter))[<spanclass=identifier>func]+ <td class="table_cells" width="34%"><code><spanclass="identifier">list_p((*<spanclass="identifier">item)[<spanclass="identifier">func],+ delimiter<spanclass="special">)</code></td>+ <td class="table_cells" width="66%"> <code><spanclass="special">(*(item+ - <spanclass="identifier">delimiter))[<spanclass="identifier">func]

       <br>

- >> *(delimiter <spanclass=special>>>- (*(item -delimiter<spanclass=special>))[func<spanclass=special>])</code></td>+ >> *(delimiter <spanclass="special">>>+ (*(item <spanclass="special">- delimiter<spanclass="special">))[func<spanclass="special">])</code></td>

   </tr>
-</table>

- <img height="16" width="15" src="theme/lens.gif"> <ahref="../example/fundamental/list_parser.cpp">list_parser.cpp </a> sampleshows the usage of the list_p utility parser:

+</tbody></table>

+ <img src="theme/lens.gif" height="16" width="15"> <ahref="../example/fundamental/list_parser.cpp">list_parser.cpp </a> sampleshows the usage of the list_p utility parser: <img src="theme/lens.gif"height="16" width="15"> <ahref="../example/fundamental/list_parser.cpp">list_parser.cpp </a>里的例子展示了list_p工具分析器的使用方法：

 <ol>
-  <li>parsing a simple ',' delimited list w/o item formatting</li>

- <li> parsing a CSV list (comma separated values - strings, integers orreals)</li>- <li>parsing a token list (token separated values - strings, integers orreals) - with an action parser directly attached to the item part of the list_pgenerated parser</li>+ <li>parsing a simple ',' delimited list w/o item formatting 分析一个简单的","分隔列表，带/不带列表项格式化</li>+ <li> parsing a CSV list (comma separated values - strings, integers orreals) 分析一个CVS列表（逗号分隔值表--字符串、整数或者实数）</li>

+  <li>parsing
+a token list (token separated values - strings, integers or reals) with
+an action parser directly attached to the item part of the list_p

+generated parser 分析一个标记表（标记分隔列表--字符串、整数或者实数）并且把一个动作分析器直接挂接到 list_p 所生成的分析器的列表项部分上</li>

 </ol>
-<p>This is part of the Spirit distribution.</p>

+This is part of the Spirit distribution. 这是Spirit发布包的组成部分。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2003 Hartmut Kaiser<br>
+<p class="copyright">Copyright © 2001-2003 Hartmut Kaiser<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/loops.html   Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/loops.html   Sun Sep 20 23:13:57 2009
@@ -1,99 +1,92 @@
-<html>
-<head>
-<title> Loops</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Loops</title><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>
     <td width="85%">

- Loops+ Loops 循环

     </td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="escape_char_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="character_sets.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

    </tr>
-</table>
+</tbody></table>

So far we have introduced a couple of EBNF operators that deal withlooping.We have the <tt>+</tt> positive operator, which matches the precedingsymbolone (1) or more times, as well as the Kleene star <tt>*</tt> whichmatches the

-  preceding symbol zero (0) or more times.</p>

+ preceding symbol zero (0) or more times. 到目前为止我们已经介绍了一些针对循环的EBNF操作符。我们有 <tt>+</tt> 加号，匹配（1）到任意多次，我们也有克林星 <tt>*</tt>，匹配零到任意多次。Taking this further, we may want to have a generalized loop operator.To somethis may seem to be a case of overkill. Yet there are grammars that areimpracticaland cumbersome, if not impossible, for the basic EBNF iteration syntaxto specify.

-  Examples:</p>

+ Examples: 更进一步，我们可能想要一个通用的循环操作符。某些人可能认为这是得不偿失的。但如果不悖离EBNF基本规范，某些语法可能会显得不切实际而笨拙。例子：

 <blockquote>

- <img src="theme/bullet.gif" width="12" height="12"> A file name mayhave

-    a maximum of 255 characters only.<br>

- <img src="theme/bullet.gif" width="12" height="12"> A specific bitmapfile

-    format has exactly 4096 RGB color information. <br>

- <img src="theme/bullet.gif" width="12" height="12"> A 32 bit binarystring

-    (1..32 1s or 0s).</p>

+ <img src="theme/bullet.gif" height="12" width="12"> A file name mayhave

+    a maximum of 255 characters only.<br>一个最大长度是255的文件名。<br>

+ <img src="theme/bullet.gif" height="12" width="12"> A specific bitmapfile+ format has exactly 4096 RGB color information. 一种固定包含有4096RGB点信息的特定位图格式。 + <img src="theme/bullet.gif" height="12" width="12"> A 32 bit binarystring

+    (1..32 1s or 0s).<br>一个32位二进制串（1..32 个1或0）。</p>
 </blockquote>

Other than the Kleene star <tt>*</tt>, the Positive closure <tt>+</tt>,andthe optional <tt>!</tt>, a more flexible mechanism for looping isprovided for

-  by the framework. <br>

+ by the framework.  除了克林星 <tt>*</tt>、加号 <tt>+</tt> 和可选的 <tt>!</tt>，框架还提供了更有弹性的循环机制：

 </p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title">Loop Constructs</td>
+<table align="center" border="0" width="80%">
+  <tbody><tr>
+    <td colspan="2" class="table_title">Loop Constructs 循环结构</td>
   </tr>
   <tr>
     <td class="table_cells" width="26%"><b>repeat_p (n) [p]</b></td>

- <td class="table_cells" width="74%">Repeat p exactly ntimes</td>+ <td class="table_cells" width="74%">Repeat p exactly ntimes 重复执行n次p</td>

   </tr>
   <tr>
     <td class="table_cells" width="26%"><b>repeat_p (n1, n2) [p]</b></td>

<td class="table_cells" width="74%">Repeat p at least n1times

-      and at most <b>n2</b> times</td>

+ and at most n2 times 重复执行p至少n1至多n2次</td>

   </tr>
   <tr>
     <td class="table_cells" width="26%"><b>repeat_p (n, more) [p] </b></td>

<td class="table_cells" width="74%">Repeat p at least ntimes,

-      continuing until <b>p</b> fails or the input is consumed</td>

+ continuing until p fails or the input is consumed 重复执行p至少n次，并一直持续到p不匹配或者输入被完全耗尽。</td>

   </tr>
-</table>

-Using the <tt>repeat_p</tt> parser, we can now write our examplesabove:

-<p>A file name with a maximum of 255 characters:<br>
+</tbody></table>

+Using the <tt>repeat_p</tt> parser, we can now write our examplesabove: 使用 <tt>repeat_p</tt> 分析器，现在我们可以把上面的例子写成：+A file name with a maximum of 255 characters: 一个最大有255个字符的文件名：

 </p>

-<pre> valid_fname_chars <spanclass=special>= /*..*/<spanclass=special>;- filename =repeat_p<spanclass=special>(1,255)[<spanclass=identifier>valid_fname_chars];</pre>-A specific bitmap file format which has exactly 4096 RGB colorinformation: 

-  </span></p>

-<pre> uint_parser<spanclass=special><unsigned<spanclass=special>, 16,6, <spanclass=number>6> <spanclass=identifier>rgb_p;- bitmap =repeat_p<spanclass=special>(4096<spanclass=special>)[rgb_p<spanclass=special>];</pre>+<pre> valid_fname_chars <spanclass="special">= /*..*/<spanclass="special">; filename= <spanclass="identifier">repeat_p(<spanclass="number">1, <spanclass="number">255)[<spanclass="identifier">valid_fname_chars<spanclass="special">];</pre>+A specific bitmap file format which has exactly 4096 RGB colorinformation: 一种包含4096 RBG点的文件格式：<spanclass="special">+<pre> uint_parser<spanclass="special"><unsigned<spanclass="special">, 16<spanclass="special">, 6<spanclass="special">, 6<spanclass="special">> rgb_p<spanclass="special">; bitmap= <spanclass="identifier">repeat_p(<spanclass="number">4096)[<spanclass="identifier">rgb_p];</pre>As for the 32 bit binary string (1..32 1s or 0s), of course we couldhave easilyused the <tt>bin_p</tt> numeric parser instead. For the sake ofdemonstration

-  however:<span class=special><br>
-  </span></p>

-<pre> bin32= lexeme_d<spanclass=special>[repeat_p<spanclass=special>(1, 32<spanclass=special>)[ch_p<spanclass=special>('1')| '0'<spanclass=special>]];</pre>

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/note.gif" width="16" height="16">Loop- parsers are run-time <ahref="parametric_parsers.html">parametric</a>.</td>+ however: 虽然针对32位的二进制串（1...32个1或0），我们可以轻松地使用<tt>bin_p</tt> 数值分析器，但出于示范的目的：<spanclass="special">+<pre> bin32= <spanclass="identifier">lexeme_d[<spanclass="identifier">repeat_p(1, <spanclass="number">32)[<spanclass="identifier">ch_p(<spanclass="literal">'1') <spanclass="special">| '0'<spanclass="special">]];</pre>

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/note.gif" height="16" width="16">Loop+ parsers are run-time <ahref="parametric_parsers.html">parametric</a>. <img src="theme/note.gif"height="16" width="16"> 循环分析器可以在运行时<ahref="parametric_parsers.html">参数化</a>。</td>

   </tr>
-</table>
+</tbody></table>

The Loop parsers can be dynamic. Consider the parsing of a binary fileof Pascal-stylelength prefixed string, where the first byte determines the length ofthe incoming

-  string. Here's a sample input:
-<blockquote>
-  <table width="363" border="0" cellspacing="0" cellpadding="0">
-    <tr>

+ string. Here's a sample input: 循环分析器可以是动态的。考虑分析一个Pascal风格的字符串的二进制文件，第一个字节表明了接下来的字符串的长度。这里是输入样本：<blockquote>

+  <table border="0" cellpadding="0" cellspacing="0" width="363">
+    <tbody><tr>
       <td class="dk_grey_bkd">
-        <table width="100%" border="0" cellspacing="2" cellpadding="2">
-          <tr>
-            <td class="white_bkd" width=8%">
+        <table border="0" cellpadding="2" cellspacing="2" width="100%">
+          <tbody><tr>
+            <td class="white_bkd" width="8%">
               <div align="center">11</div>
             </td>
             <td class="white_bkd" width="8%">
@@ -130,10 +123,10 @@
               <div align="center">d</div>
             </td>
           </tr>
-        </table>
+        </tbody></table>
       </td>
     </tr>
-  </table>
+  </tbody></table>

 </blockquote>

This trivial example cannot be practically defined in traditional EBNF.Although

@@ -141,34 +134,32 @@

star, we are still limited to parsing fixed strings. The nature of EBNFforcesthe repetition factor to be a constant. On the other hand, Spirit allowstherepetition factor to be variable at run time. We could write a grammarthat

-  accepts the input string above:</p>

-<pre> intc;- r =anychar_p<spanclass=special>[assign_a<spanclass=special>(c)]>> <spanclass=identifier>repeat_p(<spanclass=identifier>boost::<spanclass=identifier>ref(<spanclass=identifier>c))[<spanclass=identifier>anychar_p];</pre>

-<p>The expression</p>

-<pre> anychar_p<spanclass=special>[assign_a<spanclass=special>(c<spanclass=special>)]</pre>+ accepts the input string above: 这个微不足道的例子实际上不能用传统的EBNF定义。虽然某些EBNF语法允许比克林星更强大的循环构造，我们仍然只能分析定长串。EBNF的习性要求循环的因数是一个常量。而在另一边，Spirit允许循环因数是一个运行时变量。我们可以写出能接受上面的字符串的语法：+<pre> intc; r =anychar_p<spanclass="special">[assign_a<spanclass="special">(c<spanclass="special">)] >> <spanclass="identifier">repeat_p(<spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">c))[<spanclass="identifier">anychar_p];</pre>

+<p>The expression<br>表达式</p>

+<pre> anychar_p<spanclass="special">[assign_a<spanclass="special">(c<spanclass="special">)]</pre>extracts the first character from the input and puts it in <tt>c</tt>.Whatis interesting is that in addition to constants, we can also usevariables as

-  parameters to <tt>repeat_p</tt>, as demonstrated in </p>

-<pre> repeat_p<spanclass=special>(boost<spanclass=special>::ref<spanclass=special>(c<spanclass=special>))<spanclass=special>[anychar_p<spanclass=special>]</pre>+ parameters to <tt>repeat_p</tt>, as demonstrated in 从输入中抽取第一个字符并且赋值给 <tt>c</tt>。有趣的是除了常量，我们也可以把变量作为<spanstyle="font-family: Courier New;"> <tt>repeat_p</tt><spanstyle="font-family: Courier New;"> 的参数，正如下面所示范的：+<pre> repeat_p<spanclass="special">(boost<spanclass="special">::ref<spanclass="special">(c<spanclass="special">))<spanclass="special">[anychar_p<spanclass="special">]</pre>Notice that <tt>boost::ref</tt> is used to reference the integer<tt>c</tt>.This usage of <tt>repeat_p</tt> makes the parser defer the evaluation oftherepetition factor until it is actually needed. Continuing our example,sincethe value 11 is already extracted from the input, <tt>repeat_p</tt> isis now

-  expected to loop exactly 11 times.</p>

+ expected to loop exactly 11 times. 注意 <tt>boost::ref</tt> 被用来引用整数c。这种用法使得 <tt>repeat_p</tt> 把循环因数的推演推迟到了真正需要时。继续我们的例子，由于值11已经被从输入中抽取，<tt>repeat_p</tt> 现在知道该循环11次了。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/parametric_parsers.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/parametric_parsers.html Sun Sep 2023:13:57 2009

@@ -1,149 +1,117 @@
-<html>
-<head>
-<title>Parametric Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Parametric Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Parametric

-      Parsers</b></font> </td>

+      Parsers 参数化分析器</b></font> </td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="predefined_actors.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="functional.html"><img src="theme/r_arr.gif"border="0"></a></td>

    </tr>
-</table>
+</tbody></table>

We already have a hint of the dynamic nature of the Spirit framework.Thiscapability is fundamental to Spirit. Dynamic parsing is a very powerfulconcept.We shall take this concept further through run-time parametric parsers.We areable to handle parsing tasks that are impossible to do with any EBNFsyntax

-  alone.</p>
-<h2>A Little Secret</h2>

+ alone. 对于Spirit框架的动态特性，我们已经有了初步的印象。这种动态的能力是Spirit的基础。动态分析是非常强大的概念。我们将通过运行时参数化分析器来进一步了解这个概念。这样我们将可以解析那些仅仅借助EBNF语法无法完成的目标。

+<h2>A Little Secret 一个小秘密</h2>

 A little critter called <tt>boost::ref</tt> lurking in the boostdistributionis quite powerful beast when used with Spirit's primitive parsers. Weare usedto seeing the Spirit primitive parsers created with string or characterliterals

-  such as:</p>
-<pre>

- <code>ch_p<spanclass=special>('A')- range_p<spanclass=special>('A','Z')- str_p<spanclass=special>("HelloWorld")</code></pre>

-<p> str_p has a second form that accepts two iterators over the string:</p>
-<pre>

- <code>char <spanclass=keyword>const* <spanclass=identifier>first = <spanclass=string>"My oh my";- char <spanclass=keyword>const* <spanclass=identifier>last = <spanclass=identifier>first + <spanclass=identifier>std::<spanclass=identifier>strlen(<spanclass=identifier>first);

- str_p<spanclass=special>(first<spanclass=special>, last<spanclass=special>)</code></pre>

-<p> What is not obvious is that we can use <tt>boost::ref</tt> as well:</p>
-<pre>

- <code>char ch= 'A'<spanclass=special>;- char from= 'A'<spanclass=special>;- char to= 'Z'<spanclass=special>;

- ch_p<spanclass=special>(boost<spanclass=special>::ref<spanclass=special>(ch))- range_p<spanclass=special>(boost<spanclass=special>::ref<spanclass=special>(from<spanclass=special>), boost<spanclass=special>::ref<spanclass=special>(to<spanclass=special>))</code></pre>+ such as: 一个小东西，名为 <tt>boost::ref</tt>，潜伏于 boost 的分发包中，在与 Spirit 的元素分析器一起使用时，却是相当强大的野兽。我们已经见过类似如下形式以字符或者字符串创建的 Spirit 基本分析器：+<pre> <code>ch_p<spanclass="special">('A'<spanclass="special">) <spanclass="identifier">range_p(<spanclass="literal">'A', <spanclass="literal">'Z') <spanclass="identifier">str_p(<spanclass="string">"Hello World"<spanclass="special">)</code></pre>+ str_p has a second form that accepts two iterators over thestring: str_p有第二种形态，接受一个string之上的两个迭代器：+<pre> <code>char <spanclass="keyword">const* <spanclass="identifier">first = <spanclass="string">"My oh my"; <spanclass="keyword">char const<spanclass="special">* last <spanclass="special">= first <spanclass="special">+ std<spanclass="special">::strlen<spanclass="special">(first<spanclass="special">); <spanclass="identifier">str_p(<spanclass="identifier">first, <spanclass="identifier">last)</code></pre>+ What is not obvious is that we can use <tt>boost::ref</tt> aswell: 但不显眼的是，我们也可以使用 <tt>boost::ref</tt>：+<pre> <code>char <spanclass="identifier">ch = <spanclass="literal">'A'; <spanclass="keyword">char from <spanclass="special">= 'A'<spanclass="special">; char <spanclass="identifier">to = <spanclass="literal">'Z'; <spanclass="identifier">ch_p(<spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">ch)) <spanclass="identifier">range_p(<spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">from), <spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">to))</code></pre> When <tt>boost::ref</tt> is used, the actual parameters to<tt>ch_p</tt> and<tt>range_p</tt> are held by reference. This means that we can changethe valuesof <tt>ch</tt>, <tt>from</tt> and <tt>to</tt> anytime and thecorresponding<tt>ch_p</tt> and <tt>range_p</tt> parser will follow their dynamicvalues.Of course, since they are held by reference, you must make sure that thereferenced

-  object is not destructed while parsing.</p>
-<p> What about <tt>str_p</tt>?</p>

+ object is not destructed while parsing. 当使用 <tt>boost::ref</tt>时，传递给 <tt>ch_p</tt> 和 <tt>range_p</tt> 的参数实际上是引用。这意味着我们可以在任何时候改变 <tt>ch</tt>, <tt>from</tt> 和 <tt>to</tt> 的值，而

+相应的

+ <tt>ch_p</tt> 和 <tt>range_p</tt> 分析器也将追随这些动态的赋值。当然，因为这些参数是对象的引用，所以你必须确保在分析时被引用的对象不会被析构。

+<p> What about <tt>str_p</tt>?<br>那么 <tt>str_p</tt> 呢？</p>

 While the first form of <tt>str_p</tt> (the single argument form) isreservedfor null terminated string constants, the second form (the two argumentfirst/last

-  iterator form) may be used:</p>
-<pre>

- str_p<spanclass=special>(boost<spanclass=special>::ref<spanclass=special>(first<spanclass=special>), boost<spanclass=special>::ref<spanclass=special>(last<spanclass=special>))</code></pre>

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/note.gif" width="16"height="16"> Hey,+ iterator form) may be used: 虽然 <tt>str_p</tt> 的第一种形式（单参数的形式）是为null结尾的常量字符串保留的，但第二种形式（两个参数为first/last迭代器的形式）可以这么用：+<pre> <code>char <spanclass="keyword">const* <spanclass="identifier">first = <spanclass="string">"My oh my"; <spanclass="keyword">char const<spanclass="special">* last <spanclass="special">= first <spanclass="special">+ std<spanclass="special">::strlen<spanclass="special">(first<spanclass="special">); <spanclass="identifier">str_p(<spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">first), <spanclass="identifier">boost::<spanclass="identifier">ref(<spanclass="identifier">last))</code></pre>

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"> <img src="theme/note.gif" height="16"width="16"> Hey,don't forget <tt>chseq_p</tt>. All these apply to this seldom usedprimitive

-      as well. </td>

+ as well. <img src="theme/note.gif" height="16" width="16">嘿，别忘了 <tt>chseq_p</tt>。以上这些同样适用于这个很少被使用的元素。 </td>

   </tr>
-</table>
-<h2>Functional Parametric Primitives</h2>
+</tbody></table>
+<h2>Functional Parametric Primitives 函数式参数化元素</h2>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/attribute/<spanclass="identifier">parametric.hpp<spanclass="special">></pre> Taking this further, Spirit includes functional versions of theprimitives.Rather than taking in characters, strings or references to charactersand strings- (using boost::ref), the functional versions take in functions orfunctors.+ (using boost::ref), the functional versions take in functions orfunctors. 更进一步，Spirit包含了函数式版本的元素。不是使用字符、字符串或者字符和字符串的引用（通过boost::ref），函数式版使用的是函数或者仿函数。

 <h3>f_chlit and f_ch_p</h3>

 The functional version of <tt>chlit</tt>. This parser takes in afunctionor functor (function object). The function is expected to have aninterface

-  compatible with:</p>
-<pre>

- <code>CharT <spanclass=identifier>func()</code></pre>- where CharT is the character type (e.g. <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>).

-<p> The functor is expected to have an interface compatible with:</p>
-<pre>
-    <code><span class=keyword>struct </span><span class=identifier>functor
-    </span><span class=special>{

- CharT <spanclass=keyword>operator()() <spanclass=keyword>const;

-    </span><span class=special>};</span></code></pre>

- where CharT is the character type (e.g. <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>).

-<p> Here's a contrived example:</p>
-<pre>
-    <code><span class=keyword>struct </span><span class=identifier>X
-    </span><span class=special>{

- char <spanclass=keyword>operator()() <spanclass=keyword>const

-        </span><span class=special>{

- return <spanclass=literal>'X'; 

-        }
-    </span><span class=special>};</span></code></pre>
-<p> Now we can use X to create our f_chlit parser:</p>
-<pre>

- <code>f_ch_p<spanclass=special>(X<spanclass=special>())</code></pre>+ compatible with: <tt>chlit</tt> 的函数式版本。这个分析器使用函数或者仿函数（函数对象）。所使用的函数需要兼容如下的接口：+<pre> <code>CharT <spanclass="identifier">func()</code></pre>+ where CharT is the character type (e.g. <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>). 其中 CharT 为字符类型(如 <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>)。+ The functor is expected to have an interface compatible with: 仿函数则要兼容如下接口：+<pre> <code>struct <spanclass="identifier">functor { CharT <spanclass="keyword">operator()() <spanclass="keyword">const; <spanclass="special">};</code></pre>+ where CharT is the character type (e.g. <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>). 其中 CharT 为字符类型(如 <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>)。

+<p> Here's a contrived example:<br>以下是一个简单的例子：</p>

+<pre> <code>struct <spanclass="identifier">X { char <spanclass="keyword">operator()() <spanclass="keyword">const <spanclass="special">{ return'X'; <spanclass="special">

+        }
+    </span><span class="special">};</span></code></pre>

+ Now we can use X to create our f_chlit parser: 现在我们可以使用 X 来创建我们的 f_chlit 分析器：+<pre> <code>f_ch_p<spanclass="special">(X<spanclass="special">())</code></pre>

 <h3>f_range and f_range_p</h3>

 The functional version of <tt>range</tt>. This parser takes in afunctionor functor compatible with the interfaces above. The difference is that<tt>f_range</tt>(and <tt>f_range_p</tt>) expects two functors. One for the start and onefor

-  the end of the range.</p>

+ the end of the range. <tt>range</tt> 的函数式版。分析器使用的函数或仿函数需有兼容于上面的接口。不同的是，<tt>f_range</tt>（以及<tt>f_range_p</tt>）需要两个仿函数。一个对应范围的起点另一个对应终点。

 <h3>f_chseq and f_chseq_p</h3>

 The functional version of <tt>chseq</tt>. This parser takes in twofunctionsor functors. One for the begin iterator and one for the end iterator.The function

-  is expected to have an interface compatible with:</p>
-<pre>

- <code>IteratorT <spanclass=identifier>func()</code></pre>+ is expected to have an interface compatible with: 函数式版的<tt>chseq</tt>。分析器使用两个函数或仿函数。一个对应begin迭代器另一个对应end迭代器。所使用的函数要求与如下接口兼容：+<pre> <code>IteratorT <spanclass="identifier">func()</code></pre> where <tt>IteratorT</tt> is the iterator type (e.g. <tt>charconst*</tt>,

-  <tt>wchar_t const*</tt>).</p>
-<p> The functor is expected to have an interface compatible with:</p>
-<pre>
-    <code><span class=keyword>struct </span><span class=identifier>functor
-    </span><span class=special>{

- IteratorT <spanclass=keyword>operator()() <spanclass=keyword>const;

-    </span><span class=special>};</span></code></pre>

+ <tt>wchar_t const*</tt>). 其中 <tt>IteratorT</tt> 为迭代器类型(如 <tt>char const*</tt>,

+  <tt>wchar_t const*</tt>)。</p>

+ The functor is expected to have an interface compatible with: 仿函数要求与如下接口兼容：+<pre> <code>struct <spanclass="identifier">functor { IteratorT <spanclass="keyword">operator()() <spanclass="keyword">const; <spanclass="special">};</code></pre> where <tt>IteratorT</tt> is the iterator type (e.g. <tt>charconst*</tt>,

-  <tt>wchar_t const*</tt>).</p>

+ <tt>wchar_t const*</tt>). 其中 <tt>IteratorT</tt> 为迭代器类型(如 <tt>char const*</tt>,

+  <tt>wchar_t const*</tt>)。</p>
 <h3>f_strlit and f_str_p</h3>

 The functional version of <tt>strlit</tt>. This parser takes in twofunctions- or functors compatible with the interfaces that <tt>f_chseq</tt>expects.+ or functors compatible with the interfaces that <tt>f_chseq</tt>expects. 函数式版的 <tt>strlit</tt>。分析器使用与 <tt>f_chseq</tt> 所要求的接口兼容的函数或仿函数。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/phoenix.html Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/phoenix.html Sun Sep 20 23:13:57 2009
@@ -1,184 +1,193 @@
-<html>
-<head>
-<title>Phoenix</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Phoenix</title><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Phoenix+ <td width="85%"> Phoenix

     </td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="functional.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="closures.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>

-The preceding chapter introduced Phoenix as a means to implementingyour semantic actions. We shall look a little bit more into this importantlibrary with focus on how you can use it handily with Spirit. This chapteris by no means a thorough discourse of the library. For more informationon Phoenix, please take some time to read the <ahref="../phoenix/index.html">Phoenix User's Guide</a>. If you just want touse it quickly, this chapter will probably suffice. Rather than taking youto the theories and details of the library, we shall try to provide youwith annotated exemplars instead. Hopefully, this will get you into highgear quickly. -Semantic actions in Spirit can be just about any function or functionobject (functor) as long as it can satisfy the required signature. Forexample, <tt>uint_p</tt> requires a signature of <tt>void F(T)</tt>, where<tt>T</tt> is the type of the integer (typically <tt>unsigned int</tt>).Plain vanilla actions are of the <tt>void F(IterT, IterT)</tt> variety. Youcan code your actions in plain C++. Calls to C++ functions or functors willthus be of the form <tt>P[&F]</tt> or <tt>P[F()]</tt> etc. (see <ahref="semantic_actions.html">Semantic Actions</a>). Phoenix on the otherhand, attempts to mimic C++ such that you can define the function bodyinlined in the code. 

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16"> C++ in C++? 

+</tbody></table>
+<p>The preceding chapter introduced Phoenix as a means to implementing
+your semantic actions. We shall look a little bit more into this
+important library with focus on how you can use it handily with Spirit.
+This chapter is by no means a thorough discourse of the library. For

+more information on Phoenix, please take some time to read the <ahref="../phoenix/index.html">Phoenix User's Guide</a>.

+If you just want to use it quickly, this chapter will probably suffice.
+Rather than taking you to the theories and details of the library, we
+shall try to provide you with annotated exemplars instead. Hopefully,

+this will get you into high gear quickly. 前一章节把Phoenix作为实现语义动作的一种方法来介绍。下面我们将稍微深入了解这个重要的库，并把焦点集中于如何在Spirit中便利地使用它。但这一章节绝非对这个库的完整讨论。想了解Phoenix的更多信息，需要拿出点时间来阅读<a href="../phoenix/index.html">Phoenix用户指南</a>。如果只是想尽快学会使用它，这一章将可以满足。比起告诉你这个库的理论和细节，我们倾向于把带有评注的例子提供给你。希望这样能使你的水平迅速提高。 

+<p>Semantic actions in Spirit can be just about any function or
+function object (functor) as long as it can satisfy the required

+signature. For example, <tt>uint_p</tt> requires a signature of <tt>voidF(T)</tt>, where <tt>T</tt> is the type of the integer (typically<tt>unsigned int</tt>). Plain vanilla actions are of the <tt>void F(IterT,IterT)</tt> variety. You can code your actions in plain C++. Calls to C++functions or functors will thus be of the form <tt>P[&F]</tt> or<tt>P[F()]</tt> etc. (see <a href="semantic_actions.html">SemanticActions</a>). Phoenix on the other hand, attempts to mimic C++ such thatyou can define the function body inlined in the code. Spirit的语义动作可以是任意的函数和函数对象（仿函数），只要他们符合所需的签名。比如，uint_p需要void

+F(T)这样的签名，这里T是整数的类型（一般为unsigned int）。一般的动作为void

+F(IterT,IterT)的变形。你可以只用C++来编写你的动作。对这些函数和仿函数的调用将有诸如 <tt>P[&F]</tt> 或 <tt>P[F()]</tt> 这样的形式(见 <ahref="semantic_actions.html">语义动作</a>)。另一方面，Phoenix 试图模仿C++以使你能在代码中直接插入函数体。 

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"> <img src="theme/lens.gif" height="16"width="15"> C++ in C++? 

         <br>

- In as much as Spirit attempts to mimic EBNF in C++, Phoenix attemptsto mimic C++ in C++!!!</td>+ In as much as Spirit attempts to mimic EBNF in C++, Phoenix attemptsto mimic C++ in C++!!! 就像Spirit试图在C++里模仿EBNF，Phoenix试图在C++里模仿C++!!!</td>

   </tr>
-</table>
+</tbody></table>
 <h2>var</h2>

-Remember the <tt>boost::ref</tt>? We discussed that in the <ahref="parametric_parsers.html">Parametric Parsers chapter</a>. Phoenix hasa similar, but more flexible, counterpart. It's called <tt>var</tt>. Theusage is similar to <tt>boost::ref</tt> and you can use it as a directreplacement. However, unlike <tt>boost::ref</tt>, you can use it to formmore complex expressions. Here are some examples:-<pre> var<spanclass=special>(x)+= 3- var<spanclass=special>(x)= var(<spanclass=identifier>y) + <spanclass=identifier>var(<spanclass=identifier>z)- <spanclass=identifier>var(<spanclass=identifier>x) = <spanclass=identifier>var(<spanclass=identifier>y) + <spanclass=identifier>(3 * var<spanclass=special>(z))- <spanclass=identifier>var(<spanclass=identifier>x) = <spanclass=identifier>var(<spanclass=identifier>y)[var<spanclass="special">(i)] <spanclass="comment">// assuming y is indexable and i is an index</pre>-Let's start with a simple example. We'll want to parse a commaseparated list of numbers and report the sum of all the numbers. Usingphoenix's var, we do not have to write external semantic actions. We simplyinline the code inside the semantic action slots. Here's the completegrammar with our phoenix actions (see <ahref="../example/fundamental/sum.cpp">sum.cpp</a> in the examples):-<pre> <spanclass=identifier>real_p[<spanclass=identifier>var(<spanclass=identifier>n) =arg1] <spanclass=special>>> *(<spanclass=literal>',' >> <spanclass=identifier>real_p[<spanclass=identifier>var(<spanclass=identifier>n) <spanclass=special>+= arg1<spanclass=special>]) </pre>- <img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/sum.cpp">viewed here</a>.

-This is part of the Spirit distribution.</p>

+Remember the <tt>boost::ref</tt>? We discussed that in the <ahref="parametric_parsers.html">Parametric Parsers chapter</a>. Phoenix hasa similar, but more flexible, counterpart. It's called <tt>var</tt>. Theusage is similar to <tt>boost::ref</tt> and you can use it as a directreplacement. However, unlike <tt>boost::ref</tt>, you can use it to formmore complex expressions. Here are some examples: 记得<tt>boost::ref</tt> 吗？我们在<a href="parametric_parsers.html">参数化分析器</a>一章中讨论过它。Phoenix有一个类似的，但更有弹性的摹本。它叫<tt>var</tt>。使用起来类似于 <tt>boost::ref</tt>，你可以直接把他当成占位符。然而，与 <tt>boost::ref</tt> 不同，你可以用它来组成更复杂的表达式。下面是一些例子：+<pre> var<spanclass="special">(x<spanclass="special">) += 3 <spanclass="identifier">var(<spanclass="identifier">x) = <spanclass="identifier">var(<spanclass="identifier">y) + <spanclass="identifier">var(<spanclass="identifier">z) <spanclass="number"> var<spanclass="special">(x<spanclass="special">) = var<spanclass="special">(y<spanclass="special">) + <spanclass="special">(3 * var(<spanclass="identifier">z)) <spanclass="number"> var<spanclass="special">(x<spanclass="special">) = var<spanclass="special">(y<spanclass="special">)[var(i<spanclass="special">)] // assuming y is indexableand i is an index</pre>

+<p>Let's start with a simple example. We'll want to parse a comma
+separated list of numbers and report the sum of all the numbers. Using
+phoenix's var, we do not have to write external semantic actions. We
+simply inline the code inside the semantic action slots. Here's the

+complete grammar with our phoenix actions (see <ahref="../example/fundamental/sum.cpp">sum.cpp</a> in the examples): 我们以简单的例子开始。比方我们想分析一个由逗号分隔的数字列表并报告所有数字之和。使用phoenix的var，我们不需要写额外的语义动作。而只需要简单地把代码内联在语义动作槽内。下面是完整的使用phoenix语义动作的语法（例子见<ahref="../example/fundamental/sum.cpp">sum.cpp</a>）：+<pre> <spanclass="identifier">real_p[<spanclass="identifier">var(<spanclass="identifier">n) <spanclass="special">= arg1<spanclass="special">] >> <spanclass="special">*(',' <spanclass="special">>> real_p<spanclass="special">[var<spanclass="special">(n<spanclass="special">) += <spanclass="identifier">arg1]) </pre>+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/sum.cpp">viewed here</a>.+This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15">完整的源码在<ahref="../example/fundamental/sum.cpp">这里</a>。这是Spirit发布包的组成部分。

 <h3>argN</h3>

-Notice the expression: <tt>var(n) = arg1</tt>. What is <tt>arg1</tt> and what is it doing there?<tt>arg1</tt> is an argument placeholder. Remember that <tt>real_p</tt>(see <a href="numerics.html">Numerics</a>) reports the parsed number to itsattached semantic action. <tt>arg1</tt> is a placeholder for the firstargument passed to the semantic action by the parser. If there are morethan one arguments passed in, these arguments can be referred to using<tt>arg1</tt>..<tt>argN</tt>. For instance, generic semantic actions(transduction interface; see <a href="semantic_actions.html">SemanticActions</a>) are passed 2 arguments: the iterators(<tt>first</tt>/<tt>last</tt>) to the matching portion of the input stream.You can refer to <tt>first</tt> and <tt>last</tt> through <tt>arg1</tt> and<tt>arg2</tt>, respectively. 

-<p>Like var, argN is also composable. Here are some examples:</p>

-<pre> var<spanclass=special>(x)+= arg1- var<spanclass=special>(x)= arg1 +var(<spanclass=identifier>z)- <spanclass=identifier>var(<spanclass=identifier>x) = <spanclass=identifier>arg1 + <spanclass=identifier>(3 * arg2<spanclass=special>)- <spanclass=identifier>var(<spanclass=identifier>x) = <spanclass=identifier>arg1[arg2<spanclass="special">] // assuming arg1 isindexable and arg2 is an index</pre>

+Notice the expression: <tt>var(n) = arg1</tt>. What is <tt>arg1</tt> and what is it doing there?<tt>arg1</tt> is an argument placeholder. Remember that <tt>real_p</tt>(see <a href="numerics.html">Numerics</a>) reports the parsed number to itsattached semantic action. <tt>arg1</tt>

+is a placeholder for the first argument passed to the semantic action
+by the parser. If there are more than one arguments passed in, these

+arguments can be referred to using <tt>arg1</tt>..<tt>argN</tt>. Forinstance, generic semantic actions (transduction interface; see <ahref="semantic_actions.html">Semantic Actions</a>) are passed 2 arguments:the iterators (<tt>first</tt>/<tt>last</tt>) to the matching portion of theinput stream. You can refer to <tt>first</tt> and <tt>last</tt> through<tt>arg1</tt> and <tt>arg2</tt>, respectively. 注意表达式<spanclass="identifier"><tt>var(n) = arg1</tt>。<tt>arg1</tt> 是什么，干什么？<tt>arg1</tt> 是一个参数的占位符。记得 <tt>real_p</tt> (see <a href="numerics.html">数值</a>)要把分析出的数值报告给挂接着它的语义动作。<tt>arg1</tt> 就是对应由分析器传给语义动作的第一个参数的占位符。如果传入的参数超过一个，则这些参数用<tt>arg1</tt>..<tt>argN</tt> 来引用。举例来说，一般的语义动作（转换接口；见<a href="http://www.boost.org/libs/spirit/doc/semantic_actions.html";>语义动作</a>）接受两个参数：对应输入流中匹配位置的一对迭代器（<tt>first</tt>/<tt>ast</tt>）。你可以分别通过 <tt>arg1</tt> 和<tt>arg2</tt> 来引用 <tt>first</tt> 和 <tt>last</tt>。<tt></tt>Likevar, argN is also composable. Here are some examples: 类似于 var，argN 也是可复合的。这里是一些例子：+<pre> var<spanclass="special">(x<spanclass="special">) += arg1 <spanclass="identifier">var(<spanclass="identifier">x) = <spanclass="identifier">arg1 + <spanclass="identifier">var(<spanclass="identifier">z) <spanclass="number"> var<spanclass="special">(x<spanclass="special">) = arg1<spanclass="special"> + <spanclass="special">(3 * arg2<spanclass="special">) <spanclass="identifier">var(<spanclass="identifier">x) = <spanclass="identifier">arg1[arg2<spanclass="special">] // assuming arg1 isindexable and arg2 is an index</pre>

 <h3>val</h3>

-Note the expression: <tt>3 * arg2.</tt> This expression is actually ashort-hand equivalent to: <tt>val(3) * arg2</tt>. We shall see later why,in some cases, we need to explicitly wrap constants and literals inside theval. Again, like var and argN, val is also composable.

-<h3>Functions </h3>

-Remember our very first example? In the <ahref="quick_start.html">Quick Start</a> chapter, we presented a parser thatparses a comma separated list and stuffs the parsed numbers in a vector(see <a href="../example/fundamental/number_list.cpp">number_list.cpp</a>) . For simplicity, we used Spirit's pre-defined actors(see <a href="predefined_actors.html">Predefined Actors</a>). In theexample, we used <tt>push_back_a</tt>:-<pre><code> <spanclass="identifier">real_p<span class=

-"special">[</span><span class="identifier">push_back_a</span><span class=
-"special">(</span><span class="identifier">v</span><span class=
-"special">)]</span> <span class="special">&gt;&gt;</span> <span class=
-"special">*(</span><span class="literal">','</span> <span class=
-"special">&gt;&gt;</span> <span class=
-      "identifier">real_p</span><span class="special">[</span><span class=

- "identifier">push_back_a(<spanclass=- "identifier">v<spanclass="special">)])</code></pre>-Phoenix allows you to write more powerful polymorphic functions,similar to <tt>push_back_a</tt>, easily. See <ahref="../example/fundamental/stuff_vector.cpp">stuff_vector.cpp</a>. Theexample is similar to <ahref="../example/fundamental/number_list.cpp">number_list.cpp</a> infunctionality, but this time, using phoenix a function to actuallyimplement the <tt>push_back</tt> function:-<pre> structpush_back_impl

-    </span><span class=special>{

-        </span><span class=special>{

- typedef <spanclass=keyword>void type<spanclass=special>;

-        </span><span class=special>};
-

- template <spanclass=special><typename <spanclass=identifier>Container, <spanclass=keyword>typename Item<spanclass=special>>- void <spanclass=keyword>operator()(<spanclass=identifier>Container& <spanclass=identifier>c, <spanclass=identifier>Item const<spanclass=special>& item<spanclass=special>) const

-        </span><span class=special>{

- c<spanclass=special>.push_back<spanclass=special>(item<spanclass=special>);

-        </span><span class=special>}
-    </span><span class=special>};</span>
-

- function<spanclass=special><push_back_impl<spanclass=special>> const <spanclass=identifier>push_back = <spanclass=identifier>push_back_impl();</pre>-<img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/stuff_vector.cpp">viewed here</a>.This is part of the Spirit distribution.

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16"> Predefined Phoenix Functions +Note the expression: <tt>3 * arg2.</tt> This expression is actually ashort-hand equivalent to: <tt>val(3) * arg2</tt>.

+We shall see later why, in some cases, we need to explicitly wrap
+constants and literals inside the val. Again, like var and argN, val is

+also composable. 注意表达式 <tt>3 * arg2</tt>。这个表达式实际上是 <tt>val(3) * arg2</tt> 的简写。后面我们将见到为什么在某些情况下，我们需要显式地封装常量和变量于 val 中。再次，类似于 var 和 argN，val 也是可复合的。

+<h3>Functions 函数 </h3>

+Remember our very first example? In the <ahref="quick_start.html">Quick Start</a> chapter, we presented a parser thatparses a comma separated list and stuffs the parsed numbers in a vector(see <a href="../example/fundamental/number_list.cpp">number_list.cpp</a>) . For simplicity, we used Spirit's pre-defined actors(see <a href="predefined_actors.html">Predefined Actors</a>). In theexample, we used <tt>push_back_a</tt>: 记得我们很早的例子么？在<ahref="quick_start.html">快速开始</a>一章中，我们展示了一个分析逗号分隔的数值表并把数值推入一个vector的分析器（见 <ahref="../example/fundamental/number_list.cpp">number_list.cpp</a>）。简单起见，我们用了Spirit预定义的动作器。（见<a href="predefined_actors.html">预定义动作器</a>）。在那个例子中，我们使用了 <tt>push_back_a</tt>:+<pre><code> <spanclass="identifier">real_p[<spanclass="identifier">push_back_a(<spanclass="identifier">v)] <spanclass="special">>> *(<spanclass="literal">',' >> <spanclass="identifier">real_p[<spanclass="identifier">push_back_a(<spanclass="identifier">v<spanclass="special">)])</code></pre>+Phoenix allows you to write more powerful polymorphic functions,similar to <tt>push_back_a</tt>, easily. See <ahref="../example/fundamental/stuff_vector.cpp">stuff_vector.cpp</a>. Theexample is similar to <ahref="../example/fundamental/number_list.cpp">number_list.cpp</a> infunctionality, but this time, using phoenix a function to actuallyimplement the <tt>push_back</tt> function: Phoenix允许你写更强大的多态函数，类似于 <tt>push_back_a</tt>，但更简单。见 <ahref="../example/fundamental/stuff_vector.cpp">stuff_vector.cpp</a>。下面的例子功能类似于 <ahref="../example/fundamental/number_list.cpp">number_list.cpp</a>，但这次，用phoenix写一个函数来实现 <tt>push_back</tt> 函数：+<pre> structpush_back_impl <spanclass="special">{ template<typenameContainer,typename <spanclass="identifier">Item> struct <spanclass="identifier">result <spanclass="special">{ typedefvoid <spanclass="identifier">type; }; <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">Container, <spanclass="keyword">typename Item<spanclass="special">> voidoperator<spanclass="special">()(Container<spanclass="special">& c<spanclass="special">, Item <spanclass="keyword">const& <spanclass="identifier">item) <spanclass="keyword">const <spanclass="special">{ <spanclass="identifier">c.<spanclass="identifier">push_back(<spanclass="identifier">item); } };

+ function<spanclass="special"><<spanclass="identifier">push_back_impl>const <spanclass="identifier">push_back = <spanclass="identifier">push_back_impl<spanclass="special">();</pre>+<img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/stuff_vector.cpp">viewed here</a>.This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15"> 完整的源码参见<ahref="../example/fundamental/stuff_vector.cpp">这里</a>。这是Spirit分发包的组成部分。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"> <img src="theme/lens.gif" height="16"width="15"> Predefined Phoenix Functions 预定义的Phoenix函数 

       <br>

- A future version of Phoenix will include an extensive set ofpredefined functions covering the whole of STL containers, iterators andalgorithms. push_back, will be part of this suite. </td>

+A future version of Phoenix will include an extensive set of predefined
+functions covering the whole of STL containers, iterators and

+algorithms. push_back, will be part of this suite. Phoenix将来的版本将包含一个巨大的预定义函数集，涵盖整个STL容器、迭代器和算法。push_back，将是这个套装的一部分。 </td>

   </tr>
-</table>

-<tt>push_back_impl</tt> is a simplewrapper over the <tt>push_back</tt> member function of STL containers. Theextra scaffolding is there to provide phoenix with additional informationthat otherwise cannot be directly deduced. <tt>result</tt> relays tophoenix the return type of the functor (<tt>operator()</tt>) given itsargument types (<tt>Container</tt> and <tt>Item</tt>) . In this case, thereturn type is always, simply <tt>void</tt>. -<tt>push_back</tt> is a phoenix functionobject. This is the actual function object that we shall use. The beautybehind phoenix function objects is that the actual use is strikinglysimilar to a normal C++ function call. Here's the number list parserrewritten using our phoenix function object:-<pre> <spanclass=identifier>real_p[<spanclass=identifier>push_back(<spanclass=identifier>var(<spanclass=identifier>v), <spanclass=identifier>arg1)] <spanclass=special>>> *(<spanclass=literal>',' >> <spanclass=identifier>real_p[<spanclass=identifier>push_back(<spanclass=identifier>var(<spanclass=identifier>v), <spanclass=identifier>arg1)])</pre>-And, unlike predefined actors, they can be composed. See the pattern?Here are some examples:-<pre> push_back<spanclass=special>(var<spanclass=special>(v),arg1 + 2)- push_back<spanclass=special>(var<spanclass=special>(v),var(x<spanclass=special>) + <spanclass="identifier">arg1)- push_back<spanclass=special>(var<spanclass=special>(v<spanclass=special>)[arg1], <spanclass=identifier>arg2) //assuming v is a vector of vectors and arg1 is an index</pre>-push_back does not have a return type. Say, for example, we wroteanother phoenix function <tt>sin</tt>, we can use it in expressions aswell: -<pre> push_back<spanclass=special>(var<spanclass=special>(v),sin(<spanclass=identifier>arg1) <spanclass="special">* 2<spanclass=special>)

+</tbody></table>

+<tt>push_back_impl</tt> is a simplewrapper over the <tt>push_back</tt>

+member function of STL containers. The extra scaffolding is there to
+provide phoenix with additional information that otherwise cannot be

+directly deduced. <tt>result</tt> relays to phoenix the return type of thefunctor (<tt>operator()</tt>) given its argument types (<tt>Container</tt>and <tt>Item</tt>) . In this case, the return type is always, simply<tt>void</tt>. <spanclass="identifier"><tt>push_back_impl</tt> 是一个针对STL容器的<tt>push_back</tt> 成员函数的简单封装。其他的多出来的代码用来给Phoenix提供附加的信息，否则它将无法直接推演。<tt>result</tt> 把给定了参数（<tt>Container</tt> 和 <tt>Item</tt>）的仿函数（<tt>operator()</tt>）的返回类型传递给Phoenix。在这个例子里，返回类型总是单纯的 <tt>void</tt>。

+<p><span class="identifier"><tt>push_back</tt></span> is a phoenix
+function object. This is the actual function object that we shall use.
+The beauty behind phoenix function objects is that the actual use is
+strikingly similar to a normal C++ function call. Here's the number

+list parser rewritten using our phoenix function object: <spanclass="identifier"><tt>push_back</tt> 是一个phoenix函数对象。这是我们将实际使用的函数对象。phoenix函数对象幕后的美丽在于它的实际调用非常类似于一个C++的普通函数。下面是用我们的phoenix函数对象重写的数值列表分析器：+<pre> <spanclass="identifier">real_p[<spanclass="identifier">push_back(<spanclass="identifier">var(<spanclass="identifier">v), <spanclass="identifier">arg1)] <spanclass="special">>> *(<spanclass="literal">',' >> <spanclass="identifier">real_p[<spanclass="identifier">push_back(<spanclass="identifier">var(<spanclass="identifier">v), <spanclass="identifier">arg1)])</pre>+And, unlike predefined actors, they can be composed. See the pattern?Here are some examples: 并且，与预定义动作器不同，他们可以复合。看到这个模式了么？这里是一些例子：+<pre> push_back<spanclass="special">(var<spanclass="special">(v<spanclass="special">), arg1 + 2<spanclass="special">)+ push_back<spanclass="special">(var<spanclass="special">(v<spanclass="special">), var<spanclass="special">(x)<spanclass="special"> + arg1<spanclass="special">)+ push_back<spanclass="special">(var<spanclass="special">(v<spanclass="special">)[arg1], <spanclass="identifier">arg2)// assuming v is a vector of vectors and arg1 is anindex</pre>+push_back does not have a return type. Say, for example, we wroteanother phoenix function <tt>sin</tt>, we can use it in expressions aswell: push_back 并没有返回类型。假如，举例来说，我们写了另一个phoenix函数 <tt>sin</tt>，我们也可以把它用于表达式中：+<pre> push_back<spanclass="special">(var<spanclass="special">(v<spanclass="special">), sin<spanclass="special">(arg1<spanclass="special">) *<spanclass="identifier"> 2)

 </pre>
-<h3>Construct</h3>

-Sometimes, we wish to construct an object. For instance, we might wantto create a <tt>std::string</tt> given the first/last iterators. Forinstance, say we want to parse a list of identifiers instead. Our grammar,without the actions, is: -<pre> (+<spanclass=identifier>alpha_p) <spanclass=special>>> *(<spanclass=literal>',' >> <spanclass=special>(+alpha_p<spanclass=special>))</pre>-<tt>construct_</tt> is a predefined phoenix functionthat, you guessed it, constructs an object, from the arguments passed in.The usage is:-<pre> <spanclass=identifier>construct_<<spanclass=identifier>T>(<spanclass=identifier>arg1, <spanclass=identifier>arg2,... <spanclass=identifier>argN)</pre>-where T is the desired type and arg1..argN are the constructorarguments. For example, we can construct a <tt>std::string</tt> from thefirst/last iterator pair this way:-<pre> construct_<spanclass=special><std<spanclass=special>::string<spanclass=special>>(arg1<spanclass=special>, arg2<spanclass=special>)</pre>

-<p>Now, we attach the actions to our grammar:</p>

-<pre> (+<spanclass=identifier>alpha_p)

-    </span><span class=special>[

- push_back<spanclass=special>(var<spanclass=special>(v),construct_<spanclass=special><std<spanclass=special>::string<spanclass=special>>(arg1<spanclass=special>, arg2<spanclass=special>))

-    </span><span class=special>]
-    </span><span class=special>&gt;&gt;

- *(','>>- (+<spanclass=identifier>alpha_p)

-        </span><span class=special>[

-        </span><span class=special>]
-    </span><span class=special>)</span></pre>

-<img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/stuff_vector2.cpp">viewed here</a>.This is part of the Spirit distribution.

-<h3><a name="lambda"></a>Lambda expressions</h3>

-All these phoenix expressions we see above are lambda expressions. Theimportant thing to note is that these expressions are not evaluatedimmediately. At grammar construction time, when the actions are attached tothe productions, a lambda expression actually generates an unnamed functionobject that is evaluated later, at parse time. In other words, lambdaexpressions are lazily evaluated.

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16"> Lambda Expressions? 

+<h3>Construct 构造</h3>

+Sometimes, we wish to construct an object. For instance, we might wantto create a <tt>std::string</tt>

+given the first/last iterators. For instance, say we want to parse a

+list of identifiers instead. Our grammar, without the actions, is: 有时，我们希望构造一个对象。例如，我们可能像用给定的 first/last 迭代器创建一个 <tt>std::string</tt> 对象。比如，假设我们想分析一个标识符列表。我们的语法，没有语义动作，是这样的：+<pre> (+<spanclass="identifier">alpha_p) <spanclass="special">>> *(<spanclass="literal">',' >> <spanclass="special">(+alpha_p<spanclass="special">))</pre>+<tt>construct_</tt> is a predefined phoenix functionthat, you guessed it, constructs an object, from the arguments passed in.The usage is: <tt>construct_</tt> 是一个预定义的phoenix函数，正如你猜到的，构造一个对象，使用给定的参数。使用方法是：+<pre> <spanclass="identifier">construct_<<spanclass="identifier">T>(<spanclass="identifier">arg1, <spanclass="identifier">arg2,... <spanclass="identifier">argN)</pre>+where T is the desired type and arg1..argN are the constructorarguments. For example, we can construct a <tt>std::string</tt> from thefirst/last iterator pair this way: 这里T是想构造的类型而 arg1...argN 是构造函数的参数。例如，我们可以这样从 first/last 迭代器对创建<tt>std::string</tt>:+<pre> construct_<spanclass="special"><std<spanclass="special">::string<spanclass="special">>(arg1<spanclass="special">, arg2<spanclass="special">)</pre>+Now, we attach the actions to our grammar: 现在，我们把语义动作挂接到语法上：+<pre> (+<spanclass="identifier">alpha_p) [ <spanclass="identifier">push_back(<spanclass="identifier">var(<spanclass="identifier">v), <spanclass="identifier">construct_<<spanclass="identifier">std::<spanclass="identifier">string>(<spanclass="identifier">arg1, <spanclass="identifier">arg2)) <spanclass="special">] >> *(','>> <spanclass="special">(+alpha_p<spanclass="special">) [ push_back<spanclass="special">(var<spanclass="special">(v<spanclass="special">), construct_<spanclass="special"><std<spanclass="special">::string<spanclass="special">>(arg1<spanclass="special">, arg2<spanclass="special">)) ] )</pre>+<img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/stuff_vector2.cpp">viewed here</a>.This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15"> 完整的代码参见<ahref="../example/fundamental/stuff_vector2.cpp">这里</a>。这是Spirit分发包的组成部分。

+<h3><a name="lambda"></a>Lambda expressions &nbsp;Lambda表达式</h3>
+<p>All these phoenix expressions we see above are lambda expressions.
+The important thing to note is that these expressions are not evaluated
+immediately. At grammar construction time, when the actions are
+attached to the productions, a lambda expression actually generates an
+unnamed function object that is evaluated later, at parse time. In

+other words, lambda expressions are lazilyevaluated. 所有这些我们在上面见到的Phoenix表达式都是所谓的lambda表达式。值得注意的是这些表达式并不是立即推算的。在语法创建的时+候，当语义动作挂接到所生成的对象上时，一个lambda表达式是延迟计算的的，只是在分析时才实际产生一个匿名函数对象。换言之，lambda表达式是惰性推算的。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"> <img src="theme/lens.gif" height="16"width="15"> Lambda Expressions? λ表达式？ 

         <br>

- Lambda expressions are actually unnamed partially applied functionswhere placeholders (e.g. arg1, arg2) are provided in place of some of thearguments. The reason this is called a lambda expression is thattraditionally, such placeholders are written using the Greek letter lambda<img src="theme/lambda.png" width="15" height="22">.</td>

+Lambda expressions are actually unnamed partially applied functions
+where placeholders (e.g. arg1, arg2) are provided in place of some of
+the arguments. The reason this is called a lambda expression is that
+traditionally, such placeholders are written using the Greek letter

+lambda <img src="theme/lambda.png" height="22" width="15">.</td>
   </tr>
-</table>

-Phoenix uses tricks not unlike those used by Spirit to mimic C++ suchthat you can define the function body inlined in the code. It's weird, butas mentioned, Phoenix actually mimicks C++ in C++ using expressiontemplates. Surely, there are limitations...-All components in a Phoenix expression must be anactor (in phoenix parlance) in the same way thatcomponents in Spirit should be a <tt>parser</tt>. In Spirit, you canwrite:-<pre> r <spanclass=special>= ch_p<spanclass=special>('x')>> <spanclass=literal>'y';</pre>

-<p>But not:</p>

-<pre> r <spanclass=special>= 'x' <spanclass=special>>> 'y'<spanclass=special>;</pre>-In essence, <tt>parser >> char</tt> is a parser, but <tt>char>> char</tt> is a char (the char shift-right by another char).

-<p>The same restrictions apply to Phoenix. For instance:</p>

-<pre> int <spanclass=identifier>x = <spanclass=number>1;- cout <<var(<spanclass=identifier>x) <spanclass=special><< <spanclass=string>"pizza"</pre>

-<p>is a well formed Phoenix expression that's lazily evaluated. But:</p>

-<pre> cout<< x<< <spanclass=string>"pizza"</pre>-is not. Such expressions are immediately executed. C++ syntax dictatesthat at least one of the operands must be a Phoenix actortype. This also applies to compound expressions. For example:-<pre> cout<< <spanclass=identifier>var(<spanclass=identifier>x) <spanclass=special><< "pizza"<< <spanclass=string>"man"</pre>

-<p>This is evaluated as:</p>

-<pre> (((<spanclass=identifier>cout << <spanclass=identifier>var(<spanclass=identifier>x)) <spanclass=special><< <spanclass=string>"pizza") <spanclass=special><< <spanclass=string>"man")</pre>-Since <tt>(cout << var(x))</tt> is an actor, at leastone of the operands is a phoenix actor, <tt>((cout<< var(x)) << "pizza")</tt> is also a Phoenix actor,and the whole expression is thus also an actor.

-<p>Sometimes, it is safe to write:</p>

-<pre> cout<< <spanclass=identifier>var(<spanclass=identifier>x) <spanclass=special><< val<spanclass=special>("pizza"<spanclass=special>) << <spanclass=identifier>val(<spanclass=string>"man")</pre>-just to make it explicitly clear what we are dealing with, especiallywith complex expressions, in the same way as we explicitly wrap literalstrings in <tt>str_p("lit")</tt> in Spirit. -Phoenix (and Spirit) also deals with unary operators. In such cases, wehave no choice. The operand must be a Phoenix actor (or Spirit parser).Examples:

+</tbody></table>
+<p>Phoenix uses tricks not unlike those used by Spirit to mimic C++
+such that you can define the function body inlined in the code. It's
+weird, but as mentioned, Phoenix actually mimicks C++ in C++ using

+expression templates. Surely, there are limitations... Phoenix使用类似于Spirit里用的技巧来模仿C++使得你可以在代码中内联地定义函数体。这很奇怪，但正如所提到的，Phoenix实际上是用表达式模板来在C++里模仿C++。当然，这也是有限制的……+All components in a Phoenix expression must be anactor (in phoenix parlance) in the same way thatcomponents in Spirit should be a <tt>parser</tt>. In Spirit, you canwrite: Phoenix表达式里所有的元件都必须是动作器（以phoenix的行话）而Spirit里这些元件必须是 <tt>parser</tt>。在Spirit中，我们可以写：+<pre> r= <spanclass="identifier">ch_p(<spanclass="literal">'x') <spanclass="special">>> 'y'<spanclass="special">;</pre>

+<p>But not:<br>但不能：</p>

+<pre> r= 'x'>> <spanclass="literal">'y';</pre>+In essence, <tt>parser >> char</tt> is a parser, but <tt>char>> char</tt> is a char (the char shift-right by another char). 本质上，<tt>parser >> char</tt> 是一个分析器，但 <tt>char >>char</tt> 是一个char（由一个char右移位而来的另一个char）。+The same restrictions apply to Phoenix. For instance: Phoenix中同样存在这样的限制。例如：+<pre> intx =1; cout <<var<spanclass="special">(x<spanclass="special">) << <spanclass="string">"pizza"</pre>+is a well formed Phoenix expression that's lazily evaluated. But: 是一个形态良好、惰性推算的Phoenix表达式。但：+<pre> cout<< x<< <spanclass="string">"pizza"</pre>+is not. Such expressions are immediately executed. C++ syntax dictatesthat at least one of the operands must be a Phoenix actortype. This also applies to compound expressions. For example: 不是。这样的表达式是立即计算的。C++句法要求只要有一个算子是Phoenix动作器类。这对复合表达式同样成立。比如：+<pre> cout<< <spanclass="identifier">var(<spanclass="identifier">x) <spanclass="special"><< "pizza" <spanclass="special"><< "man"</pre>

+<p>This is evaluated as:<br>这个被推算为：</p>

+<pre> (((<spanclass="identifier">cout << <spanclass="identifier">var(<spanclass="identifier">x)) <spanclass="special"><< "pizza"<spanclass="special">) << <spanclass="string">"man")</pre>+Since <tt>(cout << var(x))</tt> is an actor, at leastone of the operands is a phoenix actor, <tt>((cout<< var(x)) << "pizza")</tt> is also a Phoenix actor, and thewhole expression is thus also an actor. 由于 <tt>(cout <<var(x))</tt> 是一个动作器，至少一个算子是phoenix动作器， <tt>((cout << var(x))<< "pizza")</tt> 也是一个Phoenix动作器，而整个表达式也因此是一个动作器。

+<p>Sometimes, it is safe to write:<br>有时，这么写是安全的：</p>

+<pre> cout<< <spanclass="identifier">var(<spanclass="identifier">x) <spanclass="special"><< val<spanclass="special">("pizza"<spanclass="special">) << <spanclass="identifier">val(<spanclass="string">"man")</pre>

+<p>just to make it explicitly clear what we are dealing with,
+especially with complex expressions, in the same way as we explicitly

+wrap literal strings in <tt>str_p("lit")</tt> in Spirit. 只要用与Spirit里显式地用 <tt>str_p("lit")</tt> 封装字符串相同的方法显式地表明我们在和什么打交道，在复杂表达式中这点尤为重要。

+<p>Phoenix (and Spirit) also deals with unary operators. In such cases,
+we have no choice. The operand must be a Phoenix actor (or Spirit

+parser). Examples: Phoenix（以及Spirit）也处理一元操作符。在这样的情况下，我们没选择。算子必须是Phoenix动作器（或者Spirit分析器）。例子：

 <p>Spirit:</p>

-<pre> *<spanclass=identifier>ch_p(<spanclass=literal>'z') <spanclass=comment>// good- *(<spanclass=literal>'z') //bad</pre>+<pre> *<spanclass="identifier">ch_p(<spanclass="literal">'z') <spanclass="comment">// good *(<spanclass="literal">'z') <spanclass="comment">// bad</pre>

 <p> Phoenix:</p>

-<pre> *<spanclass=identifier>var(<spanclass=identifier>x) <spanclass=comment>// good (lazy)- *x// bad (immediate)</pre>-Also, in Phoenix, for assignments and indexing to be lazily evaluated,the object acted upon should be a Phoenix actor. Examples:-<pre> var<spanclass=special>(x)= 123 <spanclass=comment>// good (lazy)- x =123 // bad (immediate)- var<spanclass=special>(x<spanclass=special>)[0]// good (lazy)- x<spanclass=special>[0]// bad, immediate- var<spanclass=special>(x<spanclass=special>)[var<spanclass=special>(i)]// good (lazy)- x<spanclass=special>[var<spanclass=special>(i)]// bad and illegal (x is not an actor)- var<spanclass=special>(x<spanclass=special>[var<spanclass=special>(i<spanclass=special>)]) // bad and illegal (x is notan actor)</pre>

-<h3>Wrapping up </h3>

-Well, there you have it. I hope with this jump-start chapter, you maybe able to harness the power of lambda expressions. By all means, pleaseread the <a href="../phoenix/index.html">phoenix manual</a> to learn moreabout the nitty gritty details. Surely, you'll get to know a lot more thanjust by reading this chapter. There are a lot of things still to betouched. There won't be enough space here to cover all the features ofPhoenix even in brief. -The next chapter, <a href="closures.html">Closures</a>, we'll see moreof phoenix. Stay tuned. +<pre> *<spanclass="identifier">var(<spanclass="identifier">x) <spanclass="comment">// good (lazy) <spanclass="special">*x <spanclass="comment">// bad (immediate)</pre>

+<p>Also, in Phoenix, for assignments and indexing to be lazily

+evaluated, the object acted upon should be a Phoenix actor. Examples: 同样，在Phoenix里，要使等号和下标被惰性推算，其上的动作对象必须是Phoenix动作器。例子：+<pre> <spanclass="identifier">var(<spanclass="identifier">x) <spanclass="special">= 123 <spanclass="comment">// good (lazy) x= 123 <spanclass="comment">// bad (immediate) <spanclass="identifier">var(<spanclass="identifier">x)[<spanclass="number">0] <spanclass="comment">// good (lazy) <spanclass="identifier">x[<spanclass="number">0] <spanclass="comment">// bad, immediate <spanclass="identifier">var(<spanclass="identifier">x)[<spanclass="identifier">var(<spanclass="identifier">i)] <spanclass="comment">// good (lazy) <spanclass="identifier">x[<spanclass="identifier">var(<spanclass="identifier">i)] <spanclass="comment">// bad and illegal (x is not an actor) <spanclass="identifier">var(<spanclass="identifier">x[<spanclass="identifier">var(<spanclass="identifier">i)]) <spanclass="comment">// bad and illegal (x is not an actor)</pre>

+<h3>Wrapping up 封装 </h3>
+<p>Well, there you have it. I hope with this jump-start chapter, you
+may be able to harness the power of lambda expressions. By all means,
+please read the <a href="../phoenix/index.html">phoenix manual</a> to
+learn more about the nitty gritty details. Surely, you'll get to know a
+lot more than just by reading this chapter. There are a lot of things
+still to be touched. There won't be enough space here to cover all the

+features of Phoenix even in brief. 好了，就到这儿了。我希望这个入门章节能够让你驾驭lambda表达式的力量。请一定要阅读<ahref="../phoenix/index.html">phoneix手册</a>以了解更多的实质细节。当然，你将获得比阅读这章更多的知识。还有很多事情要了解。这里没有足够的空间来涵盖即使是简明的Phoenix功能介绍。+The next chapter, <a href="closures.html">Closures</a>, we'll see moreof phoenix. Stay tuned. 下一章，<a href="closures.html">闭包</a>，我们将看到更多的phoenix，请不要走开，我们马上回来。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/predefined_actors.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/predefined_actors.html Sun Sep 2023:13:57 2009

@@ -1,115 +1,113 @@
-<html>
-<head>
-<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
-<title>predefined_actors</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

+<html><head><meta content="text/html; charset=UTF-8"http-equiv="content-type">

+
+

+<title>predefined_actors</title><link rel="stylesheet"href="theme/style.css" type="text/css"></head>

 <body>

-<table width="100%" height="48" border="0" background="theme/bkd2.gif"cellspacing="2">

-  <tr>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" height="48"width="100%">

+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Predefined

-      Actors</b></font></td>

+ <td width="85%"> Predefined

+      Actors 预定义动作器</b></font></td>

<td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td>- <td width="30"><a href="indepth_the_parser_context.html"><imgsrc="theme/l_arr.gif" width="20" height="19" border="0"></a></td>- <td width="20"><a href="parametric_parsers.html"><imgsrc="theme/r_arr.gif" width="20" height="19" border="0"></a></td>+ <td width="30"><a href="indepth_the_parser_context.html"><imgsrc="theme/l_arr.gif" border="0" height="19" width="20"></a></td>+ <td width="20"><a href="parametric_parsers.html"><imgsrc="theme/r_arr.gif" border="0" height="19" width="20"></a></td>

   </tr>
-</table>
-<h2>Actors</h2><p>
+</tbody></table>
+<h2>Actors 动作器</h2><p>
 The framework has a number of predefined semantic action functors.

Experience shows that these functors are so often used that they wereincluded

 as part of the core framework to spare the user from having to reinvent the
-same functionality over and over again.</p>
-<h2>Quick example: <tt>assign_a</tt> actor</h2>

+same functionality over and over again. 本框架包含了一系列预定义的语义动作仿函数。经验表明这些仿函数的使用是如此频繁，因此在库中包含这些仿函数可以把用户从反复实现相同的功能中解放出来。+<h2>Quick example: <tt>assign_a</tt> actor 快速例子：<tt>assign_a</tt> 动作器</h2>

 <code>

-<pre> int <spanclass=identifier>i,<spanclass=identifier> j;- std<spanclass=special>::string <spanclass=identifier>s;- r =int_p[<spanclass=identifier>assign_a(<spanclass=identifier>i)] >> (+<spanclass=identifier>alpha_p)[<spanclass=identifier>assign_a(<spanclass=identifier>s)] >> <spanclass=identifier>int_p[<spanclass=identifier>assign_a(<spanclass=identifier>j,<spanclass=identifier>i)];</pre>

-</code>

+</code><pre> int <spanclass="identifier">i,<spanclass="identifier"> j; <spanclass="identifier">std::<spanclass="identifier">string s<spanclass="special">; r <spanclass="special">= int_p<spanclass="special">[assign_a<spanclass="special">(i<spanclass="special">)] >> (+<spanclass="identifier">alpha_p)[<spanclass="identifier">assign_a(<spanclass="identifier">s)] >> <spanclass="identifier">int_p[<spanclass="identifier">assign_a(<spanclass="identifier">j,<spanclass="identifier">i)];</pre>

+
 <p>
-Given an input <tt>123456 Hello 789</tt>, </p>

-<ol><li><tt>assign_a(i)</tt> will extract the number <tt>123456</tt> andassign it to <tt>i</tt>, </li><li><tt>assign_a(s)</tt> will extract thestring <tt>"Hello"</tt> and assign it to<tt>s</tt>,</li><li><tt>assign_a(j,i)</tt> will assign i to j, j=i, withoutusing the parse result.</li></ol>+Given an input <tt>123456 Hello 789</tt>, 给定一个输入 <tt>123456 Hello789</tt>, +<ol><li><tt>assign_a(i)</tt> will extract the number <tt>123456</tt> andassign it to <tt>i</tt>, <tt>assign_a(i)</tt> 将取出数字 <tt>123456</tt>并将其赋值给 <tt>i</tt>, </li><li><tt>assign_a(s)</tt> will extract thestring <tt>"Hello"</tt> and assign it to<tt>s</tt>, <tt>assign_a(s)</tt> 将取出字符串 <tt>"Hello"</tt> 并将其赋值给 <tt>s</tt>,</li><li><tt>assign_a(j,i)</tt> will assign i to j, j=i,without using the parse result. <tt>assign_a(j,i)</tt> 将 i 赋值给 j,j=i, 不使用分析的结果。</li></ol> Technically, the expression <tt>assign_a(v)</tt> is a templatefunction thatgenerates a semantic action. In fact, actor instances are not createddirectlysince they usually involve a number of template parameters. Insteadgenerator- functions ("helper functions") are provided to generate actorsfrom- their arguments. All helper functions have the "_a" suffix.For example,- <tt>append_actor</tt> is created using the <tt>append_a</tt> function.

+  functions ("helper functions") are provided to generate actors from
+  their arguments. All helper functions have the "_a" suffix. For example,

+ <tt>append_actor</tt> is created using the <tt>append_a</tt>function. 技术上，表达式 <tt>assign_a(v)</tt> 是一个生成语义动作的模板函数。事实上，动作器实例都不是直接创建的，因为它们通常需要多个模板参数。取而代之的是一些生成器函数("辅助函数")，用于从它们的参数生成动作器。所有辅助函数都带有"_a"后缀。例如，<tt>append_actor</tt> 就是用 <tt>append_a</tt> 函数生成的。 

 <p>
 The semantic action generated is polymorphic and should work with any

type as long as it is compatible with the arguments received from theparser.It might not be obvious, but a string can accept the iterator first andlastarguments that are passed into a generic semantic action (see above). Infact,any STL container that has an <tt>assign(first, last)</tt> member functioncan be

-used.</p>
-<h2>Actors summary</h2><p>
-Below are tables summarizing the &quot;built-in&quot; actors with the
-conventions given below.</p>

+used. 所生成的语意动作是多态的，并且应能够处理任何兼容于传递自分析器的参数类型的类型。这可能很绕口，但比如一个 string 可以接受一个传入所产生的语义动作的 first, last 迭代器对（见上）。实际上，任何有 <tt>assign(first,last)</tt> 成员函数的标准库容器都可以使用。<tt></tt>

+<h2>Actors summary 动作器概要</h2><p>
+Below are tables summarizing the "built-in" actors with the

+conventions given below. 后面的表格概括了符合下述约定的“内建”动作器。

 <ul>

<li><tt>ref</tt> is a reference to an object stored in a policyholder

-    actor</li>

+ actor <tt>ref</tt> 是一个对对象的引用，储存于策略持有者动作器</li><li><tt>value_ref</tt> and <tt>key_ref</tt> are const referencesstored

-    in a policy holder actor</li>

+ in a policy holder actor <tt>value_ref</tt> 和 <tt>key_ref</tt> 是常量引用，储存于策略持有者动作器</li><li><tt>value</tt> is the parse result. This could be the resultfor

-    the single argument () operator or the two argument () operator</li>

+ the single argument () operator or the two argument ()operator <tt>value</tt> 是分析结果。这可以是适用于单参数或双参数的()操作符</li><li><tt>vt</tt> stands for the <tt>value_type</tt> type: <tt>type&ref;+ // vt is type::value_type</tt>. <tt>vt</tt> 即 <tt>value_type</tt>类型：<tt>type& ref;

     // vt is type::value_type</tt>.</li>
 </ul>
-<p> Note that examples are provided after the tables.</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="8"> Unary operator actors</td>

+ Note that examples are provided after the tables. 留意表格后面的例子。

+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td class="table_title" colspan="8"> Unary operator actors 单参动作器</td>

   </tr>

- <td width="30%" class="table_cells">++ref</td> <td width="70%"class="table_cells">increment_a(ref)</td>+ <tr><td class="table_cells" width="30%">++ref</td> <tdclass="table_cells" width="70%">increment_a(ref)</td>

   </tr>

- <td class="table_cells">--ref</td> <tdclass="table_cells">decrement_a(ref)</td>+ <tr><td class="table_cells">--ref</td> <tdclass="table_cells">decrement_a(ref)</td>

   </tr>
-</table>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="26"> Assign actors</td>
+</tbody></table>
+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="26"> Assign actors 赋值动作器</td>
   </tr>
   <tr>
     <td class="table_cells">ref = value</td>
     <td class="table_cells"><b>assign_a</b>(ref)</td>
   </tr>
-    <td width="30%" class="table_cells">ref = value_ref</td>

- <td width="70%" class="table_cells">assign_a(ref,value_ref)</td>

+    <tr><td class="table_cells" width="30%">ref = value_ref</td>

+ <td class="table_cells" width="70%">assign_a(ref,value_ref)</td>

   </tr>
-</table>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="30"> Container actors </td>
+</tbody></table>
+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="30"> Container actors 容器动作器 </td>
   </tr>
   <tr>
-    <td width="30%" class="table_cells">ref.push_back(value)</td>
-    <td width="70%" class="table_cells"><b>push_back_a</b>(ref)</td>
+    <td class="table_cells" width="30%">ref.push_back(value)</td>
+    <td class="table_cells" width="70%"><b>push_back_a</b>(ref)</td>
   </tr>
-  <td class="table_cells">ref.push_back(value_ref)</td>
+  <tr><td class="table_cells">ref.push_back(value_ref)</td>
   <td class="table_cells"><b>push_back_a</b>(ref, value_ref)</td>
   </tr>
-  <td class="table_cells">ref.push_front(value)</td>
+  <tr><td class="table_cells">ref.push_front(value)</td>
   <td class="table_cells"><b>push_front_a</b>(ref)</td>
   </tr>
-  <td class="table_cells">ref.push_front(value_ref)</td>
+  <tr><td class="table_cells">ref.push_front(value_ref)</td>
   <td class="table_cells"><b>push_front_a</b>(ref, value_ref)</td>
   </tr>
-  <td class="table_cells">ref.clear()</td>
+  <tr><td class="table_cells">ref.clear()</td>
   <td class="table_cells"><b>clear_a</b>(ref)</td>
   </tr>
-</table>
-<table width="90%" border="0" align="center">
-  <tr>

- <td class="table_title" colspan="14"> Associative container actors</td>

+</tbody></table>
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td class="table_title" colspan="14"> Associative container actors 关联容器动作器 </td>

   </tr>

- <td width="30%" class="table_cells">ref.insert(vt(value,value_ref))</td> <td width="70%"class="table_cells">insert_key_a(ref, value_ref)</td>+ <tr><td class="table_cells" width="30%">ref.insert(vt(value,value_ref))</td> <td class="table_cells"width="70%">insert_key_a(ref, value_ref)</td>

   </tr>  <tr>
       <td class="table_cells"> ref.insert(vt(key_ref,value_ref)) </td>

<td class="table_cells"> insert_at_a(ref, key_ref_,value_ref)</td>

@@ -118,30 +116,30 @@
       <td class="table_cells"> ref.insert(vt(key_ref,value)) </td>

<td class="table_cells"> insert_at_a(ref, key_ref)</td>

     </tr>
-    <td class="table_cells">ref[value] = value_ref</td>
+    <tr><td class="table_cells">ref[value] = value_ref</td>
     <td class="table_cells"><b>assign_key_a</b>(ref, value_ref)</td>
   </tr>
-  <td class="table_cells">ref.erase(ref,value)</td>
+  <tr><td class="table_cells">ref.erase(ref,value)</td>
   <td class="table_cells"><b>erase_a</b>(ref)</td>
   </tr>
-  <td class="table_cells">ref.erase(ref,key_ref)</td>
+  <tr><td class="table_cells">ref.erase(ref,key_ref)</td>
     <td class="table_cells"><b>erase_a</b>(ref, key_ref)</td>
   </tr>
-</table>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="8"> Miscellanous actors </td>
+</tbody></table>
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td class="table_title" colspan="8"> Miscellanous actors 杂项动作器</td>

   </tr>
   <tr>
-    <td width="30%" class="table_cells">swaps aref and bref</td>

- <td width="70%" class="table_cells">swap_a(aref,bref)</td>+ <td class="table_cells" width="30%">swaps aref and bref 交换 aref 和 bref</td>+ <td class="table_cells" width="70%">swap_a(aref,bref)</td>

   </tr>
-</table>
-<h3>Include Files</h3>
+</tbody></table>
+<h3>Include Files 包含文件</h3>

The header files for the predefined actors are located in<tt>boost/spirit/actor</tt>.The file <tt>actors.hpp</tt> contains all the includes for all theactors. Youmay include just the specific header files that you need. The list belowenumerates

-  the header files.</p>

+ the header files. 预定义动作器的头文件位于<tt>boost/spirit/actor。</tt>文件 <tt>actors.hpp</tt> 包含了所有动作器的头文件。你也可以仅仅包含你所需要的特定头文件。下面列出这些头文件。<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">assign_actor<spanclass="special">.hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/assign_key_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">clear_actor.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">decrement_actor<spanclass="special">.hpp><spanclass="special">

@@ -150,197 +148,125 @@

#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">push_back_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">push_front_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">swap_actor.hpp<spanclass="special">><spanclass="special"></pre>

-<h3>Examples</h3>
-<h4>Increment a value</h4>
+<h3>Examples 例子</h3>
+<h4>Increment a value 递增某个值</h4>
 <p>
-Suppose that your input string is </p>
+Suppose that your input string is<br>假设你的输入串为 </p>
 <code>
-<pre>    1,2,-3,4,...
-</pre>
-</code><p>

-and we want to count the number of ints. The actor <tt>increment_a</tt>applies <tt>++</tt> to its reference:

+</code><pre>    1,2,-3,4,...<br></pre>
+<p>

+and we want to count the number of ints. The actor <tt>increment_a</tt>applies <tt>++</tt> to its reference: 而你想统计整数的个数。动作器<tt>increment_a</tt> 对其引用的对象使用 <tt>++:</tt>

 <code>

-<pre> int count= 0<spanclass=special>;- rule<>r = <spanclass=identifier>list_p.<spanclass=identifier>direct(<spanclass=identifier>int_p[<spanclass=identifier>increment_a(<spanclass=identifier>count)], <spanclass=identifier>ch_p(<spanclass=literal>','));</pre>

-</code>
-<h4>Append values to a vector (or other container)</h4>

+</code><pre> int <spanclass="identifier">count = <spanclass="number">0; <spanclass="identifier">rule<> <spanclass="identifier">r = <spanclass="identifier">list_p.<spanclass="identifier">direct(<spanclass="identifier">int_p[<spanclass="identifier">increment_a(<spanclass="identifier">count)], <spanclass="identifier">ch_p(<spanclass="literal">','));</pre>

+<h4>Append values to a vector (or other container) 将某些值添加到vector(或其它容器)</h4> Here, you want to fill a <tt>vector<int></tt> with the numbers.Theactor <tt>push_back_a</tt> can be used to insert the integers at theback of

-  the vector:</p>

+ the vector: 这里，你想向一个 <tt>vector<int></tt> 填充数值。那么动作器 <tt>push_back_a</tt> 可以用来向 <tt>vector</tt> 的后端插入整数：

 <code>

-<pre> vector<spanclass=special><int<spanclass=special>> v<spanclass=special>;- rule<>r = <spanclass=identifier>list_p.<spanclass=identifier>direct(<spanclass=identifier>int_p[<spanclass=identifier>push_back_a(<spanclass=identifier>v)], <spanclass=identifier>ch_p(<spanclass=literal>','));</pre>

-</code>
-<h4>insert key-value pairs into a map</h4><p>
-Suppose that your input string is </p>

+</code><pre> vector<spanclass="special"><int<spanclass="special">> v<spanclass="special">; rule<spanclass="special"><> r <spanclass="special">= list_p<spanclass="special">.direct<spanclass="special">(int_p<spanclass="special">[push_back_a<spanclass="special">(v<spanclass="special">)], ch_p<spanclass="special">(','<spanclass="special">));</pre>

+
+<h4>insert key-value pairs into a map 将键-值对插入到一个map</h4><p>
+Suppose that your input string is<br>假设你输入的字符串为 </p>
 <code>
-<pre>    (1,2) (3,4) ...
-</pre>
-</code>
+</code><pre>    (1,2) (3,4) ... <br></pre>
+

 and you want to parse the pair into a <tt>map<int,int></tt>.<tt>assign_a</tt>can be used to store key and values in a temporary key variable, while<tt>insert_a</tt>

-  is used to insert it into the map:</p>

-<pre> <code>map<spanclass=special><int<spanclass=special>, int<spanclass="special">>::value_type k<spanclass=special>;- map<spanclass=special><int<spanclass=special>, int<spanclass=special>> m<spanclass=special>;

- rule<>pair =

-        confix_p</span><span class=special>(
-            </span><span class=literal>'('</span><span class=special>

- , int_p<spanclass=special>[assign_a<spanclass=special>(k.first)] >> <spanclass=literal>',' >> <spanclass=identifier>int_p[<spanclass=identifier>assign_a(k.second<spanclass=special>)]

-          ,</span><span class=literal> ')'

- ) [<spanclass=identifier>insert_at_a(<spanclass=identifier>m, <spanclass=identifier>k<spanclass=special>)]

-        ;</span></code></pre>
-<h2>Policy holder actors and policy actions</h2>

+ is used to insert it into the map: 且你想分析这些数值并成对插入一个<tt>map<int,int></tt>。这里 <tt>assign_a</tt> 可以用来将键-值对保存在一个临时变量中，同时 <tt>insert_a</tt> 可以用来把它插入到map：<tt></tt>+<pre> <code>map<spanclass="special"><int<spanclass="special">, int<spanclass="special">>::value_type k<spanclass="special">; map<spanclass="special"><int<spanclass="special">, int<spanclass="special">> m<spanclass="special">; <spanclass="identifier">rule<> <spanclass="identifier">pair = <spanclass="identifier">+ confix_p( <spanclass="literal">'('+ , int_p<spanclass="special">[assign_a<spanclass="special">(k.first)] >>',' >>int_p<spanclass="special">[assign_a<spanclass="special">(k.second<spanclass="special">)] ,<spanclass="literal"> ')' ) [insert_at_a<spanclass="special">(m<spanclass="special">, k<spanclass="identifier"><spanclass="special">)] ;</code></pre>

+<h2>Policy holder actors and policy actions 策略持有者动作器和策略动作</h2>

 The action takes place through a call to the <tt>()</tt> operator:singleargument <tt>()</tt> operator call for character parsers and twoargument (first,last) call for phrase parsers. Actors should implement at least one ofthe two

-  <tt>()</tt> operator.</p>

+ <tt>()</tt> operator. 语意动作通过对<tt>()</tt>操作符的调用被激活：单参数的<tt>()</tt>操作符适用于字符分析器而双参数(first,last)的适用于句子分析器。

 <p>
 A lot of actors need to store reference to one or more objects. For

-example, actions on container need to store a reference to thecontainer.+example, actions on container need to store a reference to thecontainer. 很多动作器需要储存一个或者更多的对象引用。比如，作用于容器的动作需要储存这个容器的引用。 Therefore, this kind of actor have been broken down intoa)an action policy that does the action (act member function),b)- policy holder actor that stores the references and feeds the act memberfunction.

-<h3>Policy holder actors</h3>
-<p> The available policy holders are enumerated below.</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="24"> Policy holders </td>

+ policy holder actor that stores the references and feeds the act memberfunction. 因此，这类动作器被分割成a)一个实际执行动作(act成员函数)的动作策略，b)持有传递给act成员函数的对象引用的策略持有者动作器。

+<h3>Policy holder actors 策略持有者动作器</h3>

+ The available policy holders are enumerated below. 可用的策略持有者动作器列于下表：

+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="24"> Policy holders 策略持有者 </td>
   </tr>
   <tr>
-    <td class="table_cells">Name</td>
-    <td class="table_cells">Stored variables</td>
-    <td class="table_cells">Act signature</td>
+    <td class="table_cells">Name 名字</td>
+    <td class="table_cells">Stored variables 保存的变量</td>
+    <td class="table_cells">Act signature &nbsp;Act函数签名</td>
   </tr>
-  <td class="table_cells">ref_actor</td>
+  <tr><td class="table_cells">ref_actor</td>
   <td class="table_cells">1 reference</td>
   <td class="table_cells"><tt>act(ref)</tt></td>
   </tr>
-  <td class="table_cells">ref_value_actor</td>
+  <tr><td class="table_cells">ref_value_actor</td>
   <td class="table_cells">1 ref</td>

<td class="table_cells"> <tt>act(ref, value)</tt> or <tt>act(ref,first, last)</tt></td>

   </tr>
-    <td class="table_cells">ref_const_ref_actor</td>
+    <tr><td class="table_cells">ref_const_ref_actor</td>
   <td class="table_cells">1 ref and 1 const ref</td>
   <td class="table_cells"><tt>act(ref, const_ref)</tt></td>
   </tr>
-    <td class="table_cells">ref_const_ref_value_actor</td>
+    <tr><td class="table_cells">ref_const_ref_value_actor</td>
   <td class="table_cells">1 ref</td>

<td class="table_cells"><tt>act(ref, value)</tt> or <tt>act(ref,first, last)</tt></td>

   </tr>
-    <td class="table_cells">ref_const_ref_const_ref_actor</td>
+    <tr><td class="table_cells">ref_const_ref_const_ref_actor</td>
   <td class="table_cells">1 ref, 2 const ref</td>
   <td class="table_cells"><tt>act(ref, const_ref1, const_ref2)</tt></td>
   </tr>
-</table>
-<h3>Include Files</h3>

-The predefined policy header files are located in<tt>boost/spirit/actor</tt>:

+</tbody></table>
+<h3>Include Files 包含文件</h3>

+The predefined policy header files are located in<tt>boost/spirit/actor</tt>: 预定义的策略持有者动作器的头文件位于<tt>boost/spirit/actor：</tt><pre> #include <spanclass="special"><boost/spirit<spanclass="special">/actor/ref_actor<spanclass="special">.hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/ref_value_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/ref_const_ref.hpp<spanclass="special">>#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/ref_const_ref_value<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/ref_const_ref_value<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor<spanclass="special">/ref_const_ref_const_ref<spanclass="special">.hpp><spanclass="special"></pre>

-<h3>Holder naming convention</h3>
-<p> Policy holder have the following naming convention:</p>
+<h3>Holder naming convention 持有者命名约定</h3>

+ Policy holder have the following naming convention: 策略持有者有如下的命名约定：<pre> <code><member>_ >> *<member> >> !value>> actor</code></pre>- where <tt>member</tt> is the action policy member which can be oftype:+ where <tt>member</tt> is the action policy member which can be oftype: 这里 <tt>member</tt> 是动作策略成员，它的类型可以是：

 <ul>
-  <li>ref, a reference</li>
-  <li>const_ref, a const reference</li>
-  <li>value, by value</li>
-  <li>empty, no stored members</li>
+  <li>ref, a reference<br>ref, 一个引用</li>
+  <li>const_ref, a const reference<br>const_ref, 一个常量引用</li>
+  <li>value, by value<br>value, 传值方式</li>
+  <li>empty, no stored members<br>empty，无存储成员</li>
 </ul>

- and <tt>value</tt> states if the policy uses the parse result ornot.

-<h3>Holder example: <tt>ref_actor</tt> class</h3>

-<pre><code> // this is the building block foraction that

-    // take a reference and the parse result
-
-    </span><span class=keyword>template</span><span class=special>&lt;

- typename <spanclass=identifier>T,// reference type- typename <spanclass=identifier>ActionT // action policy

-    </span><span class=special>&gt;

- class <spanclass=identifier>ref_value_actor : <spanclass=keyword>public ActionT

-    </span><span class=special>{
-</span>    <span class=keyword>public</span><span class=special>:
-

- explicit <spanclass=identifier>ref_value_actor(<spanclass=identifier>T& <spanclass=identifier>ref_)- : ref<spanclass=special>(ref_<spanclass=special>){}

- template<spanclass=special><typename <spanclass=identifier>T2>- void operator<spanclass=special>()(T2 <spanclass=keyword>const& <spanclass=identifier>val) <spanclass=keyword>const

-        </span><span class=special>{

- act<spanclass=special>(ref<spanclass=special>, val<spanclass=special>); // defined inActionT

-        </span><span class=special>}
-

- template<spanclass=special><typename <spanclass=identifier>IteratorT>- void operator<spanclass=special>()(- IteratorT <spanclass=keyword>const& <spanclass=identifier>first,- IteratorT <spanclass=keyword>const& <spanclass=identifier>last) <spanclass=keyword>const

-        </span><span class=special>{

- act<spanclass=special>(ref<spanclass=special>,first<spanclass=special>,last<spanclass=special>); // defined inActionT

-        </span><span class=special>}
-
-    </span><span class=keyword>private</span><span class=special>:
-

- T&ref;

-    };</span></code></pre>
-<h3>Actor example: <tt>assign_actor</tt></h3>

+ and <tt>value</tt> states if the policy uses the parse result ornot. 而 <tt>value</tt> 标明策略是否使用分析结果。+<h3>Holder example: <tt>ref_actor</tt> class 持有者例子：<tt>ref_actor</tt> 类</h3>+<pre><code> // this is the building block foraction that // take a reference and the parse result template<spanclass="special">< typenameT,<spanclass="comment"> // reference type+ typename <spanclass="identifier">ActionT // actionpolicy > <spanclass="keyword">class ref_value_actor: publicActionT <spanclass="special">{ public<spanclass="special">: explicitref_value_actor<spanclass="special">(T<spanclass="special">& ref_<spanclass="special">) : <spanclass="identifier">ref(<spanclass="identifier">ref_){} template<spanclass="special"><typename <spanclass="identifier">T2> void operator<spanclass="special">()(T2 <spanclass="keyword">const& <spanclass="identifier">val) <spanclass="keyword">const <spanclass="special">{ <spanclass="identifier">act(<spanclass="identifier">ref, <spanclass="identifier">val);<spanclass="comment"> // defined in ActionT+ } <spanclass="keyword">template<<spanclass="keyword">typename <spanclass="identifier">IteratorT> void operator<spanclass="special">()( <spanclass="identifier">IteratorT const<spanclass="special">& first<spanclass="special">, IteratorTconst&last)const <spanclass="special">{ <spanclass="identifier">act(<spanclass="identifier">ref,<spanclass="identifier">first,<spanclass="identifier">last);<spanclass="comment"> // defined in ActionT+ } <spanclass="keyword">private: <spanclass="identifier"> T& <spanclass="identifier">ref; };</code></pre>+<h3>Actor example: <tt>assign_actor</tt>  动作器例子：<tt>assign_actor</tt></h3>

 <code>

-<pre> // assign_action assigns the parse result tothe reference

- struct <spanclass=identifier>assign_action

-    </span><span class=special>{
-        </span><span class=keyword>template</span><span class=special>&lt;

- typename <spanclass=identifier>T,- typename <spanclass=identifier>ValueT

-        </span><span class=special>&gt;

- void <spanclass=identifier>act(<spanclass=identifier>T& <spanclass=identifier>ref, <spanclass=identifier>ValueT const<spanclass=special>& value<spanclass=special>) const

-        </span><span class=special>{

- ref =value<spanclass=special>;

-        }
-
-        </span><span class=keyword>template</span><span class=special>&lt;

- typename <spanclass=identifier>T,- typename <spanclass=identifier>IteratorT

-        </span><span class=special>&gt;

- void <spanclass=identifier>act(- T<spanclass=special>& ref<spanclass=special>,- IteratorT <spanclass=keyword>const& <spanclass=identifier>first,- IteratorT <spanclass=keyword>const& <spanclass=identifier>last) <spanclass=keyword>const

-        </span><span class=special>{

- typedef <spanclass=keyword>typename T<spanclass=special>::value_type <spanclass=identifier>value_type;- value_type <spanclass=identifier>vt(<spanclass=identifier>first,<spanclass=identifier> last);- ref =vt<spanclass=special>;

-        }
-    };</span></pre>
-</code>
-<h3>Helper function example: <tt>assign_a</tt> function</h3>

+</code><pre> // assign_action assigns the parseresult to the reference structassign_action <spanclass="special">{ <spanclass="keyword">template< typename <spanclass="identifier">T, typename <spanclass="identifier">ValueT <spanclass="special">> voidact<spanclass="special">(T<spanclass="special">& ref<spanclass="special">, ValueT <spanclass="keyword">const& <spanclass="identifier">value) <spanclass="keyword">const <spanclass="special">{ <spanclass="identifier">ref = <spanclass="special">value<spanclass="special">; } <spanclass="keyword">template< typename <spanclass="identifier">T, typename <spanclass="identifier">IteratorT <spanclass="special">> voidact<spanclass="special">( <spanclass="identifier">T& <spanclass="identifier">ref, IteratorT <spanclass="keyword">const& <spanclass="identifier">first, IteratorT <spanclass="keyword">const& <spanclass="identifier">last) <spanclass="keyword">const <spanclass="special">{ typedeftypename <spanclass="identifier">T::<spanclass="identifier">value_type <spanclass="identifier">value_type; value_type <spanclass="identifier">vt(<spanclass="identifier">first,<spanclass="identifier"> last); ref =vt<spanclass="special">; } };</pre>

+<h3>Helper function example: <tt>assign_a</tt> function  辅助函数例子：<tt>assign_a</tt> 函数</h3>

 <code>
-<pre>

- // assign_a is a polymorphic helper function thatgenerators an

-    // assign_actor based on ref_value_actor, assign_action and the
-    // type of its argument.
-

- template<spanclass=special><typename <spanclass=identifier>T>- inline <spanclass=identifier>ref_value_actor<<spanclass=identifier>T, assign<spanclass=identifier>_action><spanclass=identifier>- assign_a(<spanclass=identifier>T& <spanclass=identifier>ref)

-    {

- return <spanclass=identifier>ref_value_actor<<spanclass=identifier>T,<spanclass=identifier> assign_action>(<spanclass=identifier>ref);

-    }</span></pre>
-</code>

+</code><pre> // assign_a is a polymorphic helperfunction that generators an // assign_actor based onref_value_actor, assign_action and the // type of itsargument. template<spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword">inline <spanclass="identifier">ref_value_actor<spanclass="special"><T<spanclass="special">, assign_action<spanclass="special">>+ assign_a(<spanclass="identifier">T& <spanclass="identifier">ref) { return <spanclass="identifier">ref_value_actor<spanclass="special"><T<spanclass="special">, assign_action<spanclass="special">>(ref<spanclass="special">); }</pre>

+
 <table border="0">
-  <tr>
+  <tbody><tr>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">

-Copyright © 2003 Jonathande Halleux+Copyright © 2003 Jonathan deHalleux

   </font></font> </font><br>
-  Copyright &copy; 2003 Joel de Guzman<br>
+  Copyright © 2003 Joel de Guzman<br>
   <br>

- Use, modification and distribution is subject to theBoost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txtor copy at http://www.boost.org/LICENSE_1_0.txt) 

-</body>
-</html>
+  <font size="2">Use,
+modification and distribution is subject to the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt) </font>  </p>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/refactoring.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/refactoring.html     Sun Sep 20 23:13:57 2009
@@ -1,28 +1,26 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>Refactoring Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
-</head>
+<html><head>
+

+<title>Refactoring Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link href="theme/style.css" rel="stylesheet" type="text/css"></head>

 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>

- <td width="10">  </td>- <td width="85%"> Refactoring Parsers</td>- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>

+ <td width="10">  </td>+ <td width="85%"> Refactoring Parsers 重构分析器</td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="functor_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="regular_expression_parser.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

<a name="refactoring_parsers"></a>There are three types of RefactoringParsersimplemented right now, which help to abstract common parser refactoringtasks.Parser refactoring means, that a concrete parser construct is replaced(refactored)

@@ -32,49 +30,49 @@

Parsers</a> and <a href="list_parsers.html">List Parsers</a>. The thirdRefactoringParser (<tt>attach_action_parser</tt>) is implemented to abstract somefunctionality

   required for the Grouping Parser. Nevertheless

- these Refactoring Parsers may help in solving other complex parsingtasks too.

-<h3>Refactoring unary parsers</h3>

+ these Refactoring Parsers may help in solving other complex parsingtasks too. 目前已经实现了三种重构分析器，它们有助于抽象分析器的一般重构方法。分析器重构意味着，一个特定的分析器构造被一个非常相像的分析器构造所替代。这节所描述的两种重构分析器（<tt>refactor_unary_parser</tt> 和<tt>refactor_action_parser</tt><tt></tt>）的作用是在使用<ahref="confix.html">片段分析器</a>和<a href="list_parsers.html">列表分析器</a>时，能够使用简单乃至更加复杂的符号。第三个所实现的抽象分析器(<tt>attach_action_parser</tt>) 用于抽象在为分析器编组时所需的某些功能。然而以上这些重构分析器在应对其他复杂的分析上仍有帮助。

+<h3>Refactoring unary parsers 重构一元分析器</h3>

The <tt>refactor_unary_d</tt> parser generator, which should be used togenerate- a unary refactoring parser, transforms a construct of the followingtype-<pre><code> refactor_unary_d<spanclass=special>[*some_parser <spanclass=special>- another_parser<spanclass=special>]</code></pre>

-<p>to </p>

-<pre><code> *(<spanclass=identifier>some_parser - <spanclass=identifier>another_parser<spanclass=special>)</code></pre>+ a unary refactoring parser, transforms a construct of the followingtype <tt>refactor_unary_d</tt> 分析器生成器，用于生成一元重构分析器，转换下面类型的构造+<pre><code> refactor_unary_d<spanclass="special">[*some_parser <spanclass="special">- <spanclass="identifier">another_parser<spanclass="special">]</code></pre>

+<p>to<br>为 </p>

+<pre><code> *(<spanclass="identifier">some_parser - <spanclass="identifier">another_parser<spanclass="special">)</code></pre>

 <blockquote>

where <tt>refactor_unary_d</tt> is a predefined object of the parsergenerator

-    struct <tt>refactor_unary_gen&lt;&gt;</tt></p>

+ struct <tt>refactor_unary_gen<></tt> 其中<tt>refactor_unary_d</tt> 是分析器生成器结构<tt>refactor_unary_gen<></tt> 的一个预定义对象<tt></tt>

 </blockquote>

The <tt>refactor_unary_d</tt> parser generator generates a new parseras shownabove, only if the original construct is an auxilliary binary parser(here thedifference parser) and the left operand of this binary parser is anauxilliaryunary parser (here the kleene star operator). If the original parserisn't abinary parser the compilation will fail. If the left operand isn't anunary

-  parser, no refactoring will take place.</p>
-<h3>Refactoring action parsers</h3>

+ parser, no refactoring will takeplace. <tt>refactor_unary_d</tt> 分析器生成器只在原始的构造为辅助的二元分析器（这里为减号）且这个二元分析器左边的算子为辅助的一元分析器（这里是克林星操作符）时，才生成如上所示的新的分析器。如果原始的分析器不是二元分析器则产生编译失败。如果左边的算子不是一元分析器，则重构不会发生。

+<h3>Refactoring action parsers&nbsp;重构动作分析器</h3>

The <tt>refactor_action_d</tt> parser generator, which should be usedto generate- an action refactoring parser, transforms a construct of the followingtype-<pre><code> refactor_action_d<spanclass=special>[some_parser<spanclass=special>[some_actor<spanclass=special>] - <spanclass=identifier>another_parser<spanclass=special>]</code></pre>

-<p>to </p>

-<pre><code> (<spanclass=identifier>some_parser - <spanclass=identifier>another_parser)[<spanclass=identifier>some_actor]</code></pre>+ an action refactoring parser, transforms a construct of the followingtype <tt>refactor_action_d</tt>分析器生成器用于生成动作重构分析器，转换如下类型的结构+<pre><code> refactor_action_d<spanclass="special">[some_parser<spanclass="special">[some_actor<spanclass="special">] - <spanclass="identifier">another_parser<spanclass="special">]</code></pre>

+<p>to<br>为 </p>

+<pre><code> (<spanclass="identifier">some_parser - <spanclass="identifier">another_parser<spanclass="special">)[some_actor<spanclass="special">]</code></pre>

 <blockquote>

where <tt>refactor_action_d</tt> is a predefined object of the parsergenerator

-    struct <tt>refactor_action_gen&lt;&gt;</tt></p>

+ struct <tt>refactor_action_gen<></tt> 其中<tt>refactor_</tt><tt>action</tt><tt>_d</tt> 是分析器生成器结构<tt>refactor_</tt><tt>action</tt><tt>_gen<></tt> 的一个预定义对象

 </blockquote>

The <tt>refactor_action_d</tt> parser generator generates a new parseras shownabove, only if the original construct is an auxilliary binary parser(here thedifference parser) and the left operand of this binary parser is anauxilliaryparser generated by an attached semantic action. If the original parserisn'ta binary parser the compilation will fail. If the left operand isn't anaction

-  parser, no refactoring will take place.</p>
-<h3>Attach action refactoring</h3>

+ parser, no refactoring will takeplace. <tt>refactor_action_d</tt> 分析器生成器仅当原始的构造为辅助的二元分析器（这里为减号）且这个二元分析器左边的算子为生成自所挂接的语义动作的辅助分析器时，才生成如上所示的新的分析器。如果原始的分析器不是二元分析器则产生编译失败。如果左边的算子不是动作分析器，则重构不会发生。

+<h3>Attach action refactoring&nbsp;挂接动作重构</h3>

The <tt>attach_action_d</tt> parser generator, which should be used togeneratean attach action refactoring parser, transforms a construct of thefollowing

-  type</p>

-<pre><code> attach_action_d<spanclass=special>[(some_parser <spanclass=special>>> <spanclass=identifier>another_parser)[<spanclass=identifier>some_actor]<spanclass=special>]</code></pre>

-<p>to </p>

-<pre><code> some_parser<spanclass=special>[some_actor<spanclass=special>] <spanclass=special>>> <spanclass=identifier>another_parser[<spanclass=identifier>some_actor]</code></pre>+ type <tt>attach_action_d</tt> 分析器生成器，用于生成挂接动作重构分析器，转换如下类型的结构+<pre><code> attach_action_d<spanclass="special">[(some_parser <spanclass="special">>> <spanclass="identifier">another_parser)<spanclass="special">[some_actor<spanclass="special">]]</code></pre>

+<p>to<br>为 </p>

+<pre><code> some_parser<spanclass="special">[some_actor<spanclass="special">] <spanclass="special">>> <spanclass="identifier">another_parser[<spanclass="identifier">some_actor<spanclass="special">]</code></pre>

 <blockquote>

where <tt>attach_action_d</tt> is a predefined object of the parsergenerator

-    struct <tt>attach_action_gen&lt;&gt;</tt></p>

+ struct <tt>attach_action_gen<></tt> 其中 <tt>attach</tt><tt>_</tt><tt>action</tt><tt>_d</tt> 是分析器生成器结构 <tt>attach</tt><tt>_</tt><tt>action</tt><tt>_gen<></tt> 的一个预定义对象

 </blockquote>

The <tt>attach_action_d</tt> parser generator generates a new parser asshown

@@ -82,44 +80,42 @@

parser to it this action is attached is an auxilliary binary parser(here thesequence parser). If the original parser isn't a action parser thecompilationwill fail. If the parser to which the action is attached isn't an binaryparser,

-  no refactoring will take place.</p>
-<h3>Nested refactoring</h3>

+ no refactoring will take place. <tt>attach_action_d</tt> 分析器生成器仅当原始构造是一个动作分析器且这个动作所挂接的分析器是一个二元分析器（这里是并置分析器）时，才生成如上所示新的分析器。如果原始的分析器不是动作分析器则编译失败。如果动作所挂接到的分析器不是二元分析器，则重构不会发生。

+<h3>Nested refactoring 嵌套重构</h3>

Sometimes it is required to nest different types of refactoring, i.e.to transform

-  constructs like</p>

-<pre><code> (*<spanclass=identifier>some_parser)[<spanclass=identifier>some_actor] <spanclass=special>- <spanclass=identifier>another_parser</code></pre>

-<p>to </p>

-<pre><code> (*(<spanclass=identifier>some_parser - <spanclass=identifier>another_parser))[<spanclass=identifier>some_actor]</code></pre>

+  constructs like<br>有时需要嵌套不同类型的重构，比如转化类似下面的结构</p>

+<pre><code> (*<spanclass="identifier">some_parser)[<spanclass="identifier">some_actor] <spanclass="special">- <spanclass="identifier">another_parser</code></pre>

+<p>to<br>为 </p>

+<pre><code> (*(<spanclass="identifier">some_parser - <spanclass="identifier">another_parser<spanclass="special">))[some_actor<spanclass="special">]</code></pre>To simplify the construction of such nested refactoring parsers the<tt>refactor_unary_gen<></tt>and <tt>refactor_action_gen<></tt> both can take anotherrefactoring parsergenerator type as their respective template parameter. For instance, toconstructa refactoring parser generator for the mentioned nested transformationwe should

-  write:</p>

-<pre> typedefrefactor_action_gen<spanclass=special><<spanclass=identifier>refactor_unary_gen<>> <spanclass=identifier>refactor_t;- const <spanclass=identifier>refactor_t refactor_nested_d= <spanclass=identifier>refactor_t(<spanclass=identifier>refactor_unary_d);</pre>

-<p>Now we could use it as follows to get the required result:</p>

-<pre><code> <spanclass=identifier>refactor_nested_d<spanclass=special>[(*some_parser<spanclass=special>)[some_actor<spanclass=special>] - <spanclass=identifier>another_parser<spanclass=special>]</code></pre>+ write: 为了简化这类嵌套重构分析器的构造，<tt>refactor_unary_gen<></tt> 和 <tt>refactor_action_gen<></tt> 都可以接受对方的分析器生成器类型为自己的模板参数。比如，要构造一个我们上面提到的分析器生成器，应该这么写：+<pre> typedefrefactor_action_gen<spanclass="special"><<spanclass="identifier">refactor_unary_gen<>> <spanclass="identifier">refactor_t; const <spanclass="identifier">refactor_t <spanclass="identifier">refactor_nested_d =refactor_t<spanclass="special">(<spanclass="identifier">refactor_unary_d<spanclass="special">);</pre>+Now we could use it as follows to get the required result: 现在我们可以像下面那样使用以获得所需的结果：+<pre><code> <spanclass="identifier">refactor_nested_d<spanclass="special">[(*some_parser<spanclass="special">)[some_actor<spanclass="special">] - <spanclass="identifier">another_parser<spanclass="special">]</code></pre>An empty template parameter means not to nest this particularrefactoring parser.The default template parameter is <tt>non_nesting_refactoring</tt>, apredefinedhelper structure for inhibiting nesting. Sometimes it is required tonest aparticular refactoring parser with itself. This is achieved by providingthepredefined helper structure <tt>self_nested_refactoring</tt> as thetemplate

-  parameter to the corresponding refactoring parser generator template.</p>

-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/refactoring.cpp">refactoring.cpp</a> for acompilable example. This is part of the Spirit distribution. + parameter to the corresponding refactoring parser generatortemplate. 空的模板参数意味着不嵌套特定的重构分析器。默认的模板参数为<tt>non_nesting_refactoring</tt>，一个用于限制嵌套的预定义的辅助结构。有时特定的重构分析器需要嵌套自身。这是借由把预定义的辅助结构 <tt>self_nested_refactoring</tt> 作为对应的分析器生成器的模板参数来实现的。+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/refactoring.cpp">refactoring.cpp</a> for acompilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译的例子见 <ahref="../example/fundamental/refactoring.cpp">refactoring.cpp</a>，这是Spirit发布包的组成部分。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2003 Hartmut Kaiser<br>
+<p class="copyright">Copyright © 2001-2003 Hartmut Kaiser<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/regular_expression_parser.html Tue Mar31 01:07:16 2009+++ /trunk/libs/spirit/classic/doc/regular_expression_parser.html Sun Sep20 23:13:57 2009

@@ -1,37 +1,35 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>Regular Expression Parser</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
-</head>
+<html><head>
+

+<title>Regular Expression Parser</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link href="theme/style.css" rel="stylesheet" type="text/css"></head>

 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>

- <td width="10" height="49">  </td>- <td width="85%" height="49"> Regular Expression Parser</td>- <td width="112" height="49"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>

+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>

+ <td height="49" width="10">  </td>+ <td height="49" width="85%"> Regular Expression Parser 正则表达式分析器</td>+ <td height="49" width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td>- <td width="30"><a href="refactoring.html"><img src="theme/l_arr.gif"width="20" height="19" border="0"></a></td>+ <td width="30"><a href="refactoring.html"><img src="theme/l_arr.gif"border="0" height="19" width="20"></a></td><td width="30"><a href="scoped_lock.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

<a name="regular_expression_parser"></a>Regular expressions are a formof pattern-matchingthat are often used in text processing. Many users will be familiar withtheusage of regular expressions. Initially there were the Unix utilitiesgrep,sed and awk, and the programming language perl, each of which makeextensiveuse of regular expressions. Today the usage of such regular expressionsis integrated

-  in many more available systems.</p>

+ in many more available systems. 正则表达式是经常在字符处理中使用模式匹配的一种形式。很多用户对正则表达式都很熟悉。最初是Unix的工具grep、sed和awk，还有编程语言perl，这些都大量应用了正则表达式。今天对这样的正则表达式的应用已经集成到了很多系统之中。During parser construction it is often useful to have the power ofregularexpressions available. The Regular Expression Parser was introduced, tomake- the use of regular expressions accessible for Spirit parserconstruction.+ the use of regular expressions accessible for Spirit parserconstruction. 由于正则表达式对分析器的构造大有益处，所以正则表达式分析器出现了，作为连接正则表达式与Spirit分析器的桥梁。The Regular Expression Parser <tt>rxstrlit</tt> has a single templatetypeparameter: an iterator type. Internally, <tt>rxstrlit</tt> holds theBoost Regexobject containing the provided regular expression. The <tt>rxstrlit</tt>attempts

@@ -40,28 +38,24 @@

<tt>rxstrlit</tt> has two constructors. The first accepts anull-terminatedcharacter pointer. This constructor may be used to build<tt>rxstrlit's</tt>from quoted regular expression literals. The second constructor takes ina first/last

-  iterator pair. The function generator version is <tt>regex_p</tt>. </p>
-<p>Here are some examples:</p>

-<pre><code> <spanclass=identifier>rxstrlit<>(<spanclass=string>"Hello[[:space:]]+[W|w]orld")- regex_p<spanclass=special>("Hello[[:space:]]+[W|w]orld")

- std<spanclass=special>::string <spanclass=identifier>msg(<spanclass=string>"Hello[[:space:]]+[W|w]orld");- rxstrlit<spanclass=special><>(msg<spanclass=special>.begin<spanclass=special>(), msg<spanclass=special>.end<spanclass=special>());</code></pre>+ iterator pair. The function generator version is <tt>regex_p</tt>. 正则表达式分析器 <tt>rxstrlit</tt> 只有一个模板参数：迭代器类型。在内部，<tt>rxstrlit</tt> 有一个包含了给定的正则表达式的 Boost Regex 对象。<tt>rxstrlit</tt> 尝试使用这个正则表达式来匹配当前输入流。模板参数默认值为 <tt>char const<spanclass="operators">*</tt>。 <tt>rxstrlit</tt> 有两个构造函数。第一个接受null结尾的字符串指针。这个构造函数可从引号括起的正则表达式字串构造<spanstyle="font-family: Courier New;"> <tt>rxstrlit</tt><spanstyle="font-family: Courier New;">。第二个构造函数接受 first/last 迭代器对。它的函数生成器版本为 <tt>regex_p</tt>。

+<p>Here are some examples:<br>以下是一些例子：</p>

+<pre><code> <spanclass="identifier">rxstrlit<spanclass="special"><>("Hello[[:space:]]+[W|w]orld") <spanclass="identifier">regex_p(<spanclass="string">"Hello[[:space:]]+[W|w]orld"<spanclass="special">) <spanclass="identifier">std::<spanclass="identifier">string msg<spanclass="special">("Hello[[:space:]]+[W|w]orld"); rx<spanclass="identifier">strlit<>(<spanclass="identifier">msg.<spanclass="identifier">begin(), <spanclass="identifier">msg.<spanclass="identifier">end());</code></pre>The generated parser object acts at the character level, thus aneventuallygiven skip parser is not used during the attempt to match the regularexpression

-  (see <a href="faq.html#scanner_business">The Scanner Business</a>).</p>

+ (see <a href="faq.html#scanner_business">The Scanner Business</a>). 所生成的分析器对象作用于字符层面，因此实际上给定的忽略分析器在尝试匹配正则表达式时并不工作（见<a href="faq.html#scanner_business">扫描器事务</a>）。The Regular Expression Parser is implemented by the help of the <ahref="http://www.boost.org/libs/regex/index.html";>Boost

-  Regex++ library</a>, so you have to have some limitations in mind. </p>

+ Regex++ library</a>, so you have to have some limitations in mind. 正则表达式分析器的实现依赖于<ahref="http://www.boost.org/libs/regex/index.html";>Boost Regex++ 库</a>，因此你要牢记某些限制。

 <blockquote>

- <img src="theme/bullet.gif" width="12" height="12"> Boost librarieshave+ <img src="theme/bullet.gif" height="12" width="12"> Boost librarieshaveto be installed on your computer and the Boost root directory has tobe addedto your compiler <tt>#include<...></tt> search path. You candownload- the actual version at the <a href="http://www.boost.org/";>Boost website</a>.- <img src="theme/bullet.gif" width="12" height="12"> The Boost Regexlibrary+ the actual version at the <a href="http://www.boost.org/";>Boost website</a>. 你的电脑里必须安装了Boost库，而Boost的根目录必须被添加到编译器的 <tt>#include<...></tt> 的搜索路径中。你可以在<ahref="http://www.boost.org/";>Boost网站</a>下载所需的版本。+ <img src="theme/bullet.gif" height="12" width="12"> The Boost Regexlibraryrequires the usage of bi-directional iterators. So you have to ensurethisduring the usage of the Spirit parser, which contains a RegularExpression

-    Parser.</p>

- <img src="theme/bullet.gif" width="12" height="12"> The Boost Regexlibrary+ Parser. Boost Regex 库要求使用双向迭代器。所以在使用包含正则表达式分析器的Spirit分析器时，这点必须得到保证。+ <img src="theme/bullet.gif" height="12" width="12"> The Boost Regexlibraryis not a header only library, as Spirit is, though it provides thepossibilityto include all of the sources, if you are using it in one compilationunitonly. Define the preprocessor constant<tt>BOOST_SPIRIT_NO_REGEX_LIB</tt> before

@@ -69,23 +63,22 @@

all the Boost Regex sources into this compilation unit. If you areusing theRegular Expression Parser in more than one compilation unit, youshould notdefine this constant and must link your application against the regexlibrary

-    as described in the related documentation.</p>

+ as described in the related documentation. Boost Regex 库不是一个只有头文件的库（虽然Spirit如此），但它提供了包含所有必须的资源的能力，如果你只在一个编译单元里使用它的话。在包含Spirit正则表达式分析器头文件之前定义预处理常量 <tt>BOOST_SPIRIT_NO_REGEX_LIB</tt>，如果你想把 Boost Regex 的所有资源包含在一个编译单元里的话。如果你在不止一个的编译单元里使用正则表达式分析器，则不应该定义这个常量，而是依据相关文档连接regex库到你的应用程序中。

 </blockquote>

- <img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/regular_expression.cpp">regular_expression.cpp</a>for a compilable example. This is part of the Spirit distribution.+ <img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/regular_expression.cpp">regular_expression.cpp</a>for a compilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译的例子见 <ahref="../example/fundamental/regular_expression.cpp">regular_expression.cpp</a>，这是Spirit发布包的组成部分。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2002 Hartmut Kaiser<br>
+<p class="copyright">Copyright © 2001-2002 Hartmut Kaiser<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/scoped_lock.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/scoped_lock.html     Sun Sep 20 23:13:57 2009
@@ -1,54 +1,51 @@
-<html>
-<head>
-<title>Scoped Lock</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Scoped Lock</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Scoped

-      Lock</b></font></td>

+      Lock 范围锁</b></font></td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="regular_expression_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="distinct.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <h2>scoped_lock_d</h2>

The <tt>scoped_lock_d</tt> directive constructs a parser that locks amutex

-  during the attempt to match the contained parser.</p>
-<p>Syntax:</p>

+ during the attempt to match the containedparser. <tt>scoped_lock_d</tt> 定向器产生一个在尝试匹配所包含的分析器时锁定一个临界区的分析器。

+<p>Syntax:<br>语法：</p>

<pre> scoped_lock_d<spanclass="special">(mutex<spanclass="special">&)[body-parser<spanclass="special">]</pre>

Note, that nesting <tt>scoped_lock_d</tt> directives bears the risk ofdeadlockssince the order of locking depends on the grammar used and may evendepend onthe input being parsed. Locking order has to be consistent within anapplication

-  to ensure deadlock free operation.</p>
-<p></p>

+ to ensure deadlock free operation. 注意，嵌套的<tt>scoped_lock_d</tt> 指示符有死锁的风险，因为锁定的顺序取决于所使用的语法，且甚至取决于所分析的输入流。要做到排除死锁，锁定顺序在同一个应用中必须保持一致。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2003 Martin Wille<br>
+<p class="copyright">Copyright © 2003 Martin Wille<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/select_parser.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/select_parser.html Sun Sep 20 23:13:572009

@@ -1,7 +1,7 @@
-<html>
-<head>
-<title>The Select Parser</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>The Select Parser</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <style type="text/css">
 <!--
@@ -9,88 +9,88 @@
 .style2 {font-family: "Courier New", Courier, mono; font-style: italic; }
 .style3 {font-family: "Courier New", Courier, mono; color: #FF0000; }
 -->
-</style>
-</head>
-
+</style></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10"> </td>

- <td width="85%"> The Select Parser </td>- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>+ <td width="85%"> The Select Parser 选择分析器 </td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="the_lazy_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="switch_parser.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <p>Select parsers may be used to identify a single parser from a given list

- of parsers, which successfully recognizes the current input sequence.Example:+ of parsers, which successfully recognizes the current input sequence.Example: 选择分析器可用于从给定的分析器表中选择一个成功识别当前输入的分析器。例子：<pre> rule<> rule_select <spanclass="special">=

         select_p<span class="special">
         (</span>
             parser_a<span class="special">
           ,</span> parser_b<span class="special">
             <span class="comment">/* ... */</span>
-          ,</span> parser_n
-        <span class="special">)</span><span class="special">;</span></pre>

-The parsers (parser_a, parser_b etc.) are tried sequentially from leftto right until a parser matches the current input sequence.

-  If there is a matching parser found, the <tt>select_p</tt> parser returns

+ , parser_n )<spanclass="special">;</pre>

+<p>The parsers (parser_a, parser_b etc.) are tried sequentially from
+left to right until a parser matches the current input sequence. If
+there is a matching parser found, the <tt>select_p</tt> parser returns

the parser's position (zero based index). For instance, in the exampleabove, <tt>1</tt> is returned if parser_b

-  matches.</p>

+ matches. 列表中的分析器（parser_a, parser_b 等等）将从左到右逐个测试，直到有一个分析器匹配当前输入。如果找到一个匹配的分析器，<tt>select_p</tt> 将返回分析器的位置（索引从零起计）。比如，上面的例子里，parser_b匹配时返回的是 <tt>1</tt>。There are two predefined parsers of the select parser family:<tt>select_p</tt>

   and <tt>select_fail_p</tt>. These parsers differ in the way the no match

case is handled (when none of the parsers match the current inputsequence).

   While the <tt>select_p</tt> parser will return <tt>-1</tt>

if no matching parser is found, the <tt>select_fail_p</tt> parser willnot match

-  at all.</p>

+ at all. 在选择分析器族中有两个预定义的分析器：select_p和select_fail_p。这些分析器的不同之处在于无匹配情况的处理上（即没有分析器匹配当前输入串）。如果没有匹配，select_p分析器返回-1而select_fail_p分析器将完全不匹配。The following sample shows how the select parser may be used veryconveniently

-  in conjunction with a <a href="switch_parser.html">switch parser</a>:</p>

+ in conjunction with a <a href="switch_parser.html">switchparser</a>: 下面的例子展示了选择分析器是如何便利地与<ahref="switch_parser.html">跳转分析器</a>一起使用的：<pre> int choice <spanclass="special">= -1<spanclass="special">;rule<> rule_select <spanclass="special">=select_fail_p(<spanclass="literal">'a', <spanclass="literal">'b', <spanclass="literal">'c', <spanclass="literal">'d')[assign_a<spanclass="special">(choice)]>> switch_p(var(choice)) <spanclass="special">- [ case_p<spanclass="special"><0<spanclass="special">>(int_p<spanclass="special">), case_p<spanclass="special"><1<spanclass="special">>(ch_p(<spanclass="literal">','<spanclass="special">)), case_p<spanclass="special"><2<spanclass="special">>(str_p(<spanclass="string">"bcd"<spanclass="special">)), default_p ] <spanclass="special"> ;</pre>

-<p>This example shows a rule, which matches:</p>

+ [ case_p<spanclass="special"><0<spanclass="special">>(int_p<spanclass="special">), case_p<spanclass="special"><1<spanclass="special">>(ch_p(<spanclass="literal">','<spanclass="special">)), case_p<spanclass="special"><2<spanclass="special">>(str_p(<spanclass="string">"bcd"<spanclass="special">)), default_p ] <spanclass="special"> ;</pre>+This example shows a rule, which matches: 这个例子里的规则将匹配：

 <ul>
   <li><span class="literal"> 'a' </span>followed
-      by an integer</li>

+ by an integer 'a' 之后接一个整数</li>

   <li><span class="literal">'b' </span>followed by a<span class="literal">
-    ','</span></li>

- <li>'c' followed by <spanclass="string">"bcd"</li>

-  <li>a single <span class="literal">'d'</span>. </li>

+ ',' 'b' 之后跟一个<spanclass="literal"> ','</li>+ <li>'c' followed by <spanclass="string">"bcd" 'c' 之后跟"bcd"</li>+ <li>a single 'd'. 单一个 <spanclass="literal">'d'. </li>

 </ul>
 <p>For other input sequences the
-        give rule does not match at all.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16"> <tt>BOOST_SPIRIT_SELECT_LIMIT</tt> + give rule does not match at all. 对于其他的输入分析器完全不匹配。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> <tt>BOOST_SPIRIT_SELECT_LIMIT</tt> 

         <br>

- The number of possible entries inside the <tt>select_p</tt> parser islimited by the Spirit compile time constant<tt>BOOST_SPIRIT_SELECT_LIMIT</tt>, which defaults to 3. This value shouldnot be greater than the compile time constant given by<tt>PHOENIX_LIMIT</tt> (see <a href="../phoenix/index.html">phoenix</a>).Example:- // Define these beforeincluding anything else + The number of possible entries inside the <tt>select_p</tt> parser islimited by the Spirit compile time constant<tt>BOOST_SPIRIT_SELECT_LIMIT</tt>, which defaults to 3. This value shouldnot be greater than the compile time constant given by<tt>PHOENIX_LIMIT</tt> (see <a href="../phoenix/index.html">phoenix</a>).Example:<tt>select_p</tt> 中的条目数量受限于Spirit的编译期常量<tt>BOOST_SPIRIT_SELECT_LIMIT</tt>，默认值为3。这个值不能大于编译期常量<tt>PHOENIX_LIMIT</tt>(见 <a href="../phoenix/index.html">phoenix</a><ahref="http://www.boost.org/libs/spirit/phoenix/index.html";></a>)。例子：+ // Define these beforeincluding anything else 在包含其它头文件之前定义 

       </span><span class="style3">#define</span> PHOENIX_LIMIT 10<br>

#defineBOOST_SPIRIT_SELECT_LIMIT 10 </td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2003-2004 Hartmut Kaiser <br>
+<p class="copyright">Copyright © 2003-2004 Hartmut Kaiser <br>
   <br>

- Use, modification and distribution is subject to theBoost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txtor copy at http://www.boost.org/LICENSE_1_0.txt) 

+  <font size="2">Use,
+modification and distribution is subject to the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt) </font> </p>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/stored_rule.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/stored_rule.html     Sun Sep 20 23:13:57 2009
@@ -1,99 +1,87 @@
-<html>
-<head>
-<title>Storable Rules</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>Storable Rules</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> Storable

-      Rules</b></font></td>

+      Rules 可保存规则</b></font></td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="stored_rule.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="the_lazy_parser.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

The rule is a weird C++ citizen, unlike any other C++ object. It doesnot havethe proper copy and assignment semantics and cannot be stored and passedaroundby value. You cannot store rules in STL containers (vector, stack, etc)for- later use and you cannot pass and return rules to and from functions byvalue.+ later use and you cannot pass and return rules to and from functions byvalue. 规则是一个怪异的C++公民，和其他的C++对象不像。它没有恰当的拷贝和赋值语义，也不能被以值的方式来传递和保存。你没法把规则保存在STL容器（比如vector、stack等）以在随后使用，也不能把规则以值语义从函数中返回。EBNF is primarily declarative. Like in functional programming, an EBNFgrammaris a static recipe and there's no notion of do this then that. However,in Spirit,we managed to coax imperative C++ to take in declarative EBNF. Hah!Fun!...We did that by masquerading the C++ assignment operator to mimic EBNF's<tt>::=</tt>.To do that, we gave the rule class' assignment operator and copyconstructora different meaning and semantics. The downside is that doing so madethe rule

-  unlike any other C++ object. You can't copy it. You can't assign it. </p>

+ unlike any other C++ object. You can't copy it. You can't assignit. EBNF本质上是声明式的。类似于函数式编程，一个EBNF语法就是一个静态的配方，而且也不需要除此以外的其他东西。然而，在Spirit中，我们要+把命令式的C++和声明式的EBNF拧到一块。哈！有趣！……我们通过把C++的等号伪装起来模仿EBNF的::=来干这个事情，我们给予了规则类的赋值+符以不同于拷贝构造函数的含义和语义。这样的缺点是使用起来与其他C++对象不同。你不能把它拷贝，你不能给它赋值。We want to have the dynamic nature of C++ to our advantage. We've seendynamicSpirit in action here and there. There are indeed some interestingapplicationsof dynamic parsers using Spirit. Yet, we will not fully utilize thepower ofdynamic parsing, unless we have a rule that behaves like any other goodC++object. With such a beast, we can write full parsers that's defined atrun time,

-  as opposed to compile time.</p>

+ as opposed to compile time. 我们希望拥有C++的动态行为以方便我们。我们已经在这里和那里见过动态的Spirit。的确有些使用Spirit进行动态分析的应用。但是，我们无法+拥有动态分析的全部力量，除非我们有一个和其他C++对象有相似行为的规则。有了这个东西，我们可以把整个分析器写成运行期定义，而不是编译期。We now have dynamic rules: <tt>stored_rules</tt>. Basically they areruleswith perfect C++ assignment/copy-constructor semantics. This means that<tt>stored_rules</tt>

-  can be stored in containers and/or dynamically created at run-time.</p>

-<pre><code> <spanclass=keyword>template<- typename <spanclass=identifier>ScannerT = <spanclass=identifier>scanner<>,- typename <spanclass=identifier>ContextT = <spanclass=identifier>parser_context<spanclass=special><>,- typename<spanclass=identifier> TagT =<spanclass=identifier> parser_address_tag>- class <spanclass=identifier>stored_rule<spanclass=special>;</code></pre>+ can be stored in containers and/or dynamically created at run-time. 现在我们有了动态规则：<tt>stored_rules</tt>。基本上它们就是拥有完美的C++赋值/拷贝语义的规则。这意味着<tt>stored_rules</tt> 可以保存在容器中且/或在运行期动态创建。+<pre><code> <spanclass="keyword">template< typename <spanclass="identifier">ScannerT = <spanclass="identifier">scanner<>, typename <spanclass="identifier">ContextT = <spanclass="identifier">parser_context<spanclass="special"><>, typename TagT=parser_address_tag> <spanclass="keyword">class <spanclass="identifier">stored_rule<spanclass="special">;</code></pre>The interface is exactly the same as with the rule class (see the <ahref="rule.html">sectionon rules</a> for more information regarding the API). The onlydifference iswith the copy and assignment semantics. Now, with <tt>stored_rule</tt>s,we- can dynamically and algorithmically define our rules. Here are somesamples...+ can dynamically and algorithmically define our rules. Here are somesamples... 接口与规则类完全相同（<a href="rule.html">规则</a>一章中有关于API的更多信息）。唯一的差别是复制和赋值语义。现在，有了<tt>stored_rule</tt>，我们可以动态而系统的定义我们的规则了。下面是一些例子……

 </p>
-<p>Say I want to dynamically create a rule for:</p>
-<pre>

- start = <spanclass=special>*(a <spanclass=special>| b <spanclass=special>| c<spanclass=special>);</pre>

-<p> I can write it dynamically step-by-step:</p>

-<pre> stored_rule<spanclass=special><> start<spanclass=special>;

- start =a;- start =start.<spanclass=identifier>copy() <spanclass=special>| b;- start =start.<spanclass=identifier>copy() <spanclass=special>| c;- start =*(<spanclass=identifier>start.<spanclass=identifier>copy());</pre>-Later, I changed my mind and want to redefine it (again dynamically)as:-<pre> start =(a <spanclass=special>| b)>> <spanclass=special>(start <spanclass=special>| b<spanclass=special>);+Say I want to dynamically create a rule for: 比如我想动态创建如下规则：+<pre> start =*(a| b| <spanclass="identifier">c);</pre>+ I can write it dynamically step-by-step: 我可以以动态的形式一步步写成：+<pre> stored_rule<spanclass="special"><> start<spanclass="special">; start= <spanclass="identifier">a; <spanclass="identifier">start = <spanclass="identifier">start.<spanclass="identifier">copy() <spanclass="special">| b<spanclass="special">; start <spanclass="special">= start<spanclass="special">.copy<spanclass="special">() | <spanclass="identifier">c; <spanclass="identifier">start = <spanclass="special">*(start<spanclass="special">.copy<spanclass="special">());</pre>+Later, I changed my mind and want to redefine it (again dynamically)as: 之后，我改变主意，想把它重定义（动态赋值）为：+<pre> start =(a| <spanclass="identifier">b) <spanclass="special">>> (<spanclass="identifier">start | <spanclass="identifier">b);

 </pre>
-<p>I write:</p>

-<pre> start= b<spanclass=special>;- start =a | <spanclass=identifier>start.<spanclass=identifier>copy();- start =start.<spanclass=identifier>copy() <spanclass=special>>> (<spanclass=identifier>start | <spanclass=identifier>b);</pre>

-<p>Notice the statement:</p>

-<pre> start= <spanclass=identifier>start.<spanclass=identifier>copy() <spanclass=special>| b<spanclass=special>;</pre>

+<p>I write:<br>我写成：</p>

+<pre> start= <spanclass="identifier">b; <spanclass="identifier">start = <spanclass="identifier">a | <spanclass="identifier">start.<spanclass="identifier">copy(); <spanclass="identifier">start = <spanclass="identifier">start.<spanclass="identifier">copy() <spanclass="special">>> (<spanclass="identifier">start | <spanclass="identifier">b);</pre>

+<p>Notice the statement:<br>注意语句：</p>

+<pre> start= <spanclass="identifier">start.<spanclass="identifier">copy() <spanclass="special">| b<spanclass="special">;</pre>Why is start.copy() required? Well, because like rules, stored rulesare stillembedded by reference when found in the RHS (one reason is to avoidcyclic-shared-pointers).

-  If we write:</p>

-<pre> start= start| b<spanclass=special>;</pre>+ If we write: 为什么要 start.copy()？因为可储存规则类似于规则，在等式右边时依然是以引用的方式被嵌入的（一个原因是避免循环共享指针）。如果我们写：+<pre> start= start| <spanclass="identifier">b;</pre>We have left-recursion! Copying copy of start avoidsselfreferencing. What we are doing is making a copy of start, ORing it withb, then

-  destructively assigning the result back to start.</p>

+ destructively assigning the result back to start. 那我们就有左递归了！拷贝 strat 的副本避免了自我引用。我们所作的是创建一个start 的拷贝，把它和 b 取或，再把结果破坏性地复制回 start（即start的原有值被取代）。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/switch_parser.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/switch_parser.html Sun Sep 20 23:13:572009

@@ -1,41 +1,39 @@
-<html>
-<head>
-<title>The Switch Parser</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>The Switch Parser</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

 <link rel="stylesheet" href="theme/style.css" type="text/css">
 <style type="text/css">
 <!--
 .style1 {font-family: "Courier New", Courier, mono}
 .style3 {font-family: "Courier New", Courier, mono; color: #FF0000; }
 -->
-</style>
-</head>
-
+</style></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10"> </td>

- <td width="85%"> The Switch Parser </td>- <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" width="112" height="48" align="right"border="0"></a></td>+ <td width="85%"> The Switch Parser 跳转分析器 </td>+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="select_parser.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="escape_char_parser.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

   </tr>
-</table>

-Switch parsers may be used to simplify certain alternation constructs.Consider the following code:

+</tbody></table>

+Switch parsers may be used to simplify certain alternation constructs.Consider the following code: 跳转分析器可用来简化选择结构。考虑下面的代码：<pre> rule<> rule_overall <spanclass="special">=- ch_p(<spanclass="literal">'a') <spanclass="special">>> parser_a- | ch_p<spanclass="special">('b'<spanclass="special">) >> parser_b

-            <span class="comment">// ...</span>

- | ch_p<spanclass="special">('n'<spanclass="special">) >> parser_n

-        <span class="special">;</span></pre>

-Each of the alternatives are evaluated normally in a sequential manner.This tend to be inefficient, especially for a large number of alternatives.To avoid this inefficiency and to make it possible to write such constructsin a more readable form, Spirit contains the <tt>switch_p</tt> family ofparsers. The switch_p parser allows us to rewrite the previous constructas:+ ch_p(<spanclass="literal">'a') <spanclass="special">>> parser_a | ch_p(<spanclass="literal">'b') <spanclass="special">>> parser_b <spanclass="comment">// ...+ | ch_p<spanclass="special">('n'<spanclass="special">) >>parser_n ;</pre>

+<p>Each of the alternatives are evaluated normally in a sequential
+manner. This tend to be inefficient, especially for a large number of
+alternatives. To avoid this inefficiency and to make it possible to

+write such constructs in a more readable form, Spirit contains the<tt>switch_p</tt> family of parsers. The switch_p parser allows us torewrite the previous construct as: 这些选项被线性地依次调用。这是很低效的，尤其在有大量选择的时候。为了避免这种低效并且把这样的代码写成更加可读的形式，Spirit包含了 <tt>switch_p</tt> 分析器族。switch_p 分析器使得我们可以把上面的构造重写为：<pre> rule<> rule_overall <spanclass="special">=

             switch_p
             <span class="special">[</span>
@@ -45,15 +43,24 @@

case_p<<spanclass="literal">'n'>(parser_n<spanclass="special">)

             ]
         ;</pre>

-This <tt>switch_p</tt> parser takes the next character (or token) fromthe input stream and tries to match it against the given integral compiletime constants supplied as the template parameters to the <tt>case_p</tt>parsers. If this character matches one of the <tt>case_p</tt> branches, theassociated parser is executed (i.e. if 'a' is matched, <tt>parser_a</tt> isexecuted, if 'b' is matched, <tt>parser_b</tt> is executed and so on) . Ifno <tt>case_p</tt> branch matches the next input character, the overallconstruct does not match at all. 

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><div align="justify"><img src="theme/bulb.gif"width="13" height="18"> Nabialek trick 

+<p>This <tt>switch_p</tt> parser takes the next character (or token)
+from the input stream and tries to match it against the given integral

+compile time constants supplied as the template parameters to the<tt>case_p</tt> parsers. If this character matches one of the<tt>case_p</tt> branches, the associated parser is executed (i.e. if 'a' ismatched, <tt>parser_a</tt> is executed, if 'b' is matched,<tt>parser_b</tt> is executed and so on) . If no <tt>case_p</tt> branchmatches the next input character, the overall construct does not match atall. <tt>switch_p</tt> 分析器从输入中取出下一个要分析的字符并且尝试把它与经由 <tt>case_p</tt> 分析器模板参数给定的编译期整形常量匹配。如果字符匹配任意+一个 <tt>case_p</tt> 分支，则相关联的分析器将被执行（比如，如果 'a' 匹配，<tt>parser_a</tt> 被执行；如果匹配 'b'，<tt>parser_b</tt> 被执行；如此等+等）。如果没有那 <tt>case_p</tt> 分支匹配下一个输入字符，则整个结构都不匹配。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><div align="justify"><img src="theme/bulb.gif"height="18" width="13"> Nabialek trick  Nabialek 戏法 

             <br>

- The <ahref="techniques.html#nabialek_trick">"Nabialek trick"</a>(from the name of its inventor, Sam Nabialek), can alsoimprove the rule dispatch from linear non-deterministic to deterministic.This is similar to the <tt>switch_p</tt> parser, yet, can handle grammarswhere a keyword (operator, etc), instead of a single character or token,precedes a production.</div></td>+ The <a href="techniques.html#nabialek_trick">"Nabialektrick" </a>(from

+the name of its inventor, Sam Nabialek), can also improve the rule
+dispatch from linear non-deterministic to deterministic. This is
+similar to the <tt>switch_p</tt> parser, yet, can handle grammars
+where a keyword (operator, etc), instead of a single character or

+token, precedes a production. <ahref="techniques.html#nabialek_trick">"Nabialek 戏法"</a> （来源于发明者的名字，Sam Nabialek），同样可以把规则分配过程从线性的不确定改进为确定的。这与 <tt>switch_p</tt> 类似，但是在语法中它可以先于产生式处理一个关键字（运算符，等等），而不是单独一个字符。</div></td>

   </tr>
-</table>

-Sometimes it is desireable to add handling of the default case (none ofthe <tt>case_p</tt> branches matched). This may be achieved with the helpof a <tt>default_p</tt> branch:

+</tbody></table>

+Sometimes it is desireable to add handling of the default case (none ofthe <tt>case_p</tt> branches matched). This may be achieved with the helpof a <tt>default_p</tt> branch: 有时我们希望添加对默认情况（没有任何<tt>case_p</tt> 分支匹配）的处理。这可以借由 <tt>default_p</tt> 的帮助而完成：<pre> rule<> rule_overall <spanclass="special">=

             switch_p
             <span class="special">[</span>
@@ -62,10 +69,9 @@
             <span class="comment">    // ...</span>

case_p<<spanclass="literal">'n'>(parser_n<spanclass="special">),default_p(parser_default<spanclass="special">)

-            <span class="special">]
-        ;</span></pre>

-This form chooses the <tt>parser_default</tt> parser if none of thecases matches the next character from the input stream. Please note that,obviously, only one <tt>default_p</tt> branch may be added to the<tt>switch_p</tt> parser construct. -Moreover, it is possible to omit the parentheses and body from the<tt>default_p</tt> construct, in which case, no additional parser isexecuted and the overall <tt>switch_p</tt> construct simply returns a matchon any character of the input stream, which does not match any of the<tt>case_p</tt> branches:

+            <span class="special">]<br>        ;</span></pre>

+This form chooses the <tt>parser_default</tt> parser if none of thecases matches the next character from the input stream. Please note that,obviously, only one <tt>default_p</tt> branch may be added to the<tt>switch_p</tt> parser construct. 这一形式中如果输入流中的下一个字符没有匹配任何分支则其将选择 <tt>parser_default</tt> 分析器。请注意，很明显，只允许在 <tt>switch_p</tt> 构造中加入一个<tt>default_p</tt> 分支。+Moreover, it is possible to omit the parentheses and body from the<tt>default_p</tt> construct, in which case, no additional parser isexecuted and the overall <tt>switch_p</tt> construct simply returns a matchon any character of the input stream, which does not match any of the<tt>case_p</tt> branches: 此外，可以把 <tt>default_p</tt> 构造的括号和分析体拿掉，在这种情况下，不再执行其他分析器，并且<tt>switch_p</tt> 构造返回一个对输入流中任意字符的匹配，这个字符没有和任何 <tt>case_p</tt> 匹配。<pre> rule<> rule_overall <spanclass="special">=

             switch_p
             <span class="special">[</span>
@@ -76,7 +82,8 @@
                 default_p
             <span class="special">]</span>
         ;</pre>

-There is another form of the switch_p construct. This form allows usto explicitly specify the value to be used for matching against the<tt>case_p</tt> branches: 

+<p>There is another form of the switch_p construct. This form allows us

+to explicitly specify the value to be used for matching against the<tt>case_p</tt> branches: 这是 switch_p 构造的另一个形式。这个形式允许我们显式地指定用于匹配 <tt>case_p</tt> 的值：<pre> rule<> rule_overall <spanclass="special">=switch_p(cond<spanclass="special">)

             <span class="special">[</span>
@@ -86,30 +93,37 @@

case_p<<spanclass="literal">'n'>(parser_n<spanclass="special">)

             <span class="special">]</span>
         ;</pre>

-where <tt>cond</tt> is a parser or a nullary function or functionobject (functor). If it is a parser, then it is tried and its return valueis used to match against the <tt>case_p</tt> branches. If it is a nullaryfunction or functor, then its return value will be used. -Please note that during its compilation, the <tt>switch_p</tt>construct is transformed into a real C++ <tt>switch</tt> statement. Thismakes the runtime execution very efficient. 

-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16"> <tt>BOOST_SPIRIT_SWITCH_CASE_LIMIT</tt> 

+<p>where <tt>cond</tt> is a parser or a nullary function or function
+object (functor). If it is a parser, then it is tried and its return

+value is used to match against the <tt>case_p</tt> branches. If it is anullary function or functor, then its return value will be used. 这里<tt>cond</tt> 是一个分析器或者无参函数或者函数对象（仿函数）。如果它是分析器，那么它将被测试并且测试返回值将用来与 <tt>case_p</tt> 分支匹配。如果是无参函数或者仿函数，那么将直接使用它的返回值。+Please note that during its compilation, the <tt>switch_p</tt>construct is transformed into a real C++ <tt>switch</tt> statement. Thismakes the runtime execution very efficient. 请注意，在编译期，<tt>switch_p</tt> 构造被转换成真正的C++的 <tt>switch</tt> 语句。这使得运行时的效率相当高。

+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> <tt>BOOST_SPIRIT_SWITCH_CASE_LIMIT</tt> 

         <br>

- The number of possible <tt>case_p</tt>/<tt>default_p</tt> branches islimited by the Spirit compile time constant<tt>BOOST_SPIRIT_SWITCH_CASE_LIMIT</tt>, which defaults to 3. There is notheoretical upper limit for this constant, but most compilers won't allowyou to specify a very large number.

-    <p>Example:</p>

- // Define these beforeincluding switch.hpp + The number of possible <tt>case_p</tt>/<tt>default_p</tt> branches islimited by the Spirit compile time constant<tt>BOOST_SPIRIT_SWITCH_CASE_LIMIT</tt>,

+which defaults to 3. There is no theoretical upper limit for this
+constant, but most compilers won't allow you to specify a very large

+number.<tt>case_p</tt>/<tt>default_p</tt> 分支的最大数目受限于Spirit编译期常量 <tt>BOOST_SPIRIT_SWITCH_CASE_LIMIT</tt>，其默认值为3。这个常量理论上没有限制，但大多数编译器都不会允许你指定很大的数目。

+    <p>Example:<br>例子：</p>

+ // Define these beforeincluding switch.hpp 在包含switch.hpp之前定义 #defineBOOST_SPIRIT_SWITCH_CASE_LIMIT 10 </td>

   </tr>
-</table><br>
+</tbody></table><br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2003-2004 Hartmut Kaiser <br>
+<p class="copyright">Copyright © 2003-2004 Hartmut Kaiser <br>
   <br>

- Use, modification and distribution is subject to theBoost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txtor copy at http://www.boost.org/LICENSE_1_0.txt) 

-</body>
-</html>
+  <font size="2">Use,
+modification and distribution is subject to the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt) </font> </p>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/the_lazy_parser.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/the_lazy_parser.html Sun Sep 20 23:13:572009

@@ -1,33 +1,31 @@
-<html>
-<head>
-<title>The Lazy Parsers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+

+<title>The Lazy Parsers</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">

+<link rel="stylesheet" href="theme/style.css" type="text/css"></head>
 <body>
-<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
-  <tr>
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+  <tbody><tr>
     <td width="10">
     </td>

- <td width="85%"> The

-      Lazy Parser</b></font></td>

+      Lazy Parser 惰性分析器</b></font></td>

+ <td width="112"><a href="http://spirit.sf.net";><imgsrc="theme/spirit.gif" align="right" border="0" height="48"width="112"></a></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

<td width="30"><a href="../index.html"><img src="theme/u_arr.gif"border="0"></a></td><td width="30"><a href="dynamic_parsers.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="select_parser.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>

Closures are cool. It allows us to inject stack based local variablesanywherein our parse descent hierarchy. Typically, we store temporary variables,generatedby our semantic actions, in our closure variables, as a means to passinformation

-  up and down the recursive descent.</p>

+ up and down the recursive descent. 闭包非常酷。它使得我们可以在下降分析的任意层次注入基于栈的变量。典型地，我们在闭包里储存由我们的语义动作产生的临时变量，以之作为在递归下降中向上或向下传递信息的方法。Now imagine this... Having in mind that closure variables can be justaboutany type, we can store a parser, a rule, or a pointer to a parser orrule, ina closure variable. Yeah, right, so what?... Ok, hold on...What if

@@ -36,82 +34,73 @@

round trip from to <a href="../phoenix/index.html">Phoenix</a> andSpirit andback! <a href="../phoenix/index.html">Phoenix</a> semantic actionschoose theright Spirit parser and Spirit parsers choose the right <ahref="../phoenix/index.html">Phoenix</a>

-  semantic action. Oh MAN, what a honky cool idea, I might say!!</p>

+ semantic action. Oh MAN, what a honky cool idea, I might say!! 现在想想这个……记住闭包变量可以是任意类型，我们可以在闭包变量里储存一个分析器、规则、或是规则或分析器的指针。没错，然后呢？……OK，稍等……假如我们用这个闭包变量来开始一次分析呢？想想这个吧。突然我们拥有了某些强大的动态分析器！我们一下子拥有了从 Spirit 到<ahref="http://www.boost.org/libs/spirit/phoenix/index.html";> </a><ahref="../phoenix/index.html">Phoenix</a> 再回来的整条路线。<ahref="../phoenix/index.html">Phoenix</a> 语义动作选择正确的 Spirit 语义动作而 Spirit 语义动作又反过来选择正确的 <ahref="../phoenix/index.html">Phoenix</a> 语义动作。天啊，真是个好主意，我得这么说！

 <h2>lazy_p</h2>

This is the idea behind the <tt>lazy_p</tt> parser. The <tt>lazy_p</tt>syntax

-  is:</p>

+ is: 这是 <tt>lazy_p</tt> 幕后的构思。<tt>lazy_p</tt> 的语法是：<pre> lazy_p(actor<spanclass="special">)</pre>where actor is a <a href="../phoenix/index.html">Phoenix</a>expression that- returns a Spirit parser. This returned parser is used in the parsingprocess.

-</p>
-<p>Example: </p>

+ returns a Spirit parser. This returned parser is used in the parsingprocess. 其中 actor 是 <ahref="../phoenix/index.html">Phoenix</a> <ahref="http://www.boost.org/libs/spirit/phoenix/index.html";></a>表达式，返回一个 Spirit 分析器。所返回的分析器将用于分析过程中。

+<p>Example:<br>例如： </p>

<pre> lazy_p(phoenix<spanclass="special">::val(int_p<spanclass="special">))[assign_a(result<spanclass="special">)]

 </pre>

Semantic actions attached to the <tt>lazy_p</tt> parser expects thesame signature- as that of the returned parser (<tt>int_p</tt>, in our exampleabove).+ as that of the returned parser (<tt>int_p</tt>, in our exampleabove). 挂接于 <tt>lazy_p</tt> 分析器上的语义动作的签名要求与所返回的分析器一致（在即以上例子中的 <tt>int_p</tt>）。

 <h2>lazy_p example</h2>

To give you a better glimpse (see the <tt><ahref="../example/intermediate/lazy_parser.cpp">lazy_parser.cpp</a></tt>),

-  say you want to parse inputs such as:</p>
-<pre>    <span class=identifier>dec

- {<spanclass=identifier> 1 2 3 bin- {<spanclass=identifier> 1 10 11 <spanclass="special">} 4 5 6 }</pre>+ say you want to parse inputs such as: 为了更深入了解（见 <tt><ahref="../example/intermediate/lazy_parser.cpp">lazy_parser.cpp</a></tt>），假设你想分析如下输入：+<pre> dec <spanclass="special">{ 1 23 bin {<spanclass="identifier"> 1 10 11 <spanclass="special">} 4 5 6 }</pre>where <tt>bin {...}</tt> and <tt>dec {...}</tt> specifies the numericformat(binary or decimal) that we are expecting to read. If we analyze theinput,

-  we want a grammar like:</p>

-<pre><code> <spanclass=identifier>base =<spanclass=identifier> "bin"<spanclass=identifier> |<spanclass=identifier> "dec"<spanclass="special">;- block = <spanclass="identifier">base >> <spanclass="literal">'{' >> *<spanclass="identifier">block_line >>'}';- block_line = <spanclass="identifier">number | <spanclass=identifier>block<spanclass=special>;</code></pre>+ we want a grammar like: 其中 <tt>bin {...}</tt> 和 <tt>dec {...}</tt>区分了我们想读入的数字的格式(二进制或十进制)。如果我们要分析这个输入，那么语法是这样的：<tt></tt>+<pre><code> <spanclass="identifier">base =<spanclass="identifier"> "bin"<spanclass="identifier"> |<spanclass="identifier"> "dec"<spanclass="special">;+ block = <spanclass="identifier">base >> <spanclass="literal">'{' >> *<spanclass="identifier">block_line >>'}'; block_line = <spanclass="identifier">number | <spanclass="identifier">block<spanclass="special">;</code></pre>We intentionally left out the <code><spanclass="identifier"><tt>number</tt></code>rule. The tricky part is that the way <tt>number</tt> rule behavesdepends on- the result of the <tt>base</tt> rule. If <tt>base</tt> got a"bin",- then number should parse binary numbers. If <tt>base</tt> got a"dec",+ the result of the <tt>base</tt> rule. If <tt>base</tt> got a"bin",+ then number should parse binary numbers. If <tt>base</tt> got a"dec",then number should parse decimal numbers. Typically we'll have torewrite our

-  grammar to accomodate the different parsing behavior:</p>

-<pre><code> block=- "bin" <spanclass=special>>> '{'<spanclass=special> >> *bin_line >>'}'- | "dec" <spanclass=special>>> '{'<spanclass=special> >> *dec_line >>'}'

-        ;

- bin_line = <spanclass="identifier">bin_p | <spanclass=identifier>block;- dec_line = <spanclass="identifier">int_p | <spanclass=identifier>block<spanclass=special>;</code></pre>+ grammar to accomodate the different parsing behavior:我们有意把<spanclass="identifier"><tt>number</tt> 规则留空。精妙的部分在于<tt><spanstyle="color: rgb(0, 0, 0);"><spanclass="identifier"><tt>number</tt></tt> 规则的行为取决于 <spanclass="identifier"><tt><spanclass="identifier"><tt>base</tt></tt> 规则的结果。如果 <spanclass="identifier"><tt><spanclass="identifier"><tt>base</tt></tt> 分析得到"bin"，则 <spanclass="identifier"><tt><spanclass="identifier"><tt><spanclass="identifier"><tt>number</tt></tt></tt>将分析二进制数。如果 <spanclass="identifier"><tt><spanclass="identifier"><tt><spanclass="identifier"><tt>base</tt></tt></tt>分析得到 "dec"，则 <spanclass="identifier"><tt><spanclass="identifier"><tt><spanclass="identifier"><tt><spanclass="identifier"><tt>number</tt></tt></tt></tt>将分析十进制数。通常我们需要重写语法以适应不同的分析行为：<spanstyle="color: rgb(0, 0, 0);"><tt><spanstyle="color: rgb(0, 0, 0);"><tt><spanstyle="color: rgb(0, 0, 0);"><tt><spanstyle="color: rgb(0, 0, 0);"><spanclass="identifier"><tt></tt></tt></tt></tt>+<pre><code> block= <spanclass="identifier">"bin" >> <spanclass="literal">'{' >>*bin_line >> <spanclass="literal">'}'+ | "dec" <spanclass="special">>> '{'<spanclass="special"> >> *dec_line >>'}'

+        ;

+ bin_line = <spanclass="identifier">bin_p | <spanclass="identifier">block; dec_line = <spanclass="identifier">int_p | <spanclass="identifier">block<spanclass="special">;</code></pre>while this is fine, the redundancy makes us want to find a bettersolution;after all, we'd want to make full use of Spirit's dynamic parsingcapabilities.Apart from that, there will be cases where the set of parsing behaviorsforour <tt>number</tt> rule is not known when the grammar is written. We'llonly- be given a map of string descriptors and corresponding rules [e.g.(("dec",

-  int_p), (&quot;bin&quot;, bin_p) ... etc...)].</p>

+ be given a map of string descriptors and corresponding rules [e.g.(("dec",+ int_p), ("bin", bin_p) ... etc...)]. 虽然这样也不错，但其中的冗余使得我们想寻找更好的解决办法；最后，我们还想完全利用Spirit的动态分析能力。此外，还有我们的 <tt>number</tt> 规则需要解析的数字的类别在书写语法时还是未知的情况。那么我们只能指定一个描述字符串和相应规则的映射[比如 (("dec",+ int_p), ("bin", bin_p) ... 等等]。<tt></tt>The basic idea is to have a rule for binary and decimal numbers. That'seasyenough to do (see <a href="numerics.html">numerics</a>). When<tt>base</tt>is being parsed, in your semantic action, store a pointer to theselected base- in a closure variable (e.g. <tt>block.int_rule</tt>). Here's anexample:-<pre><code> <spanclass=identifier>base- =str_p(<spanclass="string">"bin")[<spanclass=identifier>block.int_rule = <spanclass="special">&var(<spanclass="identifier">bin_rule)]- | str_p<spanclass="special">("dec"<spanclass="special">)[block.int_rule =&var(<spanclass="identifier">dec_rule)]

-        ;</span></font></code></pre>
-<p>With this setup, your number rule will now look something like:</p>

-<pre><code> <spanclass=identifier>number =<spanclass=identifier> lazy_p(*<spanclass=identifier>block.int_rule<spanclass="special">);</code></pre>+ in a closure variable (e.g. <tt>block.int_rule</tt>). Here's anexample: 基本的原理是用一个规则解析二进制和十进制的数字。这很容易做到（见<a href="numerics.html">数值</a>）。当 <tt>base</tt> 分析过后，在你的语义动作里把一个指向所选择的进制的指针储存于一个闭包变量中（比如 <tt>block.int_rule</tt>）。这是一个例子：+<pre><code> <spanclass="identifier">base <spanclass="special">= str_p<spanclass="special">("bin"<spanclass="special">)[block.int_rule =&var(<spanclass="identifier">bin_rule)] |str_p<spanclass="special">("dec"<spanclass="special">)[block.int_rule =&var(<spanclass="identifier">dec_rule<spanclass="special">)] ;</code></pre>+With this setup, your number rule will now look something like: 有了这个，你的number规则看起来就像：+<pre><code> <spanclass="identifier">number =<spanclass="identifier"> lazy_p(*<spanclass="identifier">block.int_rule<spanclass="special">);</code></pre>The <tt><ahref="../example/intermediate/lazy_parser.cpp">lazy_parser.cpp</a></tt>does it a bit differently, ingeniously using the <ahref="symbols.html">symboltable</a> to dispatch the correct rule, but in essence, both strategiesaresimilar. This technique, using the symbol table, is detailed in theTechiques section: <ahref="techniques.html#nabialek_trick">nabialek_trick</a>. Admitedly, whenyou add up all the rules, the resulting grammar ismore complex than the hard-coded grammar above. Yet, for more complexgrammarpatterns with a lot more rules to choose from, the additional setup iswell

-  worth it.</p>

+ worth it. <a href="../example/intermediate/lazy_parser.cpp"><spanstyle="font-family: Courier New;">lazy_parser.cpp</a>所做的有些不同，它聪明地使用了<a href="symbols.html">符号表</a>来分派对应的规则，但本质上，这两种策略是相同的。这个技术，符号表的使用，其细节在技术章节：<ahref="techniques.html#nabialek_trick">nabialek戏法</a>。要承认的是，你添加以上全部规则后，所产生的语法要比原来的语法更加复杂。但j ，在需要选择更多的分析样式的更复杂的语法中，这种代价是值得的。

 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2003 Joel de Guzman<br>
-  Copyright &copy; 2003 Vaclav Vesely<br>
+<p class="copyright">Copyright © 2003 Joel de Guzman<br>
+  Copyright © 2003 Vaclav Vesely<br>
   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/index.html       Sat Oct  4 05:29:09 2008
+++ /trunk/libs/spirit/classic/index.html       Sun Sep 20 23:13:57 2009
@@ -1,6 +1,5 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -12,8 +11,8 @@



-  <title>Spirit User's Guide</title>
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+

+ <title>Spirit User's Guide</title><meta http-equiv="Content-Type"content="text/html; charset=UTF-8">




@@ -21,10 +20,7 @@



-  <link rel="stylesheet" href="doc/theme/style.css" type="text/css">
-</head>
-
-
+  <link rel="stylesheet" href="doc/theme/style.css" type="text/css"></head>
 <body>


@@ -496,7 +492,7 @@



-    <td class="toc_cells_L1"><a href="doc/phoenix.html">凤凰</a></td>
+    <td class="toc_cells_L1"><a href="doc/phoenix.html">Phoenix</a></td>



@@ -511,7 +507,7 @@



-    <td class="toc_cells_L1"><a href="doc/closures.html">关闭</a></td>
+    <td class="toc_cells_L1"><a href="doc/closures.html">闭包</a></td>



@@ -571,7 +567,7 @@

- <td class="toc_cells_L1"><a href="doc/the_lazy_parser.html">懒惰解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/the_lazy_parser.html">惰性解析器</a></td>




@@ -601,7 +597,7 @@

- <td class="toc_cells_L1"><a href="doc/switch_parser.html">开关解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/switch_parser.html">跳转解析器</a></td>




@@ -616,7 +612,7 @@



-    <td class="toc_cells_L0"><b>有用部件</b></td>
+    <td class="toc_cells_L0"><b>工具组件</b></td>



@@ -631,7 +627,7 @@

- <td class="toc_cells_L1"><a href="doc/escape_char_parser.html">退出字符解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/escape_char_parser.html">转义字符解析器</a></td>




@@ -646,7 +642,7 @@



-    <td class="toc_cells_L1"><a href="doc/loops.html">循环解析器</a></td>
+    <td class="toc_cells_L1"><a href="doc/loops.html">循环</a></td>



@@ -661,7 +657,7 @@

- <td class="toc_cells_L1"><a href="doc/character_sets.html">字符集解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/character_sets.html">字符集</a></td>




@@ -676,7 +672,7 @@

- <td class="toc_cells_L1"><a href="doc/confix.html">首尾（Confix）与注释解析</a></td>

+    <td class="toc_cells_L1"><a href="doc/confix.html">片段解释器</a></td>



@@ -706,7 +702,7 @@

- <td class="toc_cells_L1"><a href="doc/functor_parser.html">函数解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/functor_parser.html">仿函数解析器</a></td>




@@ -721,7 +717,7 @@

- <td class="toc_cells_L1"><a href="doc/refactoring.html">重因子分解解析器</a></td>+ <td class="toc_cells_L1"><a href="doc/refactoring.html">重构解析器</a></td>




@@ -1095,7 +1091,7 @@

         Joel de Guzman</font><font size="2"><br>


@@ -1111,43 +1107,43 @@



-        <font color="#666666">Copyright &copy; 2001-2003 Hartmut Kaiser<br>
+        <font color="#666666">Copyright © 2001-2003 Hartmut Kaiser<br>




-        Copyright &copy; 2001-2002 Daniel C. Nuffer<br>
+        Copyright © 2001-2002 Daniel C. Nuffer<br>




-        Copyright &copy; 2002 Chris Uzdavinis<br>
+        Copyright © 2002 Chris Uzdavinis<br>




-        Copyright &copy; 2002 Jeff Westfahl<br>
+        Copyright © 2002 Jeff Westfahl<br>




-        Copyright &copy; 2002 Juan Carlos Arevalo-Baeza<br>
+        Copyright © 2002 Juan Carlos Arevalo-Baeza<br>

+        </font><font size="2"><font color="#666666">Copyright © 2003 Martin
         Wille <br>




-        Copyright &copy; 2003 Ross Smith<br>
+        Copyright © 2003 Ross Smith<br>

+        <font size="2"><font size="2">Copyright © 2003</font></font></font>

Jonathan de Halleux</div>



@@ -1258,5 +1254,4 @@



-</body>
-</html>
+</body></html>

[boost-doc-zh] r335 committed - Spirit库译文，由 青菜肉丝 提供，第二批

Other related posts:

[boost-doc-zh] r335 committed - Spirit库译文，由青菜肉丝提供，第二批