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

From: codesite-noreply@xxxxxxxxxx
To: boost-doc-zh-notify@xxxxxxxxxxxxx
Date: Thu, 17 Sep 2009 03:27:03 +0000

Revision: 333
Author: alai04
Date: Wed Sep 16 20:25:53 2009
Log: Spirit库译文，由 青菜肉丝 提供，第一批
http://code.google.com/p/boost-doc-zh/source/detail?r=333

Modified:
 /trunk/glossary/glossary.txt
 /trunk/libs/spirit/classic/doc/basic_concepts.html
 /trunk/libs/spirit/classic/doc/directives.html
 /trunk/libs/spirit/classic/doc/epsilon.html
 /trunk/libs/spirit/classic/doc/grammar.html
 /trunk/libs/spirit/classic/doc/indepth_the_parser.html
 /trunk/libs/spirit/classic/doc/indepth_the_parser_context.html
 /trunk/libs/spirit/classic/doc/indepth_the_scanner.html
 /trunk/libs/spirit/classic/doc/introduction.html
 /trunk/libs/spirit/classic/doc/numerics.html
 /trunk/libs/spirit/classic/doc/operators.html
 /trunk/libs/spirit/classic/doc/organization.html
 /trunk/libs/spirit/classic/doc/preface.html
 /trunk/libs/spirit/classic/doc/primitives.html
 /trunk/libs/spirit/classic/doc/quick_start.html
 /trunk/libs/spirit/classic/doc/rule.html
 /trunk/libs/spirit/classic/doc/scanner.html
 /trunk/libs/spirit/classic/doc/semantic_actions.html
 /trunk/libs/spirit/classic/doc/subrules.html

=======================================
--- /trunk/glossary/glossary.txt        Wed Sep  2 00:28:21 2009
+++ /trunk/glossary/glossary.txt        Wed Sep 16 20:25:53 2009
@@ -137,7 +137,15 @@

  7) graph                      //alai04
  predecessor                   前趋
-
+
+ 8) spirit
+ parser                        解析器，分析器
+ skip parser                   跳读解析器
+ parser elements               解析器基元
+ Semantic Actions              语义动作
+ primitives                    基元
+ composites                    合成件
+ actor                         动作器

 f) misc 其它
 rationale              理论注记
=======================================

--- /trunk/libs/spirit/classic/doc/basic_concepts.html Sat Oct 4 05:29:092008+++ /trunk/libs/spirit/classic/doc/basic_concepts.html Wed Sep 16 20:25:532009

@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -47,8 +46,8 @@



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

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




@@ -67,9 +66,7 @@



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

 <body>

@@ -292,7 +289,7 @@

-有几个基础概念必须理解得很清楚： 1) 解析器Parser, 2) 匹配Match, 3) 扫描器Scanner，和 4) 语义行为Semantic Actions。这些基础概念相互联系着，它们的功能融会在框架中，形成一个统一的整体。+有几个基础概念必须理解得很清楚： 1) 解析器Parser, 2) 匹配Match, 3) 扫描器Scanner，和 4) 语义动作Semantic Actions。这些基础概念相互联系着，它们的功能融会在框架中，形成一个统一的整体。

     </p>


@@ -389,8 +386,8 @@

框架的中心是解析器。 扫描器从头到尾地读入线性输入的数据流，然后交给解析器进行实际的识别工作。-根据完备定义的文法规则，解析器尝试匹配输入串。通过一个匹配对象，解析器向客户报告成功或者失败。-当解析成功时，用户提供的语义行为会被自动调用。最后，依赖于解析器的层次上下文，和解析器给其连接的语义行为的数据，语义行为会提取出结构化信息。+根据完备定义的文法规则，解析器尝试匹配输入串。通过一个匹配对象，解析器向客户报告成功或者失败。+当解析成功时，用户提供的语义行为会被自动调用。最后，语义动作从分析器中获得结构化的信息，这些信息依赖于分析器传剃的数据和分析器所处的语境层次。

     </p>


@@ -402,7 +399,7 @@

-解析器有不同的实现风格。Spirit框架捆绑了广泛的预定义解析器，有简单的也有复杂的。在概念上，解析器有公开约定的接口。只要遵守约定，任何人都可以写一个在框架中一致的解析器，这就可以和其他预定义的部分良好地合作。关于公约的细节，我们将在后面给出蓝图。+解析器有不同的实现风格。Spirit框架捆绑了广泛的预定义解析器，有简单的也有复杂的。在概念上，解析器有公开约定的接口。只要遵守约定，任何人都可以写一个与框架一致的解析器，这就可以和其他预定义的部分良好地合作。我们将在后面给出相关接口细节的蓝图。

     </p>


@@ -414,9 +411,8 @@



-<p> 框架的客户一般不需要手写出解析器。

-Spirit有极其广泛的预定义解析器部件，涉及到语法和语义分析的方方面面。我们会在下面的章节中检阅这些解析器。-很罕见地，如果特定的功能没有提供，那写一个用户定义的解析器也是非常容易的事情。 开发新解析器部件的不费吹灰之力，造就了Spirit的可+ 框架的客户一般不需要手工写出解析器。Spirit有极其广泛的预定义解析器部件，涉及到语法和语义分析的方方面面。我们会在下面的章节中介绍这些解析器。+很罕见地，如果特定的功能没有提供，那么写一个用户自定义的解析器也是非常容易的事情。开发新解析器部件不费吹灰之力，这造就了Spirit的可

 扩展性。 </p>


@@ -442,7 +438,7 @@


 <p>

- Spirit的解析器分成两类：基元primitives 和合成件composites。这两类的意义或多或少地相似于解析领域所谓的节点和非节点。基元是不可分解的原子部件。而合成件则是由几个解析器合成的，用来合成的可以是基元，也可以是其他合成件。为了说明这点，请考虑如下Spirit表达式：+ Spirit的解析器分成两类：基元primitives 和合成件composites。这两类的意义或多或少地类似于解析领域所谓的节点和非节点。基元是不可分解的原子部件。而合成件则是由几个解析器合成的，用来合成的可以是基元，也可以是其他合成件。为了说明这点，请考虑如下Spirit表达式：

     </p>


@@ -466,7 +462,7 @@


 <p>

- <tt><tt>real_p</tt></tt> 是一个可解析浮点数的基元解析器。表达式中在单引号内的逗号 <tt class="quotes">','</tt> 是一种简化的写法，等效于<tt>ch_p(<spanclass="quotes">',')</tt>，这是另一个解析单个字符的基元解析器。+ <tt><tt>real_p</tt></tt> 是一个可解析浮点数的基元解析器。表达式中在单引号内的逗号 <tt class="quotes">','</tt> 是一种简化的写法，等效于<tt>ch_p(<spanclass="quotes">',')</tt>，这是另一个解析单个字符的基元解析器。

     </p>


@@ -587,7 +583,7 @@


 <p>

- 合成了一个序列解析器。序列 <tt>sequence</tt> 解析器是一个合成件，它包括两个解析器：左手边（lhs）一个， <tt>ch_p<spanclass="operators">(','<spanclass="operators">)</tt> ；和右手边（rhs）一个，<tt>real_p</tt>。调用这个合成件时，会按顺序转调用lhs和rhs，当两个都成功匹配时，合成件才报告成功。+ 合成了一个序列解析器。序列 <tt>sequence</tt> 解析器是一个合成件，它包括两个解析器：一个左操作数（lhs），<tt>ch_p<spanclass="operators">(','<spanclass="operators">)</tt>；和一个右操作参数（rhs）， <tt>real_p</tt>。调用这个合成件时，会按顺序转为调用lhs和rhs，当两个都成功匹配时，合成件才会报告成功。

     </p>


@@ -672,8 +668,7 @@


 <p>

- 序列 <tt>sequence</tt> 解析器是一个二元合成件。它由两个解析器组成。也有一元合成件，它仅含单个子部件。类似于二元合成件，一元合成件可以改变嵌入子部件的行为。一个特殊的例子是- Kleene星号Kleene star。当用Kleene星号解析的时候，子部件被调用零次或更多次。 “零或者更多”意味着Kleene星号总是返回一个成功的匹配，可能是匹配到空串： "" 。+ 序列 <tt>sequence</tt> 解析器是一个二元合成件。它由两个解析器组成。也有一元合成件，它仅含单个子部件。类似于二元合成件，一元合成件可以改变嵌入子部件的行为。一个特殊的例子是Kleene星号。当用Kleene星号解析的时候，子部件被调用零次或更多次。"零或者更多"意味着Kleene星号总是返回一个成功的匹配，可能是匹配到空串：""。

     </p>


@@ -709,7 +704,7 @@



-<p>把整个上面的序列合成件包装在一个kleene星号 <tt>kleene_star</tt>里面。
+<p>把整个上面的序列合成件包装在一个 <tt>kleene_star</tt> 里面。
     </p>


@@ -793,7 +788,7 @@

-最终，全部表达式组合一个<tt>real_p</tt>基元解析器和我们刚才提的<tt>kleene_star</tt>解析器，成为另一个更高层次的序列解析器合成件。+最终，整个表达式组合了一个<tt>real_p</tt>基元解析器和我们刚才提的<tt>kleene_star</tt>解析器，成为另一个更高层次的序列解析器合成件。

     </p>


@@ -877,7 +872,7 @@

-几个简单的类，组合成一个层次化结构，则形成一个非常强大的面向对象的递归下降解析器引擎。这些类提供了复杂解析器需要的基础构造。最终的解析器是一个非节点的递归下降解析器，并可能无限向前解析。+几个简单的类，组合成一个层次化结构，则形成一个非常强大的面向对象的递归下降解析器引擎。这些类提供了复杂解析器需要的基础构造。最终的解析器是一个非节点的递归下降解析器，并可能无限向前解析。

     </p>


@@ -889,9 +884,9 @@



-<p>自顶向下地经过结构层次。 外层的 <tt>sequence</tt>

- 解析器调用最左边的 <tt>real_p</tt> 解析器。如果成功，接着调用<tt>kleene_star</tt> 解析器。这个 <tt>kleene_star</tt> 星号不断调用内部的<tt>sequence</tt> 直到不能匹配或者输入序列完全匹配。在此过程内部，<tt>ch_p(',')</tt> 解析器和- <tt>real_p</tt> 解析器顺序调用。下面的图描述函数调用过程，有点类似Pascal语法图。

+<p>自顶向下地经过结构层次。外层的 <tt>sequence</tt>

+ 解析器调用最左边的 <tt>real_p</tt> 解析器。如果成功，接着调用<tt>kleene_star</tt> 解析器。这个 <tt>kleene_star</tt> 星号不断调用内部的<tt>sequence</tt> 直到不能匹配或者输入序列完全匹配。在此过程内部，<tt>ch_p(',')</tt> 解析器和+ <tt>real_p</tt> 解析器被顺序调用。下面的图描述函数调用过程，有点类似Pascal语法图。

     </p>


@@ -975,7 +970,7 @@

-对象的可递归的嵌入和合成的适应性，开辟了文本解析的道路。子类很容易构造出任意复杂的聚合和算法。复杂的解析器可用几个简单的类来组合出来。+对象的可递归嵌入和递归的合成，开辟了文本解析的道路。子类很容易构造出任意复杂的聚合和算法。复杂的解析器可用几个简单的类来组合出来。

     </p>


@@ -987,7 +982,7 @@

-框架被设计成完全无限制的和可扩充的。在任意时候都可以加入新的基元和合成件，无论复杂或简单。合成件在编译期生成。这是可能的，通过C++表达式模板和模板元编程的灵活的表达性。+框架被设计成完全无限制的和可扩充的。在任意时候都可以加入新的基元和合成件，无论复杂或简单。合成件在编译期生成。借助于C++表达式模板和模板元编程的灵活的表达性，这是可实现的。

     </p>


@@ -1000,8 +995,7 @@


 <p>

- 结果就是一个基元和小合成件的组合。这种嵌入式策略给我们能建造层次结构，去完全模拟任意复杂的EBNF表达式。

-      稍后，我们将见到更多基元和合成件模块。

+ 结果就是一个基元和小合成件的组合。这种嵌入式策略让我们能够建造层次结构，去完全模拟任意复杂的EBNF表达式。稍后，我们将见到更多基元和合成件模块。

     </p>


@@ -1026,9 +1020,9 @@

-像解析器一样，扫描器也是一个抽象的概念。扫描器的任务是给解析器提供连续的输入数据流。-扫描器有两个STL相容的前向迭代组成，first和last，其中first按引用传递，last按值传递。-first按引用传递是为了允许解析器进行重定位。有一系列规范规定了扫描器的行为。解析器从扫描器提取出数据，然后根据它的成员函数恰当地定位输入迭代器。+像解析器一样，扫描器也是一个抽象的概念。扫描器的任务是给解析器提供连续的输入数据流。+扫描器包含两个STL相容的前向迭代器，first和last，其中first以引用方式保存，last则按值方式保存。first按引用方式保存是为了+允许解析器进行重定位。有一系列规范规定了扫描器的行为。解析器从扫描器提取出数据，然后根据它的成员函数恰当地定位输入迭代器。 




@@ -1039,10 +1033,10 @@

-在大多数情况下，我们不需要知道这些复杂的技法。但是，如果想写与Spirit一致的解析器，知道扫描器的基础的API是需要的。-扫描器的API概要在独立的章节中描述。另外，为了高级用户和规避使用中潜在的危险，一整章会用来介绍扫描器的内幕。-扫描器采用的方针使Spirit非常灵活和可扩充。例如，可以修改一些政策来过滤数据。-一个现实的例子是有一个忽略大小写的扫描器方针，在解析大小写不敏感的数据时很有用。另一个例子是有一个跳过输入空白的扫描器政策。 +在大多数情况下，我们不需要知道这些复杂的技法。但是，如果想写一个与Spirit一致的解析器，那么知道扫描器的基础的API是需要的。+扫描器的API概要在单独的章节中描述。另外，为了高级用户和规避使用中潜在的危险，我们有一整章来介绍扫描器的内幕。采用

+扫描器的策略使Spirit非常灵活和可扩充。例如，可以修改一些策略来过滤数据。

+一个现实的例子是有一个忽略大小写的扫描器策略，在解析大小写不敏感的数据时很有用。另一个例子是有一个跳过输入空白的扫描器策略。 




@@ -1066,9 +1060,7 @@

-解析器有一个概念上的解析成员函数，接收一个扫描器输入，返回一个匹配对象。匹配对象主要的作用是向调用者报告解析的成功（或失败）；也就是，当解析成功它的值为真，反之为假。- 如果解析器成功，匹配对象也被要求报告成功匹配的字符个数（用<tt>match.length()</tt>）。- 如果匹配成功，长度是非负的，还有典型的解析失败的长度是-1。零长度是完全合法的并且仍然代表一个成功匹配。+解析器有一个概念上的 parse 成员函数，接收一个扫描器输入，返回一个匹配对象。匹配对象主要的作用是向调用者报告解析的成功（或失败）；也就是说，当解析成功时它的值为真，反之为假。如果解析器成功，匹配对象也被要求报告成功匹配的字符个数（用<tt>match.length()</tt>）。如果匹配成功，长度是非负的，还有典型的解析失败的长度是-1。零长度是完全合法的并且仍然代表一个成功匹配。

     </p>


@@ -1080,7 +1072,7 @@

-解析器可能有相关的属性数据。例如，real_p解析器有一个相关的数值属性。这个属性就是解析出的数值，它会被传递到返回的匹配对象。我们就可从匹配对象中取得此数值。这个数据仅仅在解析成功时有效。+解析器可能有相关的属性数据。例如，real_p解析器有一个相关的数值属性。这个属性就是解析出的数值，它会被传递到返回的匹配对象。我们就可从匹配对象中取得此数值。这个数据仅仅在解析成功时有效。

     </p>


@@ -1092,8 +1084,7 @@



-<h2>语义行为
-    </h2>
+<h2>语义动作</h2>



@@ -1104,7 +1095,7 @@

-一个合成件形成了一个层次结构。解析过程从最高层父解析器开始，把解析任务委托和分配到子解析器，然后到儿子再到儿子的儿子，一直到达一个基元解析器。通过在这个层次中缚上语义行为，我们可以有效地从扁平的线性输入构造出一个结构表示。这就是解析器本质上的作用。+一个合成件形成了一个层次结构。解析过程从最高层父解析器开始，把解析任务委派和分配到子解析器，然后到子节点再到子节点的子节点，一直到达一个基元解析器。通过在这个层次中绑上语义动作，我们可以有效地从扁平的线性输入构造出一个结构表示。这就是解析器本质上的作用。

     </p>


@@ -1141,7 +1132,7 @@


 <p>

- 通过在real_p解析器上挂接一个函数（或者函数子），我们可以从输入中提取数值：+ 通过在real_p解析器上挂接一个函数（或者仿函数），我们可以从输入中提取数值：

     </p>


@@ -1236,7 +1227,7 @@

-其中 <tt>f</tt> 是一个单输入函数。代码 <tt><spanclass="operators">[&f]</tt> 在解析器上挂接了一个函数，使当<tt>real_p</tt>识别一个合法的数值时，将调用<tt>f</tt>函数。然后让函数决定做恰当的事情。例如，它可以把数值填充进一个vector向量。又或者，如果语法稍微改变，用<tt class="quotes">'+'</tt>代替<ttclass="quotes">','</tt>，那么则得到一个求和的简单计算器。函数<tt>f</tt> 可以设计成迭加所有的输入数值。 +其中 <tt>f</tt> 是一个单输入函数。代码 <tt><spanclass="operators">[&f]</tt> 在解析器上挂接了一个函数，使当<tt>real_p</tt>识别一个合法的数值时，将调用<tt>f</tt>函数。然后让函数决定做恰当的事情。例如，它可以把数值填充进一个vector向量。又或者，如果语法稍微改变，用<tt class="quotes">'+'</tt>代替<ttclass="quotes">','</tt>，那么则得到一个求和的简单计算器。函数<tt>f</tt> 可以设计成对所有的输入数值进行相加。 




@@ -1375,7 +1366,7 @@
 <hr size="1">

 <p class="copyright">
-      Copyright &copy; 1998-2003 Joel de Guzman<br>
+      Copyright (c) 1998-2003 Joel de Guzman<br>



@@ -1422,5 +1413,4 @@



-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/directives.html      Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/directives.html      Wed Sep 16 20:25:53 2009
@@ -1,35 +1,33 @@
-<html>
-<head>
-<title>Directives</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>Directives</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%">

- Directives+ Directives 指示符

     </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="epsilon.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="scanner.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
-<p>Parser directives have the form: <b>directive[expression]</b></p>
+</tbody></table>

+Parser directives have the form: directive[expression] 分析器指示符具有如下形式：directive[expression]A directive modifies the behavior of its enclosed expression,essentially decoratingit. The framework pre-defines a few directives. Clients of the frameworkarefree to define their own directives as needed. Information on how thisis done- will be provided later. For now, we shall deal only with predefineddirectives.+ will be provided later. For now, we shall deal only with predefineddirectives. 指示符可以改变它所包含的表达式的行为，即对其进行装饰。本框架预定义了一些指示符。用户也可以随便定义他们所需的指示符。稍后再给出如何来实现的信息。目前，我们只讨论预定义的指示符。

 <h2>lexeme_d</h2>

Turns off white space skipping. At the phrase level, the parser ignoreswhitespaces, possibly including comments. Use <tt>lexeme_d</tt> in situationswhere

@@ -37,60 +35,65 @@

can be made to work at the character level by enclosing the pertinentpartsinside the lexeme_d directive. For example, let us complete the examplepresentedin the <a href="introduction.html">Introduction</a>. There, we skippedthe definition

-  of the <tt>integer</tt> rule. Here's how it is actually defined:</p>

-<pre><code> <spanclass=identifier>integer = <spanclass=identifier>lexeme_d[ <spanclass=special>!(ch_p<spanclass=special>('+')| '-'<spanclass=special>) >> <spanclass=special>+digit <spanclass=special>];</code></pre>+ of the <tt>integer</tt> rule. Here's how it is actually defined: 关闭空白字符的跳过。在语句层面上，分析器会忽略空白字符，其中可能包含注释。当我们希望在字符层面而不是语句层面上工作时，使用 <tt>lexeme_d</tt>。通过将有关的部分包含到 lexeme_d 指示符内部，就可以令分析器在字符层面上工作。例如，我们来完成在 <a href="introduction.html">介绍</a> 中给出的例子。当时，我们略过了<tt>integer</tt> 规则的定义。以下是它的真实定义：+<pre><code> <spanclass="identifier">integer = <spanclass="identifier">lexeme_d[ <spanclass="special">!(ch_p<spanclass="special">('+'<spanclass="special">) | <spanclass="literal">'-') <spanclass="special">>> +<spanclass="identifier">digit <spanclass="special">];</code></pre>The <tt>lexeme_d</tt> directive instructs the parser to work on thecharacterlevel. Without it, the <tt>integer</tt> rule would have allowederroneous embedded- white spaces in inputs such as "1 2345"- which will be parsed as <spanclass="quotes">"12345".

+  white spaces in inputs such as <span class="quotes">"1 2 345"</span>

+ which will be parsed as <spanclass="quotes">"12345". <tt>lexeme_d</tt> 指示符命令分析器工作在字符层面上。没有它，<tt>integer</tt> 规则将允许错误地把空白嵌入到输入中，如"1 2 345"

+  将被分析为 <span class="quotes">"12345"</span>。</p>
 <h2>as_lower_d</h2>

There are times when we want to inhibit case sensitivity. The<tt>as_lower_d</tt>

-  directive converts all characters from the input to lower-case.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16">+ directive converts all characters from the input to lower-case. 有时我们希望抑制大小写敏感。<tt>as_lower_d</tt>

+  指示符将来自输入的所有字符转换为小写。</p>
+<table align="center" border="0" width="80%">
+  <tbody><tr>

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

       as_lower_d behavior</b> <br>
       <br>

It is important to note that only the input is converted to lowercase.Parsers enclosed inside the <tt>as_lower_d</tt> expecting upper casecharacterswill fail to parse. Example: <tt>as_lower_d[<spanclass="quotes">'X']</tt>will never succeed because it expects an upper case <ttclass="quotes">'X'</tt>

-      that the <tt>as_lower_d</tt> directive will never supply.</td>

+ that the <tt>as_lower_d</tt> directive will never supply. 要留意，只是输入被转换为小写，这很重要。括在 <tt>as_lower_d</tt> 中的分析器如果期待大写字母，将会解析失败。例如：<tt>as_lower_d[<spanclass="quotes">'X']</tt>+ 永远不会成功，因为它期待一个大写的 <tt class="quotes">'X'</tt>，而<tt>as_lower_d</tt> 指示符永远不会提供。</td>

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

For example, in Pascal, keywords and identifiers are case insensitive.Pascalignores the case of letters in identifiers and keywords. Identifiers Id,IDand id are indistinguishable in Pascal. Without the as_lower_ddirective, it- would be awkward to define a rule that recognizes this. Here's apossibility:-<pre><code> <spanclass=identifier>r = <spanclass=identifier>str_p(<spanclass=string>"id") |"Id" | <spanclass=string>"iD" | <spanclass=string>"ID";</code></pre>-Now, try doing that with the case insensitive Pascal keyword <spanclass="quotes">"BEGIN".

-  The <tt>as_lower_d</tt> directive makes this simple:</p>

-<pre><code> <spanclass=identifier>r = <spanclass=identifier>as_lower_d[<spanclass=string>"begin"];</code></pre>

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

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

-        <b>Primitive arguments</b> <br>

+ would be awkward to define a rule that recognizes this. Here's apossibility: 例如，在Pascal中，关键字和标识符是大小写不敏感的。Pascal会忽略标识符和关键字中的字母大小写。标识符 Id, ID 和 id 在Pascal中都是一样的。没有 as_lower_d 指示符，定义一个标识此标识符的规则将非常难看。以下是一种可能性：+<pre><code> <spanclass="identifier">r = <spanclass="identifier">str_p(<spanclass="string">"id") <spanclass="special">| "Id" <spanclass="special">| "iD" <spanclass="special">| "ID"<spanclass="special">;</code></pre>+Now, try doing that with the case insensitive Pascal keyword <spanclass="quotes">"BEGIN".+ The <tt>as_lower_d</tt> directive makes this simple: 现在，尝试一下大小写不敏感的Pascal关键字 "BEGIN"。用<tt>as_lower_d</tt> 指示符就可以很简单：+<pre><code> <spanclass="identifier">r = <spanclass="identifier">as_lower_d[<spanclass="string">"begin"<spanclass="special">];</code></pre>

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

+ <td class="note_box"><div align="justify"><img src="theme/note.gif"height="16" width="16">

+        <b>Primitive arguments</b> &nbsp;基本参数<br>
         <br>

- The astute reader will notice that we did not explicitly wrap"begin"+ The astute reader will notice that we did not explicitly wrap"begin"inside an <tt>str_p</tt>. Whenever appropriate, directives shouldbe ableto allow primitive types such as <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>,<tt>char const*</tt>, <tt>wchar_tconst*</tt>

-        and so on. Examples: <tt><br>

+ and so on. Examples: 细心的读者会留意到，这里没有把<spanclass="quotes">"begin"显式地封入一个 <tt>str_p</tt> 中。在适当情况下，指示符可以允许基本类型，如 <tt>char</tt>, <tt>int</tt>,<tt>wchar_t</tt>,+ <tt>char const*</tt>, <tt>wchar_tconst*</tt>

+        等等。例如：<tt><br>
         <br>

- </tt><code>as_lower_d<tt><spanclass=special>["hello"]- // same asas_lower_d[str_p("hello")]</tt><code></code><spanclass=identifier> - as_lower_d[<spanclass=literal>'x']- // same asas_lower_d[ch_p('x')]</code></div></td>+ </tt><code>as_lower_d<tt><spanclass="special">["hello"<spanclass="special">]+ // same asas_lower_d[str_p("hello")]</tt><code></code><spanclass="identifier"> + as_lower_d[<spanclass="literal">'x']+ // same asas_lower_d[ch_p('x')]</code></div></td>

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

There are cases where you want <a href="semantic_actions.html">semanticactions</a>not to be triggered. By enclosing a parser in the <tt>no_actions_d</tt>directive,all semantic actions directly or indirectly attached to the parser willnot

-  fire. </p>

-<pre><code>no_actions_d[<spanclass=identifier>expression<spanclass=special>]</code><code><spanclass=special></code></pre>

-<h3>Tweaking the Scanner Type</h3>

-<img src="theme/note.gif" width="16" height="16"> How does<tt>lexeme_d, as_lower_d</tt>+ fire. 有些情况下，你不希望 <a href="semantic_actions.html">语义动作</a>+ 被触发。通过将分析器包入 <tt>no_actions_d</tt> 指示符，则连接到该分析器的所有直接或间接的语义动作都不会触发。<pre><code><fontcolor="#000000"> no_actions_d<spanclass="special">[expression<spanclass="special">]</code><code><spanclass="special"></code></pre>

+<h3>Tweaking the Scanner Type 调整扫描器类型</h3>

+<img src="theme/note.gif" height="16" width="16"> How does<tt>lexeme_d, as_lower_d</tt>and <tt>no_actions_d</tt> work? Thesedirectivesdo their magic by tweaking the scanner policies. Well, you don't need toknowwhat that means for now. Scanner policies are discussed <ahref="indepth_the_scanner.html">later</a>.

@@ -99,104 +102,96 @@

is tied to a particular scanner (one or more scanners, to be precise).If youwrap a rule inside a <tt>lexeme_d, as_lower_d</tt> or <fontcolor="#000000"><tt>no_actions_d,</tt>thecompiler will complain about <a href="faq.html#scanner_business">scannermismatch</a>

-  unless you associate the required scanner with the rule. </font></p>

-<tt>lexeme_scanner</tt>, <tt>as_lower_scanner</tt> and<tt>no_actions_scanner</tt>- are your friends if the need to wrap a rule inside these directivesarise. Learn- bout these beasts in the next chapter on <ahref="scanner.html#lexeme_scanner">The

-  Scanner and Parsing</a>.</p>

+ unless you associate the required scanner with the rule. <imgsrc="theme/note.gif" height="16" width="16"> <tt>lexeme_d,as_lower_d</tt> 和 <tt>no_actions_d</tt> 是如何工作的呢？这些指示符是通过调整扫描器的策略来实现它们的魔法的。好的，你现在并不需要明白这是什么意思。扫描器策略将在 <a href="indepth_the_scanner.html">稍后</a> 讨论。不过要留意，当扫描器策略被调整后，其结果是一个不同的扫描器，这很重要。为什么这很重要？因为 <a href="rule.html">规则</a> 被绑定到一个特定的扫描器(准确地说，是一个或多个扫描器)。如果你将一个规则包入某个<tt>lexeme_d, as_lower_d</tt> 或 <fontcolor="#000000"><tt>no_actions_d</tt> 中，编译器将会抱怨 <ahref="faq.html#scanner_business">扫描器不匹配</a>，除非你将所需的扫描器关联至该规则。+<tt>lexeme_scanner</tt>, <tt>as_lower_scanner</tt> 和<tt>no_actions_scanner</tt> 都是你的朋友，如果你需要将一个规则包入这些指示符。你可以在下一章的 <a href="scanner.html#lexeme_scanner">扫描器与分析</a>中了解到这些。

 <h2>longest_d</h2>

Alternatives in the Spirit parser compiler are short-circuited (see <ahref="operators.html">Operators</a>).Sometimes, this is not what is desired. The <tt>longest_d</tt> directiveinstructsthe parser not to short-circuit alternatives enclosed inside thisdirective,but instead makes the parser try all possible alternatives and choosethe one

-  matching the longest portion of the input stream.</p>
-<p>Consider the parsing of integers and real numbers:</p>

-<pre><code> <spanclass=identifier>number = <spanclass=identifier>real | <spanclass=identifier>integer<spanclass=special>;</code></pre>-A number can be a real or an integer. This grammar is ambiguous. Aninput "1234"+ matching the longest portion of the input stream. 在Spirit分析器编译器中，选择操作是短路的(见 <a href="operators.html">操作符</a>)。有时候这不是想要的。<tt>longest_d</tt> 指示符命令分析器不要将指示符内的选择操作短路，而是令分析器尝试所有可能的选择，并选中与输入流中最长部分相对应的匹配。+Consider the parsing of integers and real numbers: 看一下对整数和实数的分析：+<pre><code> <spanclass="identifier">number = <spanclass="identifier">real | <spanclass="identifier">integer<spanclass="special">;</code></pre>+A number can be a real or an integer. This grammar is ambiguous. Aninput "1234"should potentially match both real and integer. Recall though thatalternativesare short-circuited . Thus, for inputs such as above, the realalternative always

-  wins. However, if we swap the alternatives:</p>

-<pre><code> <spanclass=identifier>number = <spanclass=identifier>integer | <spanclass=identifier>real;</code></pre>-we still have a problem. Now, an input <spanclass="quotes">"123.456"+ wins. However, if we swap the alternatives: 一个 number 可以是一个real 或是一个 integer。这个语法是模糊的。输入 <spanclass="quotes">"1234"+ 可以同时匹配 real 和 integer。回想一下，选择操作是短路的。因此，对于以上输入，总是会选中 real。但是，如果我们交换一下两个选择：+<pre><code> <spanclass="identifier">number = <spanclass="identifier">integer | <spanclass="identifier">real<spanclass="special">;</code></pre>+we still have a problem. Now, an input <spanclass="quotes">"123.456"will be partially matched by integer until the decimal point. This isnot whatwe want. The solution here is either to fix the ambiguity by factoringout thecommon prefixes of real and integer or, if that is not possible nordesired,

-  use the <tt>longest_d</tt> directive:</p>

-<pre><code> <spanclass=identifier>number = <spanclass=identifier>longest_d[ <spanclass=identifier>integer | <spanclass=identifier>real <spanclass=special>];</code></pre>+ use the <tt>longest_d</tt> directive: 我们还是会有问题。现在，输入"123.456"+ 会被 integer 部分匹配至小数点之前。这不是我们想要的。解决的方法是，通过提取实数与整数的共同前缀来修正此歧义，如果这样做不可能也不想如此，则使用<tt>longest_d</tt> 指示符：+<pre><code> <spanclass="identifier">number = <spanclass="identifier">longest_d[ <spanclass="identifier">integer | <spanclass="identifier">real <spanclass="special">];</code></pre>

 <h2>shortest_d</h2>
-<p>Opposite of the <tt>longest_d</tt> directive.</p>
-<table width="80%" border="0" align="center">
-  <tr>

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

-      alternatives</b> <br>

+Opposite of the <tt>longest_d</tt> directive. 与 <tt>longest_d</tt>指示符相反。

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

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

+      alternatives</b> &nbsp;多重选择<br>
       <br>

The <tt>longest_d</tt> and <tt>shortest_d</tt> directives can accepttwo

-      or more alternatives. Examples:<br>

+ or more alternatives. Examples: <tt>longest_d</tt> 和<tt>shortest_d</tt> 指示符可以接受两个或以上的选项。例如： 

       <br>

- <spanclass=identifier><code>longest</code><code>[- a |b- | c];

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

- shortest[ a|- b |c- | d];</code></td>+ <spanclass="identifier"><code>longest</code><code>[+ a |b+ | c];

+      </span><span class="identifier"><br>

+ shortest[ <spanclass="identifier">a |+ b |c+ | d];</code></td>

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

Ensures that the result of a parser is constrained to a given min..maxrange

-  (inclusive). If not, then the parser fails and returns a no-match.</p>
-<p><b>Usage:</b></p>

-<pre><code> <spanclass=identifier>limit_d(<spanclass=identifier>min, <spanclass=identifier>max)[<spanclass=identifier>expression<spanclass=special>]</code></pre>+ (inclusive). If not, then the parser fails and returns a no-match. 确保分析器的结果被限制在给定的 min..max 范围内(含端点)。否则分析器失败并返回不匹配。

+<p><b>Usage:<br>用法：</b></p>

+<pre><code> <spanclass="identifier">limit_d(<spanclass="identifier">min, <spanclass="identifier">max)[<spanclass="identifier">expression<spanclass="special">]</code></pre>This directive is particularly useful in conjunction with parsers thatparsespecific scalar ranges (for example, <a href="numerics.html">numericparsers</a>).Here's a practical example. Although the numeric parsers can beconfigured toaccept only a limited number of digits (say, 0..2), there is no way tolimitthe result to a range (say -1.0..1.0). This design is deliberate. Doingso would- have undermined Spirit's design rule that <spanclass="quotes">"the- client should not pay for features that she does notuse". We

+  have undermined Spirit's design rule that <i><span class="quotes">"the
+  client should not pay for features that she does not use"</span></i>. We

would have stored the min, max values in the numeric parser itself, usedorunused. Well, we could get by by using static constants configured by anon-typetemplate parameter, but that is not acceptable because that way, we canonlyaccommodate integers. What about real numbers or user defined numberssuch as

-  big-ints?</p>
-<p><b>Example</b>, parse time of the form <b>HH:MM:SS</b>:</p>

-<pre><code> <spanclass=identifier>uint_parser<<spanclass=keyword>int, <spanclass=number>10, <spanclass=number>2, <spanclass=number>2> <spanclass=identifier>uint2_p;

- r =lexeme_d

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

- limit_d<spanclass=special>(0u,23u)[<spanclass=identifier>uint2_p] <spanclass=special>>> ':' <spanclass=comment>// Hours 00..23- >> <spanclass=identifier>limit_d(<spanclass=number>0u, <spanclass=number>59u)[<spanclass=identifier>uint2_p] <spanclass=special>>> ':' <spanclass=comment>// Minutes 00..59- >> <spanclass=identifier>limit_d(<spanclass=number>0u, <spanclass=number>59u)[<spanclass=identifier>uint2_p] <spanclass=comment>// Seconds 00..59

-        </span><span class=special>];</span></font></code>

+ big-ints? 当这个指示符与那些分析特定范围内(如 <ahref="numerics.html">数值分析器</a>)的分析器一起使用时，尤其有用。虽然数值分析器可以被配置为只接受限定长度的数字(如 0..2)，但是却没有办法限定结果的范围(如 -1.0..1.0)。这种设计是经过深思熟虑的。这样做将会破坏Spirit的设计原则："用户无需为不需要的特性付出代价"。因为无论是否需要，我们都要将 min, max 值保存在数值分析器中。当然，我们可以通过一个非类型模板参数来使用静态常量配置，但这也是不可接受的，因为这样的话，我们就只能容纳整数了。那么实数或是用户自定义的数值类型如 big-ints 该怎么办?+Example, parse time of the form HH:MM:SS: 例如，分析形如 HH:MM:SS 的时间：+<pre><code> <spanclass="identifier">uint_parser<<spanclass="keyword">int, <spanclass="number">10, <spanclass="number">2, <spanclass="number">2> <spanclass="identifier">uint2_p; r =lexeme_d <spanclass="special">[ <spanclass="identifier">limit_d(<spanclass="number">0u, <spanclass="number">23u)[<spanclass="identifier">uint2_p] <spanclass="special">>> ':' <spanclass="comment">// Hours 00..23 <spanclass="special">>> <spanclass="identifier">limit_d(<spanclass="number">0u, <spanclass="number">59u)[<spanclass="identifier">uint2_p] <spanclass="special">>> ':' <spanclass="comment">// Minutes 00..59 <spanclass="special">>> <spanclass="identifier">limit_d(<spanclass="number">0u, <spanclass="number">59u)[<spanclass="identifier">uint2_p]// Seconds 00..59 <spanclass="special">];</code>

 </pre>
 <h2>min_limit_d</h2>

Sometimes, it is useful to unconstrain just the maximum limit. Thiswill allowfor an interval that's unbounded in one direction. The directivemin_limit_densures that the result of a parser is not less than minimun. If not,then the

-  parser fails and returns a no-match.</p>
-<p><b>Usage:</b></p>

-<p><b>Example</b>, ensure that a date is not less than 1900</p>

-<pre><code> <spanclass=identifier>min_limit_d(<spanclass=number>1900u)[<spanclass=identifier>uint_p<spanclass=special>]</code></pre>+ parser fails and returns a no-match. 有时，我们需要不限制最大值。这样可以使用在某个方向无界的区间。指示符 min_limit_d

+  确保了分析器的结果不小于最小值。否则，分析器失败且返回不匹配。</p>
+<p><b>Usage:<br>用法：</b></p>

+<pre><code> <spanclass="identifier">min_limit_d(<spanclass="identifier">min)[<spanclass="identifier">expression<spanclass="special">]</code></pre>+Example, ensure that a date is not less than 1900 例如，确保某个日期不小于 1900+<pre><code> <spanclass="identifier">min_limit_d(<spanclass="number">1900u)[<spanclass="identifier">uint_p<spanclass="special">]</code></pre>

 <h2>max_limit_d</h2>

Opposite of <tt>min_limit_d</tt>. Take note that <tt>limit_d[p]</tt> isequivalent

-  to:</p>

-<pre><code> <spanclass=identifier>min_limit_d(<spanclass=identifier>min)[<spanclass=identifier>max_limit_d(<spanclass=identifier>max)[<spanclass=identifier>p<spanclass=special>]]</code><code><spanclass=special></code></pre>+ to: 与 <tt>min_limit_d</tt> 相反。注意，<tt>limit_d[p]</tt> 相当于：+<pre><code> <spanclass="identifier">min_limit_d(<spanclass="identifier">min)[<spanclass="identifier">max_limit_d(<spanclass="identifier">max)[<spanclass="identifier">p<spanclass="special">]]</code><code><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 (c) 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>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/epsilon.html Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/epsilon.html Wed Sep 16 20:25:53 2009
@@ -1,56 +1,55 @@
-<html>
-<head>
-<title>Epsilon</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>Epsilon</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%"> Epsilon+ <td width="85%"> Epsilon 空串

     </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="rule.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="directives.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

The Epsilon (<tt>epsilon_p</tt> and <tt>eps_p</tt>) isa multi-purpose

-  parser that returns a zero length match. </p>
-<h3>Simple Form</h3>

+ parser that returns a zero length match. 空串(<tt>epsilon_p</tt> 和 <tt>eps_p</tt>) 是一个总是返回零长度匹配，有多种用途的分析器。

+<h3>Simple Form 简单形式</h3>

In its simplest form, epsilon_p matches the null string and alwaysreturns

-  a match of zero length:</p>

-<pre><code> <spanclass="identifier">epsilon_p // always returnsa zero-length match</code></pre>+ a match of zero length: 在最简单的形式下，epsilon_p 匹配空串并且永远返回一个零长度匹配。+<pre><code> <spanclass="identifier">epsilon_p // always returnsa zero-length match 总是返回一个零长度匹配</code></pre>This form is usually used to trigger a <ahref="semantic_actions.html">semanticaction</a> unconditionally. For example, it is useful in triggeringerror messages

-  when a set of alternatives fail:</p>

-<pre><code> <spanclass="identifier">r = <spanclass="identifier">A | <spanclass="identifier">B | <spanclass="identifier">C | <spanclass="identifier">eps_p[<spanclass="identifier">error];<spanclass="identifier"> // error if A, B, or Cfails to match</code></pre>

-<h3>Semantic Predicate</h3>

+ when a set of alternatives fail: 这种形式通常用于无条件触发一个<ahref="semantic_actions.html">语义动作</a>。比如，可用于在选择的某个集合失败的情况下触发错误信息：+<pre><code> <spanclass="identifier">r = <spanclass="identifier">A | <spanclass="identifier">B | <spanclass="identifier">C | <spanclass="identifier">eps_p[<spanclass="identifier">error];<spanclass="identifier"> // error if A, B, or Cfails to match 如果A,B或C不能匹配，则错误</code></pre>

+<h3>Semantic Predicate 语义断言</h3>

Semantic predicates allow you to attach a function anywhere in thegrammar.In this role, the epsilon takes a 0-ary (nullary) function/functor. Therun-timefunction/functor is typically a test that is called upon to resolveambiguityin the grammar. A parse failure will be reported when thefunction/functor resultevaluates to false. Otherwise an empty match will be reported. Thegeneral form

-  is:</p>

+ is: 语义断言使你能够在语法的任意点挂接某个函数。在这种情况下，空串使用一个零元（无参数）函数/函数对象。运行时的函数/函数对象通常是用于解决语法二义性的一个测试。如果函数/函数对象的结果推演为假，将报告一个分析失败，否则报告空匹配。通用的格式为：<pre> eps_p(f)>> rest;

 </pre>

The nullary function <tt>f</tt> is called to do a semantic test (say,checkingif a symbol is in the <a href="symbols.html">symbol table</a>). If testreturns<tt>true</tt>, <tt>rest</tt> will be evaluated. Otherwise, theproduction will

-  return early with a no-match without ever touching <tt>rest</tt>.</p>
-<h3>Syntactic Predicate</h3>

+ return early with a no-match without ever touching <tt>rest</tt>. 无参数函数 <tt>f</tt> 被调用，以进行语义测试（比如，检测一个符号是否在<ahref="symbols.html">符号表</a>中）。如果测试返回+ <tt>true</tt>，则 <tt>rest</tt> 将被执行。否则，产生式将不再接触<tt>rest</tt>，并且提前返回一个匹配失败。

+<h3>Syntactic Predicate 句意断言</h3>

Similar to Semantic predicates, Syntactic predicates assert a certainconditionalsyntax to be satisfied before evaluating another production. This time,epsilon_p

-  accepts a (conditional) parser. The general form is:</p>

+ accepts a (conditional) parser. The general form is: 类似于语义断言，句意断言断言了在推演其他产生式之前必须满足某个确定的条件句意。这次，epsilon_p 接受一个（条件）分析器。通用的格式是：<pre> eps_p(p)>> rest;

 </pre>

If <tt>p</tt> is matched on the input stream then attempt to recognize<tt>rest</tt>.

@@ -58,64 +57,64 @@

success, <tt>eps_p(p)</tt> will always return a zero length match (i.e.theinput is not consumed). If test returns <tt>true</tt>, <tt>rest</tt>will beevaluated. Otherwise, the production will return early with a no-matchwithout

-  ever touching <tt>rest</tt>.</p>
-<p>Example:</p>

-<pre><code> <spanclass="identifier">eps_p(<spanclass="literal">'0') >> <spanclass="identifier">oct_p // note that '0' isactually a ch_p('0') </code></pre>+ ever touching <tt>rest</tt>. 如果输入流匹配 <tt>p</tt> ，则将进行 <tt>rest</tt> 的识别。分析器 <tt>p</tt> 用于作一个句意检查。无论<tt>p</tt> 的匹配是否成功，<tt>eps_p(p)</tt> 将总是返回零长匹配。（比如，没有消耗输入）。如果测试返回 <tt>true</tt>，则 <tt>rest</tt> 将被推演。否则，产生式将不再接触 <tt>rest</tt>，并且提前返回一个匹配失败。

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

+<pre><code> <spanclass="identifier">eps_p(<spanclass="literal">'0') >> <spanclass="identifier">oct_p // note that '0' isactually a ch_p('0') 注意，'0'实际上就是</code><code><spanclass="comment">ch_p('0')</code><code><spanclass="comment"> </code></pre>Epsilon here is used as a syntactic predicate. <tt>oct_p</tt> (see <ahref="numerics.html">numerics</a>)is parsed only if we see a leading <tt>'0'</tt>. Wrapping the leading<tt>'0'</tt>inside an epsilon makes the parser not consume anything from the input.If a<tt>'0'</tt> is seen, <tt>epsilon_p</tt> reports a successful match withzero

-  length. </p>
-<table width="80%" border="0" align="center">
-  <tr>

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

-        <b>Primitive arguments</b> <br>

+ length. 空串在这里被作为句意断言使用。<tt>oct_p</tt>(查看<ahref="numerics.html">数值</a>)只在有看到有先导的<tt>'0'</tt>时才会产生分析。将先导的<tt>'0'</tt>封装在空串中使得分析器不会消耗任何输入。如果发现一个<tt>'0'</tt>，<tt>epsilon_p</tt> 将报告一个零长度的成功匹配。

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

+ <td class="note_box"><div align="justify"><img src="theme/note.gif"height="16" width="16">

+        <b>Primitive arguments</b> 内置参数<br>
         <br>

Epsilon allows primitive type arguments such as <tt>char</tt>,<tt>int</tt>,<tt>wchar_t</tt>, <tt>char const<spanclass="operators">*</tt>,<tt>wchar_t const*</tt> and so on.Examples:

-        <tt><br>
-        <br>

- </tt><code>eps_p<tt><spanclass=special>("hello"<spanclass=special>)- // same as eps_p(str_p("hello"))</tt><spanclass=identifier> - eps_p(<spanclass=literal>'x')- // same aseps_p(ch_p('x'))</code></div></td>

+        <br>空串允许使用语言的内置类型诸如 <tt>char</tt>, <tt>int</tt>,

+ <tt>wchar_t</tt>, <tt>char const<spanclass="operators">*</tt>,+ <tt>wchar_t const*</tt> 等等作为参数。例子：<tt> </tt><tt> + </tt><code>eps_p<tt><spanclass="special">("hello"<spanclass="special">)+ // same as eps_p(str_p("hello"))</tt><spanclass="identifier"> + eps_p(<spanclass="literal">'x')+ // same aseps_p(ch_p('x'))</code></div></td>

   </tr>
-</table>

-<h3><img src="theme/alert.gif" width="16" height="16"> Inhibiting SemanticActions</h3>

+</tbody></table>

+<h3><img src="theme/alert.gif" height="16" width="16"> Inhibiting SemanticActions 受限制的语义动作</h3>In a syntactic predicate <tt>eps_p(p)</tt>, any semantic actiondirectly orindirectly attached to the conditional parser <tt>p</tt> will not becalled.However, semantic actions attached to epsilon itself will always becalled.

-  The following code snippets illustrates the behavior:</p>

+ The following code snippets illustrates the behavior: 在一个句意断言<tt>eps_p(p)</tt> 中，任何直接或间接地挂接于条件分析器 <tt>p</tt> 都将不被调用。然而，挂接到空集自身的语义动作却总是被调用。下面的代码片断描绘了这一特征：<pre> eps_p(c<spanclass="special">[f]) <spanclass="comment">// f not called eps_p<spanclass="special">(c)[f<spanclass="special">] // f iscalled eps_p[f<spanclass="special">] // f iscalled</pre>Actually, the conditional parser <tt>p</tt> is implicitly wrapped in a<tt><a href="scanner.html#no_actions_scanner">no_actions_d</a></tt>

-  directive:</p>

-<pre><code> no_actions_d<spanclass="special">[p]</code></pre>+ directive: 实际上，条件分析器p隐式地被封装在一个 <ahref="http://www.boost.org/libs/spirit/doc/scanner.html#no_actions_scanner";><tt><ahref="scanner.html#no_actions_scanner">no_actions_d</a></tt></a> 定向器中：+<pre><code> no_actions_d<spanclass="special">[p]</code></pre>The conditional parser is required to be free from side-effects(semantic actions).<code></code>The conditional parser's purpose is to resolve ambiguity bylookingahead in the input stream for a certain pattern. Ambiguity and semanticactionsdo not mix well. On an ambiguous grammar, backtracking happens. And whenit

-  happens, we cannot undo the effects of triggered semantic actions. </p>
-<h3>Negation</h3>

+ happens, we cannot undo the effects of triggered semantic actions. 作为条件的分析器被要求不带有副作用（语义动作）。条件分析器的目的是通过在输入中超前寻找特定的模式来消除二义性。二义性和语义动作不能很好地混合。在一个有二义性的语法中，会发生回溯。当回溯发生时，是无法将已经触发的语义动作也回溯的。

+<h3>Negation 取反</h3>

Operator <tt>~</tt> is defined for parsers constructed by<tt>epsilon_p</tt>/<tt>eps_p</tt>.It performs negation by complementing the results reported.<tt>~~eps_p(x)</tt>

-  is identical to <tt>eps_p(x)</tt>.</p>

+ is identical to <tt>eps_p(x)</tt>. 由<tt>epsilon_p</tt>/<tt>eps_p</tt> 构建的分析器定义有操作符 <tt>~</tt>。它通过对报告的结果求补来求反。<tt>~~eps_p(x)</tt> 与 <tt>eps_p(x)</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>
-  Copyright &copy; 2003 Martin Wille<br>
+<p class="copyright">Copyright (c) 1998-2003 Joel de Guzman<br>
+  Copyright (c) 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>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/grammar.html Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/grammar.html Wed Sep 16 20:25:53 2009
@@ -1,128 +1,90 @@
-<html>
-<head>
-<title>The Grammar</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 Grammar</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%">

- TheGrammar+ TheGrammar 语法

     </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="scanner.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="subrules.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

The grammar encapsulates a set of rules. The <tt>grammar</tt>classis a protocol base class. It is essentially an interface contract. The<tt>grammar</tt>is a template class that is parameterized by its derived class,<tt>DerivedT</tt>,and its context, <tt>ContextT</tt>. The template parameter ContextTdefaults

-  to <tt>parser_context</tt>, a predefined context. </p>

+ to <tt>parser_context</tt>, a predefined context.<spanstyle="font-weight: bold;"> 语法是一个语义集合的封装。<tt>grammar</tt> 类是一个协议基类。本质上是一个接口约定。<tt>grammar</tt> 是一个以它的派生类 <tt>DerivedT</tt> 以及语境 <tt>ContextT</tt> 为模板参数的模板类。模板参数ContextT的默认值为 <tt>parser_context</tt>，一个预定义的语境类。 You need not be concerned at all with the ContextT template parameterunlessyou wish to tweak the low level behavior of the grammar. Detailedinformationon the ContextT template parameter is provided <ahref="indepth_the_parser_context.html">elsewhere</a>.The <tt>grammar</tt> relies on the template parameter DerivedT, agrammar subclass

-  to define the actual rules.</p>

+ to define the actual rules. 你完全不用关心ContextT这个模板参数，除非你想调整语法的底层的行为。关于ContextT模板参数的详细信息在<ahref="indepth_the_parser_context.html">其他地方</a>提供。<tt>grammar</tt> 依赖于模板参数DerivedT，它是定义实际规则的语法子类。Presented below is the public API. There may actually be more templateparametersafter <tt>ContextT</tt>. Everything after the <tt>ContextT</tt>parameter should- not be of concern to the client and are strictly for internal useonly.-<pre><code> <spanclass=keyword>template<- typename <spanclass=identifier>DerivedT,- typename <spanclass=identifier>ContextT = <spanclass=identifier>parser_context<<spanclass=special>> >- struct <spanclass=identifier>grammar<spanclass=special>;</code></pre>

-<h2>Grammar definition</h2>

+ not be of concern to the client and are strictly for internal useonly. 下面就是公开的API。实际上在 <tt>ContextT</tt> 后面可能有更多的模板参数。在 <tt>ContextT</tt> 后面的所有东西都不应该被用户所考虑，并且被严格限定于只在内部使用。+<pre><code> <spanclass="keyword">template< typename <spanclass="identifier">DerivedT, typename <spanclass="identifier">ContextT = <spanclass="identifier">parser_context<spanclass="special"><> > struct <spanclass="identifier">grammar<spanclass="special">;</code></pre>

+<h2>Grammar definition 语法定义</h2>

A concrete sub-class inheriting from <tt>grammar</tt> is expected tohave a

-  nested template class (or struct) named <tt>definition</tt>:</p>

+ nested template class (or struct) named <tt>definition</tt>: 一个派生自 <tt>grammar</tt> 的实际子类必须有一个名为 <tt>definition</tt> 的嵌套模板类/结构：

 <blockquote>

- <img src="theme/bullet.gif" width="13" height="13"> It is a nestedtemplate

-    class with a typename <tt>ScannerT</tt> parameter.<br>

- <img src="theme/bullet.gif" width="13" height="13"> Its constructordefines

-    the grammar rules.<br>

- <img src="theme/bullet.gif" width="13" height="13"> Its constructor ispassed

-    in a reference to the actual grammar <tt>self</tt>.<br>

- <img src="theme/bullet.gif" width="13" height="13"> It has a memberfunction- named <tt>start</tt> that returns a reference to the start<tt>rule</tt>.+ <img src="theme/bullet.gif" height="13" width="13"> It is a nestedtemplate+ class with a typename <tt>ScannerT</tt> parameter. 它是一个带有typename <tt>ScannerT</tt> 参数的嵌套模板类。 <imgsrc="theme/bullet.gif" height="13" width="13"> Its constructor defines

+    the grammar rules.<br>它的构造函数定义了语法规则。<br>

+ <img src="theme/bullet.gif" height="13" width="13"> Its constructor ispassed+ in a reference to the actual grammar <tt>self</tt>. 它的构造函数被传入一个实际语法类的引用 <tt>self</tt>。 + <img src="theme/bullet.gif" height="13" width="13">It has a memberfunction+ named <tt>start</tt> that returns a reference to the start<tt>rule</tt>. 它有一个名为 <tt>start</tt> 的成员函数，返回起始<tt>rule</tt> 的引用。

 </blockquote>
-<h2>Grammar skeleton</h2>

-<pre><code> <spanclass=keyword>struct my_grammar <spanclass=special>: public <spanclass=identifier>grammar<<spanclass=identifier>my_grammar>

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

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

- rule<spanclass=special><ScannerT<spanclass=special>> r<spanclass=special>;- definition<spanclass=special>(my_grammar <spanclass=keyword>const& <spanclass=identifier>self) <spanclass=special>{ r <spanclass=special>= /*..define here..*/<spanclass=special>; }- rule<spanclass=special><ScannerT<spanclass=special>> const<spanclass=special>& start<spanclass=special>() const <spanclass=special>{ return <spanclass=identifier>r; }

-        </span><span class=special>};
-    </span><span class=special>};</span></font></code></pre>
+<h2>Grammar skeleton 语法骨架</h2>

+<pre><code> <spanclass="keyword">struct my_grammar: publicgrammar<spanclass="special"><my_grammar<spanclass="special">> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">r; definition<spanclass="special">(my_grammar <spanclass="keyword">const& <spanclass="identifier">self) <spanclass="special">{ r <spanclass="special">= /*..definehere..*/; <spanclass="special">} <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="keyword">const& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return r<spanclass="special">; } <spanclass="special">}; <spanclass="special">};</code></pre>Decoupling the scanner type from the rules that form a grammar allowsthe grammarto be used in different contexts possibly using different scanners. Wedo notcare what scanner we are dealing with. The user-defined<tt>my_grammar</tt>can be used with any type of scanner. Unlike the rule, thegrammar is- not tied to a specific scanner type. See <ahref="faq.html#scanner_business">"Scanner- Business"</a> to see why this is important and to gain furtherunderstanding

-  on this scanner-rule coupling problem.</p>
-<h2>Instantiating and using my_grammar</h2>
-<p>Our grammar above may be instantiated and put into action:</p>

-<pre><code> <spanclass=identifier>my_grammar g<spanclass=special>;

- if (<spanclass=identifier>parse(<spanclass=identifier>first, <spanclass=identifier>last, <spanclass=identifier>g, <spanclass=identifier>space_p).<spanclass=identifier>full)- cout <spanclass=special><< "parsingsucceeded\n";

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

- cout <spanclass=special><< "parsingfailed\n";</code></pre>+ not tied to a specific scanner type. See <ahref="faq.html#scanner_business">"Scanner+ Business"</a> to see why this is important and to gain furtherunderstanding+ on this scanner-rule coupling problem. 将扫描器类从构成语法的规则中解耦形成了一个可以在不同语境下使用不同扫描器的语法类。我们可以不关心使用的是什么扫描器。用户定义的 <tt>my_grammar</tt> 可以与<spanstyle="font-weight: bold;">任意类型的扫描器配合使用。与规则不同，语法并不与特定的扫描器绑定。阅读"<a href="faq.html#scanner_business">扫描器事务</a>"以理解为什么这种解耦是重要的，且获得对这个"扫描器----规则"问题的进一步理解。

+<h2>Instantiating and using my_grammar 实例化并使用 my_grammar</h2>

+Our grammar above may be instantiated and put into action: 我们前面的语法可以这么实例化并使用：+<pre><code> <spanclass="identifier">my_grammar g<spanclass="special">; if <spanclass="special">(parse<spanclass="special">(first<spanclass="special">, last<spanclass="special">, g<spanclass="special">, space_p<spanclass="special">).full<spanclass="special">) cout<< "parsingsucceeded\n"; <spanclass="keyword">else cout<< "parsingfailed\n";</code></pre><tt>my_grammar</tt> IS-A parser and can be used anywhere aparser is

-  expected, even referenced by another rule:</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>r = <spanclass=identifier>g >> <spanclass=identifier>str_p(<spanclass=string>"cool huh?"<spanclass=special>);</code></pre>

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

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

-      grammars<br>

+ expected, even referenced by anotherrule:<tt>my_grammar</tt> 是一个分析器且可以用在任意分析器适用的场合，甚至被另一个规则引用:+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">r = <spanclass="identifier">g >> <spanclass="identifier">str_p(<spanclass="string">"cool huh?"<spanclass="special">);</code></pre>

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

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

+      grammars 引用语法<br>
       </b><br>

Like the rule, the grammar is also held by reference when it isplaced inthe right hand side of an EBNF expression. It is the responsibilityof theclient to ensure that the referenced grammar stays in scope and doesnot

-      get destructed while it is being referenced. </td>

+ get destructed while it is being referenced. 与规则相类似，当语法被放在EBNF表达式的等号右边时，它也是被引用的。用户有责任保证语法在被引用的过程中始终处于作用域内，并且不被析构。 </td>

   </tr>
-</table>
-<h2><a name="full_grammar"></a>Full Grammar Example</h2>
+</tbody></table>
+<h2><a name="full_grammar"></a>Full Grammar Example 完事的语法例子</h2>

Recalling our original calculator example, here it is now rewrittenusing a

-  grammar:</p>

-<pre><code> <spanclass=keyword>struct calculator <spanclass=special>: public <spanclass=identifier>grammar<<spanclass=identifier>calculator>

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

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

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

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

- group <spanclass=special>= '(' <spanclass=special>>> expression>> <spanclass=literal>')';- factor <spanclass=special>= integer <spanclass=special>| group<spanclass=special>;- term <spanclass=special>= factor <spanclass=special>>> *((<spanclass=literal>'*' >> <spanclass=identifier>factor) <spanclass=special>| ('/'>> <spanclass=identifier>factor));- expression <spanclass=special>= term <spanclass=special>>> *((<spanclass=literal>'+' >> <spanclass=identifier>term) <spanclass=special>| ('-'>> <spanclass=identifier>term));

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

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

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

-<img src="theme/lens.gif" width="15" height="16"> A fully workingexample with

+  grammar:<br>回想一下我们最初的计算器例子，下面我们用语法来重写一次：</p>

+<pre><code> <spanclass="keyword">struct calculator: publicgrammar<spanclass="special"><calculator<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">group = <spanclass="literal">'(' >> <spanclass="identifier">expression >>')'<spanclass="special">; <spanclass="identifier">factor = <spanclass="identifier">integer | <spanclass="identifier">group; term =factor <spanclass="special">>> *((<spanclass="literal">'*' >> <spanclass="identifier">factor) <spanclass="special">| (<spanclass="literal">'/' >> <spanclass="identifier">factor<spanclass="special">)); <spanclass="identifier">expression = <spanclass="identifier">term >> <spanclass="special">*(('+' <spanclass="special">>> term<spanclass="special">) | <spanclass="special">('-' <spanclass="special">>> term<spanclass="special">)); <spanclass="special">} <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">expression, <spanclass="identifier">term, <spanclass="identifier">factor, <spanclass="identifier">group; rule<spanclass="special"><ScannerT<spanclass="special">> const<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return <spanclass="identifier">expression; <spanclass="special">} }; };</code></pre>+<img src="theme/lens.gif" height="16" width="15"> A fully workingexample with<a href="semantic_actions.html">semantic actions</a> can be <ahref="../example/fundamental/calc_plain.cpp">viewed

-  here</a>. This is part of the Spirit distribution. </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/lens.gif" width="15" height="16">self + here</a>. This is part of the Spirit distribution. 一个添加了<ahref="semantic_actions.html">语义动作</a>的可工作的完整例子可以在<ahref="../example/fundamental/calc_plain.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">self 

       <br>

You might notice that the definition of the grammar has aconstructor thataccepts a const reference to the outer grammar. In the exampleabove, notice

@@ -131,10 +93,12 @@

is very useful. The self argument is the definition's window to theoutsideworld. For example, the calculator class might have a reference tosomestate information that the definition can update while parsingproceeds

-      through <a href="semantic_actions.html">semantic actions</a>. </td>

+ through <a href="semantic_actions.html">semantic actions</a>. 你也许已经注意到了，语法的definition类有一个接受外部grammar常量引用的构造函数。在上面的例子中，注意 <tt>calculator::definition</tt> 接受一个<tt>calculator const&+ self</tt>。虽然上面的例子中并没有使用，但依然是十分有用的。self这个参数是definition与通往外界的窗口。例如，calculator类可+能会引用一些状态信息，而definition可以通过<ahref="semantic_actions.html">语义动作</a>更新这些信息。 </td>

   </tr>
-</table>
-<h2>Grammar Capsules</h2>
+</tbody></table>
+<h2>Grammar Capsules 语法封装</h2>

As a grammar becomes complicated, it is a good idea to group parts intologicalmodules. For instance, when writing a language, it might be wise to putexpressionsand statements into separate grammar capsules. The grammar takesadvantage of

@@ -142,100 +106,72 @@

makes it a perfect fit for the definition of grammars. Since the grammarisnothing more than a class declaration, we can conveniently publish it inheaderfiles. The idea is that once written and fully tested, a grammar can bereused

-  in many contexts. We now have the notion of grammar libraries.</p>
-<h2><a name="multithreading"></a>Reentrancy and multithreading</h2>

+ in many contexts. We now have the notion of grammar libraries. 随着语法变得复杂，把不同的部分封装到不同的逻辑模块中是个好主意。例如，在写一门语言时，把表达式和句子分开放到不同的语法封装中会是个明智的主+意。语法从C++的类封装中获得不少优点。由于grammar除了是类的声明以外什么也不是，我们可以舒服地把它放在头文件中。这样，一旦写完并且经过完成的测

+试，一个语法就可以在很多语境中重用。现在我们就有了语法库的概念。</p>

+<h2><a name="multithreading"></a>Reentrancy and multithreading 再入与多线程</h2>An instance of a grammar may be used in different places multiple timeswithoutany problem. The implementation is tuned to allow this at the expense ofsomeoverhead. However, we can save considerable cycles and bytes if we arecertainthat a grammar will only have a single instance. If this is desired,simplydefine <tt>BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE</tt> before includingany spirit

-  header files.</p>

-<pre><code><spanclass="preprocessor"> #define</code><spanclass="preprocessor"><code><tt>BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE</tt></code></pre>- On the other hand, if a grammar is intended to be used inmultithreaded code,+ header files. 一个语法的实例可以在不同的地方反复使用而不带来任何问题。它的实现被调整为在可以接受的效率损失下允许这种重用。然而，如果我们确信一个语法将只有一个对象，我们可以节省显著的时钟周期和字节。如果想这么做，只需在包含任何spirit头文件前定义 <tt>BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE。</tt>+<pre><code><spanclass="preprocessor"> #define</code><spanclass="preprocessor"><code><tt>BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE</tt></code></pre>On the other hand, if a grammar is intended to be used in multithreadedcode,we should then define <tt>BOOST_SPIRIT_THREADSAFE</tt> before includingany- spirit header files. In this case it will also be required to linkagainst <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads</a>+ spirit header files. In this case it will also be required to linkagainst <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads</a> 另一方面，如果一个语法是倾向于在多线程的代码中使用，我们就应该在包含任何spirit头文件前定义 <tt>BOOST_SPIRIT_THREADSAFE</tt>。在这种情况下，还需要链接 <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads</a><pre><spanclass="preprocessor"> #define <spanclass="preprocessor"><tt>BOOST_SPIRIT_THREADSAFE</tt></pre>

-<h2>Using more than one grammar start rule </h2>
+<h2>Using more than one grammar start rule 在语法中使用多重起始规则 </h2>

Sometimes it is desirable to have more than one visible entry point toa grammar(apart from the start rule). To allow additional start points, Spiritprovidesa helper template <tt>grammar_def</tt>, which may be used as a baseclass for- the <tt>definition</tt> subclass of your <tt>grammar</tt>. Here's anexample:-<pre><code> // this header has to be explicitlyincluded- #include <spanclass="string"><boost/spirit/utility/grammar_def.hpp>

- struct <spanclass=identifier>calculator2 : <spanclass=keyword>public grammar<spanclass=special><calculator2<spanclass=special>>

-    {
-</span>        <span class="keyword">enum</span>
-        {
-            expression = 0,
-            term = 1,
-            factor = 2,
-        };
-

- template<typenameScannerT>- struct <spanclass=identifier>definition- : <spanclass="keyword">publicgrammar_def<<spanclass=identifier>rule<<spanclass=identifier>ScannerT>, same<spanclass="special">, same>

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

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

-            {

- group <spanclass=special>= '(' <spanclass=special>>> expression>> <spanclass=literal>')';- factor <spanclass=special>= integer <spanclass=special>| group<spanclass=special>;- term <spanclass=special>= factor <spanclass=special>>> *(('*' <spanclass=special>>> factor<spanclass=special>) | ('/' <spanclass=special>>> factor<spanclass=special>));- expression <spanclass=special>= term <spanclass=special>>> *(('+' <spanclass=special>>> term<spanclass=special>) | ('-' <spanclass=special>>> term<spanclass=special>));

- this<spanclass="special">->start_parsers<spanclass="special">(expression, term<spanclass="special">, factor);

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

- rule<spanclass=special><ScannerT<spanclass=special>> expression<spanclass=special>, term<spanclass=special>, factor, group<spanclass=special>;

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

+ the <tt>definition</tt> subclass of your <tt>grammar</tt>. Here's anexample: 有时，我们希望一个语法有不止一个的可见的入口（不是起始规则）。为了允许附加的规则起点，Spirit提供了一个 <tt>grammar_def</tt> 模板，它可以用作你的 <tt>grammar</tt> 里 <tt>definition</tt> 的基类。以下是例子：+<pre><code> // this header has to be explicitlyincluded 必须显式包含该头文件+ #include <spanclass="string"><boost/spirit/utility/grammar_def.hpp> struct <spanclass="identifier">calculator2 : <spanclass="keyword">public grammar<spanclass="special"><calculator2<spanclass="special">> { <spanclass="keyword">enum { expression =0, term = 1, factor = 2, }; <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">: public<spanclass="identifier"> grammar_def<spanclass="special"><rule<spanclass="special"><ScannerT<spanclass="special">>, same, same<spanclass="special">>

+        <span class="special">{</span>

+ definition<spanclass="special">(calculator2 <spanclass="keyword">const& <spanclass="identifier">self) { group= '('>> <spanclass="identifier">expression >>')'<spanclass="special">; <spanclass="identifier">factor = <spanclass="identifier">integer | <spanclass="identifier">group; term =factor <spanclass="special">>> *(('*' <spanclass="special">>> factor<spanclass="special">) | ('/' <spanclass="special">>> factor<spanclass="special">)); <spanclass="identifier">expression = <spanclass="identifier">term >>*(('+' >>term) |('-' >>term));

+ this<spanclass="special">->start_parsers<spanclass="special">(expression, term<spanclass="special">, factor); }

+ rule<spanclass="special"><ScannerT<spanclass="special">> expression<spanclass="special">, term<spanclass="special">, factor, group<spanclass="special">; }; };</code></pre>The <tt>grammar_def</tt> template has to be instantiated with the typesof- all the rules you wish to make visible from outside the<tt>grammar</tt>:-<pre><code> <spanclass=identifier>grammar_def<<spanclass=identifier>rule<<spanclass=identifier>ScannerT>, same<spanclass="special">, same></code> </pre>+ all the rules you wish to make visible from outside the<tt>grammar</tt>: <tt>grammar_def</tt> 模板需要以你想使其在<tt>grammar</tt> 外部可见的全部规则类型来实例化：+<pre><code> <spanclass="identifier">grammar_def<<spanclass="identifier">rule<<spanclass="identifier">ScannerT>,same, same<spanclass="special">></code> </pre>The shorthand notation <tt>same</tt> is used to indicate that the sametypebe used as specified by the previous template parameter (e.g.<code><tt>rule<ScannerT></tt></code>).- Obviously, <tt>same</tt> may not be used as the first templateparameter. 

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

- <td class="note_box"> <img src="theme/bulb.gif" width="13"height="18"> grammar_def+ Obviously, <tt>same</tt> may not be used as the first templateparameter. <tt>same</tt> 这个简写用来表明，这个参数使用的类型与前面的模板参数（比如 <code><tt>rule<ScannerT></tt></code>）相同。很明显，<tt>same</tt> 不一定被用作第一个模板参数。 

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

+ <td class="note_box"> <img src="theme/bulb.gif" height="18"width="13"> grammar_def

       start types</strong><br>
       <br>

It may not be obvious, but it is interesting to note that aside fromrule<>s,any parser type may be specified (e.g. chlit<>,strlit<>, int_parser<>,

-      etc.).</td>

+ etc.). 可能并不明显，但是有趣的是，除了 rule<>，也可以指定任意分析器类型（比如chlit<>,strlit<>,int_parser<> 等等）。</td>

   </tr>
-</table>

-Using the grammar_def class, there is no need to provide a<tt>start()</tt>member

+</tbody></table>

+Using the grammar_def class, there is no need to provide a<tt>start()</tt> memberfunction anymore. Instead, you'll have to insert a call to the<tt>this->start_parsers()</tt>(which is a member function of the <tt>grammar_def</tt> template) todefine- the start symbols for your <tt>grammar</tt>. <img src="theme/note.gif"width="16" height="16">+ the start symbols for your <tt>grammar</tt>. <img src="theme/note.gif"height="16" width="16">Note that the number and the sequence of the rules used as theparameters tothe <tt>start_parsers()</tt> function should match the types specifiedin the

-  <tt>grammar_def</tt> template:</p>

+ <tt>grammar_def</tt> template: 使用 grammar_def 类后，就没有必要提供<tt>start()</tt> 成员函数了。取而代之的是，你要插入一个<tt>this->start_parsers()</tt>（这个是 <tt>grammar_def</tt> 的成员函数）的调用来指明你的 <tt>grammar</tt> 的起始规则。 <imgsrc="theme/note.gif" height="16" width="16">注意用于<tt>start_parsers()</tt> 函数的参数数量和顺序必须与 <tt>grammar_def</tt> 的模板参数的数量和类型相匹配：<pre><code> this<spanclass="special">->start_parsers<spanclass="special">(expression, term<spanclass="special">, factor);</code></pre>- The grammar entry point may be specified using the followingsyntax:-<pre><code> g<spanclass="special">.use_parser<spanclass="special"><N<spanclass=special>>() // Where g is yourgrammar and N is the Nth entry.</code></pre>+ The grammar entry point may be specified using the followingsyntax: 语法的入口点可以用下面的语法指定：+<pre><code>g.<spanclass="identifier">use_parser<<spanclass="identifier">N>() <spanclass="comment">// Where g is your grammar and N is the Nth entry. g是你的语法，而N是第N个入口。</code></pre>This sample shows how to use the <tt>term</tt> rule from the<tt>calculator2</tt>

-  grammar above:</p>

-<pre><code> calculator2g;

- if (<spanclass=identifier>parse(<spanclass=identifier>- first, <spanclass=identifier>last,- g<spanclass="special">.use_parser<spanclass="special"><<spanclass=identifier>calculator2::term<spanclass=special>>(),

-            space_p</span><span class=special>
-        ).</span><span class=identifier>full</span><span class=special>)
-    {

- cout <spanclass=special><< "parsingsucceeded\n";

-    }
-    </span><span class=keyword>else</span> <span class="special">{</span>

- cout <<"parsing failed\n";

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

+ grammar above: 这个例子示范了如何在以上的 <tt>calculator2</tt> 语法中使用 <tt>term</tt> 规则作为起始符：+<pre><code> calculator2g; if(<spanclass="identifier">parse(<spanclass="identifier">+ first, <spanclass="identifier">last, g.<spanclass="identifier">use_parser<<spanclass="identifier">calculator2::term<spanclass="special">>(),

+            space_p</span><span class="special">

+ ).full<spanclass="special">) { cout<< "parsingsucceeded\n"; } <spanclass="keyword">else {+ cout <spanclass="special"><< "parsingfailed\n"; }</code></pre>The template parameter for the <tt>use_parser<></tt> templatetype shouldbe the zero based index into the list of rules specified in the<tt>start_parsers()</tt>

-  function call. </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/note.gif" width="16" height="16"><tt>use_parser<0></tt> + function call. <tt>use_parser<></tt> 的模板参数必须是与<tt>start_parsers()</tt> 函数的参数列表相对应的从零开始的索引号。 

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

+ <td class="note_box"><img src="theme/note.gif" height="16" width="16"><tt>use_parser<0></tt> 

       <br>

Note, that using 0 (zero) as thetemplate parameterto <tt>use_parser</tt> is equivalent to using the start rule,exported by

@@ -244,28 +180,27 @@

above. So this notation may be used even for grammars exporting onerulethrough its <tt>start()</tt> function only. On the other hand,calling a<tt>grammar</tt> without the <tt>use_parser</tt> notation willexecute the- rule specified as the first parameter to the<tt>start_parsers()</tt> function.+ rule specified as the first parameter to the<tt>start_parsers()</tt> function. 注意，使用<spanclass="literal">0（零）作为 <tt>use_parser</tt> 的模板参数等价于使用起始规则，就是在上面第一个 <tt><ahref="grammar.html#full_grammar">calculator</a></tt> 里展示的，通过约定的<tt>start()</tt> 函数导出的规则。因此这种做法甚至可以用于只通过<tt>start()</tt> 函数输入一个规则的语法。而在另一方面，不通过<tt>use_parser</tt> 而直接调用一个 <tt>grammar</tt> 则等价与使用<tt>start_parsers()</tt> 里指定的第一个参数。

     </td>
   </tr>
-</table>

-The maximum number of usable start rules is limited by the preprocessorconstant:-<pre> <spanclass="identifier">BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT <spanclass="comment">// defaults to 3</pre>

+</tbody></table>

+The maximum number of usable start rules is limited by the preprocessorconstant: 起始规则的最大数目是被一个预处理器常量限制的：+<pre> <spanclass="identifier">BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT <spanclass="comment">// defaults to 3 默认为3</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>
-  Copyright &copy; 2003-2004 Hartmut Kaiser <br>
+<p class="copyright">Copyright (c) 1998-2003 Joel de Guzman<br>
+  Copyright (c) 2003-2004 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>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/indepth_the_parser.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/indepth_the_parser.html Wed Sep 1620:25:53 2009

@@ -1,101 +1,93 @@
-<html>
-<head>
-<title>In-depth: The 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>In-depth: The 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%">

- In-depth: The Parser+ In-depth: The Parser 深入：分析器

     </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="semantic_actions.html"><imgsrc="theme/l_arr.gif" border="0"></a></td><td width="30"><a href="indepth_the_scanner.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

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

What makes Spirit tick? Now on to some details... The parser class isthe mostfundamental entity in the framework. A parser accepts a scannercomprised ofa first-last iterator pair and returns a match object as its result. Theiteratorsdelimit the data currently being parsed. The match object evaluates totrueif the parse succeeds, in which case the input is advanced accordingly.Eachparser can represent a specific pattern or algorithm, or it can be amore complex

-  parser formed as a composition of other parsers.</p>
-<p>All parsers inherit from the base template class, parser:</p>
-<pre>

-template <<spanclass=keyword>typename DerivedT<spanclass=special>>

-</span><span class=keyword>struct </span><span class=identifier>parser
-</span><span class=special>{
-    </span><span class=comment>/*...*/
-

- DerivedT&derived();- DerivedT <spanclass=keyword>const& <spanclass=identifier>derived() <spanclass=keyword>const;

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

+ parser formed as a composition of other parsers. 是什么使得Spirit运行？现在来看些细节...... parser 类是框架中最基础的实体。分析器接受一个包含first-last 分析器对的扫描器并返回一个匹+配对象作为分析结果。迭代器界定了当前要分析的数据。如果分析成功则匹配对象为真，在这种情况下输入产生相应的步进。每个分析器都代表了特定的模式或者算

+法，或者可以作为一个更复杂的分析器的构成物。</p>

+All parsers inherit from the base template class, parser: 所有的分析器都派生自模板基类 parser：+<pre>template <spanclass="special"><typename <spanclass="identifier">DerivedT<spanclass="special">> struct <spanclass="identifier">parser { /*...*/ <spanclass="identifier">DerivedT& <spanclass="identifier">derived(); DerivedT <spanclass="keyword">const& <spanclass="identifier">derived() <spanclass="keyword">const; <spanclass="special">};</pre>This class is a protocol base class for all parsers. The parser classdoesnot really know how to parse anything but instead relies on the templateparameter- <tt>DerivedT</tt> to do the actual parsing. This technique is known asthe <a href="references.html#curious_recurring">"Curiously- Recurring Template Pattern"</a> in template meta-programmingcircles. This+ <tt>DerivedT</tt> to do the actual parsing. This technique is known asthe <a href="references.html#curious_recurring">"Curiously+ Recurring Template Pattern"</a> in template meta-programming circles.Thisinheritance strategy gives us the power of polymorphism without thevirtualfunction overhead. In essence this is a way to implement <ahref="references.html#generic_patterns">compile

-  time polymorphism</a>.</p>

+ time polymorphism</a>. 该类是针对所有分析器的协议基类。parser 类并不真正知道如何分析，而是依赖于它的模板参数+ <tt>DerivedT</tt> 来做真正的分析。这种技术在模板元编程圈子里被称为"<a href="references.html#curious_recurring">神奇递归模板模式（CRTP</a><ahref="references.html#curious_recurring">）</a>"。这种继承策略使我们拥有了多态的威力而不必承担虚函数的代价。本质上这是一个实现<ahref="references.html#generic_patterns">编译期多态</a>的方法。

 <h2> parser_category_t</h2>

 Each derived parser has a typedef <tt>parser_category_t</tt> thatdefinesits category. By default, if one is not specified, it will inherit fromthebase parser class which typedefs its parser_category_t as<tt>plain_parser_category</tt>.Some template classes are provided to distinguish different types ofparsers.The following categories are the most generic. More specific types mayinherit

-  from these.</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title">Parser categories</td>

+ from these. 每个派生的分析器都有一个名为定义其种类的typedef<tt>parser_category_t</tt>。默认情况下，如果没有指定分析器，则它将派生自一个将 parser_category_t typedef为 <tt>plain_parser_category</tt> 的 parser 类。我们提供了一些模板类以区分分析器的种类。以下分类是最粗泛的。更为具体的分类将派生自这些类。<tt></tt>

+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td colspan="2" class="table_title">Parser categories 分析器分类</td>
   </tr>
   <tr>
     <td class="table_cells" width="33%"><tt>plain_parser_category</tt></td>
-    <td class="table_cells" width="67%">Your plain vanilla parser</td>

+ <td class="table_cells" width="67%">Your plain vanilla parser 纯分析器</td>

   </tr>
   <tr>

<td class="table_cells"width="33%"><tt>binary_parser_category</tt></td><td class="table_cells" width="67%">A parser that has subject a and b(e.g.

-      alternative)</td>

+ alternative) 有a项和b项的分析器（比如选择分析器）</td>

   </tr>
   <tr>
     <td class="table_cells" width="33%"><tt>unary_parser_category</tt></td>

<td class="table_cells" width="67%">A parser that has single subject(e.g.

-      kleene star)</td>
+      kleene star)<br>只有单项的分析器（比如克林星）</td>
   </tr>
   <tr>

<td class="table_cells"width="33%"><tt>action_parser_category</tt></td>- <td class="table_cells" width="67%">A parser with an attached semanticaction</td>+ <td class="table_cells" width="67%">A parser with an attached semanticaction 挂接了语义动作的分析器</td>

   </tr>
-</table>

-<pre> structplain_parser_category <spanclass=special>{};- struct <spanclass=identifier>binary_parser_category :plain_parser_category <spanclass=special>{};- struct <spanclass=identifier>unary_parser_category :plain_parser_category <spanclass=special>{};- struct <spanclass=identifier>action_parser_category :unary_parser_category <spanclass=special>{};</pre>

+</tbody></table>

+<pre> structplain_parser_category <spanclass="special">{}; struct <spanclass="identifier">binary_parser_category <spanclass="special">: plain_parser_category{}; structunary_parser_category <spanclass="special">: plain_parser_category{}; structaction_parser_category <spanclass="special">: unary_parser_category{};</pre>

 <h2>embed_t</h2>

Each parser has a typedef <tt>embed_t</tt>. This typedef specifies howa parseris embedded in a composite. By default, if one is not specified, theparserwill be embedded by value. That is, a copy of the parser is placed as amembervariable of the composite. Most parsers are embedded by value. Incertain situationshowever, this is not desirable or possible. One particular example isthe <a href="rule.html">rule</a>.

-  The rule, unlike other parsers is embedded by reference.</p>
-<h2><a name="match"></a>The match</h2>

+ The rule, unlike other parsers is embedded by reference. 每个分析器都有一个typedef  <tt>embed_t</tt>。+这个typedef指定了分析器是如何被嵌入合成物的。默认情况下，如果某个分析器未指定的话，它将以值的方式内嵌。即，该分析器的一份拷贝将被作为该组+合的一个成员变量。多数分析器是以值的方式内嵌的。然而在特定的情况下，这可能不是我们想要的或者是不可能的。特定的例子就是 <a href="rule.html">规则</a>。规则与其他分析器不同，它是以引用的方式内嵌的。

+<h2><a name="match"></a>The match 匹配</h2>

The match holds the result of a parser. A match object evaluates totrue whena succesful match is found, otherwise false. The length of the match isthenumber of characters (or tokens) that is successfully matched. This canbe queriedthrough its <tt>length()</tt> member function. A negative value meansthat the

-  match is unsucessful. </p>

+ match is unsucessful. 匹配持有分析器的分析结果。一个 match 对象的值在产生成功匹配时为 true，否则为 false。匹配的长度即被成功匹配的字符（记号）的长度。这可以用成员函数 <tt>length()</tt> 获得。负数意味着匹配失败。 Each parser may have an associated attribute. This attribute is alsoreturnedback to the client on a successful parse through the match object. Wecan getthis attribute via the match's <tt>value()</tt> member function. Bewarned though

@@ -103,39 +95,31 @@

will result in an exception. The member function<tt>has_valid_attribute()</tt>can be queried to know if it is safe to get the match's attribute. Theattributemay be set anytime through the member function <tt>value(v)</tt>where<tt>v</tt>

-  is the new attribute value.<br>

+ is the new attribute value. 每个分析器都有一个相关联的属性。这个属性在成功分析后也会通过匹配对象返回给客户程序。我们可以通过匹配对象的<tt>value()</tt> 成员函数获得这个属性。注+意匹配的属性有可能无效，在这种情况下，试图取得这个属性将导致一个异常。<tt>has_valid_attribute()</tt> 成员函数可以用来探知是否可以安全+地取得匹配的属性。可以在任意时间通过 <tt>value(v)</tt>成员函数给匹配的属性设定新的属性值 <tt>v</tt>。 

   <br>
-  A match attribute is valid:</p>
+  A match attribute is valid:<br>一个匹配属性是有效的：</p>
 <ul>
-  <li> on a successful match</li>

- <li>when its value is set through the <tt>value(val)</tt> memberfunction</li>

+  <li> on a successful match<br>在成功匹配时</li>

+ <li>when its value is set through the <tt>value(val)</tt> memberfunction 当它的值通过 <tt>value(val)</tt> 成员函数设置时</li><li> if it is assigned or copied from a compatible match object (e.g.<tt>match<double></tt>from <tt>match<int></tt>) with a valid attribute. A match object<tt>A</tt>is compatible with another match object <tt>B</tt> if the attributetype of- <tt>A</tt> can be assigned from the attribute type of <tt></tt><tt>B</tt>

-    (i.e. <tt>a = b;</tt> must compile).</li>
+    <tt>A</tt> can be assigned from the attribute type of  <tt>B</tt>

+ (i.e. <tt>a = b;</tt> must compile). 如果它是一个兼容的带有有效属性的匹配对象(比如从 <tt>match<int></tt> 到<tt>match<double></tt> )的赋值或者拷贝时。一个匹配对象<tt>A</tt> 与另一个匹配对象 <tt>B</tt> 是兼容的如果<tt>A</tt> 的属性可以被从 <tt>B</tt> 的属性赋值（即 <tt>a =b;</tt> 必须能编译）。</li>

 </ul>
-<p>The match attribute is undefined:</p>
+<p>The match attribute is undefined:<br>匹配属性为未定义的：</p>
 <ul>
-  <li>on an unsuccessful match </li>
+  <li>on an unsuccessful match<br>在没有成功匹配时 </li>

<li>when an attempt to copy or assign from another match object with anincompatible- attribute type (e.g. <tt>match<std::string></tt> from<tt>match<int></tt>).</li>+ attribute type (e.g. <tt>match<std::string></tt> from<tt>match<int></tt>). 当试图从不兼容的另外的匹配对象拷贝或赋值匹配属性时（比如从 <tt>match<int></tt> 到<tt>match<std::string></tt> )。</li>

 </ul>
 <h3>The match class:</h3>

-<pre> template <spanclass=special><typename <spanclass=identifier>T>

-</span><span class=keyword>    class </span><span class=identifier>match
-</span><span class=keyword>    </span><span class=special>{
-</span><span class=keyword>    public</span><span class=special>:
-
-    </span><span class=keyword>    </span><span class=comment>/*...*/
-

- typedef T attr_t<spanclass="special">; - <spanclass="special"> operatorsafe_bool() <spanclass=keyword>const; // convertible to abool- int <spanclass=identifier>length() <spanclass=keyword>const;- bool has_valid_attribute<spanclass="special">() const<spanclass="special">;- void<spanclass=special> value<spanclass=special>(T <spanclass="keyword">const&) <spanclass=keyword>const;- T <spanclass=keyword>const& <spanclass=identifier>value();

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

+<pre> template <spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword"> class <spanclass="identifier">match <spanclass="special">{ public<spanclass="special">: <spanclass="comment">/*...*/ typedef Tattr_t; + <spanclass="special"> operatorsafe_bool() <spanclass="keyword">const; // convertible to abool+ int <spanclass="identifier">length() <spanclass="keyword">const; <spanclass="keyword">bool has_valid_attribute<spanclass="special">() const<spanclass="special">;+ <spanclass="identifier">void <spanclass="identifier">value(<spanclass="identifier">T const<spanclass="special">&) const; T <spanclass="keyword">const& <spanclass="identifier">value(); <spanclass="keyword"> };</pre>

 <h2>match_result</h2>

It has been mentioned repeatedly that the parser returns a match objectasits result. This is a simplification. Actually, for the sake ofgenericity,

@@ -143,19 +127,22 @@

a parser returns an object that adheres to a conceptual interface, ofwhichthe match is an example. Nevertheless, we shall call the result type ofa parsera match object regardless if it is actually a match class, a derivativeor a

-  totally unrelated type.</p>
-<table width="80%" border="0" align="center">
-  <tr>

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

+  totally unrelated type.<br>前

+面反复提到过分析器返回一个 match 对象作为结果。这只是简略的说法。事实上，为了通用性，并不要求分析器一定要返回 match

+对象。更准确的说，分析器返回的是与某个概念接口一致的对象，而 match

+只是一个例子。不过，不管实际类型是什么，我们都把分析器的结果的类型称为match 对象。

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

+ <td class="note_box"><img src="theme/lens.gif" height="16" width="15">Meta-functions 元函数 

       <br>

What are meta-functions? We all know how functions look like. Insimplestterms, a function accepts some arguments and returns a result. Hereis the

-      function we all love so much:<br>

+ function we all love so much: 什么是元函数？我们都知道函数长什么样。用最简单的话说，一个函数接受某些参数并返回一个结果。这里是我们可爱的函数： 

       <br>

<code>int identity_func<spanclass="special">(int

       arg<span class="special">)</span><br>

{ returnarg;

-      }</span> <span class="comment">// return the argument arg</span><br>

+ } // return the argument arg 返回参数arg 

       </code><br>

Meta-functions are essentially the same. These beasts also acceptargumentsand return a result. However, while functions work at runtime onvalues,

@@ -163,125 +150,90 @@

deal only with types). The meta-function is a template class (orstruct).The template parameters are the arguments to the meta-function and atypedefwithin the class is the meta-function's return type. Here is thecorresponding

-      meta-function:<code><br>

+ meta-function: 元函数本质上是一样的。这些东西同样接受参数并返回结果。然而，函数在运行时针对值工作，而元函数在+编译期针对类工作（或者常数，但我们应该只和类型打交道）。元函数是一个模板类（或者结构）。模板参数即为元函数的参数而模板类内的一个typdef则为元函

+数的返回类型。这里是对应的元函数：</font><code></code><code><br>
       <br>

template <spanclass="special"><typename

       ArgT<span class="special">&gt;</span><br>
       <span class="keyword">struct</span> identity_meta_func<br>

{ typedefArgTtype; } // returnthe

-      argument ArgT</span><br>
+      argument ArgT 返回参数ArgT</span><br>
       <br>
-      </code>The meta-function above is invoked as:<br>

+ </code>The meta-function above is invoked as: 以上元函数被调用如下： 

       <br>

<code>typename identity_meta_func<spanclass="special"><ArgT<spanclass="special">>::type</code> 

       <br>

By convention, meta-functions return the result through the typedef<tt>type</tt>.- Take note that <tt>typename</tt> is only required withintemplates.</td>+ Take note that <tt>typename</tt> is only required withintemplates. 按照习惯，元函数通过typedef <tt>type</tt>返回结果。注意<tt>typename</tt> 只有在模板中才是必须的。</td>

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

The actual match type used by the parser depends on two types: theparser'sattribute type and the scanner type. <tt>match_result</tt> is themeta-function- that returns the desired match type given an attribute type and ascanner type.+ that returns the desired match type given an attribute type and ascanner type. 分析器所使用的实际的匹配类型取决于两个类型：分析器的属性类型和扫描器类型。<tt>match_result</tt> 是一个被给予一个属性类和扫描器类并返回所希望的匹配类型的元函数。

 </p>
-<p>Usage:</p>

-<pre> typename <spanclass=identifier>match_result<<spanclass=identifier>ScannerT, <spanclass=identifier>T>::<spanclass=identifier>type</pre>-The meta-function basically answers the question "given a scannertype

+<p>Usage:<br>用法：</p>

+<pre> typename <spanclass="identifier">match_result<spanclass="special"><ScannerT<spanclass="special">, T<spanclass="special">>::type</pre>

+<p>The meta-function basically answers the question "given a scanner type

<tt>ScannerT</tt> and an attribute type <tt>T</tt>, what is the desiredmatch- type?" [<img src="theme/note.gif" width="16" height="16"><tt>typename</tt>

-  is only required within templates ].</p>
-<h2>The parse member function</h2>

+ type?" [<img src="theme/note.gif" height="16" width="16"><tt>typename</tt>+ is only required within templates ]. 这个元函数基本上回答了"给定一个分析器类+ <tt>ScannerT</tt> 和一个属性类 <tt>T</tt>，所期望的匹配类型为何"这个问题。[<img src="theme/note.gif" height="16" width="16"><tt>typename</tt> 只在模板中才是必须的 ]。

+<h2>The parse member function 成员函数parse</h2>

Concrete sub-classes inheriting from parser must have a correspondingmember- function <tt>parse(...)</tt> compatible with the conceptualInterface: + function <tt>parse(...)</tt> compatible with the conceptualInterface: 从 parser 派生的具体子类必须相应地有与概念接口一致的<tt>parse(...)</tt> 成员函数：

 </p>

-<pre> template<typenameScannerT>

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

- parse<spanclass=special>(ScannerT<spanclass=special> const& scan<spanclass=identifier>) <spanclass=keyword>const;</pre>

-<p>where <tt>RT</tt> is the desired return type of the parser. </p>
-<h2>The parser result</h2>

+<h2>The parser result 分析器的结果</h2>

Concrete sub-classes inheriting from parser in most cases need to havea nestedmeta-function <tt>result</tt> that returns the result <tt>type</tt> ofthe parser's- parse member function, given a scanner type. The meta-function has theform:-<pre> template <spanclass=special><typename <spanclass=identifier>ScannerT>

-    </span><span class=keyword>struct </span><span class=identifier>result
-    </span><span class=special>{

- typedef RT <spanclass=identifier>type<spanclass=special>;

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

+ parse member function, given a scanner type. The meta-function has theform: 从 parse 派生的具体子类在大多数情况下需要一个嵌套的元函数<tt>result</tt>，给定一个分析器类，它将返回该分析器的 parse 成员函数的结果<tt>type</tt>。该元函数有如下形式：+<pre> template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">result { typedef RT <spanclass="identifier">type<spanclass="special">; };</pre>where <tt>RT</tt> is the desired return type of the parser. This isusually,but not always, dependent on the template parameter <tt>ScannerT</tt>.For example,- given an attribute type <tt>int</tt>, we can use the match_resultmetafunction:-<pre> template <spanclass=special><typename <spanclass=identifier>ScannerT>

-    </span><span class=keyword>struct </span><span class=identifier>result
-    </span><span class=special>{

- typedef typename <spanclass=identifier>match_result<<spanclass=identifier>ScannerT, <spanclass="keyword">int>::<spanclass=identifier>type type;

-    };</span></pre>

+ given an attribute type <tt>int</tt>, we can use the match_resultmetafunction: 其中 <tt>RT</tt> 是分析器要返回的类型。通常是这样的，但并非总是如此，这取决与模板参数 <tt>ScannerT</tt>。举例来说，给定属性类 <tt>int</tt>，我们可以如下使用match_result 元函数：+<pre> template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">result { typedef typename <spanclass="identifier">match_result<spanclass="special"><ScannerT<spanclass="special">, int<spanclass="special">>::type type<spanclass="special">; };</pre>If a parser does not supply a result metafunction, a default isprovided by- the base parser class. The default isdeclared as:-<pre> template <spanclass=special><typename <spanclass=identifier>ScannerT>

-    </span><span class=keyword>struct </span><span class=identifier>result
-    </span><span class=special>{

- typedef typename <spanclass=identifier>match_result<<spanclass=identifier>ScannerT, <spanclass="identifier">nil_t>::<spanclass=identifier>type type;

-    };</span></pre>

+ the base parser class. The default isdeclared as: 如果一个分析器没有提供 result 元函数，则由 parser 基类提供一个默认的。默认元函数声明如下：+<pre> template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">result { typedef typename <spanclass="identifier">match_result<spanclass="special"><ScannerT<spanclass="special">, nil_t<spanclass="special">>::type type<spanclass="special">; };</pre>Without a result metafunction, notice that the parser's defaultattribute is

-  <tt>nil_t</tt> (i.e. the parser has no attribute).</p>
-<h2><span class=special></span>parser_result</h2>

+ <tt>nil_t</tt> (i.e. the parser has no attribute).没有 result 元函数的话，分析器的默认属性为

+  <tt>nil_t</tt>（即该分析器没有属性）。</p>
+<h2><span class="special"></span>parser_result</h2>

Given a a scanner type <tt>ScannerT</tt> and a parser type<tt>ParserT</tt>,what will be the actual result of the parser? The answer to thisquestion is

-  provided to by the <tt>parser_result</tt> meta-function.</p>
-<p>Usage:</p>

-<pre> typename <spanclass=identifier>parser_result<<spanclass=identifier>ParserT, ScannerT<spanclass=special>>::type</pre>+ provided to by the <tt>parser_result</tt> meta-function. 给定一个扫描器类 <tt>ScannerT</tt> 和一个分析器类型 <tt>ParserT</tt>，分析器的真正结果类型为何？这个问题的答案有 <tt>parser_result</tt> 元函数提供。

+<p>Usage:<br>用法：</p>

+<pre> typename <spanclass="identifier">parser_result<spanclass="special"><ParserT,ScannerT>::<spanclass="identifier">type</pre>In general, the meta-function just forwards the invocation to theparser's

-  result meta-function:</p>

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

- typedef <spanclass=keyword>typename ParserT<spanclass=special>::template <spanclass=identifier>result<<spanclass=identifier>ScannerT>::<spanclass=identifier>type type<spanclass=special>;

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

+ result meta-function: 通常，这个元函数只是前转至对分析器的 result 元函数的调用：+<pre> template<typenameParserT,typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">parser_result <spanclass="special">{ typedeftypename <spanclass="identifier">ParserT::<spanclass="keyword">template result<spanclass="special"><ScannerT<spanclass="special">>::type <spanclass="identifier">type; <spanclass="special">};</pre>This is similar to a global function calling a member function. Most ofthe

-  time, the usage above is equivalent to:</p>

-<pre> typename <spanclass=identifier>ParserT::<spanclass=keyword>template result<spanclass=special><ScannerT<spanclass=special>>::type</pre>+ time, the usage above is equivalent to: 这类似于通过全局函数来调用成员函数。大多数时候，上面的使用等同于：+<pre> typename <spanclass="identifier">ParserT::<spanclass="keyword">template result<spanclass="special"><ScannerT<spanclass="special">>::type</pre>Yet, this should not be relied upon to be true all the time because theparser_result- metafunction might be specialized for specific parser and/or scannertypes.+ metafunction might be specialized for specific parser and/or scannertypes. 但是，并不是在所有的情况下都是如此，因为 parse_result 元函数有可能针对特定的分析器和/或扫描器类型而特化。The parser_result metafunction makes the signature of the requiredparse member

-  function almost canonical:</p>

-<pre> template<typenameScannerT>- typename <spanclass=identifier>parser_result<<spanclass=identifier>self_t, ScannerT<spanclass=special>>::type <spanclass=identifier>parse(<spanclass=identifier>ScannerT const<spanclass=special>& scan<spanclass=special>) const<spanclass=special>;</pre>-where <tt>self_t</tt> is a typedef to theparser.

-<h2>parser class declaration</h2>

-<pre> template<typenameDerivedT>

-    </span><span class=keyword>struct </span><span class=identifier>parser
-    </span><span class=special>{

- typedef <spanclass=identifier>DerivedT embed_t;- typedef <spanclass=identifier>DerivedT derived_t<spanclass=special>;- typedef <spanclass=identifier>plain_parser_category parser_category_t<spanclass=special>;

- template <spanclass=special><typenameScannerT>- struct <spanclass=identifier>result

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

- typedef typename <spanclass=identifier>match_result<<spanclass=identifier>ScannerT, <spanclass=identifier>nil_t>::<spanclass=identifier>type type;

-        };
-

- DerivedT<spanclass=special>& derived<spanclass=special>();- DerivedT <spanclass=keyword>const& <spanclass=identifier>derived() <spanclass=keyword>const;

- template <spanclass=special><typename <spanclass=identifier>ActionT>- action<spanclass=special><DerivedT<spanclass=special>, ActionT<spanclass=special>>- operator<spanclass=special>[](ActionT <spanclass=keyword>const& <spanclass=identifier>actor) <spanclass=keyword>const;

-    };</span></pre>

+ function almost canonical: parse_result 元函数使得其所需要的 parse 成员函数的签名总是规范的：+<pre> template<typenameScannerT<spanclass="special">> typenameparser_result<spanclass="special"><self_t,ScannerT>::<spanclass="identifier">type <spanclass="identifier">parse(<spanclass="identifier">ScannerT const<spanclass="special">& scan<spanclass="special">) const<spanclass="special">;</pre>+where <tt>self_t</tt> is a typedef to theparser. 其中 <tt>self_t</tt> 是对这个分析器的一个 typedef。

+<h2>parser class declaration &nbsp;parser类的声明</h2>

+<pre> template<typenameDerivedT<spanclass="special">> structparser <spanclass="special">{ typedefDerivedT embed_t<spanclass="special">; typedefDerivedTderived_t; <spanclass="keyword">typedef <spanclass="identifier">plain_parser_category parser_category_t<spanclass="special">; template<<spanclass="keyword">typename ScannerT<spanclass="special">> structresult <spanclass="special">{ typedeftypename match_result<spanclass="special"><ScannerT<spanclass="special">, nil_t<spanclass="special">>::type type<spanclass="special">; }; <spanclass="identifier">DerivedT& <spanclass="identifier">derived(); DerivedT <spanclass="keyword">const& <spanclass="identifier">derived() <spanclass="keyword">const; template <spanclass="special"><typename <spanclass="identifier">ActionT> action<spanclass="special"><DerivedT<spanclass="special">, ActionT<spanclass="special">> <spanclass="keyword">operator[](<spanclass="identifier">ActionT const<spanclass="special">& actor<spanclass="special">) const<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; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 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/indepth_the_parser_context.html Tue Mar31 01:07:16 2009+++ /trunk/libs/spirit/classic/doc/indepth_the_parser_context.html Wed Sep16 20:25:53 2009

@@ -1,107 +1,82 @@
-<html>
-<head>
-<title>In-depth: The Parser Context</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>In-depth: The Parser Context</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%"> In-depth:

-      The Parser Context</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%"> In-depth:

+      The Parser Context 深入：分析器语境</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" width="20" height="19"></a></td>
+    <img src="theme/u_arr.gif" border="0" height="19" width="20"></a></td>
     <td width="30"><a href="indepth_the_scanner.html">
-    <img src="theme/l_arr.gif" border="0" width="20" height="19"></a></td>
+    <img src="theme/l_arr.gif" border="0" height="19" width="20"></a></td>
     <td width="30"><a href="predefined_actors.html">
-    <img src="theme/r_arr.gif" border="0" width="20" height="19"></a></td>
+    <img src="theme/r_arr.gif" border="0" height="19" width="20"></a></td>
   </tr>
-</table>
-<h2>Overview</h2>
+</tbody></table>
+<h2>Overview 概览</h2>

The parser's context is yet another concept. An instance(object) ofthe <tt>context</tt> class is created before a non-terminal startsparsing andis destructed after parsing has concluded. A non-terminal is either a<tt>rule</tt>,a <tt>subrule</tt>, or a <tt>grammar</tt>. Non-terminals have a<tt>ContextT</tt> template parameter. The following pseudo code depictswhat's happening when

-    a non-terminal is invoked:</p>

-<pre><code> <spanclass=identifier>return_type- a_non_terminal<spanclass=special>::parse<spanclass=special>(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan)

-    {

- context_t ctx<spanclass=special>(/**/);- ctx<spanclass=special>.pre_parse<spanclass=special>(/**/);

- // main parse code of the non-terminalhere...

- return <spanclass=identifier>ctx.<spanclass=identifier>post_parse(/**/);

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

+ a non-terminal is invoked: 分析器的语境是另一个概念。<tt>context</tt> 类的一个实例在非终结符的分析开始前被构造并在分析结束后析构。非终结符是指 <tt>rule</tt>, <tt>subrule</tt> 或<tt>grammar</tt>。非终结符有一个 <tt>ContextT</tt> 模板参数。下面的伪代码说明了当非终结符被调用时所发生的事情：+<pre><code> <spanclass="identifier">return_type <spanclass="identifier">a_non_terminal<spanclass="special">::parse<spanclass="special">(ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) { context_t ctx<spanclass="special">(/**/); <spanclass="identifier">ctx.<spanclass="identifier">pre_parse<spanclass="special">(/**/); //main parse code of the non-terminal here... 非终结符的分析代码在此... return <spanclass="identifier">ctx.<spanclass="identifier">post_parse(/**/); }</code></pre>The context is provided for extensibility. Its main purpose is toexpose thestart and end of the non-terminal's parse member function to accommodateexternalhooks. We can extend the non-terminal in a multitude of ways by writingspecializedcontext classes, without modifying the class itself. For example, we canmakethe non-terminal emit debug diagnostics information by writing a contextclassthat prints out the current state of the scanner at each point in theparse

-  traversal where the non-terminal is invoked.</p>
-<p>Example of a parser context that prints out debug information:</p>

-<pre><code> pre_parse:<fontcolor="#000000"> non-terminal XXX is entered<fontcolor="#0000ff">. The current state of the input- is "hello world, this isa test"

- post_parse: non-terminal XXX hasconcluded, the non-terminal matched <fontcolor="#616161">"hello world"<fontcolor="#0000ff">.- The current state of the input is <fontcolor="#616161">", this is atest"</code></pre>+ traversal where the non-terminal is invoked. 语境是为了可扩展性而被提供的。它的主要目的是将非终结符的 parse 成员函数的开始和终结暴露给外部的钩子函数。我们可以通过编写特定的语境类代+码来以多种方式扩展非终结符而不用修改类本身。例如我们可以通过编写一个使得扫描器在非终结符被激活时的分析周游中的每个节点上都输出扫描器的当前状态的语

+境类来使得非终结符产生调试诊断信息。</p>

+Example of a parser context that prints out debug information: 分析器语境打印调试信息的例子：+<pre><code> pre_parse:<fontcolor="#000000"> non-terminal XXX is entered<fontcolor="#0000ff">. The current state of theinput is "hello world, thisis a test"

+ post_parse: non-terminal XXX hasconcluded, the non-terminal matched <fontcolor="#616161">"hello world".+ The current state of the input is <fontcolor="#616161">", this is a test"</code></pre>Most of the time, the context will be invisible from the user's view.In general,clients of the framework need not deal directly nor even know aboutcontexts.Power users, however, might find some use of contexts. Thus, this ispart ofthe public API. Other parts of the framework in other layers above thecore

-  take advantage of the context to extend non-terminals. </p>
-<h2>Class declaration</h2>

+ take advantage of the context to extend non-terminals. 多数时候，从用户的角度来看语境是不可见的。大体而言，框架的客户不需要直接和语境打交道，甚至不需要了解。但有能力的用户，可能会找到语境的用处。因此，这是公共API的一部分。框架中核心之上其他层次的其他部分借助语境的优势以扩展非终结符。

+<h2>Class declaration 类的声明</h2>

The <tt>parser_context</tt> class is the default context class that thenon-terminal

-    uses. </p>

-<pre> <spanclass="identifier">template <<spanclass="keyword">typename AttrT <spanclass="special">= nil_t<spanclass="special">> struct <spanclass=identifier>parser_context

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

- typedef AttrT <spanclass=identifier>attr_t;- typedef <spanclass=identifier>implementation_defined base_t;- typedefparser_context_linker<spanclass="special"><parser_context<spanclass="special"><AttrT<spanclass="special">> > <spanclass="identifier">context_linker_t;

- template <spanclass=special><typename <spanclass=identifier>ParserT>- parser_context<spanclass=special>(ParserT <spanclass=keyword>const& <spanclass=identifier>p) {}

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

- pre_parse<spanclass=special>(ParserT <spanclass=keyword>const& <spanclass=identifier>p, <spanclass=identifier>ScannerT const<spanclass=special>& scan<spanclass=special>) {}

- template <spanclass=special><typename <spanclass=identifier>ResultT, <spanclass=keyword>typename ParserT<spanclass=special>, typename <spanclass=identifier>ScannerT>- ResultT<spanclass=special>&- post_parse<spanclass=special>(ResultT<spanclass=special>& hit<spanclass=special>, ParserT <spanclass=keyword>const& <spanclass=identifier>p, <spanclass=identifier>ScannerT const<spanclass=special>& scan<spanclass=special>)- { return <spanclass=identifier>hit; }

-    };</span></pre>

+ uses. <tt>parser_context</tt> 类是非终结符使用的默认语境类。 +<pre> <spanclass="identifier">template <<spanclass="keyword">typename AttrT <spanclass="special">= nil_t<spanclass="special">> structparser_context <spanclass="special"> { typedefAttrT attr_t<spanclass="special">; typedefimplementation_defined base_t<spanclass="special">; <spanclass="keyword">typedefparser_context_linker<spanclass="special"><parser_context<spanclass="special"><AttrT<spanclass="special">> > <spanclass="identifier">context_linker_t<spanclass="special">; template<typenameParserT<spanclass="special">> <spanclass="identifier">parser_context(<spanclass="identifier">ParserT const<spanclass="special">& p<spanclass="special">) {} template<typenameParserT,typename <spanclass="identifier">ScannerT> void <spanclass="identifier"> pre_parse(<spanclass="identifier">ParserT const<spanclass="special">& p<spanclass="special">, ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) {} template <spanclass="special"><typename <spanclass="identifier">ResultT, <spanclass="keyword">typename <spanclass="identifier">ParserT, <spanclass="keyword">typename <spanclass="identifier">ScannerT> ResultT<spanclass="special">& post_parse(<spanclass="identifier">ResultT& <spanclass="identifier">hit, <spanclass="identifier">ParserT const<spanclass="special">& p<spanclass="special">, ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) {return <spanclass="identifier">hit; } };</pre>The non-terminal's <tt>ContextT</tt> template parameter is a concept.The <tt>parser_context</tt>class above is the simplest model of this concept. The default<tt>parser_context</tt>'s<tt>pre_parse</tt> and <tt>post_parse</tt> member functions are simplyno-ops. Youcan think of the non-terminal's <tt>ContextT</tt> template parameter asthepolicy that governs how the non-terminal will behave before and afterparsing.The client can supply her own context policy by passing a user definedcontext

-  template parameter to a particular non-terminal.</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="8"> Parser Context Policies </td>

+ template parameter to a particular non-terminal. 非终结符的<tt>ContextT</tt> 模板参数是一个概念。上面的<tt>parser_context</tt> 类是这个概念的最简单的模型。默认的<tt>parser_context</tt> 的<tt>+ pre_parse</tt> 和 <tt>post_parse</tt> 函数只是简单的空函数。你可以把非终结符的 <tt>ContextT</tt> 模板参数视为管理非+终结符在分析前和分析后的行为的策略。用户可以通过把用户定义的语境模板参数传递给非终结符来提供自己的语境策略。

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

+ <td class="table_title" colspan="8"> Parser Context Policies 分析器语境策略 </td>

   </tr>
   <tr>
-  <tr>

- <td class="table_cells"><spanclass=identifier>attr_t</td>

+  </tr><tr>

+ <td class="table_cells"><spanclass="identifier">attr_t</td><td class="table_cells">typedef: the attribute type of thenon-terminal. See

-      the <a href="indepth_the_parser.html#match">match</a>.</td>

+ the <a href="indepth_the_parser.html#match">match</a>. typedef: 非终结符的属性类，见 <a href="indepth_the_parser.html#match">匹配</a>。</td>

   </tr>

- <td class="table_cells"><spanclass=identifier>base_t</td>+ <tr><td class="table_cells"><spanclass="identifier">base_t</td><td class="table_cells">typedef: the base class of the non-terminal. Thenon-terminal

-    inherits from this class.</td>

+ inherits from this class. typedef: 非终结符的基类。非终结符派生自该类。</td>

   </tr>
   <tr>

<td class="table_cells"><spanclass="identifier">context_linker_t</td>

@@ -109,25 +84,25 @@

for Spirit to plug in additional functionality into the non-terminalparsefunction or even bypass the given context. This should simply betypedefedto <tt>parser_context_linker<T></tt> where T is the type ofthe user

-      defined context class.</td>

+ defined context class. typedef: 这个类使得Spirit有能力把附加的功能加入非终结符的 parse 函数中，甚至可以绕开给定的语境。通常这是<tt>parser_context_linker<T></tt> 的 typedef，其中T是用户定义的语境类。</td>

   </tr>
-  <td class="table_cells"><strong>constructor</strong></td>
+  <tr><td class="table_cells"><strong>constructor</strong></td>

<td class="table_cells">Construct the context. The non-terminal ispassed as

-    an argument to the constructor.</td>

+ an argument to the constructor. 构造语境。构造函数参数为非终结符。</td>

   </tr>
   <tr>
     <td class="table_cells"><strong>pre_parse</strong></td>

<td class="table_cells">Do something prior to parsing. Thenon-terminal and

-      the current scanner are passed as arguments.</td>

+ the current scanner are passed as arguments. 先于分析的行为。函数参数为非终结符和当前的扫描器。</td>

   </tr>
   <tr>
     <td class="table_cells"><strong>post_parse</strong></td>

<td class="table_cells">Do something after parsing. This is calledregardlessof the parse result. A reference to the parser's result is passedin. Thecontext has the power to modify this. The non-terminal and thecurrent scanner

-      are also passed as arguments.</td>

+ are also passed as arguments. 分析之后的行为。无论分析结果如何，该函数都被调用。一个分析结果的引用将被传入函数。语境有能力修改这个引用。同样非终结符和当前扫描器也作为参数被传入。</td>

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

The <tt>base_t</tt> deserves further explanation. Here goes... Thecontextis strictly a stack based class. It is created before parsing anddestructed

   after the non-terminal's parse member function exits. Sometimes, we need
@@ -136,91 +111,78 @@

Since the non-terminal inherits from the context's <tt>base_t</tt>, thecontextitself, when created, gets access to this upon construction when thenon-terminalis passed as an argument to the constructor. Ditto on <tt>pre_parse</tt>and

-  <tt>post_parse</tt>.</p>

+ <tt>post_parse</tt>. 对 <tt>base_t</tt> 值得做更多的说明。这就开始......语境类是严格的基于栈的类。它在分析前构造并在离开非终结符的分析函数之后析构。有时，我们需要贯穿+非终结符整个声明周期的附加信息。由于非终结符派生自语境的<tt>base_t</tt>，因此语境本身，在构造中，当终结符作为构造函数参数传入时，可以接触到上层

+（base_t）的构造。这 <tt>pre_parse</tt> 和
+  <tt>post_parse</tt>e 同样成立。</p>

The non-terminal inherits from the context's <tt>base_t</tt> typedef.The solerequirement is that it is a class that is default constructible. Thecopy-constructionand assignment requirements depends on the host. If the host requiresit, sodoes the context's <tt>base_t</tt>. In general, it wouldn't hurt toprovide

-  these basic requirements.</p>
-<h2>Non-default Attribute Type </h2>

-Right out of the box, the <tt>parser_context</tt> class may beparamaterized with a type other than the default <tt>nil_t</tt>. Thefollowing code demonstrates the usage of the <tt>parser_context</tt>template with an explicit argument to declare rules with match resultsdifferent from <tt>nil_t</tt>:-<pre> rule<spanclass=special><parser_context<spanclass=special><int<spanclass=special>> > <spanclass=identifier>int_rule = <spanclass=identifier>int_p;

-
-    </span><span class=identifier>parse</span><span class=special>(

- "123"<spanclass=special>,- // Using a returned value in thesemantic action- int_rule<spanclass=special>[cout <spanclass=special><< arg1 <spanclass=special><< endl<spanclass=special>]

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

-In this example, <tt>int_rule</tt> is declared with <tt>int</tt>attribute type. Hence, the <tt>int_rule</tt> variable can hold any parserwhich returns an <tt>int</tt> value (for example <tt>int_p</tt> or<tt>bin_p</tt>). The important thing to note is that we can use thereturned value in the semantic action bound to the <tt>int_rule</tt>. -<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/parser_context.cpp">parser_context.cpp</a> inthe examples. This is part of the Spirit distribution.

-<h2>An Example </h2>

-As an example let's have a look at the Spirit parser context, whichinserts some debug output to the parsing process:-<pre> template<<spanclass="keyword">typename ContextT>- struct parser_context_linker : <spanclass="keyword">public ContextT

-    <span class="special">{</span>
-        <span class="keyword">typedef</span> ContextT base_t;
-

- template <<spanclass="keyword">typename ParserT>

-        parser_context_linker(ParserT const&amp; p)
-        : ContextT(p) {}
-

- // This is called just before parsing of thisnon-terminal+ these basic requirements. 非终结符派生自语境的 <tt>base_t</tt> 这个 typedef。对此唯一的要求是这个类必须有默认的构造函数。构造函数和赋值号取决于应用环境。如果应用环境需要这些，那么语境的 <tt>base_t</tt> 也同样需要。大体而言，满足这些基本的要求并没有什么害处。

+<h2>Non-default Attribute Type 非默认属性类型 </h2>

+Right out of the box, the <tt>parser_context</tt> class may beparamaterized with a type other than the default <tt>nil_t</tt>. Thefollowing code demonstrates the usage of the <tt>parser_context</tt>template with an explicit argument to declare rules with match resultsdifferent from <tt>nil_t</tt>: 在使用中，<tt>parser_context</tt> 类可以使用默认的 <tt>nil_t</tt> 以外的类作为模板参数。下面的代码展示了<tt>parser_context</tt> 类显式地以与 <tt>nil_t</tt> 不同的类为模板参数：+<pre> <spanclass="identifier">rule<<spanclass="identifier">parser_context<spanclass="special"><int<spanclass="special">> > <spanclass="identifier">int_rule = <spanclass="identifier">int_p; parse<spanclass="special">( "123"<spanclass="special">, // Using areturned value in the semantic action 在语义动作使用返回值 int_rule<spanclass="special">[cout <spanclass="special"><< arg1 <spanclass="special"><< endl<spanclass="special">] ); </pre>+In this example, <tt>int_rule</tt> is declared with <tt>int</tt>attribute type. Hence, the <tt>int_rule</tt> variable can hold any parserwhich returns an <tt>int</tt> value (for example <tt>int_p</tt> or<tt>bin_p</tt>). The important thing to note is that we can use thereturned value in the semantic action bound to the <tt>int_rule</tt>. 在这个例子中，<tt>int_rule</tt> 声明的属性类为 <tt>int</tt>。因此，<tt>int_rule</tt> 变量可以持有任意可以返回 <tt>int</tt> 的分析器（比如 <tt>int_p</tt> 或 <tt>bin_p</tt>）。要注意的重点是我们可以在绑定到<tt>int_rule</tt> 上的语义动作中使用这些返回值。+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/parser_context.cpp">parser_context.cpp</a> inthe examples. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 例子见 <ahref="../example/fundamental/parser_context.cpp">parser_context.cpp</a>。这是Spirit发行包的一部分。

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

+As an example let's have a look at the Spirit parser context, whichinserts some debug output to the parsing process: 我们以一个例子来说明Spirit的分析器语境，即在分析过程中插入一些调试输出：+<pre> template<<spanclass="keyword">typename ContextT> <spanclass="keyword">struct parser_context_linker : <spanclass="keyword">public ContextT {+ typedef ContextTbase_t; template <<spanclass="keyword">typename ParserT> parser_context_linker(ParserT const& p) : ContextT(p){} // This is called just beforeparsing of this non-terminal 在分析非终结符前被调用template <spanclass="special"><typenameParserT, typenameScannerT>void pre_parse<spanclass="special">(ParserT const<spanclass="special">& p, ScannerT <spanclass="special">&scan)

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

- // call the pre_parse function of the baseclass+ // call the pre_parse function of the baseclass 调用基类的pre_parse函数this<spanclass="special">->base_t<spanclass="special">::pre_parse(p<spanclass="special">, scan);

 <span class="preprocessor">

#if BOOST_SPIRIT_DEBUG_FLAGS <spanclass="special">& <spanclass="identifier">BOOST_SPIRIT_DEBUG_FLAGS_NODESif <spanclass="special">(trace_parser(p<spanclass="special">.derived())) {

-            <span class="comment">// print out pre parse info</span>

+ // print out pre parse info 打印出preparse信息impl::print_node_info<spanclass="special">(false<spanclass="special">, scan.get_level(),false,parser_name(p.derived<spanclass="special">()),scan.first<spanclass="special">, scan.last);

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

- scan.get_level()++; <spanclass="comment">// increase nesting level

-<span class="preprocessor">#endif</span>
-        <span class="special">}</span>

- // This is called just after parsing of thecurrent non-terminal+ scan.get_level()++; <spanclass="comment">// increase nesting level 增加缩入级别+#endif <spanclass="special">}+ // This is called just after parsing of thecurrent non-terminal 在分析当前非终结符后被调用template <spanclass="special"><typenameResultT, typenameParserT, typenameScannerT>ResultT& post_parse<spanclass="special">(- ResultT& hit<spanclass="special">, ParserT const<spanclass="special">& p, ScannerT<spanclass="special">& scan)

-        {</span>

+ ResultT& hit<spanclass="special">, ParserT const<spanclass="special">& p, ScannerT<spanclass="special">& scan) {

 <span class="preprocessor">

#if BOOST_SPIRIT_DEBUG_FLAGS <spanclass="special">& <spanclass="identifier">BOOST_SPIRIT_DEBUG_FLAGS_NODES- --scan.get_level<spanclass="special">(); // decrease nestinglevel+ --scan.get_level<spanclass="special">(); // decrease nesting level递减缩入级别if <spanclass="special">(trace_parser(p<spanclass="special">.derived())) {impl::print_node_info<spanclass="special">(hit, scan<spanclass="special">.get_level(), <spanclass="keyword">true,parser_name(p<spanclass="special">.derived()),- scan.first<spanclass="special">, scan.last<spanclass="special">);

-            }</span>

+ scan.first<spanclass="special">, scan.last<spanclass="special">); }

 <span class="preprocessor">#endif</span>

- // call the post_parse function of the baseclass- return <spanclass="keyword">this->base_t<spanclass="special">::post_parse(hit<spanclass="special">, p, scan<spanclass="special">);

-        }
-    };</span>

+ // call the post_parse function of the baseclass 调用基类的post_parse函数+ return <spanclass="keyword">this->base_t<spanclass="special">::post_parse(hit<spanclass="special">, p, scan<spanclass="special">); } };

 </pre>

-During debugging (<tt>BOOST_SPIRIT_DEBUG</tt> is defined) this parsercontext is injected into the derivation hierarchy of the current<tt>parser_context</tt>, which was originally specified to be used for aconcrete parser, so the template parameter <tt>ContextT</tt> represents theoriginal <tt>parser_context</tt>. For this reason the <tt>pre_parse</tt>and <tt>post_parse</tt> functions call it's counterparts from the baseclass. Additionally these functions call a special <tt>print_node_info</tt>function, which does the actual output of the parser state info of thecurrent non-terminal. For more info about the printed information, you maywant to have a look at the topic <a href="debugging.html">Debugging</a>.+During debugging (<tt>BOOST_SPIRIT_DEBUG</tt> is defined) this parsercontext is injected into the derivation hierarchy of the current<tt>parser_context</tt>, which was originally specified to be used for aconcrete parser, so the template parameter <tt>ContextT</tt> represents theoriginal <tt>parser_context</tt>. For this reason the <tt>pre_parse</tt>and <tt>post_parse</tt> functions call it's counterparts from the baseclass. Additionally these functions call a special <tt>print_node_info</tt>

+function, which does the actual output of the parser state info of the
+current non-terminal. For more info about the printed information, you

+may want to have a look at the topic <ahref="debugging.html">Debugging</a>. 在调试（即定义了<tt>BOOST_SPIRIT_DEBUG</tt>）中这个语境被注入到+当前的 <tt>parser_context</tt>（即原先用于普通的具体分析器的语境）的派生层次中，因此这个类的模板函数 <tt>ContextT</tt> 即原先的<tt>parser_context</tt>。因此 <tt>pre_parse</tt> 和<tt>post_parse</tt> 函数调用了基类中相应的函数。另外这些函数调用了一个特殊的  <tt>print_node_info</tt> 函数，用于输出当前非终结符的分析器状态信息。如果想了解更多的打印信息，可以查阅<a href="debugging.html">调试</a>这一主题。

 <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" width="20" height="19"></a></td>
+    <img src="theme/u_arr.gif" border="0" height="19" width="20"></a></td>
     <td width="30"><a href="indepth_the_scanner.html">
-    <img src="theme/l_arr.gif" border="0" width="20" height="19"></a></td>
+    <img src="theme/l_arr.gif" border="0" height="19" width="20"></a></td>
     <td width="30"><a href="predefined_actors.html">
-    <img src="theme/r_arr.gif" border="0" width="20" height="19"></a></td>
+    <img src="theme/r_arr.gif" border="0" height="19" width="20"></a></td>
   </tr>
-</table>
+</tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 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/indepth_the_scanner.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/indepth_the_scanner.html Wed Sep 1620:25:53 2009

@@ -1,290 +1,250 @@
-<html>
-<head>
-<title>In-depth The Scanner</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>In-depth The Scanner</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%"> In-depth:

-      The Scanner</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>

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

+<td width="85%"> In-depth:

+The Scanner 深入：扫描器</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="indepth_the_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td>- <td width="30"><a href="indepth_the_parser_context.html"><imgsrc="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="indepth_the_parser.html"><imgsrc="theme/l_arr.gif" border="0"></a></td>+<td width="30"><a href="indepth_the_parser_context.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

+</tr>
+</tbody>
 </table>
-<h2>Basic Scanner API </h2>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="10"> class scanner </td>
-  </tr>
-  <tr>
-  <tr>

- <td class="table_cells"><code><spanclass=identifier>value_t</code></td>- <td class="table_cells">typedef: The value type of the scanner'siterator</td>

-  </tr>

- <td class="table_cells"><code><spanclass=identifier>ref_t</code></td>- <td class="table_cells">typedef: The reference type of the scanner'siterator</td>

-  </tr>

- <td class="table_cells"><code>bool <spanclass=identifier>at_end()

-    </span><span class=keyword>const</span></code></td>
-  <td class="table_cells">Returns true if the input is exhausted</td>
-  </tr>

- <td class="table_cells"><code>value_toperator*()

-    </span><span class=keyword>const</span></code></td>

- <td class="table_cells">Dereference/get a <code><spanclass=identifier>value_t</code>

-      from the input</td>
-  </tr>

- <td class="table_cells"><code> <spanclass=identifier>scanner- const&operator<spanclass=special>++()</code></td>

-  <td class="table_cells">move the scanner forward</td>
-  </tr>
-  <tr>

- <td class="table_cells"><code>IteratorT&first</code></td>- <td class="table_cells">The iterator pointing to the current inputposition.

-      Held by reference</td>
-  </tr>
-  <tr>

- <td class="table_cells"><code>IteratorTconst- last<spanclass=special></code></td>- <td class="table_cells">The iterator pointing to the end of the input.Held

-      by value</td>
-  </tr>
+<h2>Basic Scanner API 基本的扫描器API </h2>
+<table align="center" border="0" width="90%">
+<tbody>
+<tr>
+<td class="table_title" colspan="10"> class
+scanner </td>
+</tr>
+<tr>
+</tr>
+<tr>

+<td class="table_cells"><code><spanclass="identifier">value_t</code></td>

+<td class="table_cells">typedef: The value type of
+the scanner's iterator
+<p>typedef,扫描器的迭代器的值类型</p>
+</td>
+</tr>
+<tr>

+<td class="table_cells"><code><spanclass="identifier">ref_t</code></td>

+<td class="table_cells">typedef: The reference type
+of the scanner's iterator
+<p>typedef,扫描器迭代器的引用类型</p>
+</td>
+</tr>
+<tr>

+<td class="table_cells"><code>bool <spanclass="identifier">at_end() <spanclass="keyword">const</code></td>

+<td class="table_cells">Returns true if the input is
+exhausted<br>
+如果输入耗尽则返回真</td>
+</tr>
+<tr>

+<td class="table_cells"><code>value_toperator*()

+</span><span class="keyword">const</span></code></td>

+<td class="table_cells">Dereference/get a <code><spanclass="identifier">value_t</code> from

+the input
+<p>从输入解引用/取得一个value_t</p>
+</td>
+</tr>
+<tr>

+<td class="table_cells"><code> <spanclass="identifier">scanner+const&operator<spanclass="special">++()</code></td>

+<td class="table_cells">move the scanner forward<br>
+使扫描器步进</td>
+</tr>
+<tr>

+<td class="table_cells"><code>IteratorT&first</code></td>

+<td class="table_cells">The iterator pointing to the
+current input position. Held by reference
+<p>指向当前位置的迭代器，以引用的方式保存。</p>
+</td>
+</tr>
+<tr>

+<td class="table_cells"><code>IteratorTconst <spanclass="identifier">last</code></td>

+<td class="table_cells">The iterator pointing to the
+end of the input. Held by value
+<p>指向输入终点的迭代器，以值的方式保存。</p>
+</td>
+</tr>
+</tbody>
 </table>

- The basic behavior of the scanner is handled by policies. The actualexecution- of the scanner's public member functions listed in the table above isimplemented

-  by the scanner policies.</p>

- Three sets of policies govern the behavior of the scanner. Thesepolicies- make it possible to extend Spirit non-intrusively. The scanner policiesallow- the core-functionality to be extended without requiring any potentiallydestabilizing- changes to the code. A library writer might provide her own policiesthat override

-  the ones that are already in place to fine tune the parsing process

- to fit her own needs. Layers above the core might also want to takeadvantage- of this policy based machanism. Abstract syntax tree generation,debuggers and

-  lexers come to mind.</p>
-<p> There are three sets of policies that govern:</p>
+<p> The basic behavior of the scanner is handled by policies. The
+actual execution of the scanner's public member functions listed in the
+table above is implemented by the scanner policies.<br>

+扫描器的基本行为是通过策略执行的。上表中列出的扫描器的公有成员函数的真正执行是由扫描器策略来实现的。

+<p> Three sets of policies govern the behavior of the scanner.
+These policies make it possible to extend Spirit non-intrusively. The
+scanner policies allow the core-functionality to be extended without
+requiring any potentially destabilizing changes to the code. A library
+writer might provide her own policies that override the ones that are
+already in place to fine tune the parsing process to fit her own needs.
+Layers above the core might also want to take advantage of this policy
+based machanism. Abstract syntax tree generation, debuggers and lexers
+come to mind.<br>

+有三类策略决定了扫描器的行为。这些策略使得非侵入性地扩展Spirit成为可能。扫描器的策略使得从根本上不必对原有代码进行修改就可以扩展其核心+功能。一个库的编写者可以用他自己编写的策略覆盖原有的策略来调整分析过程以适应自己的需要。核心之上的层次也有可能从基于策略的设计方式获得好处。抽象

+语法树的生成、调试器、词法分析器等等就是这种情况。</p>
+<p> There are three sets of policies that govern:<br>
+三类策略分别管理：</p>
 <ul>
-  <li>Iteration and filtering</li>
-  <li>Recognition and matching</li>
-  <li>Handling semantic actions</li>
+<li>Iteration and filtering<br>
+迭代与过滤</li>
+<li>Recognition and matching<br>
+识别与匹配</li>
+<li>Handling semantic actions<br>
+处理语义动作</li>
 </ul>
 <a name="iteration_policy"></a>
 <h2>iteration_policy</h2>
-<p> Here are the default policies that govern iteration and filtering:</p>
-<pre>

- <code>struct <spanclass=identifier>iteration_policy

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

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

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

- advance<spanclass=special>(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan) <spanclass=keyword>const- { <spanclass=special>++scan<spanclass=special>.first<spanclass=special>; }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- bool <spanclass=identifier>at_end(<spanclass=identifier>ScannerT const<spanclass=special>& scan<spanclass=special>) const- { returnscan.<spanclass=identifier>first == <spanclass=identifier>scan.<spanclass=identifier>last; <spanclass=special>}

- template <spanclass=special><typename <spanclass=identifier>T>- T <spanclass=identifier>filter(<spanclass=identifier>T ch<spanclass=special>) const- { returnch; <spanclass=special>}

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- typename <spanclass=identifier>ScannerT::<spanclass=identifier>ref_t- get<spanclass=special>(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan) <spanclass=keyword>const- { return*scan<spanclass=special>.first<spanclass=special>; }

-    </span><span class=special>};</span></code></pre>
-<table width="90%" border="0" align="center">
-  <tr>

- <td class="table_title" colspan="8"> Iteration and filtering policies</td>

-  </tr>
-  <tr>
-  <tr>
-    <td class="table_cells"><b>advance</b></td>
-    <td class="table_cells">Move the iterator forward</td>
-  </tr>
-  <td class="table_cells"><b>at_end</b></td>
-    <td class="table_cells">Return true if the input is exhausted</td>
-  </tr>
-  <td class="table_cells"><b>filter</b></td>
-    <td class="table_cells">Filter a character read from the input</td>
-  </tr>
-  <td class="table_cells"><b>get</b></td>
-    <td class="table_cells">Read a character from the input</td>
-  </tr>
+<p> Here are the default policies that govern iteration and
+filtering:<br>

+这是管理迭代和过滤的默认策略：<pre> <code><spanclass="keyword">struct <spanclass="identifier">iteration_policy <spanclass="special">{ template<typenameScannerT<spanclass="special">> <spanclass="keyword">void <spanclass="identifier">advance(<spanclass="identifier">ScannerT const<spanclass="special">& scan<spanclass="special">) const { ++<spanclass="identifier">scan.<spanclass="identifier">first; <spanclass="special">} template<typenameScannerT<spanclass="special">> boolat_end<spanclass="special">(ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) <spanclass="keyword">const {return <spanclass="identifier">scan.<spanclass="identifier">first == <spanclass="identifier">scan.<spanclass="identifier">last; <spanclass="special">} template<typenameT<spanclass="special">> Tfilter<spanclass="special">(T <spanclass="identifier">ch) <spanclass="keyword">const {return <spanclass="identifier">ch; <spanclass="special">} template<typenameScannerT<spanclass="special">> typenameScannerT<spanclass="special">::ref_t get<spanclass="special">(ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) <spanclass="keyword">const {return <spanclass="special">*scan<spanclass="special">.first<spanclass="special">; } <spanclass="special">};</code></pre><table align="center" border="0"width="90%">

+<tbody>
+<tr>
+<td class="table_title" colspan="8">
+Iteration and filtering policies 迭代与过滤策略 </td>
+</tr>
+<tr>
+</tr>
+<tr>
+<td class="table_cells"><b>advance</b></td>
+<td class="table_cells">Move the iterator forward<br>
+步进迭代器</td>
+</tr>
+<tr>
+<td class="table_cells"><b>at_end</b></td>
+<td class="table_cells">Return true if the input is
+exhausted<br>
+如果输入耗尽则返回真</td>
+</tr>
+<tr>
+<td class="table_cells"><b>filter</b></td>
+<td class="table_cells">Filter a character read from
+the input<br>
+过滤从输入中读入的一个字符
+</td>
+</tr>
+<tr>
+<td class="table_cells"><b>get</b></td>
+<td class="table_cells">Read a character from the
+input从<br>
+输入中读取一个字符</td>
+</tr>
+</tbody>
 </table>

- The following code snippet demonstrates a simple policy that convertsall

-  characters to lower case:</p>
-<pre>

- <code>struct <spanclass=identifier>inhibit_case_iteration_policy :public <spanclass=identifier>iteration_policy

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

- template <spanclass=special><typename <spanclass=identifier>CharT>- CharT filter<spanclass=special>(CharT ch<spanclass=special>) const

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

- return std::<spanclass=identifier>tolower(<spanclass=identifier>ch);

-        }
-    };</span></code></pre>
-<a name="match_policy"></a>
+<p> The following code snippet demonstrates a simple policy that

+converts all characters to lower case: 下面的代码片断展示了一个把所有字母转为小写的简单策略：<pre> <code>structinhibit_case_iteration_policy <spanclass="special">: public <spanclass="identifier">iteration_policy <spanclass="special">{ template<typenameCharT<spanclass="special">> CharTfilter(CharTch) <spanclass="keyword">const { return std::<spanclass="identifier">tolower(<spanclass="identifier">ch); } };</code></pre><a name="match_policy"></a>

 <h2>match_policy</h2>
-<p> Here are the default policies that govern recognition and matching:</p>
-<pre>

- <code>struct <spanclass=identifier>match_policy

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

-        {

- typedef <spanclass=identifier>match<<spanclass=identifier>T> <spanclass=identifier>type; <spanclass=special>

-        };
-

- const <spanclass=identifier>match<<spanclass=identifier>nil_t>- no_match<spanclass=special>() const

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

- return match<spanclass=special><nil_t<spanclass=special>>(); 

-        }
-

- const <spanclass=identifier>match<<spanclass=identifier>nil_t>- empty_match<spanclass=special>() const

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

- return match<spanclass=special><nil_t<spanclass=special>>(0,nil_t());

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

- template <spanclass=special><typename <spanclass=identifier>AttrT, <spanclass=keyword>typename IteratorT<spanclass=special>>- match<spanclass=special><AttrT<spanclass=special>>- create_match<spanclass=special>(- std::size_t <spanclass=identifier>length,- AttrT <spanclass=keyword>const& <spanclass=identifier>val,- IteratorT <spanclass=keyword>const& <spanclass=comment>/*first*/,- IteratorT <spanclass=keyword>const& <spanclass=comment>/*last*/) <spanclass=keyword>const

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

- return match<spanclass=special><AttrT<spanclass=special>>(length<spanclass=special>, val<spanclass=special>); 

-        }
-

- template <spanclass=special><typename <spanclass=identifier>MatchT, <spanclass=keyword>typename IteratorT<spanclass=special>>

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

- group_match<spanclass=special>(- MatchT<spanclass=special>& <spanclass=comment>/*m*/,- parser_id <spanclass=keyword>const& <spanclass=comment>/*id*/,- IteratorT <spanclass=keyword>const& <spanclass=comment>/*first*/,- IteratorT <spanclass=keyword>const& <spanclass=comment>/*last*/) <spanclass=keyword>const {}

- template <spanclass=special><typename <spanclass=identifier>Match1T, <spanclass=keyword>typename Match2T<spanclass=special>>

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

- concat_match<spanclass=special>(Match1T<spanclass=special>& l<spanclass=special>, Match2T <spanclass=keyword>const& <spanclass=identifier>r) <spanclass=keyword>const

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

- l.<spanclass=identifier>concat(<spanclass=identifier>r);

-        </span><span class=special>}
-    </span><span class=special>};</span></code></pre>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="12"> Recognition and matching </td>
-  </tr>
-  <tr>
-  <tr>
-    <td class="table_cells"><b>result</b></td>

- <td class="table_cells">A metafunction that returns a match type givenan

-      attribute type (see In-depth: The Parser)</td>
-  </tr>
-  <td class="table_cells"><b>no_match</b></td>
-  <td class="table_cells">Create a failed match</td>
-  </tr>
-  <td class="table_cells"><b>empty_match</b></td>

- <td class="table_cells">Create an empty match. An empty match is asuccessful

-    epsilon match (matching length == 0)</td>
-  </tr>
-  <td class="table_cells"><b>create_match</b></td>

- <td class="table_cells">Create a match given the matching length, anattribute- and the iterator pair pointing to the matching portion of theinput</td>

-  </tr>
-  <td class="table_cells"><b>group_match</b></td>

- <td class="table_cells">For non terminals such as rules, this is calledafter

-    a successful match has been made to allow post processing</td>
-  </tr>
-  <td class="table_cells"><b>concat_match</b></td>
-  <td class="table_cells">Concatenate two match objects</td>
-  </tr>
+<p> Here are the default policies that govern recognition and

+matching: 这是管理识别和匹配的默认策略：<pre> <code><spanclass="keyword">struct match_policy { <spanclass="keyword">template <<spanclass="keyword">typename T<spanclass="special">> structresult <spanclass="special"> { <spanclass="keyword">typedef match<spanclass="special"><T<spanclass="special">> type<spanclass="special">; }; const <spanclass="identifier">match<<spanclass="identifier">nil_t> no_match()const <spanclass="special">{ returnmatch<spanclass="special"><nil_t<spanclass="special">>(); } const <spanclass="identifier">match<<spanclass="identifier">nil_t> empty_match()const <spanclass="special">{ returnmatch<spanclass="special"><nil_t<spanclass="special">>(0<spanclass="special">, nil_t<spanclass="special">()); <spanclass="special">} template<typenameAttrT,typename <spanclass="identifier">IteratorT> match<spanclass="special"><AttrT<spanclass="special">> <spanclass="identifier">create_match<spanclass="special">( <spanclass="keyword">std::size_t <spanclass="identifier">length, AttrT <spanclass="keyword">const& <spanclass="identifier">val, IteratorT <spanclass="keyword">const& <spanclass="comment">/*first*/, IteratorT <spanclass="keyword">const& <spanclass="comment">/*last*/) <spanclass="keyword">const { return <spanclass="identifier">match<<spanclass="identifier">AttrT>(<spanclass="identifier">length, <spanclass="identifier">val); <spanclass="special"> } <spanclass="keyword">template <<spanclass="keyword">typename MatchT<spanclass="special">, typename <spanclass="identifier">IteratorT> void <spanclass="identifier">group_match( MatchT<spanclass="special">& <spanclass="comment">/*m*/, parser_id <spanclass="keyword">const& <spanclass="comment">/*id*/, IteratorT <spanclass="keyword">const& <spanclass="comment">/*first*/, IteratorT <spanclass="keyword">const& <spanclass="comment">/*last*/) <spanclass="keyword">const {} template <spanclass="special"><typename <spanclass="identifier">Match1T, <spanclass="keyword">typename <spanclass="identifier">Match2T> void <spanclass="identifier">concat_match(<spanclass="identifier">Match1T& <spanclass="identifier">l, <spanclass="identifier">Match2T const<spanclass="special">& r<spanclass="special">) const { <spanclass="identifier"> l<spanclass="special">.concat<spanclass="special">(r<spanclass="special">); } };</code></pre><table align="center"border="0" width="90%">

+<tbody>
+<tr>
+<td class="table_title" colspan="12">
+Recognition and matching 识别与匹配 </td>
+</tr>
+<tr>
+</tr>
+<tr>
+<td class="table_cells"><b>result</b></td>
+<td class="table_cells">A metafunction that returns

+a match type given an attribute type (see In-depth: The Parser) <fontcolor="#000000">给定属性类型返回匹配类型的元函数（见深入：分析器）</td>

+</tr>
+<tr>
+<td class="table_cells"><b>no_match</b></td>
+<td class="table_cells">Create a failed match<br>生成一个失败匹配</td>
+</tr>
+<tr>
+<td class="table_cells"><b>empty_match</b></td>
+<td class="table_cells">Create an empty match. An

+empty match is a successful epsilon match (matching length == 0) 生成一个空匹配。空匹配是指成功的空集匹配（匹配长度为0）</td>

+</tr>
+<tr>
+<td class="table_cells"><b>create_match</b></td>
+<td class="table_cells">Create a match given the
+matching length, an attribute and the iterator pair pointing to the

+matching portion of the input 生成一个带着匹配长度、匹配属性和指向输入中的匹配段的迭代器对的匹配</td>

+</tr>
+<tr>
+<td class="table_cells"><b>group_match</b></td>
+<td class="table_cells">For non terminals such as
+rules, this is called after a successful match has been made to allow

+post processing 对诸如 rule 这样的非终结符，将在成功匹配后调用它以进行后续处理</td>

+</tr>
+<tr>
+<td class="table_cells"><b>concat_match</b></td>

+<td class="table_cells">Concatenate two match objects 联接两个匹配对象</td>

+</tr>
+</tbody>
 </table>
 <a name="action_policy"></a>
 <h2>action_policy</h2>

- The action policy has only one function for handling semanticactions:

-<pre>

- <code>struct <spanclass=identifier>action_policy

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

- template <spanclass=special><typename <spanclass=identifier>ActorT, <spanclass=keyword>typename AttrT<spanclass=special>, typename <spanclass=identifier>IteratorT>

-        </span><span class=keyword>void
-        </span><span class=identifier>do_action</span><span class=special>(

- ActorT <spanclass=keyword>const& <spanclass=identifier>actor,- AttrT <spanclass=keyword>const& <spanclass=identifier>val,- IteratorT <spanclass=keyword>const& <spanclass=identifier>first,- IteratorT <spanclass=keyword>const& <spanclass=identifier>last) <spanclass=keyword>const;

-    </span><span class=special>};</span></code></pre>
-<p> The default action policy forwards to:</p>
-<pre>

- <code>actor<spanclass=special>(first<spanclass=special>, last<spanclass=special>);</code></pre>

-<p> If the attribute <tt>val</tt> is of type nil_t. Otherwise:</p>
-<pre>

- <code>actor<spanclass=special>(val<spanclass=special>);</code></pre>

+<p> The action policy has only one function for handling semantic

+actions: 动作策略只有一个处理语义动作的函数：<pre> <code><spanclass="keyword">struct action_policy { <spanclass="keyword">template <<spanclass="keyword">typename ActorT<spanclass="special">, typename <spanclass="identifier">AttrT, <spanclass="keyword">typename <spanclass="identifier">IteratorT> void <spanclass="identifier">do_action( ActorT <spanclass="keyword">const& <spanclass="identifier">actor, AttrT <spanclass="keyword">const& <spanclass="identifier">val, IteratorT <spanclass="keyword">const& <spanclass="identifier">first, IteratorT <spanclass="keyword">const& <spanclass="identifier">last) <spanclass="keyword">const; <spanclass="special">};</code></pre> The default action policyforwards to: 默认的策略为：+<pre> <code>actor<spanclass="special">(first<spanclass="special">, last<spanclass="special">);</code><code><spanclass="special"></code></pre>

+<p> If the attribute <tt>val</tt> is of type nil_t.
+Otherwise:<br>如果属性 <tt>val</tt> 的类型是 nil_t 的话。否则：</p>

+<pre> <code>actor<spanclass="special">(val<spanclass="special">);</code><code><spanclass="special"></code></pre>

 <a name="scanner_policies_mixer"></a>
 <h3>scanner_policies mixer</h3>

- The class <tt>scanner_policies</tt> combines the three scanner policyclasses

-  above into one:</p>
-<pre>
-    <code><span class=keyword>template </span><span class=special>&lt;

- typename <spanclass=identifier>IterationPolicyT =iteration_policy,- typename <spanclass=identifier>MatchPolicyT =match_policy,- typename <spanclass=identifier>ActionPolicyT =action_policy>- struct <spanclass=identifier>scanner_policies;

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

- This mixer class inherits from all the three policies. Thisscanner_policies

-  class is then used to parameterize the scanner:</p>
-<pre>
-    <code><span class=keyword>template </span><span class=special>&lt;

- typename <spanclass=identifier>IteratorT = <spanclass=keyword>char const<spanclass=special>*,- typename <spanclass=identifier>PoliciesT = <spanclass=identifier>scanner_policies<>>- class <spanclass=identifier>scanner;

-</span></code></pre>
-<p> The scanner in turn inherits from the PoliciesT.</p>
+<p> The class <tt>scanner_policies</tt> combines the

+three scanner policy classes above intoone: <tt>scanner_policies</tt> 类把上面三类策略捆绑在了一起：+<pre> <code>template <spanclass="special">< typenameIterationPolicyT <spanclass="special">= <spanclass="identifier">iteration_policy<spanclass="special">, typenameMatchPolicyT <spanclass="special">= match_policy<spanclass="special">, typenameActionPolicyT <spanclass="special">= action_policy<spanclass="special">> structscanner_policies<spanclass="special">;</code><code><spanclass="special"> </code></pre>

+<p> This <i>mixer</i> class inherits from all the
+three policies. This scanner_policies class is then used to

+parameterize the scanner: 这个混合器类同时继承了三个策略。然后这个scanner_policies 就被用于将扫描器参数化：+<pre> <code>template <spanclass="special">< typenameIteratorT =char <spanclass="keyword">const*, typename <spanclass="identifier">PoliciesT = <spanclass="identifier">scanner_policies<>> classscanner<spanclass="special">;</code><code><spanclass="special"></code></pre>+The scanner in turn inherits from the PoliciesT. 而空上扫描器则继承自 PoliciesT。

 <a name="rebinding_policies"></a>
-<h3>Rebinding Policies</h3>

- The scanner can be made to rebind to a different set of policiesanytime.- It has a member function <tt>change_policies(new_policies)</tt>. Given anew- set of policies, this member function creates a new scanner with the newset- of policies. The result type of the rebound scanner can be can beobtained

-  by calling the metafunction:</p>
-<pre>

- <code>rebind_scanner_policies<spanclass=special><ScannerT<spanclass=special>, PoliciesT<spanclass=special>>::type</code></pre>

+<h3>Rebinding Policies 重绑定策略</h3>
+<p> The scanner can be made to rebind to a different set of

+policies anytime. It has a member function<tt>change_policies(new_policies)</tt>.

+Given a new set of policies, this member function creates a new scanner
+with the new set of policies. The result type of the <i>rebound</i>

+scanner can be can be obtained by calling the metafunction: 扫描器在任何时刻都可以绑定另外的策略。它有一个<tt>change_policies(new_policies)</tt> 成员函数。给定一个新的策略集，这个成员函数产生一个带有给定策略集的新的扫描器。重新绑定的扫描器的结果类型可以通过下述元函数取得：+<pre> <code>rebind_scanner_policies<spanclass="special"><ScannerT<spanclass="special">, PoliciesT<spanclass="special">>::<spanclass="identifier">type</code></pre>

 <a name="rebinding_iterators"></a>
-<h3>Rebinding Iterators</h3>

- The scanner can also be made to rebind to a different iterator typeanytime.- It has a member function <tt>change_iterator(first, last)</tt>. Given anew- pair of iterator of type different from the ones held by the scanner,this member- function creates a new scanner with the new pair of iterators. Theresult type- of the rebound scanner can be can be obtained by calling themetafunction:

-<pre>

- <code>rebind_scanner_iterator<spanclass=special><ScannerT<spanclass=special>, IteratorT<spanclass=special>>::type</code></pre>

+<h3>Rebinding Iterators 重绑定迭代器</h3>
+<p> The scanner can also be made to rebind to a different
+iterator type anytime. It has a member function <tt>change_iterator(first,
+last)</tt>. Given a new pair of iterator of type different from
+the ones held by the scanner, this member function creates a new

+scanner with the new pair of iterators. The result type of therebound+scanner can be can be obtained by calling the metafunction: 扫描器也可以在任何时刻重新绑定不同的迭代器类。它有一个 <tt>change_iterator(first,+last)</tt> 成员函数。给定一对与原先的扫描器所持有的迭代器的类型不同的迭代器，这个成员函数将产生一个带有新的迭代器对的扫描器。重绑定的扫描器的结果类可以通过下述元函数取得：+<pre> <code>rebind_scanner_iterator<spanclass="special"><ScannerT<spanclass="special">, IteratorT<spanclass="special">>::<spanclass="identifier">type</code></pre>

 <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 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">Copyright (c) 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/introduction.html Sat Oct 4 05:29:092008+++ /trunk/libs/spirit/classic/doc/introduction.html Wed Sep 16 20:25:532009

@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -12,15 +11,13 @@



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

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





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

 <body>

@@ -96,13 +93,13 @@


 <p>

- Spirit是一个面向对象的递归下降解析器的生成框架，利用模板元编程技术实现。表达式模板允许我们完全用C++模仿扩展Backus泛式（EBNF）的语法。+ Spirit是一个面向对象的递归下降解析器的生成框架，利用模板元编程技术实现。表达式模板允许我们完全用C++来模拟扩展Backus泛式（EBNF）的语法。

     </p>



-<p> Spirit框架允许一个写一个独立于C++的目标文法。

-内联EBNF文法规范可以自由地混合在其他C++代码中，还有马上能执行；这个要归功于C++模板强大的生成能力。 回顾一下，常规的编译器编译或者解析器生成器，需要额外的一个翻译步骤，去把EBNF源码翻译为C代码。

+<p> Spirit框架允许只用C++来写一个目标文法。

+内联的EBNF文法规范可以自由地混合在其他C++代码中，而且还能立即执行；这个要归功于C++模板强大的生成能力。 回顾一下，常规的编译器-编译译或者解析器-生成器，都需要一个额外的翻译步骤，去把EBNF源码翻译为C代码。

 </p>


@@ -118,7 +115,7 @@


 <p>
-      用Spirit的方法来近似此片段：
+      用Spirit的方法来模拟此片段：
     </p>


@@ -127,7 +124,7 @@
 </pre>

-通过表达式模板的魔力，这是完全合法和可执行的C++代码。产生的规则<tt>expression</tt> 事实上是一个对象，有一个parse成员函数用来按照刚定义的文法来解析。是的，这是一个计算器。为了简化，省略了<tt>factor</tt>里的<tt>integer</tt>的声明。产生的规则 <tt>expression</tt> ，在我们规范的文法中，传统上叫做“开始符号”，能够识别下面的输入：+通过表达式模板的魔力，这是完全合法和可执行的C++代码。产生的规则<tt>expression</tt> 事实上是一个对象，有一个parse成员函数用来按照所定义的文法来解析。是的，这是一个计算器。为了简化，省略了<tt>factor</tt>里的<tt>integer</tt>的声明。产生的规则 <tt>expression</tt> ，在我们规范的文法中，传统上叫做"开始符号"，能够识别下面的输入：

     </p>


@@ -136,7 +133,7 @@
 </pre>

-当然，我们对原来的EBNF语法做了一些修改。这是为了和C++语法规则保持一致。最显著的是移位操作符>>的冗余。因为C++中没有“空”操作符，简直不可能写出下面代码：+当然，我们对原来的EBNF语法做了一些修改。这是为了和C++语法规则保持一致。最显著的是增加了移位操作符>>。因为C++中没有"空"操作符，不可能写出以下代码：

     </p>


@@ -145,7 +142,7 @@
 </pre>

-例如在数学语法中，这意味着乘法。在EBNF语法中，意味着跟随（b跟随a）。Spirit框架用移位操作符 <tt class="operators">>></tt> 表达这跟随的意思。我们用操作符>>，指向右的箭头，意味着“紧接着”。因此我们写：+例如在数学语法中，这意味着乘法。在EBNF语法中，意味着跟随（b跟随a）。Spirit框架用移位操作符 <tt class="operators">>></tt> 表达跟随的意思。我们用操作符>>，指向右的箭头，意味着"紧接着"。因此我们写：

     </p>


@@ -156,7 +153,7 @@

 <p>选择操作符 <tt class="operators">|</tt> 和圆括号
       <tt class="operators">()</tt> 保留原意。 附值操作符

- <tt class="operators">=</tt> 用来代替 EBNF的 <ttclass="operators">::=</tt> 。最后但还有，Kleene星号 <ttclass="operators">*</tt> 由原来EBNF的后缀改变为前缀。代替：+ <tt class="operators">=</tt> 用来代替 EBNF的 <ttclass="operators">::=</tt> 。最后但还有，Kleene星号 <ttclass="operators">*</tt> 由原来EBNF中的后缀改变为前缀。对于：

     </p>


@@ -175,7 +172,7 @@


 <p>

- 因为C++中没有后缀星号 "<tt class="operators">*</tt>"。最后，每一规则当然地用分号"<tt>;</tt>"结尾。 + 因为C++中没有后缀星号 "<tt class="operators">*</tt>"。最后，每一条规则当然要用分号"<tt>;</tt>"来结尾。 

     </p>


@@ -221,7 +218,7 @@
 <hr size="1">

 <p class="copyright">
-      Copyright &copy; 1998-2003 Joel de Guzman<br>
+      Copyright (c) 1998-2003 Joel de Guzman<br>


       <br>
@@ -240,5 +237,4 @@



-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/numerics.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/numerics.html        Wed Sep 16 20:25:53 2009
@@ -1,30 +1,28 @@
-<html>
-<head>
-<title>Numerics</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>Numerics</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%">

- Numerics+ Numerics 数值

     </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="operators.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="rule.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

Similar to <tt>chlit</tt>, <tt>strlit</tt> etc. numeric parsers arealso primitives.

   Numeric parsers are placed on

@@ -38,7 +36,10 @@

to suit. This includes the radix base, the minimum and maximum number ofallowabledigits, the exponent, the fraction etc. Policies control the real numberparsers'behavior. There are some predefined policies covering the most commonreal number

-  formats but the user can supply her own when needed. </p>

+ formats but the user can supply her own when needed. 与<tt>chlit</tt>, <tt>strlit</tt> +等类似，数值分析器也是基元。把数值分析器单独放在一节是为了让你更好地关注这个重要的构件。框架包含了很多预定义的、成对的有符号/无符号整数、实数分+析器。这些分析器都是可参数化的。调整参数就可以很好的适应数值解析的大多数方面。这些参数包含了进制、可允许的数字位数的最大最小+值、幂、小数部分等。策略用于控制实数分析器的行为。已经预定义了涵盖常见的实数格式分析器，同时，当必要时，用户也可以使用自定义的策略。 

 <h2>uint_parser</h2>

This class is the simplest among the members of the numerics package.The <tt>uint_parser</tt>can parse unsigned integers of arbitrary length and size. The<tt>uint_parser</tt>

@@ -46,120 +47,110 @@

scalars such as bigints (unlimited precision integers). Like most of theclassesin Spirit, the <tt>uint_parser</tt> is a template class. Templateparametersfine tune its behavior. The uint_parser is so flexible that the othernumeric

-  parsers are implemented using it as the backbone.</p>

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

- <td colspan="2" class="table_title">uint_parser templateparameters</td>+ parsers are implemented using it as the backbone. 这个类是数值构件中最简单的一个成员。<tt>uint_parser</tt> 可分析任意长度和大小的无符号整数。<tt>uint_parser</tt> 不仅可用于分析普通的C/C++整数，还可以分析用户自定义的整数，如 bigints（没有精度限制的整数）。像Spirit里面大多数的类那样，<tt>uint_parser</tt> 是+一个模板类。模板参数可以很好的调整它的行为。<tt>uint_parser</tt> 是如此的灵活，因此其他的数值分析器都是以它为骨架构建的。+<pre><code> <spanclass="keyword">template < typename T= <spanclass="keyword">unsigned, int Radix= 10<spanclass="special">, unsignedMinDigits =1, int MaxDigits= -1<spanclass="special">> structuint_parser {/*...*/ <spanclass="special">};</code></pre>

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

+ <td colspan="2" class="table_title">uint_parser template parameters 模板参数</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>T</b></td>

<td class="table_cells" width="79%">The numeric base type of thenumeric parser.

-      Defaults to <tt>unsigned</tt></td>

+ Defaults to <tt>unsigned </tt>数值分析器的基本数值类型。默认为<tt>unsigned</tt></td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>Radix</b></td>

<td class="table_cells" width="79%">The radix base. This can be either2:- binary, 8: octal, 10: decimal and 16: hexadecimal. Defaults to 10;decimal</td>+ binary, 8: octal, 10: decimal and 16: hexadecimal. Defaults to 10;decimal 数值进制。可以为：2：二进制、8：八进制、10：十进制以及16：十六进制。默认为10；十进制</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>MinDigits</b></td>

- <td class="table_cells" width="79%">The minimum number of digitsallowable</td>+ <td class="table_cells" width="79%">The minimum number of digitsallowable 所允许的最少数位</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>MaxDigits</b></td>

<td class="table_cells" width="79%">The maximum number of digitsallowable.

-      If this is -1, then the maximum limit becomes unbounded</td>

+ If this is -1, then the maximum limit becomes unbounded 所允许的最多数位，如果为-1，则允许任意多数位</td>

   </tr>
-</table>
+</tbody></table>
 <br>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title">Predefined uint_parsers</td>
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td colspan="2" class="table_title">Predefined uint_parsers 预定义的unit_parser</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>bin_p</b></td>

- <td class="table_cells" width="79%"><code><spanclass=identifier>uint_parser<<spanclass=keyword>unsigned,- 2, <spanclass=number>1,- -1>const</code></td>+ <td class="table_cells" width="79%"><code><spanclass="identifier">uint_parser<<spanclass="keyword">unsigned,+ 2,1,+ -1>const</code></td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>oct_p</b></td>

- <td class="table_cells" width="79%"><code><spanclass=identifier>uint_parser<<spanclass=keyword>unsigned,- 8, <spanclass=number>1,- -1>const</code></td>+ <td class="table_cells" width="79%"><code><spanclass="identifier">uint_parser<<spanclass="keyword">unsigned,+ 8,1,+ -1>const</code></td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>uint_p</b></td>

- <td class="table_cells" width="79%"><code><spanclass=identifier>uint_parser<<spanclass=keyword>unsigned,- 10,1,- -1>const</code></td>+ <td class="table_cells" width="79%"><code><spanclass="identifier">uint_parser<<spanclass="keyword">unsigned,+ 10,1,+ -1>const</code></td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>hex_p</b></td>

- <td class="table_cells" width="79%"><code><spanclass=identifier>uint_parser<<spanclass=keyword>unsigned,- 16,1,- -1>const</code></td>+ <td class="table_cells" width="79%"><code><spanclass="identifier">uint_parser<<spanclass="keyword">unsigned,+ 16,1,+ -1>const</code></td>

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

The following example shows how the uint_parser can be used to parsethousand- separated numbers. The example can correctly parse numbers such as1,234,567,890.-<pre> <spanclass=identifier>uint_parser<<spanclass=keyword>unsigned, <spanclass=number>10, <spanclass=number>1, <spanclass=number>3> <spanclass=identifier>uint3_p; <spanclass=comment>// 1..3 digits- uint_parser<spanclass=special><unsigned<spanclass=special>, 10,3, <spanclass=number>3> <spanclass=identifier>uint3_3_p; <spanclass=comment>// exactly 3 digits- ts_num_p =(uint3_p>> <spanclass=special>*(',' <spanclass=special>>> uint3_3_p<spanclass=special>)); // our thousand separatednumber parser</pre>+ separated numbers. The example can correctly parse numbers such as1,234,567,890. 下面的例子示范了如何使用uint_parser分析千位分隔的数值。该例子可正确地分析诸如1,234,567,890这样的数字。+<pre> <spanclass="identifier">uint_parser<<spanclass="keyword">unsigned, <spanclass="number">10, <spanclass="number">1, <spanclass="number">3> <spanclass="identifier">uint3_p;// 1..3 digits 1-3位数字 <spanclass="identifier">uint_parser<<spanclass="keyword">unsigned, <spanclass="number">10, <spanclass="number">3, <spanclass="number">3> <spanclass="identifier">uint3_3_p;// exactly 3 digits 正好3位数字 ts_num_p =(uint3_p>> <spanclass="special">*(',' <spanclass="special">>> <spanclass="identifier">uint3_3_p));// our thousand separated number parser 我们的千位分隔数值分析器</pre><tt>bin_p</tt>, <tt>oct_p</tt>, <tt>uint_p</tt> and <tt>hex_p</tt> areparsergenerator objects designed to be used within expressions. Here's anexample- of a rule that parses comma delimited list of numbers (We've seen this<a href="quick_start.html#list_of_numbers">before</a>):-<pre><code> <spanclass=identifier>list_of_numbers = <spanclass=identifier>real_p >> *(<spanclass=literal>',' >> <spanclass=identifier>real_p)</code>;

-</pre>
-<p></p>

+ of a rule that parses comma delimited list of numbers (We've seen this<a href="quick_start.html#list_of_numbers">before</a>): <tt>bin_p</tt>,<tt>oct_p</tt>, <tt>uint_p</tt> 和 <tt>hex_p</tt> 是设计成在表达式中使用的分析器生成器。以下是一个分析以逗号分隔的数值的规则例子(<ahref="quick_start.html#list_of_numbers">之前</a> 我们已经见过这个例子)：+<pre><code> <spanclass="identifier">list_of_numbers =real_p >>*(',' >>real_p<spanclass="special">)</code>; </pre>

Later, we shall see how we can extract the actual numbers parsed by thenumericparsers. We shall deal with this when we get to the section on <ahref="semantic_actions.html#specialized_actions">specialized

-  actions</a>.</p>

+ actions</a>. 稍后，我们将会看到如何从数值分析器中获得它们分析出的数字。我们将在<ahref="http://www.boost.org/libs/spirit/doc/semantic_actions.html#specialized_actions";>特定动作</a>一节中接触这些。

 <h2>int_parser</h2>

The <tt>int_parser</tt> can parse signed integers of arbitrary lengthand size.This is almost the same as the <tt>uint_parser</tt>. The only differenceisthe additional task of parsing the <tt><spanclass="quotes">'+'</tt>or <tt class="quotes">'-'</tt> sign preceding the number. The classinterface

-  is the same as that of the uint_parser.<br>

+ is the same as that of the uint_parser. <tt>int_parser</tt> 可以分析任意长度和大小的有符号整数。这与 <tt>uint_parser</tt> 几乎完全一样，唯一的不同是 <tt>int_parser</tt> 多分析了数值前面的'+'、'-'号。这个类的接口与 <tt>uint_parser</tt> 一样。

 </p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title">A predefined int_parser</td>
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td colspan="2" class="table_title">A predefined int_parser  预定义的 int_parser</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>int_p</b></td>

- <td class="table_cells" width="79%"><spanclass=identifier><code>int_parser</code><code><spanclass=special><int,- 10,1,- -1>const</code></td>+ <td class="table_cells" width="79%"><spanclass="identifier"><code>int_parser</code><code><spanclass="special"><int<spanclass="special">,+ 10,1,+ -1>const</code></td>

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

The <tt>real_parser</tt> can parse real numbers of arbitrary length andsizelimited by its parametric type <tt>T</tt>. The <tt>real_parser</tt> is atemplate- class with 2 template parameters. Here's the <tt>real_parser</tt>template interface:

-<pre><span class=keyword>    template</span><span class=special>&lt;

- typename <spanclass=identifier>T = <spanclass=keyword>double,- typename <spanclass=identifier>RealPoliciesT = <spanclass=identifier>ureal_parser_policies<spanclass=special><T<spanclass=special>> >- struct <spanclass=identifier>real_parser;</pre>+ class with 2 template parameters. Here's the <tt>real_parser</tt>template interface: <tt>real_parser</tt> 可以在它的模板参数 <tt>T</tt> 所限制的范围内的分析任意长度和大小的实数。<tt>real_parser</tt> 是一个有两个模板参数的模板类。以下是 <tt>real_parser</tt> 的接口：+<pre> template<spanclass="special">< typenameT =double<spanclass="special">, typenameRealPoliciesT <spanclass="special">= <spanclass="identifier">ureal_parser_policies<spanclass="special"><T<spanclass="special">> > <spanclass="keyword"> struct <spanclass="identifier">real_parser;</pre>The first template parameter is its numeric base type <tt>T</tt>. Thisdefaults

-  to <tt>double</tt>. </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/bulb.gif" width="13"height="18">

-      Parsing special numeric types</b><br>

+ to <tt>double</tt>. 第一个模板参数是它的数值基类型 <tt>T</tt>。默认值为 <tt>double</tt>. 

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

+ <td class="note_box"><img src="theme/bulb.gif" height="18"width="13">+ Parsing special numeric types 分析特定的数值类型 

       <br>

Notice that the numeric base type <tt>T</tt> can be specified by theuser.This means that we can use the numeric parsers to parse user definednumerictypes such as <tt>fixed_point</tt> (fixed point reals) and<tt>bigint</tt>

-      (unlimited precision integers).</td>

+ (unlimited precision integers). 注意，数值类型 <tt>T</tt> 可以由用户定义。这意味着我们可以使用数值分析器分析用户定义的的数值类型，比如<tt>fixed_point</tt>(定点实数)和 <tt>bigint</tt>(精度无限的整数)。</td>

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

The second template parameter is a class that groups all the policiesand defaultsto <tt>ureal_parser_policies<T></tt>. Policies control the realnumberparsers' behavior. The default policies provided are designed to parseC/C++

@@ -168,293 +159,177 @@

or <tt class="quotes">'E'</tt> and eee is the exponent optionallyprecededby <tt class="quotes">'-'</tt> or <tt><spanclass="quotes">'+'</tt>.This corresponds to the following grammar, with the exception that plainintegers

-  without the decimal point are also accepted by default.</p>

-<pre><code> <spanclass=identifier>floatingliteral- = <spanclass=identifier>fractionalconstant >>!exponentpart- | <spanclass=special>+digit_p <spanclass=special>>> exponentpart

-        </span><span class=special>;
-
-    </span><span class=identifier>fractionalconstant

- = <spanclass=special>*digit_p <spanclass=special>>> '.' <spanclass=special>>> +<spanclass=identifier>digit_p- | <spanclass=special>+digit_p <spanclass=special>>> '.'

-        </span><span class=special>;
-
-    </span><span class=identifier>exponentpart

- = <spanclass=special>('e' |'E') <spanclass=special>>> !(<spanclass=literal>'+' | <spanclass=literal>'-') <spanclass=special>>> +<spanclass=identifier>digit_p

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

+ without the decimal point are also accepted by default. 第二个模板参数是组织全部策略的策略类，默认值为 <tt>ureal_parser_policies<T></tt>。策略控制着实数分析器的行为。所提供的默认策略被设计成识别C/C++风格的实数，格式为 nnn.fff.Eeee，<spanstyle="font-weight: bold;">nnn为整数部分，fff为小数部分，E为字母'E'或'e'，eee为指数部分，前面可以有'+'或'-'。这对应于以下语法，除了一点，缺省情况下，如果没有小数点，普通的整数也是被接受的。+<pre><code> <spanclass="identifier">floatingliteral <spanclass="special">= fractionalconstant>> <spanclass="special">!exponentpart | +<spanclass="identifier">digit_p >>exponentpart <spanclass="special">; <spanclass="identifier">fractionalconstant <spanclass="special">= *<spanclass="identifier">digit_p >>'.' >>+<spanclass="identifier">digit_p |+digit_p>> <spanclass="literal">'.' ; exponentpart <spanclass="special">= (<spanclass="literal">'e' | <spanclass="literal">'E') <spanclass="special">>> !(<spanclass="literal">'+' | <spanclass="literal">'-') <spanclass="special">>> +<spanclass="identifier">digit_p <spanclass="special">;</code></pre>The default policies are provided to take care of the most common case(thereare many ways to represent, and hence parse, real numbers). In mostcases, thedefault setting of the <tt>real_parser</tt> is sufficient and can beused straightout of the box. Actually, there are four <tt>real_parser</tt>spre-defined for

-  immediate use:</p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td colspan="2" class="table_title">Predefined real_parsers</td>

+ immediate use: 为了应付最常见的情况（实数有很多种写法，因此分析过程也是），我们提供了默认策略。再大多数情况下，<tt>real_parser</tt> 的默认设定完全够用，而且可以拿来就用。实际上，有四种预定义的 <tt>real_parser</tt> 可以直接使用：

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

+ <td colspan="2" class="table_title">Predefined real_parsers  预定义的 real_parser</td>

   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>ureal_p</b></td>

- <td class="table_cells" width="79%"><spanclass=identifier><code>real_parser</code><code><spanclass=special><double<spanclass=special>,- ureal_parser_policies<spanclass=special><double<spanclass=special>>

-      &gt; </span><span class=keyword>const</span></code></td>

+ <td class="table_cells" width="79%"><spanclass="identifier"><code>real_parser</code><code><spanclass="special"><double<spanclass="special">,+ ureal_parser_policies<spanclass="special"><double<spanclass="special">>

+      &gt; </span><span class="keyword">const</span></code></td>
   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>real_p</b></td>

- <td class="table_cells" width="79%"><spanclass=identifier><code>real_parser</code><code><spanclass=special><double<spanclass=special>,- real_parser_policies<spanclass=special><double<spanclass=special>>

-      &gt; </span><span class=keyword>const</span></code></td>

+ <td class="table_cells" width="79%"><spanclass="identifier"><code>real_parser</code><code><spanclass="special"><double<spanclass="special">,+ real_parser_policies<spanclass="special"><double<spanclass="special">>

+      &gt; </span><span class="keyword">const</span></code></td>
   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>strict_ureal_p</b></td>

- <td class="table_cells" width="79%"><spanclass=identifier><code>real_parser</code><code><spanclass=special><double<spanclass=special>,- <spanclass=identifier>strict_ureal_parser_policies<spanclass=special><double<spanclass=special>>

-      &gt; </span><span class=keyword>const</span></code></td>

+ <td class="table_cells" width="79%"><spanclass="identifier"><code>real_parser</code><code><spanclass="special"><double<spanclass="special">,+ <spanclass="identifier">strict_ureal_parser_policies<spanclass="special"><double<spanclass="special">>

+      &gt; </span><span class="keyword">const</span></code></td>
   </tr>
   <tr>
     <td class="table_cells" width="21%"><b>strict_real_p</b></td>

- <td class="table_cells" width="79%"><spanclass=identifier><code>real_parser</code><code><spanclass=special><double<spanclass=special>,- <spanclass=identifier>strict_real_parser_policies<spanclass=special><double<spanclass=special>>

-      &gt; </span><span class=keyword>const</span></code></td>

+ <td class="table_cells" width="79%"><spanclass="identifier"><code>real_parser</code><code><spanclass="special"><double<spanclass="special">,+ <spanclass="identifier">strict_real_parser_policies<spanclass="special"><double<spanclass="special">>

+      &gt; </span><span class="keyword">const</span></code></td>
   </tr>
-</table>

-We've seen <tt>real_p</tt> before. <tt>ureal_p</tt> is its unsignedvariant.

-<h3><a name="strict_reals"></a>Strict Reals </h3>
+</tbody></table>

+We've seen <tt>real_p</tt> before. <tt>ureal_p</tt> is its unsignedvariant. 前面我们已经见过 <tt>real_p</tt>。<tt>ureal_p</tt> 是它的有符号变体。+<h3><a name="strict_reals"></a>Strict Reals 严格实数 </h3>Integer numbers are considered a subset of real numbers, so<tt>real_p</tt>and <tt>ureal_p</tt> recognize integer numbers (without a dot) as realnumbers.<tt>strict_real_p</tt> and <tt>strict_ureal_p</tt> are the equivalentparsersthat require a dot to be present for a number to beconsidered

-  a successful match.</p>
-<h2>Advanced: real_parser policies</h2>
-<p>The parser policies break down real number parsing into 6 steps:</p>
-<table width="90%" border="0" align="center">
-  <tr>

+ a successful match. 整数被认为是实数的一个子集，所以 <tt>real_p</tt>和 <tt>ureal_p</tt> 将整数（没有小数点的数值）识别为实数。<tt>strict_real_p</tt> 和 <tt>strict_ureal_p</tt> 与前面两个分析器相同，只是需要小数点在数值中出现才会产生成功匹配。

+<h2>Advanced: real_parser policies&nbsp;高级：real_parser的策略</h2>

+The parser policies break down real number parsing into 6 steps: 分析器的策略将实数的分析过程分为六步：

+<table align="center" border="0" width="90%">
+  <tbody><tr>
     <td class="table_cells">1</td>
     <td class="table_cells"><b>parse_sign</b></td>
-    <td class="table_cells">Parse the prefix sign</td>
+    <td class="table_cells">Parse the prefix sign<br>分析前缀的符号</td>
   </tr>
   <tr>
     <td class="table_cells">2</td>
     <td class="table_cells"><b>parse_n</b></td>

- <td class="table_cells">Parse the integer at the left of the decimalpoint</td>+ <td class="table_cells">Parse the integer at the left of the decimalpoint 分析小数点左边的整数部分</td>

   </tr>
   <tr>
     <td class="table_cells">3</td>
     <td class="table_cells"><b>parse_dot</b></td>
-    <td class="table_cells">Parse the decimal point</td>
+    <td class="table_cells">Parse the decimal point<br>分析小数点</td>
   </tr>
   <tr>
     <td class="table_cells">4</td>
     <td class="table_cells"><b>parse_frac_n</b></td>
-    <td class="table_cells">Parse the fraction after the decimal point</td>

+ <td class="table_cells">Parse the fraction after the decimalpoint 分析小数点之后的小数部分</td>

   </tr>
   <tr>
     <td class="table_cells">5</td>
     <td class="table_cells"><b>parse_exp</b></td>
-    <td class="table_cells">Parse the exponent prefix (e.g. 'e')</td>

+ <td class="table_cells">Parse the exponent prefix (e.g. 'e') 分析指数前缀(比如字母'e')</td>

   </tr>
   <tr>
     <td class="table_cells">6</td>
     <td class="table_cells"><b>parse_exp_n</b></td>
-    <td class="table_cells">Parse the actual exponent</td>

+ <td class="table_cells">Parse the actual exponent 分析实际的指数</td>

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

And the interaction of these sub-parsing tasks is further controlled bythese

-  3 policies:</p>
-<table width="90%" border="0" align="center">
-  <tr>

+ 3 policies: 而且这些子分析步骤间的互动更进一步被下面这三个策略所控制：

+<table align="center" border="0" width="90%">
+  <tbody><tr>
     <td class="table_cells">1</td>
     <td class="table_cells"><b>allow_leading_dot</b></td>

- <td class="table_cells">Allow a leading dot to be present(".1" becomes

-      equivalent to &quot;0.1&quot;)</td>
+    <td class="table_cells">Allow a leading dot to be present (".1" becomes

+ equivalent to "0.1") 允许数值以小数点打头（".1"变得与"0.1"等价）</td>

   </tr>
   <tr>
     <td class="table_cells">2</td>
     <td class="table_cells"><b>allow_trailing_dot</b></td>

- <td class="table_cells">Allow a trailing dot to be present("1." becomes

-    equivalent to &quot;1.0&quot;)</td>

+ <td class="table_cells">Allow a trailing dot to be present ("1."becomes

+    equivalent to "1.0")<br>允许数值以小数点结尾("1."变得与"1.0"等价)</td>
   </tr>
   <tr>
     <td class="table_cells">3</td>
     <td class="table_cells"><b>expect_dot</b></td>

- <td class="table_cells">Require a dot to be present (disallows"1" to

-    be equivalent to &quot;1.0&quot;)</td>
+    <td class="table_cells">Require a dot to be present (disallows "1" to

+ be equivalent to "1.0") 要求数值中有小数点(不允许"1"与"1.0"等价)</td>

   </tr>
-</table>

-[ <img src="theme/lens.gif" width="15" height="16"> From here on,required

+</tbody></table>

+[ <img src="theme/lens.gif" height="16" width="15"> From here on,requiredreading: <a href="scanner.html">The Scanner</a>, <ahref="indepth_the_parser.html">In-depthThe Parser</a> and <a href="indepth_the_scanner.html">In-depth TheScanner</a>

-  ]</p>

+ ][<img style="width: 15px; height: 16px;" alt=""src="theme/lens.gif"> 要理解以下内容，需要阅读：<a href="scanner.html">扫描器</a>、<a href="indepth_the_parser.html">深入分析器</a> 和 <ahref="indepth_the_scanner.html">深入扫描器</a>]

 <h2>sign_parser and sign_p</h2>

Before we move on, a small utility parser is included here to ease theparsingof the '-' or <spanclass="quotes">'+' sign.

-  While it is easy to write one:</p>

-<pre> sign_p =(ch_p<spanclass=special>('+') |'-')<spanclass=literal>;</pre>+ While it is easy to write one: 在我们继续深入之前，先加入一个工具分析器，以使解析 '-' 或 <spanclass="quotes">'+' 符号变得容易些。虽然这玩意很容易写：<spanclass="quotes">+<pre> sign_p =(<spanclass="identifier">ch_p(<spanclass="literal">'+') | <spanclass="literal">'-')<spanclass="literal">;</pre>it is not possible to extract the actual sign (positive or negative)withoutresorting to semantic actions. The sign_p parser has a bool attributereturnedto the caller through the match object which, after parsing, is set totrueif the parsed sign is negative. This attribute detects if the negativesign

-  has been parsed. Examples:</p>

-<pre> bool <spanclass=identifier>is_negative;- r =sign_p<spanclass=special>[assign_a<spanclass=special>(is_negative<spanclass=special>)];</pre>

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

-<pre> // directly extract the result from the matchresult's value- bool is_negative= <spanclass=identifier>sign_p.<spanclass=identifier>parse(<spanclass=identifier>scan).<spanclass=identifier>value();<spanclass=comment> </pre>+ has been parsed. Examples: 抛开语义动作而又正确的提取符号（正或负）是不可能的。sign_p分析器在匹配后，在返回给调用着的匹配对象中有一个bool属性，如果所解析的符号为负号，则该属性值为true。这个属性用于检测是否分析到符号。例：+<pre> boolis_negative<spanclass="special">; r <spanclass="special">= sign_p<spanclass="special">[assign_a<spanclass="special">(is_negative<spanclass="special">)];</pre>

+<p><span class="special"></span>or simply...<br>或者简单些...</p>

+<pre> // directly extract the result from thematch result's value 从匹配结果的值中直接取出结果+ bool is_negative= <spanclass="identifier">sign_p.<spanclass="identifier">parse(<spanclass="identifier">scan).<spanclass="identifier">value();<spanclass="comment"> </pre>The sign_p parser expects attached semantic actions to have a signature(see<a href="semantic_actions.html#specialized_actions">SpecializedActions</a>

-  for further detail) compatible with: </p>
-<p><b>Signature for functions:</b></p>

-<pre><code> <spanclass=keyword>void func<spanclass=special>(bool<spanclass=identifier> is_negative<spanclass=special>);</code></pre>

-<p><b>Signature for functors:</b> </p>

-<pre><code> <spanclass=keyword>struct ftor

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

- void <spanclass=keyword>operator()(<spanclass="keyword">bool is_negative<spanclass=special>) const;

-    </span><span class=special>};</span></font></code></pre>
-<h2><span class=identifier>ureal_parser_policies</span></h2>

-<pre> template<typenameT>- struct <spanclass=identifier>ureal_parser_policies

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

- typedef <spanclass=identifier>uint_parser<<spanclass=identifier>T, <spanclass=number>10, <spanclass=number>1, -<spanclass=number>1> <spanclass=identifier>uint_parser_t;- typedef <spanclass=identifier>int_parser<<spanclass=identifier>T, <spanclass=number>10, <spanclass=number>1, -<spanclass=number>1> <spanclass=identifier>int_parser_t;

- static const bool <spanclass=identifier>allow_leading_dot =true;<spanclass=special>- static const bool <spanclass=identifier>allow_trailing_dot =true;<spanclass=special>- static constbool expect_dot <spanclass=special> = false<spanclass=special>; - template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>match_result<<spanclass=identifier>ScannerT, <spanclass="identifier">nil_t>::<spanclass=identifier>type- parse_sign(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>scan.<spanclass=identifier>no_match(); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>uint_parser_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_n(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>uint_parser_t().<spanclass=identifier>parse(<spanclass=identifier>scan); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>chlit<>, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_dot(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>ch_p(<spanclass=literal>'.').<spanclass=identifier>parse(<spanclass=identifier>scan); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>uint_parser_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_frac_n(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>uint_parser_t().<spanclass=identifier>parse(<spanclass=identifier>scan); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>chlit<>, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_exp(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>as_lower_d[<spanclass=literal>'e'].<spanclass=identifier>parse(<spanclass=identifier>scan); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=keyword>int_parser_t<spanclass=special>, ScannerT<spanclass=special>>::type- parse_exp_n(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return int<spanclass=identifier>_parser_t().<spanclass=identifier>parse(<spanclass=identifier>scan); }

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

-The defaultureal_parser_policies

-  uses the lower level integer numeric parsers to do its job. </span></p>
-<h2><span class=identifier>real_parser_policies</span></h2>

-<pre> template <spanclass=special><typename <spanclass=identifier>T>- struct <spanclass=identifier>real_parser_policies :public <spanclass=identifier>ureal_parser_policies<spanclass=special><T<spanclass=special>>

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

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static <spanclass=keyword>typename <spanclass=identifier>parser_result<<spanclass=identifier>sign_parser, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_sign<spanclass=special>(ScannerT<spanclass=special>& scan<spanclass=special>)- { returnsign_p<spanclass=special>.parse<spanclass=special>(scan<spanclass=special>); }

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

+ for further detail) compatible with: sign_p分析器要求连接的语义动作有与下面兼容的签名（查看<a href="semantic_actions.html#specialized_actions">特定动作</a>可获得更进一步的细节）： 

+<p><b>Signature for functions: 函数签名：</b></p>

+<pre><code> <spanclass="keyword">void func<spanclass="special">(bool<spanclass="identifier"> is_negative<spanclass="special">);</code></pre>

+<p><b>Signature for functors: 仿函数签名：</b> </p>

+<h2><span class="identifier">ureal_parser_policies</span></h2>

+<pre> template<typenameT> struct <spanclass="identifier">ureal_parser_policies <spanclass="special">{ typedefuint_parser<spanclass="special"><T<spanclass="special">, 10<spanclass="special">, 1<spanclass="special">, -1<spanclass="special">> <spanclass="identifier">uint_parser_t; typedef <spanclass="identifier">int_parser<<spanclass="identifier">T, <spanclass="number">10, <spanclass="number">1, -<spanclass="number">1> <spanclass="identifier">int_parser_t<spanclass="special">; static constbool allow_leading_dot <spanclass="special"> = true<spanclass="special">;+ static const bool <spanclass="identifier">allow_trailing_dot =true;<spanclass="special">+ static constbool expect_dot <spanclass="special"> = false<spanclass="special">;<spanclass="special"> + template <spanclass="special"><typename <spanclass="identifier">ScannerT> static typename <spanclass="identifier">match_result<spanclass="special"><ScannerT<spanclass="special">, nil_t<spanclass="special">>::type parse_sign(<spanclass="identifier">ScannerT& <spanclass="identifier">scan) {return <spanclass="identifier">scan.<spanclass="identifier">no_match();} template <spanclass="special"><typename <spanclass="identifier">ScannerT> static typename <spanclass="identifier">parser_result<spanclass="special"><<spanclass="identifier">uint_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_n<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnuint_parser_t<spanclass="special">().parse<spanclass="special">(scan<spanclass="special">); } template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><chlit<spanclass="special"><>, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_dot<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnch_p<spanclass="special">('.'<spanclass="special">).parse<spanclass="special">(scan<spanclass="special">); } template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><<spanclass="identifier">uint_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_frac_n<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnuint_parser_t<spanclass="special">().parse<spanclass="special">(scan<spanclass="special">); } template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><chlit<spanclass="special"><>, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_exp<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnas_lower_d<spanclass="special">['e'<spanclass="special">].parse<spanclass="special">(scan<spanclass="special">); } template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><int<spanclass="identifier">_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_exp_n<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnint_parser_t<spanclass="special">().parse<spanclass="special">(scan<spanclass="special">); } }; </pre>+The defaultureal_parser_policies+ uses the lower level integer numeric parsers to do its job. 默认的ureal_parser_policies用更低一层的整数分析器来完成它的工作。

+<h2><span class="identifier">real_parser_policies</span></h2>

+<pre> template <spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword">struct real_parser_policies: publicureal_parser_policies<spanclass="special"><T<spanclass="special">> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> static typenameparser_result<spanclass="special"><sign_parser<spanclass="special">, ScannerT<spanclass="special">>::type parse_sign<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { <spanclass="keyword">return sign_p<spanclass="special">.parse<spanclass="special">(scan<spanclass="special">); } <spanclass="special">};</pre>Notice how the real_parser_policies replaced <tt>parse_sign</tt>ofthe ureal_parser_policies from which it is subclassed. Thedefault real_parser_policiessimply uses a <tt>sign_p</tt> instead of <tt>scan.no_match()</tt> in the<tt>parse_sign

-  </tt> step. </p>

-<h2>strict_ureal_parser_policies andstrict_real_parser_policies</h2>-<pre> template <spanclass=special><typename <spanclass=identifier>T>- struct <spanclass=identifier>strict_ureal_parser_policies :public <spanclass=identifier>ureal_parser_policies<spanclass=special><T<spanclass=special>>

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

- static constbool expect_dot= true;<spanclass=special>

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

- template <spanclass=special><typename <spanclass=identifier>T>- struct <spanclass=identifier>strict_real_parser_policies :public <spanclass=identifier>real_parser_policies<spanclass=special><T<spanclass=special>>

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

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

+ </tt> step. 注意，real_parser_policies 是如何替换<spanstyle="font-weight: bold;">ureal_parser_policies----它的基类的<tt>parse_sign</tt> 的。默认的real_parser_policies只是在<tt>parse_sign</tt> 这步简单的使用 <tt>sign_p</tt> 替换<tt>scan.no_match()</tt>。 +<h2>strict_ureal_parser_policies andstrict_real_parser_policies</h2>+<pre> template <spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword">struct <spanclass="identifier">strict_ureal_parser_policies <spanclass="special">: public <spanclass="identifier">ureal_parser_policies<spanclass="special"><T<spanclass="special">> {+ static constbool expect_dot<spanclass="special"> = true<spanclass="special">;<spanclass="special">

+    <span class="special">};</span>
+

+ template <spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword">struct <spanclass="identifier">strict_real_parser_policies <spanclass="special">: public <spanclass="identifier">real_parser_policies<spanclass="special"><T<spanclass="special">> {+ static constbool expect_dot<spanclass="special"> = true<spanclass="special">;<spanclass="special">

+    <span class="special">};</span></pre>

Again, these policies replaced just the policies they wanted differentfrom

-  their superclasses.</p>

+ their superclasses. 再次，这些策略类只替换了那些它们想与基类不同的策略。Specialized real parser policies can reuse some of the defaultswhilereplacing a few. For example, the following is a real number parserpolicy that- parses thousands separated numbers with at most two decimal places andno exponent.+ parses thousands separated numbers with at most two decimal places andno exponent. 特化的实数分析器策略可复用一些经过小的修改的默认策略。例如，下面是一个分析千位分隔、最多两位小数、没有指数部分的实数。

 </p>

-<img src="theme/lens.gif" width="15" height="16">The full source codecan be- viewed <a href="../example/fundamental/thousand_separated.cpp">here</a>.

-<pre>

- template<typenameT>- struct <spanclass=identifier>ts_real_parser_policies :public <spanclass=identifier>ureal_parser_policies<spanclass=special><T<spanclass=special>>

-    {

- // These policies can be used to parsethousand separated

-        //  numbers with at most 2 decimal digits after the decimal
-        //  point. e.g. 123,456,789.01
-

- typedef <spanclass=identifier>uint_parser<<spanclass=keyword>int, <spanclass=number>10, <spanclass=number>1, <spanclass=number>2> <spanclass=identifier>uint2_t;- typedef <spanclass=identifier>uint_parser<<spanclass=identifier>T, <spanclass=number>10, <spanclass=number>1, -<spanclass=number>1> <spanclass=identifier>uint_parser_t;- typedef <spanclass=identifier>int_parser<<spanclass=keyword>int, <spanclass=number>10, <spanclass=number>1, -<spanclass=number>1> <spanclass=identifier>int_parser_t;

- ////////////////////////////////// 2decimal places Max- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>uint2_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_frac_n(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>uint2_t().<spanclass=identifier>parse(<spanclass=identifier>scan); }

- <spanclass=comment>////////////////////////////////// Noexponent template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>chlit<>, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_exp(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>scan.<spanclass=identifier>no_match(); }

- <spanclass=comment>////////////////////////////////// Noexponent template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>int_parser_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse_exp_n(<spanclass=identifier>ScannerT& <spanclass=identifier>scan)- { return <spanclass=identifier>scan.<spanclass=identifier>no_match(); }

- //////////////////////////////////Thousands separated numbers- template <spanclass=special><typename <spanclass=identifier>ScannerT>- static typename <spanclass=identifier>parser_result<<spanclass=identifier>uint_parser_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- <a name="scanner_save"></a>parse_n<spanclass=special>(ScannerT<spanclass=special>& scan<spanclass=special>)

-        {

- typedef typename <spanclass=identifier>parser_result<<spanclass=identifier>uint_parser_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type RT;- static <spanclass=identifier>uint_parser<<spanclass=keyword>unsigned, <spanclass=number>10, <spanclass=number>1, <spanclass=number>3> <spanclass=identifier>uint3_p;- static <spanclass=identifier>uint_parser<<spanclass=keyword>unsigned, <spanclass=number>10, <spanclass=number>3, <spanclass=number>3> <spanclass=identifier>uint3_3_p;

- if <spanclass=special>(RT hit <spanclass=special>= uint3_p<spanclass=special>.parse<spanclass=special>(scan<spanclass=special>))

-            {

- T n<spanclass=special>;- typedef typenameScannerT::iterator_t iterator_t;<spanclass=special>- iterator_t save =scan.first;- while <spanclass=special>(match<spanclass=special><> next <spanclass=special>= (',' <spanclass=special>>> uint3_3_p<spanclass=special>[assign_a<spanclass=special>(n<spanclass=special>)]).parse<spanclass=special>(scan<spanclass=special>))

-                {

- hit<spanclass=special>.value<spanclass=special>() *= 1000<spanclass=special>;- hit<spanclass=special>.value<spanclass=special>() += n<spanclass=special>;- scan<spanclass=special>.concat_match<spanclass=special>(hit<spanclass=special>, next<spanclass=special>);- save <spanclass=special>= <spanclass="identifier">scan.<spanclass="identifier">first<spanclass="special">;

-                }

- scan.first<spanclass="special"> = save;- return <spanclass=identifier>hit;

- // Note: On erroneous inputsuch as "123,45", the result should // be apartial match "123". 'save' is used to makes surethat // the scanner position is placed at the last*valid* parse // position. }- return <spanclass=identifier>scan.<spanclass=identifier>no_match();

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

+<img src="theme/lens.gif" height="16" width="15">The full source codecan be+ viewed <ahref="../example/fundamental/thousand_separated.cpp">here</a>. <imgsrc="theme/lens.gif" height="16" width="15">完整的代码在 <ahref="../example/fundamental/thousand_separated.cpp">这里</a>。 +<pre> template<typenameT> struct <spanclass="identifier">ts_real_parser_policies :public <spanclass="identifier">ureal_parser_policies<spanclass="special"><T<spanclass="special">> { //These policies can be used to parse thousand separated //numbers with at most 2 decimal digits after the decimal //point. e.g. 123,456,789.01 // 这些策略可用于分析小数点后最多两位数字的千位分隔数值。如 123,456,789.01 typedef <spanclass="identifier">uint_parser<<spanclass="keyword">int, <spanclass="number">10, <spanclass="number">1, <spanclass="number">2> <spanclass="identifier">uint2_t; typedef <spanclass="identifier">uint_parser<<spanclass="identifier">T, <spanclass="number">10, <spanclass="number">1, -<spanclass="number">1> <spanclass="identifier">uint_parser_t; typedef <spanclass="identifier">int_parser<<spanclass="keyword">int, <spanclass="number">10, <spanclass="number">1, -<spanclass="number">1> <spanclass="identifier">int_parser_t<spanclass="special">; <spanclass="comment">////////////////////////////////// 2 decimal places Max 最多两位数字 template <spanclass="special"><typename <spanclass="identifier">ScannerT> static typename <spanclass="identifier">parser_result<spanclass="special"><uint2_t<spanclass="special">, ScannerT<spanclass="special">>::type parse_frac_n(<spanclass="identifier">ScannerT& <spanclass="identifier">scan) {return <spanclass="identifier">uint2_t().<spanclass="identifier">parse(<spanclass="identifier">scan);} <spanclass="comment">////////////////////////////////// No exponent 无指数 template <spanclass="special"><typename <spanclass="identifier">ScannerT> static typename <spanclass="identifier">parser_result<spanclass="special"><chlit<spanclass="special"><>, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_exp<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnscan<spanclass="special">.no_match<spanclass="special">(); } ////////////////////////////////// Noexponent 无指数 template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><<spanclass="identifier">int_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type parse_exp_n<spanclass="special">(ScannerT<spanclass="special">& scan<spanclass="special">) { returnscan<spanclass="special">.no_match<spanclass="special">(); } <spanclass="comment">////////////////////////////////// Thousands separatednumbers 千位分隔数值 template<typenameScannerT<spanclass="special">> statictypename parser_result<spanclass="special"><<spanclass="identifier">uint_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type <aname="scanner_save"></a>parse_n(<spanclass="identifier">ScannerT& <spanclass="identifier">scan) { typedef typename <spanclass="identifier">parser_result<spanclass="special"><<spanclass="identifier">uint_parser_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type RT; static <spanclass="identifier">uint_parser<<spanclass="keyword">unsigned, <spanclass="number">10, <spanclass="number">1, <spanclass="number">3> <spanclass="identifier">uint3_p; static <spanclass="identifier">uint_parser<<spanclass="keyword">unsigned, <spanclass="number">10, <spanclass="number">3, <spanclass="number">3> <spanclass="identifier">uint3_3_p<spanclass="special">; if(RT hit= <spanclass="identifier">uint3_p.<spanclass="identifier">parse(<spanclass="identifier">scan)) { T n<spanclass="special">; typedeftypename ScannerT::iterator_titerator_t;+ iterator_t save =scan.first; <spanclass="keyword">while (<spanclass="identifier">match<> <spanclass="identifier">next = (<spanclass="literal">',' >> <spanclass="identifier">uint3_3_p[<spanclass="identifier">assign_a(<spanclass="identifier">n)]).<spanclass="identifier">parse(<spanclass="identifier">scan)) { hit<spanclass="special">.value<spanclass="special">() *= 1000<spanclass="special">; <spanclass="identifier">hit.<spanclass="identifier">value() += <spanclass="identifier">n; scan<spanclass="special">.concat_match<spanclass="special">(hit<spanclass="special">, next<spanclass="special">); <spanclass="identifier">save <spanclass="special">= scan<spanclass="special">.first<spanclass="special">;

+                }

+ scan.first<spanclass="special"> = save; return <spanclass="identifier">hit; <spanclass="special"> // Note: On erroneous input suchas "123,45", the result should // be a partialmatch "123". 'save' is used to makes sure that // thescanner position is placed at the last *valid* parse //position. // 注：当输入错误时，如 "123,45"，结果会是部分匹配 "123"。'save' 用于确保 // 扫描器位置位于最后的 *有效* 分析位置。 } return <spanclass="identifier">scan.<spanclass="identifier">no_match(); } };</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-2002 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 1998-2002 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>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/operators.html       Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/operators.html       Wed Sep 16 20:25:53 2009
@@ -1,81 +1,79 @@
-<html>
-<head>
-<title>Operators</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>Operators</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%">

- Operators+ Operators 操作符

     </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="primitives.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="numerics.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

Operators are used as a means for object composition and embedding.Simpleparsers may be composed to form composites through operator overloading,craftedto approximate the syntax of an Extended Backus-Normal Form (EBNF)variant.

-  An expression such as:</p>

-<pre><code> a <spanclass=special>| b</code></pre>+ An expression such as: 操作符用于对象的组合和内嵌。简单的分析器可以经由操作符重载组合而成合成分析器，构造类似于EBNF的语法变体。诸如下面的表达式：+<pre><code> a| <spanclass="identifier">b</code></pre>actually yields a new parser type which is a composite of its operands,a andb. Taking this example further, if a and b were of type<tt>chlit</tt><>,

-  the result would have the composite type:</p>

-<pre><code> <spanclass=identifier>alternative<<spanclass=identifier>chlit<>, <spanclass=identifier>chlit<> <spanclass=special>></code></pre>+ the result would have the composite type: 实际上构成了一个新的分析器，它的类型由两个操作子组合而成，a与b。在这例子上更进一步，如果a和b的类型是 <tt>chlit</tt><>，那么结果就是一个合成的类：+<pre><code> <spanclass="identifier">alternative<<spanclass="identifier">chlit<>, <spanclass="identifier">chlit<> <spanclass="special">></code></pre> In general, for any binary operator, it will take its two arguments,parser1

-  and parser2, and create a new composed parser of the form</p>

-<pre><code> op<spanclass=special><parser1<spanclass=special>, parser2<spanclass=special>></code></pre>+ and parser2, and create a new composed parser of the form 总而言之，任意二元操作符都接受两个参数，parser1 和 parser2，并创建一个新的合成分析器，形式为：+<pre><code> <spanclass="identifier">op<<spanclass="identifier">parser1, <spanclass="identifier">parser2<spanclass="special">></code></pre>where parser1 and parser2 can be arbitrarily complex parsersthemselves, with

-  the only limitations being what your compiler imposes. </p>
-<h3>Set Operators</h3>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="3">Set operators</td>

+ the only limitations being what your compiler imposes. 其中 parser1和 parser2 可以是任意复杂的分析器，他们的复杂度仅取决于编译期的限制。 

+<h3>Set Operators 集合操作符</h3>
+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="3">Set operators 集合操作符</td>
   </tr>
   <tr>

- <td class="table_cells" width="20%"><code>a|

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="24%">Union</td>

- <td class="table_cells" width="56%">Match a or b. Also referred to asalternative</td>+ <td class="table_cells" width="20%"><code>a|

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="24%">Union<br>并集</td>

+ <td class="table_cells" width="56%">Match a or b. Also referred to asalternative 匹配a或b。也叫选择操作符</td>

   </tr>
   <tr>

- <td class="table_cells" width="20%"><code>a&

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="24%">Intersection</td>
-    <td class="table_cells" width="56%">Match a and b</td>

+ <td class="table_cells" width="20%"><code>a&

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="24%">Intersection<br>交集</td>
+    <td class="table_cells" width="56%">Match a and b<br>同时匹配a和b</td>
   </tr>
   <tr>

- <td class="table_cells" width="20%"><code>a-

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="24%">Difference</td>

+ <td class="table_cells" width="20%"><code>a-

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="24%">Difference<br>差集</td>

<td class="table_cells" width="56%">Match a but not b. If both matchand b's- matched text is shorter than a's matched text, a successful match ismade</td>+ matched text is shorter than a's matched text, a successful match ismade 匹配a，但并不匹配b。如果二者同时匹配且b的匹配串长度小于a的匹配串长度，那么认为匹配成功</td>

   </tr>
   <tr>

- <td class="table_cells" width="20%"><code>a^

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="24%">XOR</td>
-    <td class="table_cells" width="56%">Match a or b, but not both</td>

+ <td class="table_cells" width="20%"><code>a^

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="24%">XOR<br>异或</td>

+ <td class="table_cells" width="56%">Match a or b, but not both 匹配a或b，但不同时匹配二者</td>

   </tr>
-</table>
-<p><b>Short-circuiting</b></p>
+</tbody></table>
+<p><b>Short-circuiting 短路行为</b></p>

Alternative operands are tried one by one on a first come first servedbasisstarting from the leftmost operand. After a successfully matchedalternativeis found, the parser concludes its search, essentially short-circuitingthesearch for other potentially viable candidates. This short-circuitingimplicitly

-  gives the highest priority to the leftmost alternative.</p>

+ gives the highest priority to the leftmost alternative. 选择符自左向右以先到先得的方式逐个测试它的操作数。当成功地找到一个可选匹配之后，分析器就结束搜索，从而彻底停止搜索潜在的匹配，也就是短路搜索。这种短路行为隐式地给予最左边的选项以最高优先级。Short-circuiting is done in the same manner as C or C++'s logicalexpressions;e.g. <tt>if</tt> <tt>(x <spanclass="operators"><3 || y <spanclass="operators">< 2)</tt>

@@ -84,139 +82,143 @@

rule for alternatives which is necessary, given the non-deterministicnatureof the Spirit parser compiler, short-circuiting improves the executiontime.If the order of your alternatives is logically irrelevant, strive to putthe

-  (expected) most common choice first for maximum efficiency.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/lens.gif" width="15" height="16">Intersections + (expected) most common choice first for maximum efficiency. 这种短路在C/C++的表达式中同样存在：比如在 <tt>if</tt> <tt><spanclass="operators">(x <+ 3 || y <spanclass="operators">< 2<spanclass="operators">)</tt> 中，如果x小于3成立，那么y<2这个条件根本就不+会被测试。短路行为除了给予选项必要的隐式优先级规则，还赋予Spirit分析器非确定性行为，从而缩短了执行时间。如果你的选项的顺序与表达式的逻辑没+有关系，那么尽可能的把最可能出现的匹配项放在最前面，这样可以将效率最大化。

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

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

       <br>

Some researchers assert that the intersections (e.g. <tt>a &b</tt>)- let us define context sensitive languages (<ahref="references.html#intersections">"XBNF"</a>- [citing Leu-Weiner, 1973]). "The theory of defining a languageas the+ let us define context sensitive languages (<ahref="references.html#intersections">"XBNF"</a>

+      [citing Leu-Weiner, 1973]). "The theory of defining a language as the

intersection of a finite number of context free languages wasdeveloped

-      by Leu and Weiner in 1973&quot;.<br>

+ by Leu and Weiner in 1973". 某些研究者断言，交集（如 <tt>a &b</tt>）使我们能够定义语境相关的语法(<ahref="references.html#intersections">"XBNF"</a><ahref="http://www.boost.org/libs/spirit/doc/references.html#intersections";></a>[citing Leu-Weiner, 1973])。"定义一个语言，使之成为有限语境无关语言的交集的理论，由Leu 和 Weiner在1973年提出"。 

       <br>

- <img src="theme/lens.gif" width="15" height="16"> ~Operator + <img src="theme/lens.gif" height="16" width="15"> ~ Operator 取反操作符 

       <br>

The complement operator <tt>~</tt> was originally put intoconsideration.Further understanding of its value and meaning leads us touncertainty.The basic problem stems from the fact that <tt>~a</tt> will yield<tt>U-a</tt>,where <tt>U</tt> is the universal set of all strings. However, whereitmakes sense, some parsers can be complemented (see the <ahref="primitives.html#negation">primitive

-      character parsers</a> for examples).</td>

+ character parsers</a> for examples). 最初是打算实现取反操作符~的。但是随着对它的值和含义的进一步理解，我们变得没那么确定了。问题来源于这里：<tt>~a</tt> 将产生 <tt>U-a</tt>，其中 <tt>U</tt> 是所有串的全集。然而，对某些分析器来说，求反是有意义的（相关例子在<ahref="primitives.html#negation">单字符分析器</a>）。</td>

   </tr>
-</table>
-<h3>Sequencing Operators</h3>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="3">Sequencing operators</td>
+</tbody></table>
+<h3>Sequencing Operators 序列操作符</h3>
+<table align="center" border="0" width="90%">
+  <tbody><tr>

+ <td class="table_title" colspan="3">Sequencing operators 序列操作符</td>

   </tr>
   <tr>

- <td class="table_cells" width="21%"><code>a>>

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="23%">Sequence</td>
-    <td class="table_cells" width="56%">Match a and b in sequence</td>

+ <td class="table_cells" width="21%"><code>a>>

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="23%">Sequence <br>并置</td>

+ <td class="table_cells" width="56%">Match a and b in sequence 顺序匹配a和b</td>

   </tr>
   <tr>

- <td class="table_cells" width="21%"><code>a&&

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="23%">Sequential-and</td>

+ <td class="table_cells" width="21%"><code>a&&

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="23%">Sequential-and<br>顺序与</td>

<td class="table_cells" width="56%">Sequential-and. Same as above,match a

-      and b in sequence</td>
+      and b in sequence<br>顺序与，与上面类似，顺序匹配a与b</td>
   </tr>
   <tr>

- <td class="table_cells" width="21%"><code>a||

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="23%">Sequential-or</td>
-    <td class="table_cells" width="56%">Match a or b in sequence</td>

+ <td class="table_cells" width="21%"><code>a||

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="23%">Sequential-or<br>顺序或</td>

+ <td class="table_cells" width="56%">Match a or b in sequence 顺序匹配a或b</td>

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

The sequencing operator <tt class="operators">>></tt> canalternativelybe thought of as the sequential-and operator. The expression <tt>a <spanclass="operators">&&b</tt> reads as match a and b in sequence. Continuing this logic, we canalsohave a sequential-or operator where the expression <tt>a <spanclass="operators">||b</tt> reads as match a or b and in sequence. That is, if both a and bmatch,- it must be in sequence; this is equivalent to <tt>a >> !b |b</tt>. 

-<h3>Optional and Loops</h3>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="3">Optional and Loops</td>

+ it must be in sequence; this is equivalent to <tt>a >> !b |b</tt>. 可以认为并置操作符 <tt class="operators">>></tt> 和顺序与一样。表达式 <tt>a &&+ b</tt> 读作顺序匹配a与b。照着这个逻辑，我们就有了顺序或操作符，它的表达式 <tt>a ||+ b</tt> 读作顺序匹配a或b。即，如果a与b都匹配了，那么他们一定是按顺序匹配的。这个表达式等价于 <tt>a >> !b | b</tt>. 

+<h3>Optional and Loops 可选与循环</h3>
+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_title" colspan="3">Optional and Loops 可选与循环</td>
   </tr>
   <tr>

- <td class="table_cells" width="21%"><code><spanclass=special>*a</code></td>

-    <td class="table_cells" width="23%">Kleene star</td>
-    <td class="table_cells" width="56%">Match a zero (0) or more times</td>

+ <td class="table_cells" width="21%"><code><spanclass="special">*a</code></td>

+    <td class="table_cells" width="23%">Kleene star<br>克林闭包</td>

+ <td class="table_cells" width="56%">Match a zero (0) or moretimes 匹配a 零到任意多次</td>

   </tr>
   <tr>

- <td class="table_cells" width="21%"><code><spanclass=special>+a</code></td>

-    <td class="table_cells" width="23%">Positive</td>
-    <td class="table_cells" width="56%">Match a one (1) or more times</td>

+ <td class="table_cells" width="21%"><code><spanclass="special">+a</code></td>

+    <td class="table_cells" width="23%">Positive<br>加号</td>

+ <td class="table_cells" width="56%">Match a one (1) or more times 匹配a 一到任意多次</td>

   </tr>
   <tr>

- <td class="table_cells" width="21%"><code><spanclass=special>!a</code></td>

-    <td class="table_cells" width="23%">Optional</td>

- <td class="table_cells" width="56%">Match a zero (0) or one (1)time</td>+ <td class="table_cells" width="21%"><code><spanclass="special">!a</code></td>

+    <td class="table_cells" width="23%">Optional<br>可选</td>

+ <td class="table_cells" width="56%">Match a zero (0) or one (1)time 匹配a零次或一次</td>

   </tr>
   <tr>

- <td class="table_cells" width="21%"><code>a%

-      </span><span class=identifier>b</span></code></td>
-    <td class="table_cells" width="23%">List</td>

+ <td class="table_cells" width="21%"><code>a%

+      </span><span class="identifier">b</span></code></td>
+    <td class="table_cells" width="23%">List<br>列表</td>

<td class="table_cells" width="56%">Match a list of one or morerepetitionsof a separated by occurrences of b. This is the same as <tt>a>> *(b- >> a)</tt>. Note that <tt>a</tt> must not also match<tt>b</tt></td>+ >> a)</tt>. Note that <tt>a</tt> must not also match<tt>b </tt>匹配出现任意多 a 的列表，表中各项由 b 分隔。等同于 <tt>a>> *(b

+      &gt;&gt; a)</tt>。注意，<tt>a</tt> 必须不能也匹配 <tt>b</tt></td>
   </tr>
-</table>

-<img src="theme/note.gif" width="16" height="16"> If we look moreclosely,

+</tbody></table>

+<img src="theme/note.gif" height="16" width="16"> If we look moreclosely,take note that we generalized the optional expression of the form<tt>!a</tt>in the same category as loops. This is logical, considering that theoptional

-  matches the expression following it zero (0) or one (1) time. </p>
-<p><b>Primitive type operands</b></p>

+ matches the expression following it zero (0) or one (1) time. 如果看得更近一些，会注意到 <tt>!a</tt> 这种形式的可选符被划分到循环这类里。这是逻辑上的划分，可以认为可选符循环它的操作子0或1次。 

+<p><b>Primitive type operands 基本的类型操作数</b></p>

 For binary operators, one of the operands but not both may be a<tt>char</tt>,<tt> wchar_t</tt>, <tt>char const*</tt>or <tt>wchar_tconst*</tt>. Where P is a parser object,here

-  are some examples:</p>

-<pre><code> P| 'x'- P -L"Hello World"- 'x' >>P- "bebop" >>P</code></pre>+ are some examples: 对于二元操作符，他们的操作数中的一个，且只有一个可以是 <tt>char</tt>,+ <tt> wchar_t</tt>, <tt>char const*</tt>or <tt>wchar_t+ const*</tt>。下面是一些例子，其中 P 是分析器对象：+<pre><code> P| 'x' P -L"HelloWorld" 'x' <spanclass="special">>> P "bebop" >>P</code></pre>It is important to emphasize that C++ mandates that operators may onlybe overloadedif at least one argument is a user-defined type. Typically, in anexpressioninvolving multiple operators, explicitly typing the leftmost operand asa parseris enough to cause propagation to all the rest of the operands to itsright

-  to be regarded as parsers. Examples:</p>

-<p>The second case is parsed as follows:</p>

-<pre><code> r <imgsrc="theme/arrow.gif"> (((<spanclass=identifier>chlit<<spanclass=keyword>char> <spanclass=special>| char)| char<spanclass=special>) | <spanclass=keyword>char)

- a <img src="theme/arrow.gif"> <spanclass=special>(chlit<spanclass=special><char<spanclass=special>> | <spanclass=keyword>char)- r <img src="theme/arrow.gif"> <spanclass=special>(((a<spanclass=special>) | <spanclass=keyword>char) |char)

- b <img src="theme/arrow.gif"> <spanclass=special>(a |char)- r <img src="theme/arrow.gif"> <spanclass=special>(((b<spanclass=special>)) | <spanclass=keyword>char)

- c <img src="theme/arrow.gif"> <spanclass=special>(b |char)- r <img src="theme/arrow.gif"> <spanclass=special>(((c<spanclass=special>)))</code></pre>

-<p><b>Operator precedence and grouping</b></p>

+ to be regarded as parsers. Examples: 必须强调，C++要求只有在至少一个操作数为用户定义类型时，才允许操作符重载。一般而言，在一个包涵多个操作符的表达式中，显式地将最左边的操作数的类型声明为分析器就足以使其他的操作数也被视为分析器了。例如：+<pre><code> <spanclass="identifier">r = <spanclass="literal">'a' | <spanclass="literal">'b' | <spanclass="literal">'c' | <spanclass="literal">'d'; <spanclass="comment">// 错误形式 r= <spanclass="identifier">ch_p(<spanclass="literal">'a') <spanclass="special">| 'b' <spanclass="special">| 'c' <spanclass="special">| 'd'<spanclass="special">; //OK</code></pre>

+<p>The second case is parsed as follows:<br>第二个表达式是这样分析的：</p>

+<pre><code> r <imgsrc="theme/arrow.gif"> (((<spanclass="identifier">chlit<<spanclass="keyword">char> <spanclass="special">| char<spanclass="special">) | <spanclass="keyword">char) <spanclass="special">| char<spanclass="special">)

+ a <img src="theme/arrow.gif"> <spanclass="special">(chlit<spanclass="special"><char<spanclass="special">> | <spanclass="keyword">char)+ r <img src="theme/arrow.gif"> <spanclass="special">(((a<spanclass="special">) | <spanclass="keyword">char) <spanclass="special">| char<spanclass="special">)

+ b <img src="theme/arrow.gif"> <spanclass="special">(a <spanclass="special">| char<spanclass="special">)+ r <img src="theme/arrow.gif"> <spanclass="special">(((b<spanclass="special">)) | <spanclass="keyword">char)

+ c <img src="theme/arrow.gif"> <spanclass="special">(b <spanclass="special">| char<spanclass="special">)+ r <img src="theme/arrow.gif"> <spanclass="special">(((c<spanclass="special">)))</code></pre>

+<p><b>Operator precedence and grouping 操作符优先级和分组</b></p>

Since we are defining our meta-language in C++, we follow C/C++'soperatorprecedence rules. Grouping expressions inside the parentheses overridethis(e.g., <tt>*(a |b)</tt> reads: match a or b zero (0) ormore

-  times). </p>

+ times). 由于我们的元语言是在C++里定义的，我们必须遵守C/C++的操作符优先级规则。把表达式用括号分组则可超越这个规则。比如，<tt><spanclass="operators">*(a |+ b)</tt> 解读为：匹配a或b零到任意多次。

 <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 (c) 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>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/organization.html Sat Oct 4 05:29:092008+++ /trunk/libs/spirit/classic/doc/organization.html Wed Sep 16 20:25:532009

@@ -1,19 +1,16 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>





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

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




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

 <body>

@@ -382,47 +379,47 @@
 </table>

-Spirit有四层，再加一个独立的顶层。独立的那层由行为器和迭代器组成，不依赖于其他层。框架的结构是完全正交的。层与层之间的关系是无循环的。下层不需要依赖或了解上层。

-  同一层的模块之间也不互相依赖。 </p>

+Spirit有四层，再加一个独立的顶层。独立的那层由动作器和迭代器组成，不依赖于其他层。框架的结构是完全正交的。层与层之间的关系是无循环的。下层不需要依赖或了解上层。同一层的模块之间也不互相依赖。 

-客户可以只使用需要的模块，而不会带来任何的编译器或运行期的负担。最小的使用方法是仅仅使用内核core。高度流水化内核本身就是可用的。内核core足够执行一些如宏解析的任务。+客户可以只使用需要的模块，而不会带来任何的编译器或运行期的负担。最小的使用方法是仅仅使用内核core。这个高度流水化的内核是自给自足的。内核core足以执行一些如宏解析这样的任务。

-迭代器iterator模块是独立于Spirit的，它也可用于非Spirit的应用。这个模块的编制包括独立的迭代器和迭代器的Spirit兼容包装。随着时间的流逝，这些迭代器被发现是最有用的Spirit解析工具。 +迭代器iterator模块是独立于Spirit的，它也可用于非Spirit的应用。这个模块包括独立的迭代器和迭代器的Spirit兼容封装。时间已经证明，这些迭代器被发现是最有用的Spirit解析工具。 

-行为器actor模块，也是独立于Spirit，编制为预定义的语义行为，包含了最常用的语义操作任务。+动作器actor模块，也是独立于Spirit的，汇集了预定义的语义动作，包含了最常用的语义处理任务。

-调试器debug模块提供对库的解析调试。这个模块穿过中间层次，直接把自己挂接在内核上，并且是非侵入式的和仅仅在需要的地方挂接。-属性attribute模块引入了高阶语义行为机制，利用经继承和综合的属性对象，加强了在解析器层次间提取和传递数据。属性也可以用来实际控制解析过程。参数化的解析器是动态的，能够基于一些属性或者数据，在运行时改变行为。+调试器debug模块提供对库的解析调试。这个模块穿过中间层次，直接把自己挂接在内核上，是非侵入式的，且仅在需要的地方挂接。+属性attribute模块引入了高阶语义动作机制，通过属性的继承和合成，加强了在解析器层次间提取和传递数据。属性也可以用来实际控制解析过程。参数化的解析器是动态的，能够基于一些属性或者数据，在运行时改变行为。



-<p>动态<strong>dynamic</strong>模块关注在解析器在运行时能改变行为。</p>
+<p>动态<strong>dynamic</strong>模块关注的是在运行时能改变行为的解析器。</p>

-出错处理error_handling。没有出错处理的框架是不完整的框架。 C++的异常（exception）处理机制是可以完美地实现Spirit的出错处理，因为它的高度可递归的函数本质。在这个模块中，C++异常被广泛用作出错处理。+出错处理error_handling。没有出错处理的框架是不完整的框架。C++的异常（exception）处理机制是可以完美地实现Spirit的出错处理，因为它的高度可递归的函数本质。在这个模块中，C++异常被广泛用作出错处理。

-符号symbols模块关注于符号表管理。这个模块现在是非常基础的。目标是建立一个子框架，可以容纳C++风格的多可见域机制。 C++是一个伟大的模型，在控制可见域的复杂度上可能其他语言无出其右。- 那里有类和继承，私有、保护和公有访问限制，友元，命名空间，using声明，using指示符，Koenig查找（参数依赖查找）等等。我们现有的符号表功能是一个基础部件，为了以后完全模拟和实现C++的可见域功能。+符号symbols模块关注于符号表管理。这个模块现在还很简陋。目标是建立一个子框架以适应C++风格的多重范围控制机制。C+++是一个伟大的模型，在范围控制的复杂度上可能其他语言无出其右。那里有类和继承，私有、保护和公有访问限制，友元，命名空间，using声明，+using指示符，Koenig查找（参数依赖查找）等等。我们现有的符号表功能是一个基础部件，为了以后完全模拟和实现C++的以上功能。



 <blockquote>

- 我盼望我能够看见，一个结构如同树般美… （I wish that I could ever see, a structure as lovely+ 我盼望我能够看见，一个结构如同树般美... （Iwish that I could ever see, a structure as lovely

     as a tree</font></em><font color="#003366">...）</font></p>


 </blockquote>

- 解析树和抽象语法树（AST）的产生通过树Tree模块处理。使用解析树和抽象语法树，比使用语义行为有若干优点。你可以多次传递数据而不用每次都重新解析输入。你可以对树进行转换。你可以以任意的顺序进行计算，但是按照属性计划你必须从头到尾处理。你不须担心在有歧义的文法中可能发生的反向作用和行为附作用。+ 解析树和抽象语法树（AST）的产生通过树Tree模块处理。使用解析树和抽象语法树，比使用语义动作有若干优点。你可以多次传递数据而不用每次都重新解析输入。你可以对树进行转换。你可以以任意的顺序进行计算，但是按照属性计划你必须从头到尾处理。你无须担心在有歧义的文法中可能发生的回溯和动作副作用。

-有用部件utility模块有很多通用的解析器和一些有用的支持类，适用于普通的任务例如表处理，注释，confix表达式，等等。+工具部件utility模块有很多通用的解析器和一些有用的支持类，适用于普通的任务，例如表处理、注释、confix表达式，等等。

元meta, 为高端Spirit开发者提供元编程工具。这个模块使Spirit解析器的编译时和运行时的内部分析设计更方便。

@@ -460,7 +457,7 @@


 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 1998-2003 Joel de Guzman<br>


   <br>
@@ -474,5 +471,4 @@
 <p class="copyright">&nbsp;</p>


-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/preface.html Sat Oct  4 05:29:09 2008
+++ /trunk/libs/spirit/classic/doc/preface.html Wed Sep 16 20:25:53 2009
@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -17,17 +16,15 @@



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

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







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

 <body>

@@ -145,9 +142,9 @@


       <p>

- “作为设计的例子要符合多数的“好”标准（如：易读性，灵活

+            <i>"作为设计的例子要符合多数的"好"标准（如：易读性，灵活
 性，有效性）。递归下降解析器，作为传统的过程化代码，正是这样的一个好例子。

-另外一个例子是STL，它是一个基于传统过程化代码与参数化多态性的通用的容器与算法的库。”+另外一个例子是STL，它是一个基于传统过程化代码与参数化多态性的通用的容器与算法的库。"

           </p>


@@ -185,7 +182,7 @@

-十五年前，我用Pascal写下了自己的第一计算器。这是一段难忘的编程经历，我惊讶于一组互相递归的函数集如何相互协作并表达出一个特定文法模+十五年前，我用Pascal写下了自己的第一个计算器。这是一段难忘的编程经历，我惊讶于一组互相递归的函数集如何相互协作并表达出一个特定文法模型。同时，我从这个学术经验中得到的技能是很有用的。时不时地，我被分派到一些写解析器的任务。例如：每当需要执行任何形式的输入/输出操作，即使是二进制形式，我完成任务的途径都是，先写好一个类Pascal的语法分析图，再写一个相应的递归下降

 解析器。这样运作良好。 </p>
@@ -202,11 +199,11 @@

- 它必须能实用地解析简单的文法（例如emal地址）到适度复杂的文法（例如XML和一些小的脚本语言）。+ 它必须能实用地解析简单的文法（例如email地址）到适度复杂的文法（例如XML和一些小的脚本语言）。可伸缩性是一个主要的目标。当你用它解决小任务例如命令行解析时，并不会带来很重的运行开销，而当你用YACC或PCCTS时则不然。-到现在，它已经进化并成熟，已经成为一个多模块的库，这正如最初的目的，Spirit仍然可以用在极小的解析任务中。

-只有你需要的特性才会产生开销。Spirit的威力在于它的模块性和可扩充性。

-不同于用一把万能而笨重的锤子，它能使你很容易地订制一把有恰当成分的锤子。例如，它没有 lexer+到现在，它已经进化并成熟，已经成为一个由多个模块组成的库，正如最初的目的，Spirit仍然可以用在极小的解析任务中。

+只有你需要的特性才会产生开销。Spirit的威力在于它的模块化和可扩充性。

+不同于一把万能而笨重的锤子，它能使你很容易地订制一把有恰当分量的锤子。例如，它没有 lexer

 ，但它提供了所有的原始材料，如果你想要，你就写一个。 </p>


@@ -214,8 +211,8 @@

考虑以上种种，结果就是 Spirit。我在日本做R&D开发时构思出Spirit 这个个人项目。受到GoF的合成和解释模式启发，我意识到可以把递归下降解析器模型化为一个由终端对象和合成对象构成的层次组合。-最初的版本是用运行时多态性来实现的。通过提供描述合成规则的字符串（例<tt>"prod ::= {‘A’- | ‘B’} ‘C’;"</tt>），解析器在运行时产生。一个函数对编译出解析器，动态创建对象的层次组合和对象间语义连接。很早前的参考文本在 <ahref="http://spirit.sourceforge.net/dl_docs/pre-spirit.htm";>这里</a> 找到。+最初的版本是用运行时多态性来实现的。通过提供描述合成规则的字符串（例<tt>"prod ::= {'A'+ | 'B'} 'C';"</tt>），解析器在运行时产生。一个编译函数对其编译出解析器，动态创建对象的层次组合和对象间的语义连接。早期的参考文档在 <ahref="http://spirit.sourceforge.net/dl_docs/pre-spirit.htm";>这里</a> 找到。

     </p>


@@ -230,7 +227,7 @@

在它最初的开源发布（2001年5月）之后， static-Spirit 得到了胜利。在大约 2001年11月，Spirit的网站有98%的活动百分点，一跃成为 Source Forge- 当时排名第一的解析器。对于这般一个小项目(一个解析器库)，已经是不错的了。  后来"static"这个词被省略， static-Spirit 简称为 Spirit。整个框架很快地进化，拥有更多动态特性。+ 当时排名第一的解析器。对于这样一个小项目(一个解析器库)，已经是不错的了。  后来"static"这个词被省略， static-Spirit 简称为 Spirit。整个框架很快地进化，拥有更多动态特性。

     </p>


@@ -244,7 +241,7 @@


 <p>

- Spirit的框架以逻辑模块来组织，首先以内核开始。这个文档提供一个用户向导和每个模块的使用参考。一个简单和干净的代码离子值得用一百行文档介绍；因此，用户向导里有丰富的例子，带有注释和一步步的解析。用户向导多数是基于例子的。+ Spirit的框架以逻辑模块来组织，首先以内核开始。这个文档提供一个用户指南和每个模块的使用参考。一个简单和干净的代码例子顶得上一百行的文档介绍；因此，用户指南里有丰富的例子，带有注释和一步步的解析。用户指南多数是基于例子的。

     </p>


@@ -314,7 +311,7 @@


               <td class="table_cells" width="627">
-                提供的信息是适当地重要，应该得到读者注意。
+                提供的信息比较重要，应该得到读者注意。
               </td>


@@ -391,7 +388,7 @@


               <td class="table_cells" width="627">
-                有潜在的作用的一小块信息。
+                有潜在作用的一小块信息。
               </td>


@@ -592,7 +589,7 @@
 <hr size="1">

 <p class="copyright">
-      Copyright &copy; 1998-2003 Joel de Guzman<br>
+      Copyright (c) 1998-2003 Joel de Guzman<br>



@@ -615,5 +612,4 @@



-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/primitives.html      Sat Oct  4 05:29:09 2008
+++ /trunk/libs/spirit/classic/doc/primitives.html      Wed Sep 16 20:25:53 2009
@@ -1,6 +1,5 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -21,8 +20,8 @@



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

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




@@ -36,9 +35,7 @@



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

 <body>

@@ -207,7 +204,7 @@

-框架预定义了一些基元解析器。这里有最底层的建造单元，用户可用它来构造更复杂的解析器。这些基元解析器是模板类，这使它们很灵活。+框架预定义了一些基元解析器。这里有最底层的建造单元，用户可用它来构造更复杂的解析器。这些基元解析器是模板类，这使它们很灵活。




@@ -215,7 +212,7 @@

-这些基元解析器能够直接实例化或者通过一个模板帮助函数。一般来说，帮助函数是非常容易处理，因为它需要更少输入。+这些基元解析器能够直接实例化或者通过一个模板辅助函数。一般来说，辅助函数是非常容易处理，因为它需要更少输入。




@@ -223,8 +220,7 @@



-<p>我很已经见过字面字符解析器，通过函数<tt>ch_p</tt> 就可以产生。

- 类 <tt>chlit<CharT></tt> 是隐藏在字面解析器背后的实际的模板类。要去实例化一个<tt>chlit</tt>对象，你必须在模板参数中显示提供字符的类型，<tt>CharT</tt>，来确定字符的类型。这个类型正是和输入类型相关，通常是<tt>char</tt> 或者 <tt>wchar_t</tt>。下面的表达式创建一个临时的解析器对象，只识别单个子 'X' 。+我很已经见过字面字符解析器，通过函数<tt>ch_p</tt> 就可以产生。类<tt>chlit<CharT></tt> 是隐藏在字面解析器背后的实际的模板类。要去实例化一个<tt>chlit</tt>对象，你必须在模板参数中显示提供字符的类型，<tt>CharT</tt>，来确定字符的类型。这个类型正是和输入类型相关，通常是<tt>char</tt> 或者 <tt>wchar_t</tt>。下面的表达式创建一个临时的解析器对象，只识别单个子 'X' 。




@@ -240,7 +236,7 @@

-用<tt>chlit</tt>的产生函数 <tt>ch_p</tt> 能简化<tt>chlit<></tt>类的使用（这是大多数Spirit解析器类的情况，多数都有相应的产生函数）。调用函数更方便，因为编译器会自动进行参数推导得模板类型。上面的例子可以用更简短的方式表达，用<tt>ch_p</tt>帮助函数。 +用<tt>chlit</tt>的产生函数 <tt>ch_p</tt> 能简化<tt>chlit<></tt>类的使用（这是大多数Spirit解析器类的情况，多数都有相应的产生函数）。调用函数更方便，因为编译器会自动进行参数推导得模板类型。上面的例子可以用更简短的方式表达，用<tt>ch_p</tt>帮助函数。 




@@ -330,7 +326,7 @@

-<pre><code> // 一个规则rule 可以“保存”一个解析器对象。规则rule将以后介绍 // ，但是现在只把规则rule考虑为一个黑匣，不需要知道内部实现 rule<spanclass="special"><> r1<spanclass="special">, r2<spanclass="special">, r3<spanclass="special">; <spanclass="identifier">chlit<<spanclass="keyword">char> <spanclass="identifier">x(<spanclass="literal">'X'); <spanclass="comment">// 声明有名解析器 x <spanclass="identifier">r1 = <spanclass="identifier">chlit<<spanclass="keyword">char>(<spanclass="literal">'X'); <spanclass="comment">// 显式声明 r2= <spanclass="identifier">x;// 使用 x <spanclass="identifier">r3 = <spanclass="identifier">ch_p(<spanclass="literal">'X') <spanclass="comment">// 使用生成器</code></pre>+<pre><code> // 一个规则rule 可以"保存"一个解析器对象。规则rule将以后介绍 <spanclass="comment">// ，但是现在只把规则rule考虑为一个黑盒，不需要知道内部实现 rule<spanclass="special"><> r1<spanclass="special">, r2<spanclass="special">, r3<spanclass="special">; <spanclass="identifier">chlit<<spanclass="keyword">char> <spanclass="identifier">x(<spanclass="literal">'X'); <spanclass="comment">// 声明有名解析器 x <spanclass="identifier">r1 = <spanclass="identifier">chlit<<spanclass="keyword">char>(<spanclass="literal">'X'); <spanclass="comment">// 显式声明 r2= <spanclass="identifier">x;// 使用 x <spanclass="identifier">r3 = <spanclass="identifier">ch_p(<spanclass="literal">'X') <spanclass="comment">// 使用生成器</code></pre>




@@ -346,7 +342,7 @@

-匹配单一个字面字符。 <tt>chlit</tt> 有单一个模板类型，默认值是<tt>char</tt>（也就是，<tt>chlit<></tt>等价于<tt>chlit<char></tt>）。这个类型变量是<tt>chlit</tt>在解析的时候将识别的字符类型。函数生成器版本会从实际函数参数中推导出模板类型参数。模板类<tt>chlit</tt>构造函数接受单一参数：用于匹配输入的字符。例子：+匹配单一个字面字符。 <tt>chlit</tt> 有一个模板参数，默认值是<tt>char</tt>（也就是，<tt>chlit<></tt>等价于<tt>chlit<char></tt>）。这个类型参数是<tt>chlit</tt>在解析的时候将识别的字符类型。函数生成器版本会从实际函数参数中推导出模板类型参数。模板类<tt>chlit</tt>构造函数接受单一参数：用于匹配输入的字符。例子：




@@ -378,7 +374,7 @@



-<p></p>
+



@@ -491,7 +487,7 @@

-一个字符的范围 <tt>range</tt> 是通过一对字符创建的，表示下界和上界。这样的解析器匹配在范围<tt>range</tt>内（包含两端点）的单一个字符。类似<tt>chlit</tt>, <tt>range</tt> 只有一个模板参数，类型默认为<tt>char</tt>。类 <tt>range</tt> 构造函数接受两个参数：匹配字符的范围（起始和结束，包含端点）。它的函数生成器的版本是 <tt>range_p</tt>。+一个字符的范围 <tt>range</tt> 是通过一对字符创建的，表示下界和上界。这样的解析器匹配在范围<tt>range</tt>内（包含两端点）的单一个字符。类似<tt>chlit</tt>, <tt>range</tt> 只有一个模板参数，类型默认为<tt>char</tt>。类 <tt>range</tt> 构造函数接受两个参数：匹配字符的范围（起始和结束，包含端点）。它的函数生成器的版本是 <tt>range_p</tt>。

   例子：</p>


@@ -508,7 +504,7 @@

-注意，第一个字符必须在第二个“之前”，要取决与内在编码方式。范围 range，和chlit一样是单个字符的解析器。+注意，第一个字符必须在第二个"之前"，要取决与内在编码方式。范围range，和chlit一样是单个字符的解析器。




@@ -551,7 +547,7 @@
       <br>

-字符映射固有地平台相关的。在标准中并不保证例如 'A' < 'Z' 的关系，但是，在很多情况下，我们很清楚所用的字符集如 ASCII, ISO-8859-1 或者 Unicode。但是在平台移植时要很小心。</td>+字符映射自然与平台相关。在标准中并不保证例如 'A' < 'Z' 的关系，但是，在很多情况下，我们很清楚所用的字符集如 ASCII, ISO-8859-1 或者 Unicode。但是在平台移植时要很小心。</td>




@@ -590,11 +586,9 @@

-这个解析器匹配字面字符串。类<tt>strlit</tt> 有单个模板参数:一个迭代器的类型。在内部，<tt>strlit</tt> 含有一对表示开始和终止的迭代器，指向有字符的串或容器。  <tt>strlit</tt>- 尝试用此串来匹配当前输入流。模板参数类型默认是 <tt>char const<spanclass="operators">*</tt>。 <tt>strlit</tt>

-  有两个构造函数。 第一个接受一个以字符零结尾的字符指针。
-  这个构造函数可用于从一个字面字符串引用构件 <tt>strlits</tt> 。

- 第二个构造函数接受首/尾迭代器对。函数生成器的版本是 <tt>str_p</tt>。例子：+这个解析器匹配字面字符串。类<tt>strlit</tt> 只有一个模板参数：迭代器的类型。在内部，<tt>strlit</tt> 含有一对表示开始和终止的迭代器，指向字符串或字符容器。<tt>strlit</tt>+ 尝试用此串来匹配当前输入流。模板参数类型默认是 <tt>char const<spanclass="operators">*</tt>。<tt>strlit</tt>+ 有两个构造函数。第一个接受一个以NULL结尾的字符指针。这个构造函数可用于从一个字面字符串引用构件 <tt>strlits</tt>。第二个构造函数接受首/尾迭代器对。函数生成器的版本是 <tt>str_p</tt>。例子：




@@ -643,8 +637,7 @@

       <br>

-典型的解析器把字符（组成词或词位的符号）处理和单词（组成句子的词）处理分开考虑。- 各种实体例如保留词，操作符，字面字符串，数值常量等等，都是一个文法的终端节点；一般在一个独立的词法分析阶段提取这些实体。 +典型的解析器把字符（组成词或词位的符号）处理和单词（组成句子的词）处理分开考虑。各种实体例如保留词，操作符、字面字符串、数值常量等等，都是一个文法的终端节点；一般在一个独立的词法分析阶段提取这些实体。 




@@ -653,7 +646,7 @@


       <br>

-在这个问题上，从目前所举的例子中显然地可以注意到很重要的一点，此点和一般标准做法不同，就是在Spirit框架同时在字符层和词语层处理解析任务。你可以认为一个词法分析器被无缝地整合在Spirit框架中。 +在这个问题上，从目前所举的例子中显然地可以注意到很重要的一点，此点和一般标准做法不同，就是在Spirit框架同时在字符层和词语层处理解析任务。你可以认为一个词法分析器被无缝地整合在Spirit框架中。 




@@ -662,7 +655,7 @@


       <br>

-虽然Spirit解析器库不需要一个词法分析器，但是我们仍然有理由需要一个。你总是可以需要有任意多的解析层次。理论上，你可以在同样的Spirit框架下，创建一个预处理器，一个词法分析器和一个正规的解析器。</td>+虽然Spirit解析器库不需要一个词法分析器，但是我们仍然有理由需要一个。你总是可以需要有任意多的解析层次。理论上，你可以在同一个Spirit框架下，创建一个预处理器，一个词法分析器和一个正规的解析器。</td>




@@ -701,9 +694,7 @@

-Matches a character sequence. <tt>chseq</tt> has the same template typeparameters- and constructor parameters as strlit. The function generator version is<tt>chseq_p</tt>.

-  Examples:</p>

+匹配一个字符序列。<tt>chseq</tt> 拥有与 strlit 相同的模板类型参数和构造函数参数。生成器函数是 <tt>chseq_p</tt>。例如：




@@ -719,10 +710,7 @@

-<tt>strlit</tt> is an implicit lexeme. That is, it works solely on thecharacter- level. <tt>chseq</tt>, <tt>strlit</tt>'s twin, on the other hand, canwork on- both the character and phrase levels. What this simply means is that itcan

-  ignore white spaces in between the string characters. For example:</p>

+<tt>strlit</tt> 是一个隐式的词位。也就是说，它只在字符层面工作。<tt>chseq</tt> 是 <tt>strlit</tt> 的孪生子，但是另一方面，它在字符层面和句子层面都可以工作。简而言之，它可以忽略连续字符之间的空格。例如：




@@ -738,7 +726,7 @@



-<p>can parse:</p>
+<p>可以匹配：</p>



@@ -754,7 +742,7 @@



-<h2>More character parsers</h2>
+<h2>其它字符解析器</h2>



@@ -762,7 +750,7 @@

-The framework also predefines the full repertoire of single characterparsers:

+<p>本框架还预定义了全部的单字符解析器：</p>



@@ -793,7 +781,7 @@



-    <td class="table_title" colspan="2">Single character parsers</td>
+    <td class="table_title" colspan="2">单字符解析器</td>



@@ -825,8 +813,7 @@

- <td class="table_cells" width="70%">Matches any single character(including

-      the null terminator: '\0')</td>

+ <td class="table_cells" width="70%">匹配任意单字符（包括NULL终结符'\0'）</td>




@@ -858,7 +845,7 @@

- <td class="table_cells" width="70%">Matches alpha-numericcharacters</td>

+    <td class="table_cells" width="70%">匹配字母和数字字符</td>



@@ -890,7 +877,7 @@



-    <td class="table_cells" width="70%">Matches alphabetic characters</td>
+    <td class="table_cells" width="70%">匹配字母字符</td>



@@ -922,7 +909,7 @@



-    <td class="table_cells" width="70%">Matches spaces or tabs</td>
+    <td class="table_cells" width="70%">匹配空格或制表符</td>



@@ -954,7 +941,7 @@



-    <td class="table_cells" width="70%">Matches control characters</td>
+    <td class="table_cells" width="70%">匹配控制字符</td>



@@ -986,7 +973,7 @@



-    <td class="table_cells" width="70%">Matches numeric digits</td>
+    <td class="table_cells" width="70%">匹配数字字符</td>



@@ -1018,7 +1005,7 @@

- <td class="table_cells" width="70%">Matches non-space printingcharacters</td>

+    <td class="table_cells" width="70%">匹配非空格的打印字符</td>



@@ -1050,7 +1037,7 @@



-    <td class="table_cells" width="70%">Matches lower case letters</td>
+    <td class="table_cells" width="70%">匹配小写字符</td>



@@ -1082,7 +1069,7 @@



-    <td class="table_cells" width="70%">Matches printable characters</td>
+    <td class="table_cells" width="70%">匹配可打印字符</td>



@@ -1114,7 +1101,7 @@



-    <td class="table_cells" width="70%">Matches punctuation symbols</td>
+    <td class="table_cells" width="70%">匹配标点符号</td>



@@ -1146,7 +1133,7 @@

- <td class="table_cells" width="70%">Matches spaces, tabs, returns, andnewlines</td>

+    <td class="table_cells" width="70%">匹配空格、制表、回车、换行符</td>



@@ -1178,7 +1165,7 @@



-    <td class="table_cells" width="70%">Matches upper case letters</td>
+    <td class="table_cells" width="70%">匹配大写字符</td>



@@ -1210,7 +1197,7 @@



-    <td class="table_cells" width="70%">Matches hexadecimal digits</td>
+    <td class="table_cells" width="70%">匹配16进制数字字符</td>



@@ -1241,7 +1228,7 @@



-<h2><a name="negation"></a>negation ~</h2>
+<h2><a name="negation"></a>取反 ~</h2>



@@ -1249,8 +1236,8 @@

-Single character parsers such as the <tt>chlit</tt>, <tt>range</tt>,<tt>anychar_p</tt>,

-  <tt>alnum_p</tt> etc. can be negated. For example:</p>
+<p>象 <tt>chlit</tt>, <tt>range</tt>, <tt>anychar_p</tt>,
+  <tt>alnum_p</tt> 等等这样的单字符解析器可以被取反。例如：</p>



@@ -1266,8 +1253,7 @@

-matches any character except <tt>'x'</tt>. Double negation of acharacter parser- cancels out the negation. <tt>~~alpha_p</tt> is equivalent to<tt>alpha_p</tt>.+匹配除 <tt>'x'</tt> 以外的任意字符。一个字符解析器的两次取反相当于不取反。<tt>~~alpha_p</tt> 等价于 <tt>alpha_p</tt>.




@@ -1283,7 +1269,7 @@



-<p>Matches the end of line (CR/LF and combinations thereof).</p>
+<p>匹配换行符(CR/LF 或它们的混合)。</p>



@@ -1299,7 +1285,7 @@



-<p>Never matches anything and always fails.</p>
+<p>永不匹配，总是返回失败。</p>



@@ -1315,8 +1301,7 @@

-Matches the end of input (returns a sucessful match with 0 length whenthe

-  input is exhausted)</p>
+<p>匹配输入的结束(当输入耗尽时返回长度为零的成功匹配)。</p>



@@ -1411,7 +1396,7 @@


 <hr size="1">
-<p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 1998-2003 Joel de Guzman<br>



@@ -1419,7 +1404,7 @@



-  Copyright &copy; 2003 Martin Wille<br>
+  Copyright (c) 2003 Martin Wille<br>



@@ -1453,5 +1438,4 @@



-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/quick_start.html     Sat Oct  4 05:29:09 2008
+++ /trunk/libs/spirit/classic/doc/quick_start.html     Wed Sep 16 20:25:53 2009
@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
+<html><head>



@@ -22,8 +21,8 @@



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

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




@@ -32,9 +31,7 @@



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

 <body>

@@ -154,34 +151,32 @@


 <h2>
-      <b>你为什么想用 Spirit ?</b>
+      <b>你为什么要用 Spirit ?</b>
     </h2>





-<p> Spirit

-设计为实际的解析工具。 从一个内联于C++中的标准EBNF规范，产生一个能完全工作的解析器，这种能力的确能减少了开发的时间。当要开发一-个计算机语言例如C或Pascal，实际中也可用一个成熟并且卓越的解析器（如YACC，ANTLR），但是当我们需要非常微小的解析器时，继续这样做无-异于大炮打蚊子。在这领域的一端，程序员在着手处理时一般不是把任务看待为标准的解析任务，而是特定地用粗糙的工具如<tt>scanf</tt>来"搞"任务。真的，是有一些解析工具例如正则表达式库 (如 <ahref="http://www.boost.org/libs/regex/index.html";>boost regex</a>) 或者扫描仪+ Spirit 是作为实用的解析工具来设计的。从一个内联于C++中的标准EBNF规范，产生一个能完全工作的解析器，这种能力的确能减少了开发的时间。当要开发一+个计算机语言时，例如C或Pascal，实际中也可以用一个成熟并且卓越的解析器（如YACC，ANTLR），但是当我们需要微型的解析器时，这样做无+异于大炮打蚊子。在这个领域的这一端，程序员在着手处理时一般不会把任务看待为标准的解析任务，而是特定地用粗糙的工具如<tt>scanf</tt>来完成任务。确实，是有一些解析工具例如正则表达式库 (如 <ahref="http://www.boost.org/libs/regex/index.html";>boost regex</a>) 或者扫描器

       (如 <a href="http://www.boost.org/libs/tokenizer/index.html";>boost

- tokenizer</a>)，但是当我们需要写更精细的解析器的时候，这些工具不能很好地伸缩扩展。如果企图用这些工具写一个适度复杂的解析器，将导致难理解，难维护的代码。+ tokenizer</a>)，但是当我们需要编写更为精细的解析器的时候，这些工具不能很好地伸缩扩展。如果企图用这些工具写一个适度复杂的解析器，将导致难以理解和维护的代码。

     </p>

-其中一个最初目的是使工具很容易使用。当提起解析器生成器时，通常的想法是“它一定是很大很复杂，并且很难学的”。现在不是这样了！Spirit 设计成完全可伸缩。- Spirit的框架是层次化结构。在学习最小的内核和基础概念之后，可以只学习需要的基础。+其中一个最初的目的是使工具很容易使用。当提起解析器生成器时，通常的想法是"它一定是很大很复杂，并且很难学的"。现在不是这样了！Spirit 设计成完全可伸缩。Spirit的框架是层次化结构。在学习最小的内核和基础概念之后，可以只学习你需要的部分。

     </p>

-为了开发的简易，整个框架只由头文件组成，不需要连接或者编译额外的库。只需要把Spirit的发布包放在include目录下，编译，运就可以了。代码的大小？非常少。在快速上手中，我们给出很简短的例子，代码的大小主要由<tt>std::vector</tt>和<tt>std::iostream</tt>实例化的开销主导。+为了开发的简易，整个框架只由头文件组成，不需要连接或者编译额外的库。只需要把Spirit的发布包放在include目录下，编译，运行就可以了。代码的大小？非常小。在快速上手中，我们给出一些简短的例子，代码的大小主要是由<tt>std::vector</tt>和<tt>std::iostream</tt>实例化所导致的开销。

     </p>


@@ -238,14 +233,14 @@

 <p>
       这里你看到熟悉的浮点数解析器

- <code><tt>real_p</tt></code> 被用了两次，每个数用一次。那么操作符<tt class="operators">>></tt> 在这里做什么呢？恩，一定要有些东西分开它们吧，操作符<tt class="operators">>></tt>用作“紧跟着”序列操作符。上面的程序通过用胶水(序列操作符)把两个简单的解析器粘在一起，建立了一个稍复杂的解析器。  数字之间的空白符的处理隐含于解析器的调用方法（见下面）。+ <code><tt>real_p</tt></code> 被用了两次，每个数用一次。那么操作符<tt class="operators">>></tt> 在这里做什么呢？恩，一定要有些东西分开它们吧，操作符<tt class="operators">>></tt>被用作"跟随"序列操作符。上面的程序通过用胶水(序列操作符)把两个简单的解析器粘在一起，建立了一个稍复杂的解析器。数字之间的空白符的处理隐含于解析器的调用方法（见下文）。

   </p>

-注意：对解析器进行组合的时候，我们得到一个“更大”的解析器，但是它仍然是个解析器，所以可以继续嵌套，越变越大。总之，当你用胶水的时候，将产生一个更大的解析器，这是一个重要的概念。+注意：对解析器进行组合的时候，我们得到了一个"更大"的解析器，但它仍然是个解析器，所以可以继续嵌套，越变越大。总之，当你用胶水的时候，将产生一个更大的解析器，这是一个重要的概念。

     </p>


@@ -268,14 +263,14 @@

-这样很像正则表达式的 Kleene 星号，语法上可能有点古怪，特别对于那些没见过重载<tt class="operators">*</tt>操作符的C++程序员。但事实上，如果你了解过正则表达式，古怪之处或许在于星号是作为表达式的前缀而不是后缀。 C'est la vie先生把这种形式不协调指责于我们不得不遵守的C++语法规则。+这样很像正则表达式的 Kleene 星号，语法上可能有点古怪，特别对于那些没见过重载<tt class="operators">*</tt>操作符的C++程序员。但事实上，如果你了解过正则表达式，古怪之处或许在于星号是作为表达式的前缀而不是后缀。没办法，这就是生活，要怪就怪我们要和C++的语法一起工作吧。

   </p>

- Kleene 星号可用在任意的解析器表达式上。但要谨记着，因为C++操作符的优先级规则，你可能需要用圆括号括上复杂的表达式。  Kleene 星号也被称作Kleene 结尾，但文中多数地方仍称之为 Kleene星号。+ Kleene 星号可用在任意的解析器表达式上。但要谨记着，因为C++操作符的优先级规则，你可能需要用圆括号括上复杂的表达式。Kleene 星号也被称作 Kleene 结尾，但文中多数地方仍称之为 Kleene星号。

     </p>


@@ -283,7 +278,7 @@


 <h3>
-      <b><a name="list_of_numbers"></a> 例子 #4 [ 一个稍不简单的例子</b>
+      <b><a name="list_of_numbers"></a> 例子 #4 [ 一个不太简单的例子</b>
 ]    </h3>


@@ -310,7 +305,7 @@

-请注意 <tt>ch_p(',') 。</tt> 这是一个识别逗号<tt>','</tt>的字面字符解析器。在这里，Kleene星号作用在一个更复杂的解析器上，这是指由下面的表达式生成的解析器：+请注意 <tt>ch_p(',')。</tt>这是一个识别逗号<tt>','</tt>的字面字符解析器。在这里，Kleene星号作用在一个更复杂的解析器上，这是指由下面的表达式生成的解析器：

     </p>


@@ -324,7 +319,7 @@

-要注意，这种情况必须要用圆括号。 Kleene 星号作用在上面写的整个表达式上。

+<p>要注意，这种情况必须要用圆括号。Kleene 星号作用在上面写的整个表达式上。
   </p>


@@ -366,14 +361,14 @@


 <p>

- 并不十分惊讶，这只是你用了多年的平常的附值操作。真正酷的事情是，当你把解析器存储在规则中时，规则就是解析器，以后你就可以用名字来引用它。 (在上面情况下，规则名字就是 <tt>r</tt>)。要注意，这是一个完整的附值表达式，所以我们要用分号"<tt>;</tt>"终结。+ 并不十分惊讶，这只是你用了多年的平常的赋值操作。真正酷的事情是，当你把解析器存储在规则中时，规则就是解析器，以后你就可以用名字来引用它。 (在上面情况下，规则名字就是 <tt>r</tt>)。要注意，这是一个完整的赋值表达式，所以我们要用分号"<tt>;</tt>"终结。

   </p>

-正是如此。我们已经懂得去定义一个解析器了。那么下一步就是要让解析器进行操作了。这有很多方法。在这里，我们介绍的方法是用非成员函数 <tt>parse</tt> 来解析一个字符串 <tt>char const*</tt> 。这个函数有三个输入参数：+正是如此。我们已经懂得如何去定义一个解析器了。那么下一步就是要让解析器进行操作了。这有很多方法。在这里，我们介绍的方法是用非成员函数 <tt>parse</tt>来解析一个字符串 <tt>char const*</tt> 。这个函数有三个输入参数：

     </p>


@@ -386,7 +381,7 @@


   <p>
-        <img src="theme/bullet.gif" height="12" width="12"> 以带零终止符的
+        <img src="theme/bullet.gif" height="12" width="12"> 以NULL结尾的
         <tt>const char*</tt> 作为输入字符串<br>


@@ -410,7 +405,7 @@


 <p>

- 在如下例子中，我们希望跳过空白符和tab符。另一个称为<tt>space_p</tt>的解析器是Spirit库预定义的。一个非常简单的只识别空白符的解析器。我们会用 <tt>space_p</tt> 作为跳读解析器。跳读解析器负责跳过那些解析器基元（如<tt>real_p</tt>和<tt>ch_p</tt>）之间的字符。+ 在以下例子中，我们希望跳过空白符和tab符。另一个称为<tt>space_p</tt>的解析器是Spirit库预定义的。一个非常简单的、只识别空白符的解析器。我们会用<tt>space_p</tt> 作为跳读解析器。跳读解析器负责跳过那些解析器基元（如<tt>real_p</tt>和<tt>ch_p</tt>）之间的字符。

     </p>


@@ -476,7 +471,7 @@


 <p>

- 这里要注意我们没有用带名字的规则，而直接把解析器内联在parse函数中。当调用函数parse时，表达式的值被放在一个临时解析器变量中，这个无名的解析器被传入到parse函数，用完后就销毁。+ 这里要注意，我们没有用带名字的规则，而直接把解析器内联在parse函数中。当调用函数parse时，表达式的值被放在一个临时解析器变量中，这个无名的解析器被传入到parse函数，用完后就销毁。

   </p>


@@ -504,8 +499,7 @@


           <br>

-细心的读者可能注意到解析器表达式里用一个<tt class="quotes">','</tt>代替了之前例子的<tt>ch_p(',')</tt>。这在C++的类型转换语法规则中是允许的。库中重载了<tt>>></tt>操作符，接受<tt>char</tt>或者<tt>wchar_t</tt>类型的参数，左参数或者右参数（但不能同时）。 起码一个参数是用户定义类型的时候，操作符就会进行重载。在例子的情况下，- <tt>real_p</tt> 是<tt>operator<spanclass="operators">>></tt>的第二个参数，所以重载了恰当的<ttclass="operators">>></tt> ， <tt class="quotes">','</tt> 被自动转换为字面字符解析器。 +细心的读者可能注意到解析器表达式里用一个<tt class="quotes">','</tt>代替了之前例子的<tt>ch_p(',')</tt>。这在C++的类型转换语法规则中是允许的。库中重载了<tt>>></tt>操作符，接受<tt>char</tt>或者<tt>wchar_t</tt>类型的参数作为左参数或者右参数（但不能同时）。在起码有一个参数是用户自定义类型的时候，操作符就会进行重载。在例子的情况下，<tt>real_p</tt> 是<tt>operator<spanclass="operators">>></tt>的第二个参数，所以重载了恰当的<ttclass="operators">>></tt> ，<tt class="quotes">','</tt> 被自动转换为字面字符解析器。 




@@ -516,7 +510,7 @@


            省略<tt>ch_p</tt> 会有明显的问题：

- <tt>'a' >> 'b'</tt> 不是一个spirit解析器，而是一个数值表达式，代表对ASCII值（或其他编码）<ttclass="quotes">'a'</tt> 进行右移ASCII值<tt class="quotes">'b'</tt>的操作。但是， <tt>ch_p('a') >>+ <tt>'a' >> 'b'</tt> 不是一个spirit解析器，而是一个数值表达式，代表对ASCII值（或其他编码）<ttclass="quotes">'a'</tt> 进行右移ASCII值<tt class="quotes">'b'</tt>的操作。但是，<tt>ch_p('a') >>'b'</tt> 和 <tt>'a' >> ch_p('b')</tt> 都是 Spirit方式的序列解析器，字 <tt class="quotes">'a'</tt> 后面紧跟着<ttclass="quotes">'b'</tt>。你迟早会习惯这样的。

         </td>

@@ -539,7 +533,7 @@

-请注意，从parse函数返回的对象有一个布尔成员叫<tt>full</tt>，它是真（true），仅当我们的两个要求都满足（也就是输入字符串被完全地解析）。+请注意，从parse函数返回的对象有一个布尔成员叫<tt>full</tt>，它仅当我们的两个要求都满足（也就是输入字符串被完全地解析）时为真（true）。

     </p>


@@ -553,9 +547,10 @@

-刚才的解析器只不过是一个识别器。它回答了问题"输入符合我们定义的文法吗？"，但它没有记录任何数据，也没有执行额外的操作。谨记：我们想把被解析的数字放入一个vector中。这通过一种action操作来完成，此操作要连接到特定的解析器中。例如，当我们解析一个实数的时候，我们希望保存下成功解析匹配得到的数。我们现在希望从解析器中提取信息。- 这需要执行语义行为。语义行为可以连接在语法规范的任意一点上。这些行为是C++的函数或者函数子(functor)；当解析器的一部分成功匹配了输入的一部分时，就会调用语义行为。设你有一个解析器P，和一个C++函数- F，你可以把F连接到解析器，当解析器匹配了输入时则会调用F：+刚才的解析器只不过是一个识别器。它回答了问题"输入符合我们定义的文法吗？"，但它没有记录任何数据，也没有执行额外的操作。记住：我们要把被解析的数字放入一个vector中。这通过一种action操+作来完成，此操作要连接到特定的解析器中。例如，当我们解析一个实数的时候，我们希望保存下成功解析匹配得到的数。我们现在希望从解析器中提取信息。这需+要执行语义行为。语义行为可以连接到语法规范的任意一点上。这些行为是C++的函数或者仿函数；当解析器的一部分成功匹配了输入的一部分时，就会调用语义+行为。假设你有一个解析器P，和一个C++函数F，你可以把F连接到解析器，当解析器匹配了输入时则会调用F：

     </p>


@@ -569,7 +564,7 @@


 <p>
-      又或者 <b>F</b> 是一个函数子（functor）时：
+      又或者 <b>F</b> 是一个仿函数时：
   </p>


@@ -582,7 +577,7 @@

-这种函数/函数子签名，依赖于它连接的解析器的类型。解析器<tt>real_p</tt> 传递单一个参数：被解析的数。因此如果我们要连接函数F到<tt>real_p</tt> ，我们要求F被声明为：+这种函数/仿函数签名，依赖于它连接的解析器的类型。解析器 <tt>real_p</tt>传递单个参数：被解析的数。因此如果我们要连接函数F到<tt>real_p</tt>，我们要求F被声明为：

   </p>


@@ -594,7 +589,7 @@

-在我们的例子中，我们再次利用一些预定义的语义函数子和函数子生成器（<imgsrc="theme/lens.gif" height="16" width="15">一个函数子生成器是一个返回函数子的函数）。为了达到目的，我们用Spirit的一个函数子生成器<tt>push_back_a(c)</tt>。简单地讲，这个语义行为被调用时，会把从连接的解析器接收到的的数appends添加到一个容器<tt>c</tt>中。+在我们的例子中，我们再次利用一些预定义的语义仿函数和仿函数生成器（<imgsrc="theme/lens.gif" height="16" width="15">一个仿函数生成器是一个返回仿函数的函数）。为了达到目的，我们用Spirit的一个仿函数生成器<tt>push_back_a(c)</tt>。简单地讲，这个语义行为被调用时，会把从所连接的解析器接收到的的数添加到一个容器<tt>c</tt>中。

   </p>


@@ -614,7 +609,7 @@

-这是和之前相同的解析器。这次有合适的语义行为连接到计划好的地方，这样解析到的数会被提取出来填充在vector <tt>v</tt>中。如果解析成功，函数parse_numbers 返回真。+这是和之前相同的解析器。这次有合适的语义行为连接到预定的位置，这样解析到的数会被提取出来填入在 vector <tt>v</tt> 中。如果解析成功，函数parse_numbers 返回真。

   </p>


@@ -695,12 +690,12 @@
 <hr size="1">

 <p class="copyright">
-      Copyright &copy; 1998-2003 Joel de Guzman<br>
+      Copyright (c) 1998-2003 Joel de Guzman<br>




-       Copyright &copy; 2002 Chris Uzdavinis<br>
+       Copyright (c) 2002 Chris Uzdavinis<br>



@@ -727,5 +722,4 @@



-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/rule.html    Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/rule.html    Wed Sep 16 20:25:53 2009
@@ -1,41 +1,35 @@
-<html>
-<head>
-<title>The Rule</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 Rule</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%">

- TheRule+ TheRule 规则

     </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="numerics.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="epsilon.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

The rule is a polymorphic parser that acts as a namedplace-holder capturingthe behavior of an EBNF expression assigned to it. Naming an EBNFexpressionallows it to be referenced later. The <tt>rule</tt> is a template classparameterizedby the type of the scanner (<tt>ScannerT</tt>), the rule's <ahref="indepth_the_parser_context.html">context</a>and its <a href="#tag">tag</a>. Default template parameters are providedto

-  make it easy to use the rule.</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>rule;</code></pre>+ make it easy to use the rule. 规则是一个多态的分析器，就是一个有名字的占位符，这个占位符保有赋给它的EBNF表达式的行为。为EBNF表达式命名是为了在以后能引用它。<tt>rule</tt>是一个模板类，其模板参数是扫描器类型(<tt>ScannerT</tt>)、规则的语境(<ahref="indepth_the_parser_context.html">context</a>)和标签(<ahref="#tag">tag</a>)。所提供的默认模板参数使得规则很易于使用。+<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 rule<spanclass="special">;</code></pre>Default template parameters are supplied to handle the most commoncase. <tt>ScannerT</tt>defaults to <tt>scanner<></tt>, a plain vanilla scanner that actson <tt>charconst*</tt> iterators and does nothingspecial

@@ -45,30 +39,21 @@

cases, declaring a rule as <tt>rule<></tt> is enough. You need notbeconcerned at all with the <tt>ContextT</tt> template parameter unlessyou wishto tweak the low level behavior of the rule. Detailed information on the<tt>ContextT</tt>- template parameter is provided <ahref="indepth_the_parser_context.html">elsewhere</a>.+ template parameter is provided <ahref="indepth_the_parser_context.html">elsewhere</a>. 所提供的默认模板参数足以应付最常见的情况。<tt>ScannerT</tt> 默认为<tt>scanner<></tt>，一个最基本的分析器，使用 <tt>char+ const*</tt> 迭代器，且除了以每次读取一个字符的方式对一个null结尾的输入的所有字符进行迭代，什么也不作。规则的标签<tt>TagT</tt>，主要配合抽象语法树（<a href="trees.html">ASTs</a>）使用，用于识别不同的规则。在<a href="#tag">这里</a>有说明。在简单类里，将规则声明为<tt>rule<></tt> 就足够了。你完全不必考虑 <tt>ContextT</tt> 参数，除非你想调整规则的底层行为。<tt>ContextT</tt> 参数的详细信息将<ahref="indepth_the_parser_context.html">另行提供</a>。

 </p>
-<h3><a name="order_of_parameters"></a>Order of parameters</h3>
+<h3><a name="order_of_parameters"></a>Order of parameters 参数的顺序</h3>

As of v1.8.0, the <tt>ScannerT</tt>, <tt>ContextT</tt> and<tt>TagT</tt> canbe specified in any order. If a template parameter is missing, it willassume

-  the defaults. Examples:</p>

-<pre> rule<>rx1;- rule<spanclass=special><scanner<spanclass=special><> > <spanclass=identifier>rx2;- rule<spanclass=special><parser_context<code><fontcolor="#000000"><></code>> <spanclass=identifier>rx3;- rule<spanclass=special><parser_context<code><fontcolor="#000000"><spanclass=special><></code>,parser_address_tag<spanclass=special>> rx4<spanclass=special>;- rule<spanclass=special><<spanclass=identifier>parser_address_tag>rx5;- rule<spanclass=special><<spanclass=identifier>parser_address_tag,scanner<>,parser_context<code><fontcolor="#000000"><></code>> <spanclass=identifier>rx6;- rule<spanclass=special><parser_context<code><fontcolor="#000000"><spanclass=special><></code>,scanner<>,parser_address_tag<spanclass=special>> rx7<spanclass=special>;</pre>-<h3><a name="multiple_scanner_support"id="multiple_scanner_support"></a>Multiple scanners</h3>+ the defaults. Examples: 在1.8.0这个版本中，<tt>ScannerT</tt>,<tt>ContextT</tt> 和 <tt>TagT</tt> 可以以任意顺序排列。如果某个模板参数缺失，则适用默认的参数。例：+<pre> rule<spanclass="special"><> rx1<spanclass="special">; rule<spanclass="special"><scanner<spanclass="special"><> > <spanclass="identifier">rx2; <spanclass="identifier">rule<<spanclass="identifier">parser_context<code><spanclass="special"><></code> <spanclass="special">> rx3<spanclass="special">; rule<spanclass="special"><<spanclass="identifier">parser_context<code><spanclass="special"><></code>,parser_address_tag<spanclass="special">> rx4<spanclass="special">; rule<spanclass="special"><<spanclass="identifier">parser_address_tag>rx5<spanclass="special">; rule<spanclass="special"><<spanclass="identifier">parser_address_tag,scanner<spanclass="special"><>, <spanclass="identifier">parser_context<code><spanclass="special"><></code> <spanclass="special">> rx6<spanclass="special">; rule<spanclass="special"><<spanclass="identifier">parser_context<code><spanclass="special"><></code>,scanner<spanclass="special"><>, <spanclass="identifier">parser_address_tag>rx7<spanclass="special">;</pre>+<h3><a name="multiple_scanner_support"id="multiple_scanner_support"></a>Multiple scanners 多扫描器</h3>As of v1.8.0, rules can use one or more scanner types. There are cases,forinstance, where we need a rule that can work on the phrase and characterlevels.Rule/scanner mismatch has been a source of confusion and is the no. 1 <ahref="faq.html#scanner_business">FAQ</a>.

-  To address this issue, we now have multiple scanner support. Example:</p>

-<pre> typedefscanner_list<spanclass=special><scanner<spanclass=special><>, <spanclass=identifier>phrase_scanner_t>scanners;

- rule<spanclass=special><scanners<spanclass=special>> r <spanclass=special>= +<spanclass=identifier>anychar_p;- assert<spanclass=special>(parse<spanclass=special>(<spanclass=string>"abcdefghijk",r).<spanclass=identifier>full);- assert<spanclass=special>(parse<spanclass=special>("a b c d e f g h i jk", <spanclass=identifier>r, <spanclass=identifier>space_p).<spanclass=identifier>full);</pre>-Notice how rule <tt>r</tt> is used in both the phrase and characterlevels.+ To address this issue, we now have multiple scanner support.Example: 在1.8.0中，规则可以使用一个或者多个扫描器类型。在诸如需要一个能同时工作于短句层次和字符层次的分析器的情况下，规则/扫描器的不匹配是迷惑的来源，也是最常见的 <a href="faq.html#scanner_business">FAQ</a>。为了解决这个问题，就有了对多扫描器的支持。例子：+<pre> typedefscanner_list<spanclass="special"><scanner<spanclass="special"><>, <spanclass="identifier">phrase_scanner_t>scanners<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">scanners> <spanclass="identifier">r = <spanclass="special">+anychar_p<spanclass="special">; assert<spanclass="special">(parse<spanclass="special">("abcdefghijk"<spanclass="special">, r<spanclass="special">).full<spanclass="special">); <spanclass="identifier">assert(<spanclass="identifier">parse(<spanclass="string">"a b c d e f g h i j k",r,space_p<spanclass="special">).full<spanclass="special">);</pre>+Notice how rule <tt>r</tt> is used in both the phrase and characterlevels. 留意规则 <tt>r</tt> 是如何同时在句子和字符的层次中使用的<tt></tt>。

 </p>
 <p>By default support for multiple scanners is disabled.  The macro
   <tt>BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT</tt> must be defined to the
@@ -76,156 +61,146 @@
   be greater than 1 to enable multiple scanners.  Given the
   example above, to define a limit of two scanners for the list, the
   following line must be inserted into the source file before the
-  inclusion of Spirit headers:
+  inclusion of Spirit headers:<br>对多扫描器的支持在默认情况下是关闭的。宏

+ <tt>BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT</tt> 必须定义成 scanner_list 所允许的扫描器的最大数目。 比如上面的例子，要把扫描器列表的最大数目限定为2，就必须在源码中Spirit的头文件之前插入以下一行：

 </p>

-<pre> #defineBOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT2</pre>

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

- <td class="note_box"><img src="theme/bulb.gif" width="13" height="18">See+<pre> #defineBOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT2</pre>

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

+ <td class="note_box"><img src="theme/bulb.gif" height="18" width="13">Seethe techniques section for an <ahref="techniques.html#multiple_scanner_support">example</a>of a <a href="grammar.html">grammar</a> using a multiple scannerenabled- rule, <a href="scanner.html#lexeme_scanner">lexeme_scanner</a> and<a href="scanner.html#as_lower_scanner">as_lower_scanner.</a></td>+ rule, <a href="scanner.html#lexeme_scanner">lexeme_scanner</a> and<a href="scanner.html#as_lower_scanner">as_lower_scanner.</a>查看关于<ahref="grammar.html">语法</a>如何使用允许多扫描器的规则、<ahref="scanner.html#lexeme_scanner">lexeme_scanner</a> 和 <ahref="scanner.html#as_lower_scanner">as_lower_scanner</a> 的<ahref="techniques.html#multiple_scanner_support">例子</a>，请见技术一节。<ahref="scanner.html#as_lower_scanner"></a><ahref="http://www.boost.org/libs/spirit/doc/scanner.html#as_lower_scanner";></a></td>

   </tr>
-</table>
-<h3>Rule Declarations</h3>
-<p>The rule class models EBNF's production rule. Example:</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>a_rule = <spanclass=special>*(a <spanclass=special>| b)& +(<spanclass=identifier>c | <spanclass=identifier>d | <spanclass=identifier>e);</code></pre>

+</tbody></table>
+<h3>Rule Declarations 规则声明</h3>

+The rule class models EBNF's production rule. Example: rule 类实现了EBNF的产生规则。例：+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">a_rule = <spanclass="special">*(a <spanclass="special">| b<spanclass="special">) & <spanclass="special">+(c <spanclass="special">| d <spanclass="special">| e<spanclass="special">);</code></pre>The type and behavior of the right-hand (rhs) EBNF expression, whichmay bearbitrarily complex, is encoded in the rule named a_rule. a_rule may nowbe

-  referenced elsewhere in the grammar:</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>another_rule = <spanclass=identifier>f >> <spanclass=identifier>g >> <spanclass=identifier>h >> <spanclass=identifier>a_rule<spanclass=special>;</code></pre>

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

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

-      rules <br>

+ referenced elsewhere in the grammar: 右操作数（rhs）的EBNF表达式的类型（它可以有任意的复杂度），被一个名为a_rule的规则所包含。a_rule可以在语法的任意处被引用。+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">another_rule = <spanclass="identifier">f >> <spanclass="identifier">g >> <spanclass="identifier">h >> <spanclass="identifier">a_rule<spanclass="special">;</code></pre>

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

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

+      rules &nbsp;引用规则<br>
       </b><br>

When a rule is referenced anywhere in the right hand side of an EBNFexpression,the rule is held by the expression by reference. It is theresponsibilityof the client to ensure that the referenced rule stays in scope anddoes

-      not get destructed while it is being referenced. </td>

+ not get destructed while it is being referenced.当一个规则被在EBNF的表达式右边引用时，表达式适用的是规则的引用。保证被引用的规则的可见性和被引用时的有效性，是客户程序的责任。 </td>

   </tr>
-</table>

-<pre> a <spanclass=special>= int_p<spanclass=special>;- b =a;- c =int_p >>b;</pre>

-<h3>Copying Rules</h3>
+</tbody></table>

+<pre> a= <spanclass="identifier">int_p; <spanclass="identifier">b = <spanclass="identifier">a; <spanclass="identifier">c = <spanclass="identifier">int_p >> <spanclass="identifier">b;</pre>

+<h3>Copying Rules 复制规则</h3>

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. If you need to copy a rule you have to explicitly call itsmember

-  function <tt>copy()</tt>:</p>

-<pre> r<spanclass="special">.copy()<spanclass=special>;</pre>+ function <tt>copy()</tt>: 规则是一个别扭的C++公民。与其他C++对象不同，它没有拷贝和赋值语义，且不能被存储和以值方式传递。如果你需要复制一个规则，就必须显式地调用它的成员函数 <tt>copy()</tt>:+<pre> <spanclass="identifier">r.<spanclass="identifier">copy();</pre>However, be warned that copying a rule will not deep copy otherreferencedrules of the source rule being copied. This might lead to danglingreferences.Again, it is the responsibility of the client to ensure that allreferencedrules stay in scope and does not get destructed while it is beingreferenced.

-  Caveat emptor.</p>

+ Caveat emptor. 然而，对一个规则的拷贝并不会引起对这个规则所引用的其他规则的深度拷贝。因为这可能会导致悬挂引用。当然，客户程序同样有责任保证所有被引用的规则都在范围内，并且在被引用期间不会被析构。你得风险自担。If you copy a rule, then you'll want to place it in a storagesomewhere. The

-  problem is how? The storage can't be another rule:</p>

-<pre> <code><spanclass=identifier>rule<spanclass=special><></code> r2 <spanclass="special">= r<spanclass="special">.copy()<spanclass=special>; // BAD!</pre>+ problem is how? The storage can't be another rule: 如果你复制一个规则，那么你可能会想把它储存在某处。问题是怎么储存？反正不能用另一个规则：+<pre> <code><spanclass="identifier">rule<spanclass="special"><></code> r2 <spanclass="special">= r<spanclass="special">.copy()<spanclass="special">; // BAD!</pre>because rules are weird and does not have the expected C++copy-constructorand assignment semantics! As a general rule: Don't put a copiedruleinto another rule! Instead, use the <ahref="stored_rule.html">stored_rule</a>

-  for that purpose.</p>
-<h3>Forward declarations</h3>

+ for that purpose. 因为规则是别扭的，而且没有所需要的C++拷贝构造函数和赋值语义！基本原则：不要把拷贝的规则放到另一个规则中去。而是使用<a href="stored_rule.html">可存储规则</a>来达到这一目的。

+<h3>Forward declarations 前向声明</h3>

A <tt>rule</tt> may be declared before being defined to allow cyclicstructures

-  typically found in BNF declarations. Example:</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>a, <spanclass=identifier>b, <spanclass=identifier>c;

- a =b | <spanclass=identifier>a;- b =c | <spanclass=identifier>a;</code></pre>

-<h3>Recursion</h3>

+ typically found in BNF declarations. Example: <tt>rule</tt> 可以在定义前声明以允许EBNF中常见的循环结构。例子：+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">a, <spanclass="identifier">b, <spanclass="identifier">c; <spanclass="identifier">a = <spanclass="identifier">b | <spanclass="identifier">a; <spanclass="identifier">b = <spanclass="identifier">c | <spanclass="identifier">a<spanclass="special">;</code></pre>

+<h3>Recursion 递归</h3>

The right-hand side of a rule may reference other rules, includingitself.The limitation is that direct or indirect left recursion is not allowed(thisis an unchecked run-time error that results in an infinite loop). Thisis typical

-  of top-down parsers. Example:</p>

-<pre><code> <spanclass=identifier>a = <spanclass=identifier>a | <spanclass=identifier>b; <spanclass=comment>// infinite loop!</code></pre>

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

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

-      is left recursion?<br>

+ of top-down parsers. Example: 规则的右边可以是其他规则，包括它自己。但是直接或间接的左递归是不允许的（这是一个无法自动检查的错误，在运行时将引起无限循环）。这是自顶向下分析器的典型情况。例子：+<pre><code> <spanclass="identifier">a = <spanclass="identifier">a | <spanclass="identifier">b; <spanclass="comment">// infinite loop! 无限循环！</code></pre>

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

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

+      is left recursion? 什么是左递归？<br>
       </b><br>

Left recursion happens when you have a rule that calls itself beforeanythingelse. A top-down parser will go into an infinite loop when thishappens.See the <a href="faq.html#left_recursion">FAQ</a> for details on howto

-      eliminate left recursion.</td>

+ eliminate left recursion.当某个规则的等号右边的第一个元素是它自己的时候，就产生了左递归。一个自顶向下分析器在这种情况下将陷入无限循环中。 <ahref="faq.html#left_recursion">FAQ</a>中有如何消除左递归的细节。</td>

   </tr>
-</table>
-<h3>Undefined rules</h3>

-An undefined rule matches nothing and is semantically equivalent to<tt>nothing_p</tt>.

-<h3>Redeclarations</h3>
+</tbody></table>
+<h3>Undefined rules 未定义规则</h3>

+An undefined rule matches nothing and is semantically equivalent to<tt>nothing_p</tt>. 未定义的规则什么都不匹配，语义上等同于<tt>nothing_p</tt>。

+<h3>Redeclarations 重声明</h3>

Like any other C++ assignment, a second assignment to a rule isdestructiveand will redefine it. The old definition is lost. Rules are dynamic. Arule

-  can change its definition anytime:</p>

-<pre><code> r <spanclass=special>= a_definition<spanclass=special>;- r =another_definition<spanclass=special>;</code></pre>+ can change its definition anytime: 与C++的其他赋值相同，对一个规则的二次赋值会引起它的析构和重定义。老的定义就此丢失。规则是动态的。一个规则可以在任意时间改变它的定义：+<pre><code> r= <spanclass="identifier">a_definition<spanclass="special">; r <spanclass="special">= <spanclass="identifier">another_definition<spanclass="special">;</code></pre>Rule <tt>r</tt> loses the old definition when the second assignment ismade.As mentioned, an undefined rule matches nothing and is semanticallyequivalent

-  to <tt>nothing_p</tt>.
-<h3>Dynamic Parsers</h3>

+ to <tt>nothing_p</tt>. 规则 <tt>r</tt> 在第二次赋值发生时，丢掉了它的旧定义。正如上面所提到的，一个未定义的规则总是不匹配，语义上等同于<tt>nothing_p</tt>。 <h3>Dynamic Parsers 动态分析器</h3>Hosting declarative EBNF in imperative C++ yields an interesting blend.Wehave the best of both worlds. We have the ability to conveniently modifythegrammar at run time using imperative constructs such as <tt>if</tt>,<tt>else</tt>

-  statements. Example:</p>

-<pre><code> <spanclass=keyword>if (<spanclass=identifier>feature_is_available)- r =add_this_feature<spanclass=special>;</code></pre>+ statements. Example: 将函数式的EBNF置于指令式的C++中，产生了一个有趣的混合。我们集二者之长。我们可以轻松地在运行时使用指令式的构造，比如<tt>if</tt>, <tt>else</tt> 语句，来改变一个语法。例如：+<pre><code> <spanclass="keyword">if (<spanclass="identifier">feature_is_available<spanclass="special">) r <spanclass="special">= <spanclass="identifier">add_this_feature<spanclass="special">;</code></pre>Rules are essentially dynamic parsers. A dynamic parser ischaracterized byits ability to modify its behavior at run time. Initially, an undefinedrulematches nothing. At any time, the rule may be defined and redefined,thus, dynamically

-  altering its behavior.</p>
-<h3>No start rule</h3>

+ altering its behavior. 规则本质上就是动态分析器。之所以是动态的，是因为它在运行时可以改变其行为的这一特征。最初，一个未定义的规则总是不匹配。而在任何时候，规则都可以定义和重定义，由此动态地改变它的行为。

+<h3>No start rule 没有起始规则</h3>

Typically, parsers have what is called a start symbol, chosen to be therootof the grammar where parsing starts. The Spirit parser framework has nonotionof a start symbol. Any rule can be a start symbol. This feature promotesstep-wisecreation of parsers. We can build parsers from the bottom up while fullytesting

-  each level or module up untill we get to the top-most level.</p>
-<h3><a name="tag"></a>Parser Tags</h3>

+ each level or module up untill we get to the top-most level. 一般来说，分析器都有一个起始符号，作为语法的根源，分析的起点。Spirit分析器框架并没有起始符号。任何规则都可以是起始符号。这加强了逐步构造分析器的能力。构建分析器时，可以自底向上，同时完整测试所有层次，或者构建所有层次，直到最顶层。

+<h3><a name="tag"></a>Parser Tags 分析器标签</h3>

Rules may be tagged for identification purposes. This is necessary,especiallywhen dealing with <a href="trees.html">parse trees and ASTs</a> to seewhichrule created a specific AST/parse tree node. Each rule has an ID of type<tt>parser_id</tt>.- This ID can be obtained through the rule's <tt>id()</tt> memberfunction:-<pre><code>my_rule.<spanclass=identifier>id(); <spanclass=comment>// get my_rule's id</code></pre>

-<p>The <tt>parser_id</tt> class is declared as:</p>

+ This ID can be obtained through the rule's <tt>id()</tt> memberfunction: 为了识别，可以给规则加上标签。这是有需要的，尤其是在<ahref="trees.html">分析树和AST树</a>中要判断是哪个规则产生了特定的AST/分析树节点时。每个规则都有一个类型为 <tt>parser_id</tt> 的ID。这个ID可以通过规则的 <tt>id()</tt> 成员函数得到：+<pre><code>my_rule.<spanclass="identifier">id(); <spanclass="comment">// get my_rule's id 取出my_rule的id</code></pre>+The <tt>parser_id</tt> class is declared as: 类 <tt>parser_id</tt> 声明如下：<pre> class <spanclass="identifier">parser_id <spanclass="special">{ public<spanclass="special">: parser_id<spanclass="special">(); <spanclass="keyword">explicit parser_id<spanclass="special">(void const<spanclass="special">* p<spanclass="special">); parser_id<spanclass="special">(std::size_t l<spanclass="special">);

bool <spanclass="keyword">operator==(<spanclass="identifier">parser_id const<spanclass="special">& x) const<spanclass="special">; <spanclass="keyword">bool <spanclass="keyword">operator!=(<spanclass="identifier">parser_id const<spanclass="special">& x) const<spanclass="special">;bool operator<(<spanclass="identifier">parser_id const<spanclass="special">& x) const<spanclass="special">;- <spanclass="keyword">std::size_tto_long() <spanclass="keyword">const;

-    };</span></pre>

+ <spanclass="keyword">std::size_tto_long() <spanclass="keyword">const; };</pre>

 <h3>parser_address_tag</h3>

The rule's <tt>TagT</tt> template parameter supplies this ID. Thisdefaultsto <tt>parser_address_tag</tt>. The <tt>parser_address_tag</tt> uses theaddressof the rule as its ID. This is often not the most convenient, since itis not

-  always possible to get the address of a rule to compare against. </p>

+ always possible to get the address of a rule to compare against. 规则的TagT模板参数支持这个ID。默认是 <tt>parser_address_tag</tt>。<tt>parser_address_tag</tt> 适用规则在内存中的地址作为它的ID。这样通常不是很方便，因为并不总是能够得到一个规则的地址拿来比较的。

 <h3>parser_tag</h3>

It is possible to have specific constant integers to identify a rule.For thispurpose, we can use the <tt>parser_tag<N></tt>, where N is aconstant

-  integer:</p>

-<pre><code>rule<<spanclass=identifier>parser_tag<<spanclass=identifier>123> > <spanclass="identifier">my_rule; <spanclass="comment">// set my_rule's id to 123</code></pre>+ integer: 使用特定的常整数来识别规则也是可以的。为了达到这一目的，可以使用 <tt>parser_tag<N></tt>，这里N是一个常整数。+<pre><code>rule<<spanclass="identifier">parser_tag<<spanclass="identifier">123> > <spanclass="identifier">my_rule; <spanclass="comment">// set my_rule's id to 123 将my_rule的id设为123</code></pre>

 <h3>dynamic_parser_tag</h3>

The <tt>parser_tag<N></tt> can only specifiy a staticID,which is defined at compile time. If you need the ID to bedynamic(changeable at runtime), you can use the <tt>dynamic_parser_tag</tt>class asthe <tt>TagT</tt> template parameter. This template parameter enablesthe <tt>set_id()</tt>

-  function, which may be used to set the required id at runtime:</p>

-<pre><code>rule<<spanclass=identifier>dynamic_parser_tag>my_dynrule<spanclass="special">;- my_dynrule.set_id(1234); // set my_dynrule'sid to 1234</code></pre>+ function, which may be used to set the required id atruntime: <tt>parser_tag<N></tt> 只能表示一个在编译期定义的静态ID。如果你想让ID变成动态的（在运行期可更改），可以使用<tt>dynamic_parser_tag</tt> 类作为 <tt>TagT</tt> 模板参数。这个参数允许<tt>set_id()</tt> 函数，作用是在运行时设定所需的 id 值：+<pre><code>rule<<spanclass="identifier">dynamic_parser_tag>my_dynrule<spanclass="special">; my_dynrule.set_id(1234); <spanclass="comment">// set my_dynrule's id to1234</code><code>将my_rule的id设为1234</code></pre>If the <tt>set_id()</tt> function isn't called, the parser id defaultsto theaddress of the rule as its ID, just like the <tt>parser_address_tag</tt>template

-  parameter would do. </p>

+ parameter would do. 如果 <tt>set_id()</tt> 没有被调用，分析器的id默认为它的地址。就像 <tt>parser_address_tag</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 (c) 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/scanner.html Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/scanner.html Wed Sep 16 20:25:53 2009
@@ -1,186 +1,146 @@
-<html>
-<head>
-<title>The Scanner and Parsing</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 Scanner and Parsing</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%">

- TheScanner and Parsing+ TheScanner and Parsing 扫描器与分析

     </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="directives.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="grammar.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

The scanner's task is to feed the sequential input data streamto theparser. The scanner extracts data from the input, parceling, potentiallymodifyingor filtering, and then finally relegating the result to individualparser elementson demand until the input is exhausted. The scanner is composed of twoSTL conformingforward iterators, first and last, where first is held by reference andlast,by value. The first iterator is held by reference to allow it to bere-positioned.

-  The following diagram illustrates what's happening:</p>
-<table width="62%" border="0" align="center">
-  <tr>

+ The following diagram illustrates what's happening:<spanstyle="font-weight: bold;">扫描器的任务是将线性输入的数据流喂给分析器。它从输入中提+取，包裹，还有可能修改或者过滤数据，接着最后把结果移交给每个有需要的分析器，直到耗尽输入。扫描器有两个STL兼容的前向迭代器，first 和+last，first 以引用方式保存，last 以值方式保存。first 迭代器作为引用保存，使得它可以被重定位。下图描绘的就是所发生的：

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

The scanner manages various aspects of the parsing process through aset of

-  policies. There are three sets of policies that govern:</p>

+ policies. There are three sets of policies that govern: 扫描器通过一系列策略集管理分析过程的多个方面。策略集有三个：

 <blockquote>

- <img src="theme/bullet.gif" width="12" height="12"> Iteration andfiltering - <img src="theme/bullet.gif" width="12" height="12"> Recognition andmatching - <img src="theme/bullet.gif" width="12" height="12"> Handling semanticactions+ <img src="theme/bullet.gif" height="12" width="12"> Iteration andfiltering 迭代与过滤 + <img src="theme/bullet.gif" height="12" width="12"> Recognition andmatching 识别与匹配 + <img src="theme/bullet.gif" height="12" width="12"> Handling semanticactions 处理语义动作

 </blockquote>

These policies are mostly hidden from view and users generally need notknowabout them. Advanced users might however provide their own policies thatoverride

   the ones that are already in place to fine tune the parsing process

to fit their own needs. We shall see how this can be done. This will becovered

-  in further detail later.</p>

+ in further detail later. 这些策略隐藏在最深处，用户一般是不需要了解它们的。然而高级用户也许会提供自己的策略来代替它们以调整分析器，使之符合用户的需求。我们将会看到这是如何做到的。不久将会看到更详尽的细节。The <tt>scanner</tt> is a template class expecting two parameters:<tt>IteratorT</tt>,the iterator type and <tt>PoliciesT</tt>, its set of policies.<tt>IteratorT</tt>defaults to <tt>char const*</tt> while <tt>PoliciesT</tt> defaults to<tt>scanner_policies<></tt>,- a predefined set of scanner policies that we can use straight out of thebox.-<pre><code>template<- typename <spanclass=identifier>IteratorT = <spanclass=keyword>char const<spanclass=special>*,- typename <spanclass=identifier>PoliciesT = <spanclass=identifier>scanner_policies<>>- class <spanclass=identifier>scanner<spanclass=special>;</code></pre>+ a predefined set of scanner policies that we can use straight out of thebox. <tt>scanner</tt> 是一个模板类，有两个模板参数：<tt>IteratorT</tt> 迭代器类型，以及 <tt>PoliciesT</tt> 它的策略集。<tt>IteratorT</tt> 默认为 <tt>char const*</tt> 而 <tt>PoliciesT</tt> 默认为 <tt>scanner_policies<></tt>，一个可以直接使用的预定义分析器策略集。+<pre><code>template< <spanclass="keyword">typename IteratorT= charconst<spanclass="special">*, typenamePoliciesT =scanner_policies<spanclass="special"><> > class <spanclass="identifier">scanner<spanclass="special">;</code></pre>Spirit uses the same iterator concepts and interface formally definedby theC++ Standard Template Library (STL). We can use iterators supplied bySTL'scontainers (e.g. <tt>list</tt>, <tt>vector</tt>, <tt>string</tt>, etc.)as is,or perhaps write our own. Iterators can be as simple as a pointer (e.g.<tt>charconst*</tt>). At the other end of thespectrum,iterators can be quite complex; for instance, an iterator adapter thatwraps

-  a lexer such as LEX.</p>
-<h2>The Free Parse Functions</h2>

+ a lexer such as LEX. Spirit使用与在C++标准模板库（STL）中正式定义的迭代器概念和接口相一致的迭代器。我们可以使用STL的容器（比如 <tt>list</tt>,<tt>vector</tt>, <tt>string</tt> 等）提供的迭代器，或者，也可以用自己写的。迭代器可以和一个指针一样简单（比如 <tt>char+ const*</tt>）。而在族谱的另一端，它也可以相当复杂；比如一个封装了诸如LEX这样的词法分析器的迭代器适配器。

+<h2>The Free Parse Functions 自由分析函数</h2>

The framework provides a couple of free functions to make parsing asnap. Theseparser functions have two forms. The first form works on thecharacter level.- The second works on the phrase level and asks for a skipparser.+ The second works on the phrase level and asks for a skipparser. 本框架提供了一些自由函数，以进行短小的分析。这些分析函数有两种形式。第一种工作于字符层面，第二种则工作于短句层面，并且需要一个<spanstyle="font-weight: bold;">跳读分析器。The skip parser is just about any parser primitive or composite.Itspurpose is to move the scanner's <tt>first</tt> iterator to valid tokensbyskipping white spaces. In C for instance, the tab <ttclass="quotes">'\t'</tt>,the newline <tt class="quotes">'\n'</tt>, return <tt><spanclass="quotes">'\r'</tt>,space <tt class="quotes">' '</tt> and characters inside comments <ttclass="quotes">/*...*/</tt>

-  are considered as white spaces.</p>
-<p><b>Character level parsing</b></p>

-<pre><code> <spanclass=keyword>template <<spanclass=keyword>typename IteratorT<spanclass=special>, typename <spanclass=identifier>DerivedT>- parse_info<spanclass=special><IteratorT<spanclass=special>>

-    </span><span class=identifier>parse
-    </span><span class=special>(

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

-<pre><code> <spanclass=keyword>template <<spanclass=keyword>typename CharT<spanclass=special>, typename <spanclass=identifier>DerivedT>- parse_info<spanclass=special><CharT <spanclass=keyword>const*>

-    </span><span class=identifier>parse
-    </span><span class=special>(

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

+ are considered as white spaces. 跳读分析器可以是任意的基本或者合成分析器。它的目的是跳过空白字符，把扫描器的<tt>first</tt>迭代器移动到有效的记号上。比如在C语言里，制表符 <ttclass="quotes">'\t'</tt>、回车<tt>'\r'</tt>、空格<tt class="quotes">' '</tt>以及注释内的字符<ttclass="quotes">/*...*/</tt>被认为是空白字符。

+<p><b>Character level parsing 字符层面的分析</b></p>

+<pre><code> <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">DerivedT> parse_info<spanclass="special"><IteratorT<spanclass="special">> parse ( <spanclass="identifier">IteratorT const<spanclass="special">& <spanclass="identifier">first, IteratorT <spanclass="keyword">const& <spanclass="identifier">last, parser<spanclass="special"><DerivedT<spanclass="special">> const<spanclass="special">& p <spanclass="special">);</code></pre>+<pre><code> <spanclass="keyword">template <<spanclass="keyword">typename CharT<spanclass="special">, typename <spanclass="identifier">DerivedT> parse_info<spanclass="special"><CharT <spanclass="keyword">const*> <spanclass="identifier">parse ( CharT <spanclass="keyword">const* <spanclass="identifier">str, parser<spanclass="special"><DerivedT<spanclass="special">> const<spanclass="special">& p <spanclass="special">);</code></pre>There are two variants. The first variant accepts a <tt>first</tt>,<tt>last</tt>iterator pair like you do STL algorithms. The second variant accepts anullterminated string. The last argument is a parser <tt>p</tt> which willbe used

-  to parse the input.</p>
-<p><b>Phrase level parsing</b></p>

-<pre><code> <spanclass=keyword>template <<spanclass=keyword>typename IteratorT<spanclass=special>, typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>>- parse_info<spanclass=special><IteratorT<spanclass=special>>

-    </span><span class=identifier>parse
-    </span><span class=special>(

- IteratorT <spanclass=keyword>const& <spanclass=identifier>first,- IteratorT <spanclass=keyword>const& <spanclass=identifier>last,- parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& p,- parser<spanclass=special><SkipT<spanclass=special>> const<spanclass=special>& skip

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

-<pre><code> <spanclass=keyword>template <<spanclass=keyword>typename CharT<spanclass=special>, typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>>- parse_info<spanclass=special><CharT <spanclass=keyword>const*>

-    </span><span class=identifier>parse
-    </span><span class=special>(

- CharT <spanclass=keyword>const* <spanclass=identifier>str,- parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& p,- parser<spanclass=special><SkipT<spanclass=special>> const<spanclass=special>& skip

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

+ to parse the input. 这里存在两种变体，第一个变体接受一对<tt>first</tt>, <tt>last</tt> 迭代器，就像你在STL算法里面用的一样。第二个变体接受一个null结尾的字符串。最后一个参数是一个用于分析输入的分析器<tt>p</tt>。

+<p><b>Phrase level parsing 短句层面的分析</b></p>

+<pre><code> <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">parse_info<<spanclass="identifier">IteratorT> parse <spanclass="special">( IteratorTconst&first<spanclass="special">, IteratorTconst&last<spanclass="special">, <spanclass="identifier">parser<<spanclass="identifier">ParserT> <spanclass="keyword">const& <spanclass="identifier">p, <spanclass="identifier">parser<<spanclass="identifier">SkipT> <spanclass="keyword">const& <spanclass="identifier">skip <spanclass="special">);</code></pre>+<pre><code> <spanclass="keyword">template <<spanclass="keyword">typename CharT<spanclass="special">, typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">parse_info<<spanclass="identifier">CharT const<spanclass="special">*> parse ( <spanclass="identifier">CharT const<spanclass="special">* <spanclass="identifier">str, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& p<spanclass="special">, <spanclass="identifier">parser<<spanclass="identifier">SkipT> <spanclass="keyword">const& <spanclass="identifier">skip <spanclass="special">);</code></pre>Like above, there are two variants. The first variant accepts a<tt>first</tt>,<tt>last</tt> iterator pair like you do STL algorithms. The secondvariant acceptsa null terminated string. The argument <tt>p</tt> is the parser whichwill be- used to parse the input. The last argument <tt>skip</tt> is the skipparser.

-<p><b>The parse_info structure</b></p>

+ used to parse the input. The last argument <tt>skip</tt> is the skipparser. 和前面一样，这里也有两个变体。第一个变体接受一对 <tt>first</tt>,<tt>last</tt> 迭代器，就像你在STL算法里面用的一样。第二个变体接受一个null结尾的字符串。参数 <tt>p</tt> 是一个用于分析输入的分析器。最后一个参数<tt>skip</tt> 就是跳读分析器。

+<p><b>The parse_info structure &nbsp;结构 parse_info</b></p>

The functions above return a <tt>parse_info</tt> structureparameterized by

-  the iterator type passed in. The parse_info struct has these members:</p>
-<table width="90%" border="0" align="center">
-  <tr>

+ the iterator type passed in. The parse_info struct has thesemembers: 以上函数返回一个以传入的迭代器类型为模板参数的<tt>parse_info</tt> 结构。parse_info 结构有如下成员：

+<table align="center" border="0" width="90%">
+  <tbody><tr>
     <td colspan="2" class="table_title"><b>parse_info</b></td>
   </tr>
   <tr>
-    <td width="14%" class="table_cells"><b>stop</b></td>

- <td width="86%" class="table_cells">Points to the final parse position(i.e

-      The parser recognized and processed the input up to this point)</td>
+    <td class="table_cells" width="14%"><b>stop</b></td>

+ <td class="table_cells" width="86%">Points to the final parse position(i.e+ The parser recognized and processed the input up to this point) 指向最终的分析位置（比如，分析器识别和处理的输入到这里为止）</td>

   </tr>
   <tr>
-    <td width="14%" class="table_cells"><b>hit</b></td>

- <td width="86%" class="table_cells">True if parsing is successful.This may

+    <td class="table_cells" width="14%"><b>hit</b></td>

+ <td class="table_cells" width="86%">True if parsing is successful.This maybe full: the parser consumed all the input, or partial: the parserconsumed

-      only a portion of the input.</td>

+ only a portion of the input. 如果分析成功，则为真。这个成功有可能是完全的：分析器消耗了全部的输入，或者部分的：分析器只消耗了一部分输入</td>

   </tr>
   <tr>
-    <td width="14%" class="table_cells"><b>full</b></td>

- <td width="86%" class="table_cells">True when we have a full match(i.e The

-      parser consumed all the input).</td>
+    <td class="table_cells" width="14%"><b>full</b></td>

+ <td class="table_cells" width="86%">True when we have a full match(i.e The+ parser consumed all the input). 如果完全匹配则为真（比如分析器消耗了全部输入）</td>

   </tr>
   <tr>
-    <td width="14%" class="table_cells"><b>length</b></td>

- <td width="86%" class="table_cells">The number of characters consumedby the

+    <td class="table_cells" width="14%"><b>length</b></td>

+ <td class="table_cells" width="86%">The number of characters consumedby theparser. This is valid only if we have a successful match (eitherpartial

-      or full). </td>

+ or full). 分析器消耗的字符数目。只有在成功匹配（无论是部分的或者全部的）时，这个值才有效。 </td>

   </tr>
-</table>

-<h2><a name="phrase_scanner_t" id="phrase_scanner_t"></a><imgsrc="theme/lens.gif" width="15" height="16">

+</tbody></table>

+<h2><a name="phrase_scanner_t" id="phrase_scanner_t"></a><imgsrc="theme/lens.gif" height="16" width="15">

   The phrase_scanner_t and wide_phrase_scanner_t</h2>
-<p>For convenience, Spirit declares these typedefs:</p>
-<pre>

- typedef scanner<spanclass="special"><char const<spanclass="special">*, unspecified>phrase_scanner_t;+For convenience, Spirit declares these typedefs: 方便起见，Spirit声明了这些 typedef：+<pre> typedef scanner<spanclass="special"><char const<spanclass="special">*, unspecified>phrase_scanner_t;typedef scanner<spanclass="special"><wchar_t const<spanclass="special">*, unspecified<spanclass="special">> wide_phrase_scanner_t<spanclass="special">;

 </pre>

These are the exact scanner types used by Spirit on calls to the parsefunctionpassing in a <tt>char const*</tt> (C string) or a <tt>wchar_tconst*</tt> (widestring) as the first parameter and a <tt>space_p</tt> as skip-parser(the third- parameter). For instance, we can use these typedefs to declare somerules. Example:-<pre> rule<phrase_scanner_t<spanclass="special">> my_rule<spanclass="special">;- parse<spanclass="special">(<spanclass="string">"abrakadabra",my_rule<spanclass="special">, space_p<spanclass="special">);</pre>-<h2><img src="theme/lens.gif" width="15" height="16"> Direct parsing withIterators</h2>+ parameter). For instance, we can use these typedefs to declare somerules. Example: 这些是这些是Spirit里那些被传入 <tt>char const*</tt>(C字符串)或者 <tt>wchar_t const*</tt>(宽字符串)作为第一个参数，以及以一个<tt>space_p</tt> 作为跳读分析器（第三个参数）的parse函数所用的扫描器的准确类型。比如，我们可以使

+用这些 typedef 去声明一些规则。例子：</p>

+<pre> rule<phrase_scanner_t<spanclass="special">> my_rule<spanclass="special">; parse<spanclass="special">("abrakadabra"<spanclass="special">, my_rule<spanclass="special">, space_p<spanclass="special">);</pre>+<h2><img src="theme/lens.gif" height="16" width="15"> Direct parsing withIterators 使用迭代器直接分析</h2>The free parse functions make it easy for us. By using them, we neednot botherwith the scanner intricacies. The free parse functions hide the dirtydetails.However, sometime in the future, we will need to get under the hood.It's nicethat we know what we are dealing with when that need comes. We will needto

-  go low-level and call the parser's parse member function directly. </p>

-If we wish to work on the character level, the procedure isquite simple:-<pre> <spanclass=identifier>scanner<<spanclass=identifier>IteratorT> <spanclass=identifier>scan(<spanclass=identifier>first, <spanclass=identifier>last);

- if (<spanclass=identifier>p.<spanclass=identifier>parse(<spanclass=identifier>scan))

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

- // Parsed successfully. If first ==last, then we have

-        //  a full parse, the parser recognized the input in whole.
-    </span><span class=special>}
-    </span><span class=keyword>else
-    </span><span class=special>{

- // Parsing failure. The parser failedto recognize the input

-    </span><span class=special>}</span></pre>
-<table width="80%" border="0" align="center">
-  <tr>

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

-      scanner position on an unsucessful match</strong><br> <br>

+ go low-level and call the parser's parse member function directly. 自由分析函数把这件事情变简单了。通过使用他们，我们不必为分析器的复杂细节烦神。自由分析函数隐藏了那些肮脏的细节。然而，将来的某些时候，我们将需要+更深入底层。在需求来临时，我们知道我们对付的是什么，这样会比较好。我们将需要深入底层并直接调用分析器的 parse 成员函数。 +If we wish to work on the character level, the procedure isquite simple: 如果我们想在字符层面上工作，那么过程很简单：+<pre> <spanclass="identifier">scanner<<spanclass="identifier">IteratorT> <spanclass="identifier">scan(<spanclass="identifier">first, <spanclass="identifier">last); if (<spanclass="identifier">p.<spanclass="identifier">parse(<spanclass="identifier">scan)) <spanclass="special">{ // Parsedsuccessfully. If first == last, then we have 分析成功。如果 first ==last，则为 // a full parse, the parser recognized the input inwhole. 全分析，分析器识别出整个输入。 } else <spanclass="special">{ // Parsingfailure. The parser failed to recognize the input 分析失败。分析器不能识别输入。 }</pre>

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

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> The+ scanner position on an unsucessful match 匹配不成功时扫描器的位置 On a successful match, the input is advanced accordingly. But whathappenson an unsuccessful match? Be warned. It might be intuitive to thinkthatthe scanner position is reset to its initial position prior toparsing.

@@ -190,37 +150,23 @@

descent. If this behavior is not desired, you may need to positionthe scanneryourself. The <a href="numerics.html#scanner_save">example in thenumericschapter</a> illustrates how the scanner position can be saved andlater

-      restored.</td>

+ restored. 在成功匹配的情况下，输入会一直步进。但如果匹配没成功会发生什么？注意，也许你会直觉地认为扫描器的位置会被重置到上个分析阶段的初始位置。但是不对，它的位置不会被重置。在匹配不成功的情况下，扫描器的位置是<spanstyle="font-weight: bold;">未定义的！通常，它会被放到在递归下降过程中所产生的最深的一个错误那儿。如果你不想要这种行为，那就要自己改变分析器的位置。在<a href="numerics.html#scanner_save">数值分析里的例子</a>描绘了如何保存分析器的位置并在之后恢复。</td>

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

Where <tt>p</tt> is the parser we want to use, and<tt>first</tt>/<tt>last</tt>are the iterator pairs referring to the input. We just create a scannergiven- the iterators. The scanner type we will use here uses the default<tt>scanner_policies<></tt>.-The situation is a bit more complex when we wish to work on thephrase level:-<pre> typedefskip_parser_iteration_policy<spanclass=special><SkipT<spanclass=special>> iter_policy_t<spanclass=special>;- typedef <spanclass=identifier>scanner_policies<spanclass=special><iter_policy_t<spanclass=special>> <spanclass=identifier>scanner_policies_t;- typedef <spanclass=identifier>scanner<<spanclass=identifier>IteratorT, <spanclass=identifier>scanner_policies_t>scanner_t;

- iter_policy_titer_policy<spanclass=special>(skip<spanclass=special>);- scanner_policies_t <spanclass=identifier>policies(<spanclass=identifier>iter_policy);- scanner_t <spanclass=identifier>scan(<spanclass=identifier>first, <spanclass=identifier>last, <spanclass=identifier>policies);

-</span>

- if (<spanclass=identifier>p.<spanclass=identifier>parse(<spanclass=identifier>scan))

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

- // Parsed successfully. If first ==last, then we have

-        //  a full parse, the parser recognized the input in whole.
-    </span><span class=special>}
-    </span><span class=keyword>else
-    </span><span class=special>{

- // Parsing failure. The parser failedto recognize the input

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

+ the iterators. The scanner type we will use here uses the default<tt>scanner_policies<></tt>. 这里 <tt>p</tt> 是我们想使用的分析器，而 <tt>first</tt>/<tt>last</tt> 是指向输入的迭代器对。我们只是创建了一个使用这两个迭代器的扫描器。这里使用的扫描器类使用的是默认的<tt>scanner_policies<></tt>。+The situation is a bit more complex when we wish to work on thephrase level: 当我们想在短句层面上工作时，情况就有些复杂了：+<pre> typedefskip_parser_iteration_policy<spanclass="special"><SkipT<spanclass="special">> <spanclass="identifier">iter_policy_t; typedef <spanclass="identifier">scanner_policies<spanclass="special"><<spanclass="identifier">iter_policy_t>scanner_policies_t<spanclass="special">; typedef <spanclass="identifier">scanner<<spanclass="identifier">IteratorT, <spanclass="identifier">scanner_policies_t>scanner_t<spanclass="special">; <spanclass="identifier">iter_policy_t <spanclass="identifier">iter_policy(<spanclass="identifier">skip); <spanclass="identifier">scanner_policies_t <spanclass="identifier">policies(<spanclass="identifier">iter_policy); scanner_t <spanclass="identifier">scan(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">policies); + if (<spanclass="identifier">p.<spanclass="identifier">parse(<spanclass="identifier">scan)) <spanclass="special">{ // Parsedsuccessfully. If first == last, then we have 分析成功。如果 first ==last，则为 // a full parse, the parser recognized the input inwhole. 全分析，分析器识别出整个输入。 <spanclass="special">} else { //Parsing failure. The parser failed to recognize the input 分析失败。分析器不能识别输入。 }</pre>Where <tt>SkipT</tt> is the type of the skip-parser, <tt>skip</tt>.Again,<tt>p</tt> is the parser we want to use, and<tt>first</tt>/<tt>last</tt> arethe iterator pairs referring to the input. Given a skip-parser type<tt>SkipT</tt>,- <tt>skip_parser_iteration_policy</tt>creates+ <tt>skip_parser_iteration_policy</tt>createsa scanner iteration policy that skips over portions that are recognizedby theskip-parser. This may then be used to create a scanner. The<tt>scanner_policies</tt>- class wraps all scanner related policies including the iterationpolicies.+ class wraps all scanner related policies including the iterationpolicies. 这里 <tt>SkipT</tt> 是跳读分析器 <tt>skip</tt> 的类型。同样，<tt>p</tt> 是我们要用的分析器，而<tt>first</tt>/<tt>last</tt> 是指向输入的迭代器对。给与一个类型为<tt>SkipT</tt> 的跳读分析器，+则<spanclass="identifier"><tt>skip_parser_iteration_policy</tt> 将创建一个会跳过被跳读分析器所匹配的内容的扫描器迭代策略。<tt>scanner_policies</tt> 类封装了包括迭代策略在内的所有与扫描器相关的策略。

 <h2><a name="lexeme_scanner"></a>lexeme_scanner</h2>

When switching from phrase level to character level parsing, the<tt>lexeme_d</tt>(see <a href="directives.html">directives.html</a>) does its magic bydisabling

@@ -229,60 +175,61 @@

type. This should not be a problem in most cases. However, when rulesare calledinside the <tt>lexeme_d</tt>, the compiler will choke if the rule doesnot havethe proper scanner type. If a rule must be used inside a<tt>lexeme_d</tt>,

-  the rule's type must be:</p>

-<pre> rule<spanclass=special><lexeme_scanner<spanclass="special"><ScannerT<spanclass=special>>::type<spanclass=special>> r;</pre>-where <tt>ScannerT</tt> is the actualtype of- the scanner used. Take note that <tt>lexeme_scanner</tt> will only workfor phrase level scanners. + the rule's type must be: 当分析层面从字符层面转向短句层面时，<tt>lexeme_d</tt> (见 <a href="directives.html">directives.html</a>)通过禁止跳过空白字符来完成它的魔法。这是通过调整<a href="scanner.html">扫描器</a>来+完成的。然而，当我们这么做时，所有在 lexeme 里的分析器都会得到一个变换后的分析器类。在大多数情况下，这并不是问题。可是，当规则在 <tt>lexeme_d</tt> 内被调用时，如果它没有恰当的分析器类型，那么编译器会在此受阻。如果非要在 <tt>lexeme_d</tt> 内使用规则，那么规则的类型必须是：+<pre> rule<spanclass="special"><<spanclass="identifier">lexeme_scanner<spanclass="special"><ScannerT<spanclass="special">>::type<spanclass="special">> r;</pre>+where <tt>ScannerT</tt> is the actualtype of+ the scanner used. Take note that <tt>lexeme_scanner</tt> will only workfor phrase level scanners. 这里 <spanclass="identifier"><tt>ScannerT</tt> 是所使用的分析器的真正类型。注意 <tt>lexeme_scanner</tt> 将只在短句层面工作。 

 <h2><a name="as_lower_scanner"></a>as_lower_scanner</h2>

Similarly, the <tt>as_lower_d</tt> does its work by filtering andconvertingall characters received from the scanner to lower case. This is alsodone bytweaking the <a href="scanner.html">scanner</a>. Then again, all parsersinsidethe <tt>as_lower_d</tt> gets a transformed scanner type. If a rule mustbe used

-  inside a <tt>as_lower_d</tt>, the rule's type must be:</p>

-<pre> rule<spanclass=special><<spanclass=identifier>as_lower_scanner<spanclass="special"><ScannerT<spanclass=special>>::type<spanclass=special>> r;</pre>-where <tt>ScannerT</tt> is the actualtype of

-  the scanner used. </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/bulb.gif" width="13" height="18">See+ inside a <tt>as_lower_d</tt>, the rule's type must be: 类似的，<tt>as_lower_d</tt> 通过把所有从分析器收到的字符转成小写来完成自己的工作。这同样是通过调整扫描器来完成的。同样，所有在<tt>as_lower_d</tt> 里面的分析器都会得到一个变换后的分析器类。如果要在<tt>as_lower_d</tt> 内使用规则，那么规则的类型必须是：+<pre> rule<spanclass="special"><<spanclass="identifier">as_lower_scanner<spanclass="special"><ScannerT<spanclass="special">>::type<spanclass="special">> r;</pre>+where <tt>ScannerT</tt> is the actualtype of+ the scanner used. 其中 <spanclass="identifier"><tt>ScannerT</tt> 是所使用的扫描器的实际类型。

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

+ <td class="note_box"><img src="theme/bulb.gif" height="18" width="13">Seethe techniques section for an <ahref="techniques.html#multiple_scanner_support">example</a>of a <a href="grammar.html">grammar</a> using a <ahref="rule.html#multiple_scanner_support">multiplescanner enabled rule</a>, <ahref="scanner.html#lexeme_scanner">lexeme_scanner</a>- and <ahref="scanner.html#as_lower_scanner">as_lower_scanner.</a></td>+ and <ahref="scanner.html#as_lower_scanner">as_lower_scanner.</a> <imgsrc="theme/bulb.gif" height="18" width="13"> 在技术章节内有关于使用<ahref="rule.html#multiple_scanner_support">多扫描器规则</a>、<ahref="scanner.html#lexeme_scanner">lexeme_scanner</a> 和 <ahref="scanner.html#as_lower_scanner">as_lower_scanner</a>的<ahref="grammar.html">语法</a>的<ahref="techniques.html#multiple_scanner_support">例子</a>。<ahref="scanner.html#as_lower_scanner"></a></td>

   </tr>
-</table>
+</tbody></table>
 <h3><a name="no_actions_scanner"></a>no_actions_scanner</h3>

Again, <tt>no_actions_d</tt> directive tweaks the scanner to disablefiringsemantic actions. Like before, all parsers inside the<tt>no_actions_d</tt>gets a transformed scanner type. If a rule must be used inside a<tt>no_actions_d</tt>,

-  the rule's type must be:</p>

-<pre> rule<spanclass=special><no_actions_scanner<spanclass="special"><ScannerT<spanclass=special>>::type<spanclass=special>> r;</pre>-where <tt>ScannerT</tt> is the actual type of the scanner used. <spanclass=special>

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

- <td class="note_box"><img src="theme/note.gif" width="16" height="16">Be- sure to add "<tt>typename</tt>" before <tt><spanclass=identifier><tt>lexeme_scanner</tt>,+ the rule's type must be: 同样，<tt>no_actions_d</tt> 指示符也是通过调整扫描器来禁止语义动作。就像前面的，在 <tt>no_actions_d</tt> 中的所有分析器得到的也是变换后的分析器类。如果想在 <tt>no_actions_d</tt> 里使用规则，规则的类型必须是：+<pre> rule<spanclass="special"><no_actions_scanner<spanclass="special"><ScannerT<spanclass="special">>::type<spanclass="special">> r;</pre>+where <tt>ScannerT</tt> is the actual type of the scanner used. 其中<tt>ScannerT</tt> 是所使用的扫描器的实际类型。 

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

+ <td class="note_box"><img src="theme/note.gif" height="16" width="16">Be+ sure to add "<tt>typename</tt>" before <tt><spanclass="identifier"><tt>lexeme_scanner</tt>,<tt>as_lower_scanner</tt></tt> and<tt>no_actions_scanner</tt> when

-      these are used inside a template class or function.</td>

+ these are used inside a template class or function. <imgsrc="theme/note.gif" height="16" width="16"> 记住当在模板类或函数中使用<tt><tt>lexeme_scanner</tt>,+ <tt>as_lower_scanner</tt></tt> 和<tt>no_actions_scanner</tt>时，在它们前加 "<tt>typename</tt>"。</td>

   </tr>
-</table>

-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/no_actions.cpp">no_actions.cpp</a>. This ispart of the Spirit distribution.

+</tbody></table>

+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/no_actions.cpp">no_actions.cpp</a>. This ispart of the Spirit distribution. 可以查看<ahref="../example/fundamental/no_actions.cpp">no_actions.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; 1998-2003 Joel de Guzman<br>
+<p class="copyright">Copyright (c) 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>&nbsp;</p>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/semantic_actions.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/semantic_actions.html Wed Sep 1620:25:53 2009

@@ -1,31 +1,29 @@
-<html>
-<head>
-<title>Semantic Actions</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>Semantic Actions</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%">

- Semantic Actions+ Semantic Actions 语义动作

     </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="subrules.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="indepth_the_parser.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

    </tr>
-</table>
-<p>Semantic actions have the form: <b>expression[action]</b></p>
+</tbody></table>

+Semantic actions have the form: expression[action] 语义动作有如下格式：表达式[动作]Ultimately, after having defined our grammar and having generated acorrespondingparser, we will need to produce some output and do some work besidessyntaxanalysis; unless, of course, what we want is merely to check for theconformance

@@ -33,47 +31,39 @@

may be attached to any expression at any level within the parserhierarchy.An action is a C/C++ function or function object that will be called ifa matchis found in the particular context where it is attached. The actionfunction

-  serves as a hook into the parser and may be used to, for example:</p>

+ serves as a hook into the parser and may be used to, for example: 总的来说，在定义了我们的语法并生成相应的分析器之后，我们就需要在语法分析之外产生某些输出或者其他的工作；当然，除非我们仅仅想验证输入与语法+的一致性，但是这种情况不大可能。语义动作可以挂接到分析器内任意层次的任意表达式上。一个动作就是一个在其挂接的特定语境下产生匹配时被调用的C/C++函数或者函数对象。一个动作函数就像一个钩入分析器内并且可能被使用的钩子。比如：

 <blockquote>

- <img src="theme/bullet.gif" width="13" height="13"> Generate outputfrom

-    the parser (ASTs, for example)<br>

- <img src="theme/bullet.gif" width="13" height="13"> Report warnings orerrors - <img src="theme/bullet.gif" width="13" height="13"> Manage symboltables+ <img src="theme/bullet.gif" height="13" width="13"> Generate outputfrom

+    the parser (ASTs, for example)<br>从分析器产生输出（AST树，比如）<br>

+ <img src="theme/bullet.gif" height="13" width="13"> Report warnings orerrors 报告警告或者错误 + <img src="theme/bullet.gif" height="13" width="13"> Manage symboltables 管理符号表

 </blockquote>
-<h2>Generic Semantic Actions (Transduction Interface)</h2>

+<h2>Generic Semantic Actions (Transduction Interface) 一般的语义动作(Transduction接口)</h2>A generic semantic action can be any free function or function objectthat

-  is compatible with the interface:</p>

-<pre><code><spanclass=keyword> void f<spanclass=special>(IteratorT <spanclass=identifier>first, <spanclass=identifier>IteratorT last<spanclass=special>);</code></pre>+ is compatible with the interface: 一个一般的语义动作可以是与接口兼容的任意的自由函数或者函数对象：+<pre><code><spanclass="keyword"> void f<spanclass="special">(IteratorT <spanclass="identifier">first, <spanclass="identifier">IteratorT <spanclass="identifier">last<spanclass="special">);</code></pre>where <tt>IteratorT</tt> is the type of iterator used, <tt>first</tt>pointsto the current input and <tt>last</tt> points to one after the end ofthe input(identical to STL iterator ranges). A function object (functor) shouldhave

-  a member <tt>operator()</tt> with the same signature as above:</p>

-<pre><code> <spanclass=keyword>struct my_functor

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

- void <spanclass=keyword>operator()(<spanclass=identifier>IteratorT first<spanclass=special>, IteratorT <spanclass=identifier>last) <spanclass=keyword>const;

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

+ a member <tt>operator()</tt> with the same signature as above: 其中<tt>IteratorT</tt> 是所使用的迭代器类型，<tt>first</tt> 指向当前输入而<tt>last</tt> 指向输入终点的后一个位置（与STL迭代器的区间一致）。函数对象（仿函数）则应有与上面签名一致的<tt>operator()</tt> <fontface="Courier New">成员函数：+<pre><code> <spanclass="keyword">struct my_functor { voidoperator<spanclass="special">()(IteratorT <spanclass="identifier">first, <spanclass="identifier">IteratorT <spanclass="identifier">last) <spanclass="keyword">const; <spanclass="special">};</code></pre>Iterators pointing to the matching portion of the input are passed intothe

-  function/functor.</p>
+  function/functor.<br>指向输入的迭代器将被传入函数/仿函数</p>

In general, semantic actions accept the first-last iterator pair. Thisis thetransduction interface. The action functions or functors receive theunprocesseddata representing the matching production directly from the input. Inmany cases,this is sufficient. Examples are source to source translation,pre-processing,

-  etc. </p>
-<h3>Example:</h3>

-<pre><code> <spanclass=keyword>void- my_action<spanclass=special>(char const<spanclass=special>* first<spanclass=special>, char const<spanclass=special>* last<spanclass=special>)

-    {

- std<spanclass=special>::string<spanclass=special> str<spanclass=special>(first<spanclass=special>, last<spanclass=special>);- std<spanclass=special>::cout <spanclass=special><< str <spanclass=special><< std<spanclass=special>::endl<spanclass=special>;

-    }
-

- rule<>myrule =(a | <spanclass=identifier>b | *(<spanclass=identifier>c >> <spanclass=identifier>d))[&<spanclass=identifier>my_action<spanclass=special>];</code></pre>+ etc. 总而言之，语义动作接受 first-last 迭代器对。这是一个transduction 接口。动作函数或者仿函数直接从输入中接收代表匹配生成式的未处理的数据。在很多情况下，这已经足够了。比如从代码到代码的翻译、预处理等等。

+<h3>Example: 例子：</h3>

+<pre><code> <spanclass="keyword">void <spanclass="identifier">my_action(<spanclass="keyword">char const* <spanclass="identifier">first, <spanclass="keyword">char const* <spanclass="identifier">last) { std<spanclass="special">::string<spanclass="special"> str<spanclass="special">(first<spanclass="special">, last<spanclass="special">); <spanclass="identifier">std::<spanclass="identifier">cout << <spanclass="identifier">str << <spanclass="identifier">std::<spanclass="identifier">endl; } rule<>myrule =(a |b |*(c >>d<spanclass="special">))[&<spanclass="identifier">my_action<spanclass="special">];</code></pre>The function <tt>my_action</tt> will be called whenever the expression<tt>(a| b | *(c >> d)</tt> matches a portion of the input stream whileparsing.Two iterators, <tt>first</tt> and <tt>last</tt>, are passed into thefunction.These iterators point to the start and end, respectively, of the portionof

-  input stream where the match is found.</p>
-<h3>Const-ness:</h3>

+ input stream where the match is found. 函数 <tt>my_action</tt> 在表达式 <tt>(a+ | b | *(c >> d)</tt> 匹配输入流中的某一段时将被调用。两个迭代器 <tt>first</tt> 和 <tt>last</tt> 被分别传入函数，它们指向输入流中匹配的片段的起点和终点。

+<h3>Const-ness: 不变性：</h3>

With functors, take note that the <tt>operator()</tt> should be<tt>const</tt>.This implies that functors are immutable. One may wish to have somemember variablesthat are modified when the action gets called. This is not a good idea.First

@@ -85,174 +75,108 @@

functor that the client passed in since they are distinct copies. If afunctorneeds to update some state variables, which is often the case, it isbetterto use references to external data. The following example shows how thiscan

-  be done:</p>

-<pre><code> <spanclass=keyword>struct my_functor

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

- my_functor<spanclass=special>(std<spanclass=special>::string<spanclass=special>& str_<spanclass=special>)- : <spanclass=identifier>str(<spanclass=identifier>str_) <spanclass=special>{}

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

- operator<spanclass=special>()(IteratorT <spanclass=identifier>first, <spanclass=identifier>IteratorT last<spanclass=special>) const

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

- str<spanclass=special>.assign<spanclass=special>(first<spanclass=special>, last<spanclass=special>);

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

- std<spanclass=special>::string<spanclass=special>& str<spanclass=special>;

-    </span><span class=special>};</span></font></code></pre>
-<h3>Full Example:</h3>
-<p>Here now is our calculator enhanced with semantic actions:</p>

-<pre><code> <spanclass=keyword>namespace

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

- void <spanclass=identifier>do_int(<spanclass=keyword>char const<spanclass=special>* str<spanclass=special>, char <spanclass=keyword>const* <spanclass=identifier>end)

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

- string <spanclass=identifier>s(<spanclass=identifier>str, <spanclass=identifier>end);- cout <spanclass=special><< "PUSH(" <spanclass=special><< s <spanclass=special><< ')' <spanclass=special><< endl<spanclass=special>;

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

- void <spanclass=identifier>do_add(<spanclass=keyword>char const<spanclass=special>*, char <spanclass=keyword>const*) <spanclass=special>{ cout <spanclass=special><< "ADD\n"<spanclass=special>; }- void <spanclass=identifier>do_subt(<spanclass=keyword>char const<spanclass=special>*, char <spanclass=keyword>const*) <spanclass=special>{ cout <spanclass=special><< "SUBTRACT\n"<spanclass=special>; }- void <spanclass=identifier>do_mult(<spanclass=keyword>char const<spanclass=special>*, char <spanclass=keyword>const*) <spanclass=special>{ cout <spanclass=special><< "MULTIPLY\n"<spanclass=special>; }- void <spanclass=identifier>do_div(<spanclass=keyword>char const<spanclass=special>*, char <spanclass=keyword>const*) <spanclass=special>{ cout <spanclass=special><< "DIVIDE\n"<spanclass=special>; }- void <spanclass=identifier>do_neg(<spanclass=keyword>char const<spanclass=special>*, char <spanclass=keyword>const*) <spanclass=special>{ cout <spanclass=special><< "NEGATE\n"<spanclass=special>; }

-    </span><span class=special>}</span></font></code></pre>
-<p>We augment our grammar with semantic actions:</p>

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

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

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

- = <spanclass=identifier>term- >> <spanclass=special>*( (<spanclass=literal>'+' >> <spanclass=identifier>term)[&<spanclass=identifier>do_add]- | <spanclass=special>('-' <spanclass=special>>> term<spanclass=special>)[&do_subt<spanclass=special>]

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

- term <spanclass=special>=

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

- >> <spanclass=special>*( (<spanclass=literal>'*' >> <spanclass=identifier>factor)[&<spanclass=identifier>do_mult]- | <spanclass=special>('/' <spanclass=special>>> factor<spanclass=special>)[&do_div<spanclass=special>]

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

- = <spanclass=identifier>lexeme_d[(+<spanclass=identifier>digit_p)[&<spanclass=identifier>do_int]]- | <spanclass=literal>'(' >> <spanclass=identifier>expression >>')'- | <spanclass=special>('-' <spanclass=special>>> factor<spanclass=special>)[&do_neg<spanclass=special>]- | <spanclass=special>('+' <spanclass=special>>> factor<spanclass=special>)

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

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

+ be done: 使用仿函数时，注意 <tt>operator()</tt> 需要声明为<tt>const</tt>。暗示了仿函数是不可变的。有人也许希望当动作被调用时可以改变某些成员变量。这不是+个好主意。首先，仿函数应该是轻量级的。仿函数被反复传递，如果它有沉重的负载，那将产生大量的额外消耗。其次，仿函数是传值的。因此，真正挂接到分析器+上的函数对象，肯定不是由客户程序提供的最初的实例。这意味着仿函数状态的改变无法影响到由客户程序传入的原始的仿函数，因为它们是不同的拷贝。如果一个+仿函数需要更新某些状态变量，这是很常见的，最好还是引用外部数据。下面的例子说明了如何做到这点：+<pre><code> <spanclass="keyword">struct my_functor { <spanclass="identifier">my_functor(<spanclass="identifier">std::<spanclass="identifier">string& <spanclass="identifier">str_) : <spanclass="identifier">str(<spanclass="identifier">str_) <spanclass="special">{} <spanclass="keyword">void <spanclass="keyword">operator()(<spanclass="identifier">IteratorT <spanclass="identifier">first, <spanclass="identifier">IteratorT <spanclass="identifier">last) <spanclass="keyword">const <spanclass="special">{ <spanclass="identifier">str.<spanclass="identifier">assign(<spanclass="identifier">first, <spanclass="identifier">last); } <spanclass="identifier">std::<spanclass="identifier">string& <spanclass="identifier">str; <spanclass="special">};</code></pre>

+<h3>Full Example: 完整的例子：</h3>

+Here now is our calculator enhanced with semantic actions: 以下用语义动作来增强我们的计算器：+<pre><code> <spanclass="keyword">namespace { void <spanclass="identifier">do_int(<spanclass="keyword">char const<spanclass="special">* str<spanclass="special">, char <spanclass="keyword">const* <spanclass="identifier">end) { <spanclass="identifier">string s<spanclass="special">(str<spanclass="special">, end<spanclass="special">); cout<< "PUSH("<< s<< ')'<< <spanclass="identifier">endl; } <spanclass="keyword">void do_add<spanclass="special">(char <spanclass="keyword">const*, <spanclass="keyword">char const<spanclass="special">*) { <spanclass="identifier">cout << <spanclass="string">"ADD\n"; <spanclass="special">} voiddo_subt<spanclass="special">(char <spanclass="keyword">const*, <spanclass="keyword">char const<spanclass="special">*) { <spanclass="identifier">cout << <spanclass="string">"SUBTRACT\n"; <spanclass="special">} voiddo_mult<spanclass="special">(char <spanclass="keyword">const*, <spanclass="keyword">char const<spanclass="special">*) { <spanclass="identifier">cout << <spanclass="string">"MULTIPLY\n"; <spanclass="special">} voiddo_div<spanclass="special">(char <spanclass="keyword">const*, <spanclass="keyword">char const<spanclass="special">*) { <spanclass="identifier">cout << <spanclass="string">"DIVIDE\n"; <spanclass="special">} voiddo_neg<spanclass="special">(char <spanclass="keyword">const*, <spanclass="keyword">char const<spanclass="special">*) { <spanclass="identifier">cout << <spanclass="string">"NEGATE\n"; <spanclass="special">} <spanclass="special">}</code></pre>+We augment our grammar with semantic actions: 我们给我们的语法增加语义动作：+<pre><code> <spanclass="keyword">struct calculator: publicgrammar<spanclass="special"><calculator<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">expression <spanclass="special">= <spanclass="identifier">term <spanclass="special">>> *( <spanclass="special">('+' <spanclass="special">>> term<spanclass="special">)[&do_add<spanclass="special">] <spanclass="special">| (<spanclass="literal">'-' >> <spanclass="identifier">term)[&<spanclass="identifier">do_subt<spanclass="special">] <spanclass="special">) <spanclass="special">; <spanclass="identifier">term <spanclass="special">= <spanclass="identifier">factor <spanclass="special">>> *( <spanclass="special">('*' <spanclass="special">>> factor<spanclass="special">)[&do_mult<spanclass="special">] <spanclass="special">| (<spanclass="literal">'/' >> <spanclass="identifier">factor)[&<spanclass="identifier">do_div<spanclass="special">] <spanclass="special">) <spanclass="special">; <spanclass="identifier">factor <spanclass="special">= lexeme_d<spanclass="special">[(+digit_p<spanclass="special">)[&do_int<spanclass="special">]] |'(' >>expression <spanclass="special">>> <spanclass="literal">')' |('-' <spanclass="special">>> factor<spanclass="special">)[&do_neg<spanclass="special">] |('+' <spanclass="special">>> factor<spanclass="special">) <spanclass="special">; <spanclass="special">} <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">expression, <spanclass="identifier">term, <spanclass="identifier">factor; rule<spanclass="special"><ScannerT<spanclass="special">> const<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return <spanclass="identifier">expression; <spanclass="special">} }; };</code></pre>Feeding in the expression <tt>(-1 + 2) * (3 + -4)</tt>, for example, tothe

-  rule <tt>expression</tt> will produce the expected output:</p>
-<pre><code><span class=special>-</span><span class=number>1
-</span><span class=number>2
-</span><span class=identifier>ADD
-</span><span class=number>3
-</span><span class=special>-</span><span class=number>4
-</span><span class=identifier>ADD
-</span><span class=identifier>MULT</span></code></pre>

+ rule <tt>expression</tt> will produce the expected output: 比如把表达式 <tt>(-1 + 2) * (3 + -4)</tt> 喂给规则<tt>expression</tt>，将产生所预期的输出：+<pre><code>-<spanclass="number">1 2 <spanclass="identifier">ADD 3 <spanclass="special">-4 <spanclass="identifier">ADD <spanclass="identifier">MULT</code></pre>which, by the way, is the Reverse Polish Notation (RPN) of the givenexpression,

-  reminiscent of some primitive calculators and the language Forth.</p>

-<img src="theme/lens.gif" width="15" height="16"> <ahref="../example/fundamental/calc_plain.cpp">View- the complete source code here</a>. This is part of the Spiritdistribution.

-</p>
-<h2><a name="specialized_actions"></a>Specialized Actions</h2>

+ reminiscent of some primitive calculators and the language Forth. 此即上面表达式的逆波兰式（RPN），类似于某些低等计算器或Forth语言。+<img src="theme/lens.gif" height="16" width="15"> <ahref="../example/fundamental/calc_plain.cpp">View+ the complete source code here</a>. This is part of the Spiritdistribution. <img src="theme/lens.gif" height="16" width="15"><ahref="../example/fundamental/calc_plain.cpp">在这里查看完整代码。</a>这是Spirit发布包的一部分。 

+<h2><a name="specialized_actions"></a>Specialized Actions 特殊动作</h2>

In general, semantic actions accept the first-last iterator pair. Therearesituations though where we might want to pass data in its processedform. Aconcrete example is the numeric parser. It is unwise to pass unprocesseddatato a semantic action attached to a numeric parser and just throw awaywhat has

-  been parsed by the parser. We want to pass the actual parsed number.</p>

+ been parsed by the parser. We want to pass the actual parsednumber. 一般来说，语义动作接受 first-last 迭代器对。但在某些情况下我们希望以已被处理的格式传入数据。一个典型的例子就是数值分析器。直接把未处理的数据传给挂接在数值分析器上的语义动作并扔掉刚刚被分析的数据是不明智的。我们希望传递解析出的实际数值。The function and functor signature of a semantic action variesdepending onthe parser where it is attached to. The following table lists theparsers that

-  accept unique signatures.</p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/note.gif" width="16" height="16">Unless+ accept unique signatures. 语义动作的函数和仿函数的签名的变化取决于它被挂接到哪个分析器上。下面的表格列举了接受一元函数签名的分析器。

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

+ <td class="note_box"><img src="theme/note.gif" height="16" width="16">Unlessexplicitly stated in the documentation of a specific parser type,parsersnot included in the list by default expect the generic signature asexplained

-      above.</td>

+ above.除非文档中明确指出的分析器类型，否则文档所不包含的分析器都接受上面所说的一般形式的签名。</td>

   </tr>
-</table>
-<h3>Numeric Actions</h3>
-<p><b>Applies to:</b></p>
+</tbody></table>
+<h3>Numeric Actions 数值动作</h3>
+<p><b>Applies to: 对应于：</b></p>
 <blockquote>
-  <p><img src="theme/bullet.gif" width="13" height="13"> uint_p<br>
-    <img src="theme/bullet.gif" width="13" height="13"> int_p<br>
-    <img src="theme/bullet.gif" width="13" height="13"> ureal_p<br>
-    <img src="theme/bullet.gif" width="13" height="13"> real_p</p>
+  <p><img src="theme/bullet.gif" height="13" width="13"> uint_p<br>
+    <img src="theme/bullet.gif" height="13" width="13"> int_p<br>
+    <img src="theme/bullet.gif" height="13" width="13"> ureal_p<br>
+    <img src="theme/bullet.gif" height="13" width="13"> real_p</p>
 </blockquote>
-<p><b>Signature for functions:</b></p>

-<pre><code> <spanclass=keyword>void func<spanclass=special>(NumT <spanclass=identifier>val);</code></pre>

-<p><b>Signature for functors:</b> </p>

-<pre><code> <spanclass=keyword>struct ftor

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

- void <spanclass=keyword>operator()(<spanclass=identifier>NumT val<spanclass=special>) const;

-    </span><span class=special>};</span></font></code></pre>
+<p><b>Signature for functions: 函数的签名：</b></p>

+<pre><code> <spanclass="keyword">void func<spanclass="special">(NumT <spanclass="identifier">val<spanclass="special">);</code></pre>

+<p><b>Signature for functors: 仿函数的签名：</b> </p>

+<pre><code> <spanclass="keyword">struct ftor { voidoperator<spanclass="special">()(NumT <spanclass="identifier">val) <spanclass="keyword">const; <spanclass="special">};</code></pre>Where <tt>NumT</tt> is any primitive numeric type such as <tt>int</tt>,<tt>long</tt>,<tt>float</tt>, <tt>double</tt>, etc., or a user defined numeric typesuch asbig_int. <tt>NumT</tt> is the same type used as template parameter to<tt>uint_p</tt>,<tt>int_p</tt>, <tt>ureal_p</tt> or <tt>real_p</tt>. The parsed numberis passed

-  into the function/functor.</p>
-<h3>Character Actions</h3>
-<p><b>Applies to:</b></p>

+ into the function/functor. 其中 <tt>NumT</tt> 是任意基本的数值类型，如 <tt>int</tt>, <tt>long</tt>,

+  <tt>float</tt>, <tt>double</tt> 等等，或者用户定义的数据类型，如
+  big_int。<tt>NumT</tt> 与 <tt>uint_p</tt>,

+ <tt>int_p</tt>, <tt>ureal_p</tt> 或 <tt>real_p</tt> 所使用的模板参数的类型相同。被解析出的数字将被传入函数/仿函数。

+<h3>Character Actions 字符动作</h3>
+<p><b>Applies to: 对应于：</b></p>
 <blockquote>
-  <p><img src="theme/bullet.gif" width="13" height="13"> chlit, ch_p<br>
-    <img src="theme/bullet.gif" width="13" height="13"> range, range_p<br>
-    <img src="theme/bullet.gif" width="13" height="13"> anychar<br>
-    <img src="theme/bullet.gif" width="13" height="13"> alnum, alpha<br>
-    <img src="theme/bullet.gif" width="13" height="13"> cntrl, digit<br>
-    <img src="theme/bullet.gif" width="13" height="13"> graph, lower<br>
-    <img src="theme/bullet.gif" width="13" height="13"> print, punct<br>
-    <img src="theme/bullet.gif" width="13" height="13"> space, upper<br>
-    <img src="theme/bullet.gif" width="13" height="13"> xdigit</p>
+  <p><img src="theme/bullet.gif" height="13" width="13"> chlit, ch_p<br>
+    <img src="theme/bullet.gif" height="13" width="13"> range, range_p<br>
+    <img src="theme/bullet.gif" height="13" width="13"> anychar<br>
+    <img src="theme/bullet.gif" height="13" width="13"> alnum, alpha<br>
+    <img src="theme/bullet.gif" height="13" width="13"> cntrl, digit<br>
+    <img src="theme/bullet.gif" height="13" width="13"> graph, lower<br>
+    <img src="theme/bullet.gif" height="13" width="13"> print, punct<br>
+    <img src="theme/bullet.gif" height="13" width="13"> space, upper<br>
+    <img src="theme/bullet.gif" height="13" width="13"> xdigit</p>
 </blockquote>
-<p><b>Signature for functions:</b></p>

-<pre><code> <spanclass=keyword>void func<spanclass=special>(CharT <spanclass=identifier>ch);</code></pre>

-<p><b>Signature for functors:</b></p>

-<pre><code> <spanclass=keyword>struct ftor

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

- void <spanclass=keyword>operator()(<spanclass=identifier>CharT ch<spanclass=special>) const;

-    </span><span class=special>};</span></font></code></pre>
+<p><b>Signature for functions: 函数的签名：</b></p>

+<pre><code> <spanclass="keyword">void func<spanclass="special">(CharT <spanclass="identifier">ch<spanclass="special">);</code></pre>

+<p><b>Signature for functors: 仿函数的签名：</b></p>

+<pre><code> <spanclass="keyword">struct ftor { voidoperator<spanclass="special">()(CharT <spanclass="identifier">ch) <spanclass="keyword">const; <spanclass="special">};</code></pre>Where <tt>CharT</tt> is the value_type of the iterator used in parsing.A <tt>charconst*</tt> iterator for example has a <tt>value_type</tt> of<tt>char</tt>.

-  The matching character is passed into the function/functor.</p>
-<h2>Cascading Actions</h2>

+ The matching character is passed into the function/functor. 其中<tt>CharT</tt> 为分析中所使用的迭代器的 value_type。比如一个 <tt>char+ const*</tt> 迭代器有 <tt>char</tt> 的 <tt>value_type</tt>。匹配的字符将被传入函数/仿函数。

+<h2>Cascading Actions 级联动作</h2>

Actions can be cascaded. Cascaded actions also inherit thefunction/functor

-  interface of the original. For example:</p>

-<pre><code> <spanclass=identifier>uint_p[<spanclass=identifier>fa][<spanclass=identifier>fb][<spanclass=identifier>fc]</code></pre>+ interface of the original. For example: 动作可以级联。级联的动作也继承了原有函数/仿函数的接口。比如：+<pre><code> <spanclass="identifier">uint_p[<spanclass="identifier">fa][<spanclass="identifier">fb][<spanclass="identifier">fc<spanclass="special">]</code></pre>Here, the functors <tt>fa</tt>, <tt>fb</tt> and <tt>fc</tt> all expectthe

-  signature <tt>void operator()(unsigned n) const</tt>.</p>
-<h2>Directives and Actions</h2>

+ signature <tt>void operator()(unsigned n) const</tt>. 这里，函数<tt>fa</tt>, <tt>fb</tt> 和 <tt>fc</tt> 都需要 <tt>voidoperator()(unsigned n) const</tt> 的成员函数签名。

+<h2>Directives and Actions 指示符和动作</h2>

Directives inherit the the function/functor interface of the subject itis

-  enclosing. Example:</p>

-<pre><code> <spanclass=identifier>as_lower_d[<spanclass=identifier>ch_p(<spanclass=literal>'x')][<spanclass=identifier>f]</code></pre>

+  enclosing. Example:<br>指示符继承其所封装的对象的函数接口。比如：</p>

+<pre><code> <spanclass="identifier">as_lower_d[<spanclass="identifier">ch_p(<spanclass="literal">'x')][<spanclass="identifier">f<spanclass="special">]</code></pre>Here, the functor <tt>f</tt> expects the signature <tt>voidoperator()(char- ch) const</tt>, assuming that the iterator used is a <tt>charconst*</tt>.+ ch) const</tt>, assuming that the iterator used is a <tt>charconst*</tt>. 这里，仿函数 <tt>f</tt> 需要 <tt>void operator()(char ch)const</tt> 这样的签名，假定所使用的迭代器是 <tt>char const*</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 (c) 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>&nbsp;</p>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/subrules.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/subrules.html        Wed Sep 16 20:25:53 2009
@@ -1,30 +1,28 @@
-<html>
-<head>
-<title>Subrules</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>Subrules</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%">

- Subrules+ Subrules 子规则

     </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="grammar.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="semantic_actions.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

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

Spirit is implemented using expression templates. This is a verypowerful technique.Along with its power comes some complications. We almost take forgranted thatwhen we write <tt>i | j >> k</tt> where <tt>i</tt>, <tt>j</tt> and<tt>k</tt>

@@ -34,256 +32,205 @@

<a href="basic_concepts.html">Basic Concepts</a>]. Spirit expressions,whichare combinations of primitives and composites yield an infinite set ofnew types.One problem is that C++ offers no easy facility to deduce the type of anarbitrarily- complex expression that yields a complex type. Thus, while it is easy towrite:-<pre><code> <spanclass=keyword>int r <spanclass=special>= i <spanclass=special>| j <spanclass=special>>> k<spanclass=special>; // where i, j, and k areints</code></pre>+ complex expression that yields a complex type. Thus, while it is easy towrite: Spirit 是用表达式模板来实现的。这是很强大的技术。与这种强大相伴的是一些复杂性。我们得到的保证是，当我们写下<tt>i | j >> k</tt> 其中<tt>i</tt>, <tt>j</tt> 和 <tt>k</tt>+ 都是整数时，其结果也还是一个整数。然而，对于表达式模板，同一个表达式<tt>i | j >> k</tt> 若其中 <tt>i</tt>, <tt>j</tt> 和

+  <tt>k</tt> 为类型 <tt>T</tt>，那么结果就是一个复杂的合成类型[见

+ <a href="basic_concepts.html">基本概念</a>]。Spirit的表达式，这个元素和复合物的混合体导致了一个新类型的无穷集。一个问题就是，C++没有提供一个简便的方法来推演一个会产生复杂类型的复杂表达式的类型。因此，虽然这么写很容易：+<pre><code> <spanclass="keyword">int r <spanclass="special">= i <spanclass="special">| j <spanclass="special">>> k<spanclass="special">; // where i, j, and k areints 其中i,j和k都是int</code></pre>Expression templates yield an endless supply of types. Without the <ahref="rule.html">rule</a>,there is no easy way to do this in C++ if <tt>i</tt>, <tt>j</tt> and<tt>k</tt>

-  are Spirit parsers:</p>

-<pre><code> <spanclass=special><what_type???<spanclass=special>> r <spanclass=special>= i <spanclass=special>| j <spanclass=special>>> k<spanclass=special>; // where i, j, and k are Spiritparsers</code></pre>+ are Spirit parsers: 但表达式模板造成了新类型的无限可能。没有<ahref="rule.html">规则</a>的话，在C++中，如果 <tt>i</tt>, <tt>j</tt> 和<tt>k</tt> 是Spirit的分析器，就没什么好办法来作这个了。+<pre><code> <spanclass="special"><<spanclass="identifier">what_type???>r =i |j >>k;// where i, j, and k are Spirit parsers 其中i,j和k是Spirit分析器</code></pre>If <tt>i</tt>, <tt>j</tt> and <tt>k</tt> are all <tt>chlit<></tt>objects,

-  the type that we want is:</p>

-<pre><code> <spanclass=keyword>typedef- alternative<spanclass=special><- chlit<spanclass=special><> // i- , <spanclass=identifier>sequence<- chlit<spanclass=special><> // j- ,chlit<>// k

-            </span><span class=special>&gt;
-        &gt;
-    </span><span class=identifier>rule_t</span><span class=special>;
-

- rule_t r =i | <spanclass=identifier>j >> <spanclass=identifier>k; <spanclass=comment>// where i, j, and k are chlit<>objects</code></pre>+ the type that we want is: 如果 <tt>i</tt>, <tt>j</tt> 和 <tt>k</tt> 都是 <tt>chlit<></tt> 对象，那么我们想要的类型就是：+<pre><code> <spanclass="keyword">typedef <spanclass="identifier">alternative<spanclass="special">< <spanclass="identifier">chlit<><spanclass="comment"> // i <spanclass="special">, sequence<spanclass="special">< <spanclass="identifier">chlit<> <spanclass="comment">// j <spanclass="special"> , <spanclass="identifier">chlit<> <spanclass="comment">// k <spanclass="special">> > <spanclass="identifier">rule_t; rule_t r =i |j >>k;// where i, j, and k are chlit<>objects 其中i,j和k都是chlit<>对象</code></pre>We deliberately formatted the type declaration nicely to make itunderstandable.Try that with a more complex expression. While it can be done,explicitly spellingout the type of a Spirit expression template is tedious and error prone.The- right hand side (rhs) has to mirror the type of the left hand side(lhs). (<img src="theme/lens.gif" width="15" height="16">+ right hand side (rhs) has to mirror the type of the left hand side(lhs). (<img src="theme/lens.gif" height="16" width="15">Yet, if you still wish to do it, see this <ahref="techniques.html#no_rules">link</a>

-  for a technique). </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"><img src="theme/lens.gif" width="15"height="16">+ for a technique). 我们故意把类型声明的格式弄得好看些，以方便理解。试着对更复杂的表达式用这个。虽然的确也可以做到，但显式拼写Spirit表达式模板的类型是冗烦而易错的。右操作数（rhs）必须是左操作数（lhs）的镜像。（<imgsrc="theme/lens.gif" height="16" width="15">不过，如果你坚持这么作的话，这个<a href="techniques.html#no_rules">链接</a>里有相关的技术）。

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

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

         typeof and auto</b> <br>
         <br>

Some compilers already support the <tt>typeof</tt> keyword. Thiscan beused to free us from having to explicitly type the type (punintentional).Using the <tt>typeof</tt>, we can rewrite the Spirit expressionabove

-        as:<br>

+ as:有些编译器已经支持 <tt>typeof</tt> 关键字了。这可以把我们从显式地打出类型中解放出来。使用 <tt>typeof</tt>，我们可以把上面的Spirit表达式写成这样： 

         <br>

- <spanclass="keyword"><code>typeof</code><code></code><code><spanclass=special>(i- | j>>- k)r- = i|- j <spanclass=special>>> k<spanclass=special>;</code> + <spanclass="keyword"><code>typeof</code><code></code><code><spanclass="special">(i+ | j>>+ k)r+ = i|+ j <spanclass="special">>> k<spanclass="special">;</code> 

         <br>

While this is better than having to explicitly declare a complextype,it is redundant, error prone and still an eye sore. The expressionistyped twice. The only way to simplify this is to introduce a macro(See- this <a href="techniques.html#typeof">link</a> for moreinformation). + this <a href="techniques.html#typeof">link</a> for moreinformation). 虽然这比显示声明复杂类型好些，但还是有冗余，易错以及晃眼。表达式被输入了两次。唯一简化这个的方法是引进一个宏（这个<ahref="techniques.html#typeof">链接</a>里有更多的信息） 

         <br>

<a href="http://www.boost-consulting.com";>David Abrahams</a>proposedin comp.std.c++ to reuse the <tt>auto</tt> keyword for typededuced variables.- This has been extensibly discussed in <ahref="http://www.boost.org";>boost.org</a>. Example:+ This has been extensibly discussed in <ahref="http://www.boost.org";>boost.org</a>. Example: <ahref="http://www.boost-consulting.com/";>David Abrahams</a>在 comp.std.c++ 中提议重用 <tt>auto</tt> 关键字来标识类型推演变量。这在 <ahref="http://www.boost.org/";>boost.org</a> 中有延伸讨论。例子： 

         <br>
-        <br>

- <code>auto </code><code><spanclass=identifier>r- = i|- j <spanclass=special>>> k<spanclass=special>;</code> + <code>auto </code><code><spanclass="identifier">r+ = i|+ j <spanclass="special">>> k<spanclass="special">;</code> 

         <br>

Once such a C++ extension is accepted into the standard, thiswould bea neat solution and a nice fit for our purpose. It's not acomplete solutionthough since there are still situations where we do not know therhs beforehand;

-        for instance when pre-declaring cyclic dependent rules.</p>

+ for instance when pre-declaring cyclic dependent rules. 一旦这个C++的扩展被标准接纳，将是一个干净利落的解决方案，而且和我们的目标相当吻合。但这还不是一个完整的解决方案，某些情况下我们无法预知rhs的类型；例如在前置声明有环形依赖的规则的时候。

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

Fortunately, rules come to the rescue. Rules can capture the type ofthe expression

-  assigned to it. Thus:</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>r = <spanclass=identifier>i | <spanclass=identifier>j >> <spanclass=identifier>k; <spanclass=comment>// where i, j, and k are chlit<>objects</code></pre>+ assigned to it. Thus: 幸运的是，规则这个救星出现了。规则可以捕获赋予它的表达式的类型。因此：+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">r = <spanclass="identifier">i | <spanclass="identifier">j >> <spanclass="identifier">k; <spanclass="comment">// where i, j, and k are chlit<>objects</code><code><spanclass="comment"> 其中i,j和k都是chlit<>对象</code></pre>It might not be apparent but behind the scenes, plain rules areactually implementedusing a pointer to a runtime polymorphic abstract class that holds thedynamictype of the parser assigned to it. When a Spirit expression is assignedto arule, its type is encapsulated in a concrete subclass of the abstractclass.- A virtual parse function delegates the parsing to the encapsulatedobject.

-<p>Rules have drawbacks though:</p>

-<img src="theme/bullet.gif" width="12" height="12"> It is coupled to aspecific+ A virtual parse function delegates the parsing to the encapsulatedobject. 可+能不那么直观，但在幕后，单纯的规则实际上是用一个保有分配给它的分析器的动态类型的运行时多态的抽象类的指针来实现的。当一个Spirit表达式被赋值+给一个规则，它的类型就被一个抽象类的具体派生类所封装了。一个虚的 parse 函数代理了被封装的对象的分析工作。

+<p>Rules have drawbacks though:<br>然而规则也有缺点：</p>

+<img src="theme/bullet.gif" height="12" width="12"> It is coupled to aspecificscanner type. The rule is tied to a specific scanner [see <ahref="faq.html#scanner_business">The

-  Scanner Business</a>].<br>

- <img src="theme/bullet.gif" width="12" height="12"> The rule's parsemember

-function has a virtual function call overhead that cannot be inlined.</p>
-<h2>Static rules: subrules</h2>

+ Scanner Business</a>]. 它与特定的扫描器类型耦合。规则是被绑定到特定的扫描器上的[见<a href="faq.html#scanner_business">分析器事务</a>]。 + <img src="theme/bullet.gif" height="12" width="12"> The rule's parsemember+function has a virtual function call overhead that cannot be inlined. 规则的 parse 成员函数有虚函数调用的负担，不能被内联。

+<h2>Static rules: subrules 静态规则：子规则</h2>

The subrule is a fully static version of the rule. The subrule does nothave

-  the drawbacks listed above. </p>

-<img src="theme/bullet.gif" width="12" height="12"> The subrule is nottied

-  to a specific scanner so just about any scanner type may be used<br>

- <img src="theme/bullet.gif" width="12" height="12"> The subrule alsoallows

-  aggressive inlining since there are no virtual function calls</p>

-<pre><code> <spanclass=keyword>template<<spanclass=keyword>int ID<fontcolor="#000000">, typenameContextT =parser_context<spanclass=special><> >- class <spanclass=identifier>subrule<spanclass=special>;</code></pre>+ the drawbacks listed above. 子规则是规则的全静态版本。它没有上面列出的那些缺点。+<img src="theme/bullet.gif" height="12" width="12"> The subrule is nottied+ to a specific scanner so just about any scanner type may be used 子规则没有与特定的扫描器类型绑定，因此可以使用任意的扫描器类型 + <img src="theme/bullet.gif" height="12" width="12"> The subrule alsoallows+ aggressive inlining since there are no virtual function calls 子规则也允许最大限度的内联，因为它没有虚函数调用+<pre><code> <spanclass="keyword">template<<spanclass="keyword">int ID<fontcolor="#000000">, <spanclass="keyword">typename ContextT= <spanclass="identifier">parser_context<spanclass="special"><> > class <spanclass="identifier">subrule<spanclass="special">;</code></pre>The first template parameter gives the subrule an identification tag.Likethe <a href="rule.html">rule</a>, there is a ContextT template parameterthatdefaults to <code><tt>parser_context</tt></code>. You need not beconcernedat all with the <tt>ContextT</tt> template parameter unless you wish totweakthe low level behavior of the subrule. Detailed information on the<tt>ContextT</tt>- template parameter is provided <ahref="indepth_the_parser_context.html">elsewhere</a>.

-</p>

+ template parameter is provided <ahref="indepth_the_parser_context.html">elsewhere</a>. 第一个模板参数给了子规则一个身份标签。就像<a href="rule.html">规则</a>一样，它也有一个默认为<code><tt>parser_context</tt></code> 的 ContextT 模板参数。你完全不用理会 <tt>ContextT</tt> 这个模板参数，除非你想调整子规则的底层行为。有关<tt>ContextT</tt> 模板参数的细节在<ahref="indepth_the_parser_context.html">其他地方</a>提供。

Presented above is the public API. There may actually be more templateparametersafter <tt>ContextT</tt>. Everything after the <tt>ContextT</tt>parameter should- not be of concern to the client and are strictly for internal useonly.-Apart from a few minor differences, the subrule follows the usage andsyntax

-  of the rule closely. Here's the calculator grammar using subrules:</p>

-<pre><code> <spanclass=keyword>struct calculator <spanclass=special>: public <spanclass=identifier>grammar<<spanclass=identifier>calculator>

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

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

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

- first <spanclass=special>=

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

- expression <spanclass=special>= term <spanclass=special>>> *((<spanclass=literal>'+' >> <spanclass=identifier>term) <spanclass=special>| ('-'>> <spanclass=identifier>term)),- term <spanclass=special>= factor <spanclass=special>>> *((<spanclass=literal>'*' >> <spanclass=identifier>factor) <spanclass=special>| ('/'>> <spanclass=identifier>factor)),- factor <spanclass=special>= integer <spanclass=special>| group<spanclass=special>,- group <spanclass=special>= '(' <spanclass=special>>> expression>> ')'

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

- subrule<spanclass=special><0<spanclass=special>> expression<spanclass=special>;- subrule<spanclass=special><1<spanclass=special>> term<spanclass=special>;- subrule<spanclass=special><2<spanclass=special>> factor<spanclass=special>;- subrule<spanclass=special><3<spanclass=special>> group<spanclass=special>;

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

-<img src="theme/lens.gif" width="15" height="16"> A fully workingexample with+ not be of concern to the client and are strictly for internal useonly. 上面出现的是它的公共API。实际上在 <tt>ContextT</tt> 后面还可能有其他的模板参数。所有在 <tt>ContextT</tt> 之后的东西都不应该被用户所关心，并且被严格限定在内部使用。Apart from a few minor differences,the subrule follows the usage and syntax+ of the rule closely. Here's the calculator grammar using subrules: 除了某些细节的不同，子规则的使用和语法与规则很接近。这里是用子规则实现的计算器语法：+<pre><code> <spanclass="keyword">struct calculator: publicgrammar<spanclass="special"><calculator<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">first = ( <spanclass="identifier">expression = <spanclass="identifier">term >> <spanclass="special">*(('+' <spanclass="special">>> term<spanclass="special">) | <spanclass="special">('-' <spanclass="special">>> term<spanclass="special">)), <spanclass="identifier">term = <spanclass="identifier">factor >>*(('*'>> <spanclass="identifier">factor) <spanclass="special">| (<spanclass="literal">'/' >> <spanclass="identifier">factor<spanclass="special">)), <spanclass="identifier">factor = <spanclass="identifier">integer | <spanclass="identifier">group<spanclass="special">, <spanclass="identifier">group = <spanclass="literal">'(' >> <spanclass="identifier">expression >>')' <spanclass="special">); <spanclass="special">} <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">expression; subrule<spanclass="special"><1<spanclass="special">> term<spanclass="special">; <spanclass="identifier">subrule<<spanclass="number">2> <spanclass="identifier">factor; subrule<spanclass="special"><3<spanclass="special">> group<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">first; rule<spanclass="special"><ScannerT<spanclass="special">> const<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return first<spanclass="special">; } <spanclass="special">}; <spanclass="special">};</code></pre>+<img src="theme/lens.gif" height="16" width="15"> A fully workingexample with<a href="semantic_actions.html">semantic actions</a> can be <ahref="../example/fundamental/subrule_calc.cpp">viewed

-  here</a>. This is part of the Spirit distribution. </p>
-<table border="0" align="left">
-  <tr>

- <td width="199"><img src="theme/subrule1.png" width="234"height="224"></td>+ here</a>. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15">绑定了<ahref="semantic_actions.html">语义动作</a>的完整的例子<ahref="../example/fundamental/subrule_calc.cpp">见这里</a>。这是Spirit发布包的一部分。

+<table align="left" border="0">
+  <tbody><tr>

+ <td width="199"><img src="theme/subrule1.png" height="224"width="234"></td>

     <td width="2"></td>
   </tr>
-</table>
+</tbody></table>

The subrule as an efficient version of the rule. Compiler optimizationssuch- as aggressive inlining help reduce the code size and increaseperformance significantly.

-</p>

+ as aggressive inlining help reduce the code size and increaseperformance significantly. 子规则是高效版的规则。编译器用诸如高度内联这样的优化帮助减小程序尺寸和显著提高效率。The subrule is not a panacea however. Subrules push the C++ compilerhard toits knees. For example, current compilers have a limit on recursiondepth thatmay not be exceeded. Don't even think about writing a full pascalgrammar usingsubrules alone. A grammar using subrules is a single C++ expression.CurrentC++ compilers cannot handle very complex expressions very well. Finally,a plain

-  rule is still needed to act as place holder for subrules.</p>

+ rule is still needed to act as place holder for subrules. 但子规则并不是万灵药。子规则把C++编译器逼到了极限。比如，目前的编译器有可能不能克服的递归深度的极限。千万不要想写一个Pascal语法而+只使用子规则。一个使用子规则的语法是一个单一的C++表达式。目前C++编译器还不能很好地应付复杂的表达式。最后，一个普通的规则还是要作为保有子规

+则的占位符而出现的。</p>

The code above is a good example of the recommended way to usesubrules. Noticethe hierarchy. We have a grammar that encapsulates the whole calculator.Thestart rule is a plain rule that holds the set of subrules. The subrulesin turn

-  defines the actual details of the grammar.</p>
-<table width="80%" border="0" align="center">
-  <tr>

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

-      Template instantiation depth</b> <br> <br>

+ defines the actual details of the grammar. 以上代码是一个关于如何按照推荐的范式使用子规则的很好的例子。注意它的层次。我们有一个语法来封装整个计算器。起始规则是一个保有子规则的集合的纯规则。子规则依次定义语法的实际细节。

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

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

+      Template instantiation depth</b> 模板实例化深度<br> <br>

Spirit pushes the C++ compiler hard. Current C++ compilers cannothandlevery complex heavily nested expressions very well. One restrictingfactoris the typical compiler's limit on template recursion depth. Some,but not

-      all, compilers allow this limit to be configured.<br>

+ all, compilers allow this limit to be configured.<fontcolor="#c0c0c0"> Spirit给C++编译器的负担很重，目前的C++编译器无法很好地处理非常复杂的重重嵌套的表达式。一个制约因素是典型的编译器在模板递归上的深度的限制。某些，但并非全部编译器允许调整这个深度。 

       <br>

g++'s maximum can be set using a compiler flag: -ftemplate-depth.Set this

-      appropriately if you have a relatively complex grammar.<br>

+ appropriately if you have a relatively complex grammar. g++的最大值可以用编译器标志-ftemplate-depth来设置。可以把它设置成合适的值，如果你有相对复杂的语法的话。 

       <br>

Microsoft Visual C++ can take greater than 1000 for both templateclassand function instantiation depths. However, the linker chokes withdeeptemplate function instantiation unless inline recursion depth is setusing

-      these pragmas:<br>

+ these pragmas: Microsoft Visual C++在类模板和函数模板上都大于1000。然而，连接器处理深度模板函数实例时会阻塞，除非内联递归深度被用这的参数设置了： 

       <br>

#pragma inline_depth<spanclass="special">(255) #pragma inline_recursion<spanclass="special">(on) 

       <br>

Perhaps this limitations no longer applies to more currentversions- of these compilers. Be sure to check your compilerdocumentation.</td>+ of these compilers. Be sure to check your compilerdocumentation. 也许这些限制在现在的编译器上已经不存在了。查阅你的编译器文档以确认这些。</td>

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

This setup gives a good balance. The subrules do all the work. Eachgrammarwill have only one rule: <tt>first</tt>. The rule is used just to holdthe subrules

-  and make them visible to the grammar. </p>
-<h3>The subrule definition</h3>

+ and make them visible to the grammar. 这种设置带来一个好的平衡。子规则干所有事情。每个语法都只有一个规则：<tt>first</tt>。规则只是用来持有子规则并使他们对语法可见。

+<h3>The subrule definition 子规则的定义</h3>

Like the rule, the expression after assignment operator <tt>=</tt>defines

-  the subrule:</p>

-<pre> identifier =expression</pre>+ the subrule: 类似于规则，赋值号 <tt>=</tt> 后面的表达式定义了子规则：+<pre> identifier <spanclass="special">= expression</pre>Unlike rules, subrules may be defined only once. Redefining a subruleis illegal

-  and will result to a compile time assertion.</p>
-<h3>Separators [ , ]</h3>

+ and will result to a compile time assertion. 与规则不同的是，子规则只能定义一次。重定义子规则是非法的，将导致编译时断言失败。

+<h3>Separators [ , ] 分隔符</h3>

While rules are terminated by the semicollon <tt>';'</tt>. Subrules arenotterminated but are separated by the comma: <tt>','</tt>. Like Pascalstatements,

-  the last subrule in a group may not have a trailing comma.</p>

-<pre> a= ch_p<spanclass=special>('a'),- b =ch_p(<spanclass=literal>'b'),- c =ch_p(<spanclass=literal>'c'), <spanclass=comment>// BAD, trailing comma<code><fontcolor="#000000"><fontcolor="#800000"></code><code><fontcolor="#000000"><fontcolor="#800000"></code></pre>+ the last subrule in a group may not have a trailing comma. 虽然规则以分号<tt>';'</tt>终结，但子规则并无终结，而是以逗号<tt>','</tt>分隔。就像Pascal语句，一组子规则中最后一个子规则并不需要后缀的逗号。+<pre> a= <spanclass="identifier">ch_p(<spanclass="literal">'a'), <spanclass="identifier">b = <spanclass="identifier">ch_p(<spanclass="literal">'b'), <spanclass="identifier">c = <spanclass="identifier">ch_p(<spanclass="literal">'c'), <spanclass="comment">// BAD, trailing comma 错误，以逗号结尾<code></code><code></code></pre>

<p>

-<pre><code> a= ch_p<spanclass=special>('a'),- b =ch_p(<spanclass=literal>'b'),- c =ch_p(<spanclass=literal>'c') <spanclass=comment>// OK</code></pre>

-<h3> The start subrule</h3>

+<pre><code> a= <spanclass="identifier">ch_p(<spanclass="literal">'a'), <spanclass="identifier">b = <spanclass="identifier">ch_p(<spanclass="literal">'b'), <spanclass="identifier">c = <spanclass="identifier">ch_p(<spanclass="literal">'c') <spanclass="comment">// OK</code></pre>

+<h3> The start subrule 起始子规则</h3>

Unlike rules, parsing proceeds from the start subrule. The first(topmost)subrule in a group of subrules is called the start subrule. Inour exampleabove, <tt>expression</tt> is the start subrule. When a group ofsubrules is

-  called forth, the start subrule <tt>expression</tt> is called first.</p>

+ called forth, the start subrule <tt>expression</tt> is calledfirst. 与规则不同，分析过程从起始子规则开始。一组子规则中第一个（最高层）的子规则被称为起始子规则。在上面的例子里，<tt>expression</tt> 是起始子规则。当一组子规则被有效调用时，起始子规则<tt>expression</tt> 将首先被调用。

 <h3>IDs</h3>

Each subrule has a corresponding ID; an integral constant that uniquelyspecifies- the subrule. Our example above has four subrules. They are declaredas:-<pre><code> <spanclass=identifier>subrule<<spanclass=number>0> <spanclass=identifier>expression;- subrule<spanclass=special><1<spanclass=special>> term<spanclass=special>;- subrule<spanclass=special><2<spanclass=special>> factor<spanclass=special>;- subrule<spanclass=special><3<spanclass=special>> group<spanclass=special>;</code></pre>

-<h3> Aliases</h3>

+ the subrule. Our example above has four subrules. They are declaredas: 每个子规则都有相应的ID；一个用于唯一标识子规则的整形常量。上面的例子有四个子规则。这么声明他们：+<pre><code> <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">expression; subrule<spanclass="special"><1<spanclass="special">> term<spanclass="special">; <spanclass="identifier">subrule<<spanclass="number">2> <spanclass="identifier">factor; <spanclass="identifier">subrule<<spanclass="number">3> <spanclass="identifier">group;</code></pre>

+<h3> Aliases 别名</h3>

It is possible to have subrules with similar IDs. A subrule with asimilar- ID to will be an alias of the other. Both subrules may be usedinterchangeably.-<pre><code> <spanclass=identifier>subrule<<spanclass=number>0> <spanclass=identifier>a;- subrule<spanclass=special><0<spanclass=special>> alias<spanclass=special>; // alias ofa</code></pre>

-<h3>Groups: scope and nesting</h3>

+ ID to will be an alias of the other. Both subrules may be usedinterchangeably. 有可能多个子规则具有相同的ID。有相同ID的子规则将互为对方的别名。这些子规则可以互换使用。+<pre><code> <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">a; <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">alias; <spanclass="comment">// alias of a a的别名</code></pre>

+<h3>Groups: scope and nesting 编组：范围与嵌套</h3>

The scope of a subrule and its definition is the enclosing group,typically(and by convention) enclosed inside the parentheses. IDs outside a scopearenot directly visible. Inner subrule groups can be nested by enclosingeach sub-groupinside another set of parentheses. Each group is unique and actsindependently.Consequently, while it may not be advisable to do so, a subrule in agroup mayshare the same ID as a subrule in another group since both groups areindependent

-  of each other.</p>

-<pre><code> <spanclass=identifier>subrule<<spanclass=number>0> <spanclass=identifier>a;- subrule<spanclass=special><1<spanclass=special>> b<spanclass=special>;- subrule<spanclass=special><0<spanclass=special>> c<spanclass=special>;- subrule<spanclass=special><1<spanclass=special>> d<spanclass=special>;

- ( <spanclass=comment>// outer subrule group, scope of a and b- a =ch_p(<spanclass=literal>'a'),

-        </span><span class=identifier>b </span><span class=special>=

- ( <spanclass=comment>// inner subrule group, scope of b and c- c =ch_p(<spanclass=literal>'c'),- d =ch_p(<spanclass=literal>'d')

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

+ of each other. 子规则及其定义的范围是封装他们的组，典型（同时也是约定）情况是封装在括号内。范围之外的ID并不直接可见。内部的子规则组可以使用另外一对括号来封装以实现嵌套。每个组都是唯一的并且独立工作。因此，虽然不建议这么做，但两个不同组的子规则可以使用同一个id。+<pre><code> <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">a; <spanclass="identifier">subrule<<spanclass="number">1> <spanclass="identifier">b; <spanclass="identifier">subrule<<spanclass="number">0> <spanclass="identifier">c; <spanclass="identifier">subrule<<spanclass="number">1> <spanclass="identifier">d; <spanclass="special">( //outer subrule group, scope of a and b 外层子规则组，a和b的范围 a =ch_p<spanclass="special">('a'<spanclass="special">), b= <spanclass="special">( // innersubrule group, scope of b and c 内层子规则组，c和d的范围 c =ch_p<spanclass="special">('c'<spanclass="special">), d= <spanclass="identifier">ch_p(<spanclass="literal">'d') <spanclass="special">) )</code></pre>Subrule IDs need to be unique only within a group. A grammar is animplicitgroup. Furthermore, even subrules in a grammar may have the same IDswithoutclashing if they are inside a group. Subrules may be explicitly groupedusingthe parentheses. Parenthesized groups have unique scopes. In the codeabove,the outer subrule group defines the subrules <tt>a</tt> and <tt>b</tt>whilethe inner subrule group defines the subrules <tt>c</tt> and <tt>d</tt>.Notice

-  that the definition of <tt>b</tt> is the inner subrule.</p>

+ that the definition of <tt>b</tt> is the inner subrule. 子规则的ID的唯一性只是在同组中要求。一个语法就是一个隐式的组。更进一步，甚至同一个语法中的子规则也可以使用相同的ID，只要他们在不同组+中。子规则可以用括号显示分组。带括号的组有唯一的范围。上面的代码中，外层的子规则组定义了子规则 <tt>a</tt> 和 <tt>b</tt>，而内层的子规则组定义了子规则<tt>c</tt> 和 <tt>d</tt>。注意b的定义就是内层的

+子规则。</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 (c) 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>&nbsp;</p>

<code><fontcolor="#0000ff"></code>

-</body>
-</html>
+</body></html>

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

Other related posts:

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