[boost-doc-zh] r336 committed - Spirit库译文，由 alai04 翻译，第三批

From: codesite-noreply@xxxxxxxxxx
To: boost-doc-zh-notify@xxxxxxxxxxxxx
Date: Tue, 13 Oct 2009 03:28:03 +0000

Revision: 336
Author: alai04
Date: Mon Oct 12 20:27:43 2009
Log: Spirit库译文，由 alai04 翻译，第三批
http://code.google.com/p/boost-doc-zh/source/detail?r=336

Modified:
 /trunk/libs/spirit/classic/doc/acknowledgments.html
 /trunk/libs/spirit/classic/doc/debugging.html
 /trunk/libs/spirit/classic/doc/error_handling.html
 /trunk/libs/spirit/classic/doc/faq.html
 /trunk/libs/spirit/classic/doc/file_iterator.html
 /trunk/libs/spirit/classic/doc/includes.html
 /trunk/libs/spirit/classic/doc/multi_pass.html
 /trunk/libs/spirit/classic/doc/portability.html
 /trunk/libs/spirit/classic/doc/position_iterator.html
 /trunk/libs/spirit/classic/doc/quickref.html
 /trunk/libs/spirit/classic/doc/rationale.html
 /trunk/libs/spirit/classic/doc/references.html
 /trunk/libs/spirit/classic/doc/style_guide.html
 /trunk/libs/spirit/classic/doc/symbols.html
 /trunk/libs/spirit/classic/doc/techniques.html
 /trunk/libs/spirit/classic/doc/trees.html
 /trunk/libs/spirit/classic/index.html

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

--- /trunk/libs/spirit/classic/doc/acknowledgments.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/acknowledgments.html Mon Oct 12 20:27:432009

@@ -1,30 +1,28 @@
-<html>
-<head>
-<title>Acknowledgments</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>Acknowledgments</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%">

- Acknowledgments+ Acknowledgments 鸣谢

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

   </tr>
-</table>
+</tbody></table>
 <p>Special thanks to </p>

Dan Nuffer for his work on lexers, parse trees, ASTs, XMLparsers, themulti-pass iterator as well as administering Spirit's site, editing,maintaining

@@ -34,9 +32,11 @@

utility parsers, the original port to Intel 5.0, various work onPhoenix, portingto v1.5, the meta-parsers, the grouping-parsers, extensive testing andpainstaking

   attention to details.</p>

-Martin Wille who improved grammar multi thread safety,contributed the- eol_p parser, the dynamic parsers, documentation and for taking anactive role- in almost every aspect from brainstorming and design to coding. And, asalways, helps keep the regression tests for g++ on Linux as green asever :-). 

+<p><b>Martin Wille</b> who improved grammar multi thread safety,
+contributed the eol_p parser, the dynamic parsers, documentation and
+for taking an active role in almost every aspect from brainstorming and
+design to coding. And, as always, helps keep the regression tests for
+g++ on Linux as green as ever :-). </p>

Martijn W. Van Der Lee our Web site administrator and forcontributing

   the RFC821 parser<b>.</b></p>

Giovanni Bajo for last minute tweaks of Spirit 1.8.0 forCodeWarrior

@@ -48,7 +48,9 @@

Juan Carlos Arevalo-Baeza (JCAB) for his work on the C++ parser,theposition iterator, ports to v1.5 and keeping the mailing listdiscussions alive

   and kicking.</p>

-Vaclav Vesely, lots of stuff, the no_actionsdirective, various patches fixes, the distinct parsers, the lazy parser,some phoenix tweaks and add-ons (e.g. <tt>new_</tt>). Also,Stefan Slapeta and wife for editingVaclav's distinct parser doc. 

+<p><strong>Vaclav Vesely, </strong>lots of stuff, the no_actions
+directive, various patches fixes, the distinct parsers, the lazy

+parser, some phoenix tweaks and add-ons (e.g. <tt>new_</tt>). Also,Stefan Slapeta and wife for editingVaclav's distinct parser doc. Raghavendra Satish for doing the original v1.3 port to VC++ andhis

     work on Phoenix.</p>

Noah Stein for following up and helping Ragav on the VC++ports.

@@ -64,7 +66,7 @@
   the file iterator.</p>

Peter Simons for the RFC date parser example and tutorial plushelping

   out with some nitty gritty details.</p>

-Markus Schöpflin for suggesting the end_p parser and lotsof other+Markus Schöpflin for suggesting the end_p parser and lots ofother

   nifty things and his active presence in the mailing list.</p>

Doug Gregor for mentoring and his ability to see things thatothers

   don't. </p>
@@ -82,12 +84,16 @@

Steve Rowe for his splendid work on the TSTs that willsoon

   be taken into Spirit.</p>
 <p><strong>Jonathan de Halleux</strong> for his work on actors.</p>

-Angus Leeming for last minute editing work on the1.8.0 release documentation, his work on Phoenix and his active presence inthe Spirit mailing list.

+<p><strong>Angus Leeming</strong> for last minute editing work on the
+1.8.0 release documentation, his work on Phoenix and his active
+presence in the Spirit mailing list.</p>

 Joao Abecasis for his active presence in the Spiritmailing list, providing user support, participating in the discussions andso on. Guillaume Melquiond for a last minute patch to<tt>multi_pass</tt> for 1.8.1. Peder Holt for his porting work on Phoenix, Fusionand Spirit to VC6. 

 <p>To my wife <b>Mariel</b> who did the graphics in this document.</p>

-My, there's a lot in this list! And it's a continuing list. I addpeople to this list everytime. I hope I did not forget anyone. If Imissed 

+<p>My, there's a lot in this list! And it's a continuing list. I add
+people to this list everytime. I hope I did not forget anyone. If I
+missed<br>
 someone you know who has helped in any way, please inform me.</p>

 Special thanks also to people who gave feedback and valuable comments,particularlymembers of Boost and Spirit mailing lists. This includes all those whoparticipated

@@ -128,19 +134,18 @@

comprised of extremely talented library authors who participate in thediscussion

   and peer review of well crafted C++ libraries.</p>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

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

Use, modification and distribution is subject to theBoost SoftwareLicense, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy athttp://www.boost.org/LICENSE_1_0.txt)

   </font> </p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/debugging.html       Sat Sep 12 00:52:19 2009
+++ /trunk/libs/spirit/classic/doc/debugging.html       Mon Oct 12 20:27:43 2009
@@ -1,35 +1,35 @@
-<html>
-<head>
-<title>Debugging</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>Debugging</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%"> Debugging+ <td width="85%"> Debugging 调试

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

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

The top-down nature of Spirit makes the generated parser easy to micro-debugusing the standard debugger bundled with the C++ compiler we are using.Withrecursive-descent, the parse traversal utilizes the hardware stackthrough C++function call mechanisms. There are no difficult to debug tables orstate machinesthat obscure the parsing logic flow. The stack trace we see in thedebugger

-  follows faithfully the hierarchical grammar structure.</p>
+  follows faithfully the hierarchical grammar structure.<br>Spirit

+自上而下的本质使得生成的分析器很容易使用与我们所用的C++编译器捆绑在一起的标准调试器来进行微型调试。通过递归下降，分析的遍历通过C++函数调用+机制利用了硬件的堆栈。调试解析模糊逻辑流的表格或状态机并没有难度。我们在调试器中所看到的堆栈跟踪忠实地遵守语法结构的层次。 Since any production rule can initiate a parse traversal , it is a loteasierto pinpoint the bugs by focusing on one or a few rules. For relativelycomplexparsing tasks, the same way we write robust C++ programs, it isadvisable to

@@ -37,13 +37,16 @@

subset of the complete grammar. That way, we can stress-test individualmodulespiecemeal until we reach the top-most module. For instance, whendevelopinga scripting language, we can start with expressions, then move on tostatements,

-  then functions, upwards until we have a complete grammar. </p>
+  then functions, upwards until we have a complete grammar.&nbsp;<br>因

+为任何产生式规则都可以启动一个分析遍历，所以就更容易通过集中关注一个或几个规则来查明缺陷。对于相对复杂的分析任务，与我们编写强大的C++程序一+样，建议基于每个模块来开发语法，每个模块都是完整语法的一个小子集。这样，我们可以对单个模块进行压力测试，直至到达最顶层的模块。例如，在开发一种脚+本语言时，我们可以从表达式开始，然后是语句，然后是函数，向上直至我们完成一个完整的语法。 At some point when the grammar gets quite complicated, it is desirabletovisualize the parse traversal and see what's happening. There are somefacilitiesin the framework that aid in the visualisation of the parse traversalfor the

-  purpose of debugging. The following macros enable these features.</p>

+ purpose of debugging. The following macros enable these features. 当语法变得足够复杂的某一点时，最好进行可视化的分析遍历，看看发生了什么。在框架中有一些工具，可以帮助分析遍历的可视化，达到调试的目的。以下宏将启用这些功能。

 <a name="debugging_macros"></a>
-<h2>Debugging Macros</h2>
+<h2>Debugging Macros 调试所用的宏</h2>
 <a name="spirit_assert_exception"></a>
 <h3>BOOST_SPIRIT_ASSERT_EXCEPTION</h3>

 Spirit contains assertions that may activate when spirit is usedincorrectly.

@@ -52,114 +55,122 @@

to the name of the class that you want to be thrown. This class'sconstructorwill be passed a <tt>const char*</tt> stringified version of the file,line,and assertion condition, when it is thrown. If you want to totallydisable the

-  assertion, <tt>#define NDEBUG</tt>.</p>

+ assertion, <tt>#define NDEBUG</tt>. Spirit带有一些断言，它们会在spirit被错误使用时激活。缺省情况下，这些断言使用标准库的 assert 宏。如果你希望spirit抛出异常，则将 <tt>BOOST_SPIRIT_ASSERT_EXCEPTION</tt>+ 定义为你要抛出的异常类。在被抛出时，该类的构造函数将被传入一个 <tt>constchar*</tt>，其中记录了文件版本、行号和断言条件。如果想完全关闭断言，请<tt>#define NDEBUG</tt>.

 <a name="spirit_debug"></a>
 <h3>BOOST_SPIRIT_DEBUG</h3>
-<p>Define this to enable debugging.</p>
+<p>Define this to enable debugging.<br>定义此宏以激活调试。</p>
 <p>With debugging enabled, special output is generated at key points of the

parse process, using the standard output operator (<tt><spanclass="keyword">operator<<</tt>)with <tt>BOOST_SPIRIT_DEBUG_OUT</tt> (default is <tt><spanclass="identifier">std::<spanclass="identifier">cout</tt>,

-  see below) as its left operand.</p>
-<table width="80%" border="0" align="center">
-  <tr>

+ see below) as its left operand. 当调试被激活时，在分析过程的关键点将生成一些特定的输出，输出的方式是使用标准输出操作符(<tt><spanclass="keyword">operator<<</tt>)并以 <tt>BOOST_SPIRIT_DEBUG_OUT</tt> (缺省为 <tt><spanclass="identifier">std::<spanclass="identifier">cout</tt>,

+  见后)作为左操作数。</p>
+<table align="center" border="0" width="80%">
+  <tbody><tr>

<td class="note_box"><img src="theme/note.gif"> In order to usespirit's

     debugging support you must ensure that appropriate overloads of

<tt>operator<spanclass="special"><<</tt>taking <tt>BOOST_SPIRIT_DEBUG_OUT</tt> as its left operand areavailable.

-    The expected semantics are those of the standard output operator.<br>

+ The expected semantics are those of the standard outputoperator. <img src="theme/note.gif"> 为了使用spirit的调试支持，你必须确保以 <tt>BOOST_SPIRIT_DEBUG_OUT</tt> 作为左操作数的合适+ <tt>operator<spanclass="special"><<</tt> 是可用的。所期望的语义就是标准输出操作符的语义。 

     <br>
     These overloads may be provided either within the namespace where the

corresponding class is declared (will be found through ArgumentDependent Lookup) or [within ananonymous namespace] within <tt>namespaceboost::<spanclass="identifier">spirit</tt>,

     so it is visible where it is called.<br>

+这些重载可以在相应类被声明的名字空间中提供(通过ADL查找)，也可以在<tt>namespace <spanclass="identifier">boost::<spanclass="identifier">spirit</tt> 中提供，这样在调用时它就是可见的。 

     <br>

<img src="theme/alert.gif"> Note in particular that when<tt>BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES</tt>is set, overloads of <tt>operator<spanclass="special"><<</tt>- taking instances of the types used in closures as their right operandsare required. + taking instances of the types used in closures as their right operandsare required. <img src="theme/alert.gif"> 注意，特别地，当<tt>BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES</tt>+ 被设置时，<tt>operator<spanclass="special"><<</tt>

+    的重载所要求的右操作数是在闭包中所使用的类型的实例。<br>
     <br>
     You may find an example of overloading the output operator for

<tt>std<spanclass="special">::pair</tt>

-    in a <a href="faq.html#output_operator">related FAQ entry</a>.</td>

+ in a <a href="faq.html#output_operator">related FAQ entry</a>. 你可在 <a href="faq.html#output_operator">相关FAQ条目</a> 中看到一个例子，示范了用于+ <tt>std<spanclass="special">::pair</tt>

+    的输出操作符重载。</td>
   </tr>
-</table>
+</tbody></table>

By default, if the <tt>BOOST_SPIRIT_DEBUG</tt> macro is defined, allavailabledebug output is generated. To fine tune the amount of generated text youcandefine the <tt>BOOST_SPIRIT_DEBUG_FLAGS</tt> constant to be equal of acombination

-  of the following flags:</p>
-<table width="90%" border="0" align="center">
-  <tr>

+ of the following flags: 缺省情况下，如果 <tt>BOOST_SPIRIT_DEBUG</tt>宏被定义，将生成所有可用的调试输出。要细调生成文本的数量，你可以将<tt>BOOST_SPIRIT_DEBUG_FLAGS</tt> 常量定义为以下标志位的组合：

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

<td colspan="2" class="table_title">Available flags to fine tunedebug

-      output </b></td>
+      output 用于细调调试输出的标志 </b></td>
   </tr>
   <tr>

- <td width="29%" height="27"class="table_cells"><tt>BOOST_SPIRIT_DEBUG_FLAGS_NODES</tt></td>- <td width="71%" class="table_cells">print information about nodes(general

-        for all parsers)</p></td>

+ <td class="table_cells" height="27"width="29%"><tt>BOOST_SPIRIT_DEBUG_FLAGS_NODES</tt></td>+ <td class="table_cells" width="71%">print information about nodes(general+ for all parsers)打印关于节点的信息(对所有分析器通用)</td>

   </tr>
   <tr>

- <td height="27"class="table_cells"><tt>BOOST_SPIRIT_DEBUG_FLAGS_TREES</tt></td>+ <td class="table_cells"height="27"><tt>BOOST_SPIRIT_DEBUG_FLAGS_TREES</tt></td><td class="table_cells">print information about parse trees andAST's (general

-        for all tree parsers)</p></td>

+ for all tree parsers)打印关于分析树和AST的信息(对所有树分析器通用)</td>

   </tr>
   <tr>

- <td height="27"class="table_cells"><tt>BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES</tt></td>+ <td class="table_cells"height="27"><tt>BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES</tt></td><td class="table_cells">print information about closures (general forall

-      parsers with closures)</td>

+ parsers with closures) 打印关于闭包的信息(对所有带闭包的分析器通用)</td>

   </tr>
   <tr>

- <td height="27"class="table_cells"><tt>BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR</tt></td>- <td class="table_cells">print information out of the<tt>esc_char_parser</tt></td>+ <td class="table_cells"height="27"><tt>BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR</tt></td>+ <td class="table_cells">print information out of the<tt>esc_char_parser</tt>打印 <tt>esc_char_parser</tt> 的信息<tt></tt></td>

   </tr>
   <tr>

- <td height="27"class="table_cells"><tt>BOOST_SPIRIT_DEBUG_FLAGS_SLEX</tt></td>- <td class="table_cells">print information out of the <tt>SLEX</tt>parser</td>+ <td class="table_cells"height="27"><tt>BOOST_SPIRIT_DEBUG_FLAGS_SLEX</tt></td>+ <td class="table_cells">print information out of the <tt>SLEX</tt>parser 打印 <tt>SLEX</tt> 分析器的信息</td>

   </tr>
-</table>
+</tbody></table>
 <p><a name="spirit_debug_out"></a> </p>
 <h3>BOOST_SPIRIT_DEBUG_OUT</h3>

 Define this to redirect the debugging diagnostics printout tosomewhere else

-  (e.g. a file or stream). Defaults to <tt>std::cout</tt>.</p>

+ (e.g. a file or stream). Defaults to <tt>std::cout</tt>. 定义此宏可将调试诊断输出重定向至其它地方(如某个文件或流)。缺省输出至<tt>std::cout</tt>.

 <a name="spirit_debug_token printer"></a>
 <h3>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</h3>

- The <tt>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</tt> macro allows you toredefine the way characters are printed on the stream. + The <tt>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</tt> macro allows you toredefine the way characters are printed on the stream. 宏<tt>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</tt> 允许你重定义打印至流的方式字符。If <tt>BOOST_SPIRIT_DEBUG_OUT</tt> is of type <tt>StreamT</tt>, thecharacter type is <tt>CharT</tt> and<tt>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</tt> is

-  defined to <tt>foo</tt>, it must be compatible with this usage:</p>

-<pre><code> foo<spanclass=special>(StreamT<spanclass=special>, CharT<spanclass=special>)</code></pre>+ defined to <tt>foo</tt>, it must be compatible with this usage: 如果<tt>BOOST_SPIRIT_DEBUG_OUT</tt> 的类型为 <tt>StreamT</tt>，字符类型为<tt>CharT</tt> 且 <tt>BOOST_SPIRIT_DEBUG_TOKEN_PRINTER</tt> 被定义为<tt>foo</tt>，则它必须兼容于以下用法：+<pre><code> foo<spanclass="special">(StreamT<spanclass="special">, CharT<spanclass="special">)</code></pre>The default printer requires <tt>operator<<(StreamT, CharT)</tt>tobe defined. Additionaly, if <tt>CharT</tt> is convertible to a normalcharacter

   type (<tt>char</tt>, <tt>wchar_t</tt> or <tt>int</tt>), it prints control

- characters in a friendly manner (e.g., when it receives <spanclass=special>'\n' it- actually prints the \ and <spanclass=special>n charactes,

-instead of a newline).</p>

+ characters in a friendly manner (e.g., when it receives <spanclass="special">'\n' it+ actually prints the \ and <spanclass="special">n charactes,+instead of a newline). 缺省的打印机要求 <tt>operator<<(StreamT,CharT)</tt> 被定义。另外，如果 <tt>CharT</tt> 可以转换为普通的字符类型(<tt>char</tt>, <tt>wchar_t</tt> 或 <tt>int</tt>)，则它会以一种友好的风格打印控制字符(如，当它收到 '\n' 时，实际打印的是\ 和 n 字符，而不是换行)。

 <a name="spirit_debug_print_some"></a>
 <h3>BOOST_SPIRIT_DEBUG_PRINT_SOME</h3>

 The <tt>BOOST_SPIRIT_DEBUG_PRINT_SOME</tt> constant defines the numberofcharacters from the stream to be printed for diagnosis. This defaults tothe

-  first 20 characters.</p>

+ first 20 characters. <tt>BOOST_SPIRIT_DEBUG_PRINT_SOME</tt> 常量定义了从流至被打印的诊断信息的字符数量。缺省为头20个字符。

 <p><a name="spirit_debug_tracenode"></a> </p>
 <h3>BOOST_SPIRIT_DEBUG_TRACENODE</h3>

 By default all parser nodes are traced. This constant may be used toredefinethis default. If this is <tt>1</tt> (<tt>true</tt>), then tracing isenabledby default, if this constant is <tt>0</tt> (<tt>false</tt>), the tracingisdisabled by default. This preprocessor constant is set to <tt>1</tt>(<tt>true</tt>)

-  by default.</p>

+ by default. 缺省情况下，所有分析器节点都被跟踪。这个常量可用于重定义该缺省行为。如果它为 <tt>1</tt> (<tt>true</tt>)，则跟踪被缺省打开，如果该常量为 <tt>0</tt> (<tt>false</tt>)，则跟踪被缺省关闭。这个预处理器常量缺省被设为 <tt>1 </tt>(<tt>true</tt>)。Please note, that the following <tt>BOOST_SPIRIT_DEBUG_...()</tt>macros are

-  to be used at function scope only.</p>

+ to be used at function scope only. 请注意，以下的<tt>BOOST_SPIRIT_DEBUG_...() </tt>宏只能被用在函数作用域中。

 <a name="spirit_debug_node_p_"></a>
 <h3>BOOST_SPIRIT_DEBUG_NODE(p)</h3>

- Define this to print some debugging diagnostics for parser p. Thismacro+ Define this to print some debugging diagnostics for parser p. Thismacro 定义此宏为分析器 p 打印某些调试诊断信息。该宏

 <ul>
-  <li>Registers the parser name for debugging</li>

- <li>Enables/disables the tracing for parser depending on<tt>BOOST_SPIRIT_DEBUG_TRACENODE</tt></li>

+  <li>Registers the parser name for debugging<br>为调试注册分析器名</li>

+ <li>Enables/disables the tracing for parser depending on<tt>BOOST_SPIRIT_DEBUG_TRACENODE</tt> 根据<tt>BOOST_SPIRIT_DEBUG_TRACENODE</tt> 为分析器打开/关闭跟踪<tt></tt></li>

 </ul>

 Pre-parse: Before entering the rule, the rule name followed bya peek

-  into the data at the current iterator position is printed.</p>

+ into the data at the current iterator position is printed. 分析前：在进行规则之前，打印规则名及当前迭代器位置读入的数据。 Post-parse: After parsing the rule, the rule name followed by apeekinto the data at the current iterator position is printed. Here,<tt>'/'</tt>before the rule name flags a succesful match while <tt>'#'</tt> beforethe rule

-  name flags an unsuccesful match.</p>
-<p> The following are synonyms for <tt>BOOST_SPIRIT_DEBUG_NODE</tt></p>

+ name flags an unsuccesful match. 分析后：在规则被分析之后，打印规则名及当前迭代器位置读入的数据。在此，规则名之前的<tt>'/'</tt>表示成功匹配，而规则名之前的<tt>'#'</tt>表示不成功的匹配。+ The following are synonyms for <tt>BOOST_SPIRIT_DEBUG_NODE</tt> 以下是 <tt>BOOST_SPIRIT_DEBUG_NODE</tt> 的同义词

 <ol>
   <li>BOOST_SPIRIT_DEBUG_RULE</li>
   <li>BOOST_SPIRIT_DEBUG_GRAMMAR</li>
@@ -168,8 +179,8 @@
 <h3>BOOST_SPIRIT_DEBUG_TRACE_NODE(p, flag)</h3>

 Similar to <tt>BOOST_SPIRIT_DEBUG_NODE</tt>. Additionally allowsselective debugging.This is useful in situations where we want to debug just a hand pickedset of

-  nodes.</p>

- The following are synonyms for<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt>+ nodes. 类似于 <tt>BOOST_SPIRIT_DEBUG_NODE</tt>。另外还允许选择性调试。当我们想只对部分节点调试时可用。+ The following are synonyms for<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt> 以下是<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt> 的同义词

 <ol>
   <li>BOOST_SPIRIT_DEBUG_TRACE_RULE</li>
   <li>BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR</li>
@@ -179,29 +190,16 @@

 Similar to <tt>BOOST_SPIRIT_DEBUG_NODE</tt>. Additionally allowsselectivedebugging and allows to specify the name used during debug printout.This isuseful in situations where we want to debug just a hand picked set ofnodes.- The <tt>name</tt> may be redefined in situations, where the parserparameter does not reflect the name of the parser to debug.- The following are synonyms for<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt>+ The <tt>name</tt> may be redefined in situations, where the parserparameter does not reflect the name of the parser to debug. 类似于<tt>BOOST_SPIRIT_DEBUG_NODE</tt>。并允许选择性调试和在调试输出时指定名字。当我们想只调试部分节点时可用。当分析器参数不能反映被调试分析器的名字时，<tt>name</tt> 可用于重定义。+ The following are synonyms for<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt> 以下是<tt>BOOST_SPIRIT_DEBUG_TRACE_NODE</tt> 的同义词

 <ol>
   <li>BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME</li>
   <li>BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME</li>
 </ol>
 <hr>
-<p>Here's the original calculator with debugging features enabled:</p>
-<pre>

- <code>#define <spanclass=identifier>BOOST_SPIRIT_DEBUG ///$$$DEFINE THIS BEFORE ANYTHING ELSE $$$///- #include <spanclass=string>"boost/spirit/include/classic.hpp"

-
-    </span><span class=comment>/***/
-
-    /*** CALCULATOR GRAMMAR DEFINITIONS HERE ***/
-

- BOOST_SPIRIT_DEBUG_RULE<spanclass=special>(integer<spanclass=special>);- BOOST_SPIRIT_DEBUG_RULE<spanclass=special>(group<spanclass=special>);- BOOST_SPIRIT_DEBUG_RULE<spanclass=special>(factor<spanclass=special>);- BOOST_SPIRIT_DEBUG_RULE<spanclass=special>(term<spanclass=special>);- BOOST_SPIRIT_DEBUG_RULE<spanclass=special>(expr<spanclass=special>);

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

- <img src="theme/note.gif" width="16" height="16"> Be sure to add themacros inside the grammar definition's constructor. Nowhere's a sample session with the calculator.+Here's the original calculator with debugging features enabled: 以下是带有调试功能的原始计算器：+<pre> <code>#define <spanclass="identifier">BOOST_SPIRIT_DEBUG ///$$$DEFINE THIS BEFORE ANYTHING ELSE $$$/// <spanclass="preprocessor">#include <spanclass="string">"boost/spirit/include/classic.hpp" <spanclass="comment">/***/ /*** CALCULATOR GRAMMAR DEFINITIONS HERE***/ <spanclass="identifier">BOOST_SPIRIT_DEBUG_RULE<spanclass="special">(integer<spanclass="special">); <spanclass="identifier">BOOST_SPIRIT_DEBUG_RULE<spanclass="special">(group<spanclass="special">); <spanclass="identifier">BOOST_SPIRIT_DEBUG_RULE<spanclass="special">(factor<spanclass="special">); <spanclass="identifier">BOOST_SPIRIT_DEBUG_RULE<spanclass="special">(term<spanclass="special">); <spanclass="identifier">BOOST_SPIRIT_DEBUG_RULE<spanclass="special">(expr<spanclass="special">); </code></pre>+ <img src="theme/note.gif" height="16" width="16"> Be sure to add themacros inside the grammar definition's constructor. Nowhere's a sample session with the calculator. <img src="theme/note.gif"height="16" width="16"> 请确认将这些宏加在语法定义的构造函数内部。以下是该计算器的一个会话示例。

<pre><code> Type an expression...or [q or Q]to quit


@@ -226,45 +224,42 @@

popped 1 and 2 from the stack. pushing 3onto the stack.

       /rule(expression):       ""
     /grammar(calc):    ""
-    <span class="preprocessor">-------------------------
-    Parsing succeeded
-    result = 3
-    -------------------------</span></code></pre>
-

- We typed in "1 + 2". Notice that there are two successfulbranches+ ------------------------- Parsingsucceeded result = 3 -------------------------</code></pre>

+
+<p> We typed in "1 + 2". Notice that there are two successful branches

from the top rule <tt>expr</tt>. The text in red is generated by theparser'ssemantic actions while the others are generated by the debug-diagnosticsof- our rules. Notice how the first <tt>integer</tt> rule took"1", the- first <tt>term</tt> rule took "+" and finally the second<tt>integer</tt>

-  rule took &quot;2&quot;.</p>
+  our rules. Notice how the first <tt>integer</tt> rule took "1", the
+  first <tt>term</tt> rule took "+" and finally the second <tt>integer</tt>

+ rule took "2". 我们输入 "1 + 2"。注意，顶层规则 <tt>expr</tt> 有两个成功的分支。红色的文本是由分析器的语义动作所生成，而其它文本是由我们规则的调试诊断所生成。留意第一个 <tt>integer</tt> 规则是如何获得 "1"，第一个<tt>term</tt> 规则如何获得 "+" 以及最后，第二个 <tt>integer</tt>

+  如何获得 "2"。</p>

Please note the special meaning of the first characters appearing onthe printed

-  lines:</p>
+  lines:<br>请注意，出现在打印行的第一个字符的特殊意义：</p>
 <ul>

<li>a single '/' starts a line containingthe informationabout a successfully matched parser node (<tt>rule<></tt>,<tt>grammar<></tt>

-    or <tt>subrule&lt;&gt;</tt>)</li>

+ or <tt>subrule<></tt>) 以单个 <spanclass="literal">'/' 开始的行，包含了一个成功匹配的分析器节点(<tt>rule<></tt>, <tt>grammar<></tt> 或<tt>subrule<></tt>)的信息</li><li>a single '#' starts a line containingthe information

-    about a failed parser node</li>

+ about a failed parser node 以单个 '#'开始的行，包含了一个失败的分析器节点的信息</li><li>a single '^' starts a line containingthe first member (return value/synthesised

-    attribute) of the closure of a successfully matched parser node.</li>

+ attribute) of the closure of a successfully matched parser node. 以单个 '^' 开始的行，包含了一个成功匹配的分析器节点的闭包的第一个成员(返回值/synthesised属性attribute)。</li>

 </ul>

-Check out <ahref="../example/fundamental/calc_debug.cpp">calc_debug.cpp</a> to seedebugging in action. +Check out <ahref="../example/fundamental/calc_debug.cpp">calc_debug.cpp</a> to seedebugging in action. 关于调试的运作，请查看 <ahref="../example/fundamental/calc_debug.cpp">calc_debug.cpp</a>。 

 <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 Hartmut Kaiser<br>
+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
+  Copyright © 2003 Hartmut Kaiser<br>
   <br>

Use, modification and distribution is subject to the BoostSoftware

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

--- /trunk/libs/spirit/classic/doc/error_handling.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/error_handling.html Mon Oct 12 20:27:432009

@@ -1,103 +1,87 @@
-<html>
-<head>
-<title>Error Handling</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>Error Handling</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%"> Error

-      Handling </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%"> Error

+      Handling 错误处理 </b></font></td>

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

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

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

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

C++'s exception handling mechanism is a perfect match for errorhandling inthe framework. Imagine a complete parser as a maze. At each branch, theinputdictates where we will turn. Given an erroneous input, we may reach adead end.If we ever reach one, it would be a waste of time to backtrack fromwhere wecame from. Instead, we supply guards in strategic points. Beyond acertain point,- we put put parser assertions in places where one is not allowed to go.+ we put put parser assertions in places where one is not allowed togo. C+++的异常处理机制是对本框架中的错误处理的完美匹配。想象一下，一个完整的分析器就象一个迷宫一样。在每一个分支，输入支配着我们向哪里转。给定一个错误+的输入，我们可能会达到一个死胡同。如果我们达到了一个死胡同，就要浪费时间回到我们的来处。相反，我们战略要点提供了防护(guard)。超出了某一

+点，我们把断言置于分析器中不得进入的地方。 </p>

The assertions are like springs that catapult us back to the guard. Ifwe everreach a brick wall given a specific input pattern, everything unwindsquicklyand we are thrown right back to the guard. This can be a very effectiveoptimizationwhen used wisely. Right back at the guard, we have a chance to correctthe situation,

-  if possible. The following illustration depicts the scenario.</p>
-<table border="0" align="center">
-  <tr>
-    <td><img src="theme/error_handling.png" width="313" height="238"></td>

+ if possible. The following illustration depicts the scenario. 这种断言就象弹簧一样将我们弹回到防护处。如果我们在某个特定的输入模式下到达死胡同，所有东西都会迅速回退，我们被抛至刚好在防护之后。在正确使用时，这是一个非常有效的优化。恰好在防护之后，我们有机会纠正这种情况，如果可能的话。下面的插图描绘了这种场景。

+<table align="center" border="0">
+  <tbody><tr>
+    <td><img src="theme/error_handling.png" height="238" width="313"></td>
   </tr>
-</table>
+</tbody></table>
 <a name="the_parser_exception"></a>
-<h2>Parser Errors</h2>
+<h2>Parser Errors 分析器错误</h2>

 The <tt>parser_error</tt> class is the generic parser exception classused

-  by Spirit. This is the base class for all parser exceptions.</p>

-<pre> <code>template <spanclass=special><typename <spanclass=identifier>ErrorDescrT, <spanclass=keyword>typename IteratorT <spanclass=special>= char <spanclass=keyword>const*>- class <spanclass=identifier>parser_error 

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

- parser_error<spanclass=special>(IteratorT <spanclass=identifier>where, <spanclass=identifier>ErrorDescrT <spanclass=identifier>descriptor);- IteratorT <spanclass=identifier>where;- ErrorDescrT<spanclass=identifier> descriptor;

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

+ by Spirit. This is the base class for all parserexceptions. <tt>parser_error</tt> 类是Spirit使用的泛型分析器异常类。它是所有分析器异常的基类。+<pre> <code>template <spanclass="special"><typename <spanclass="identifier">ErrorDescrT, <spanclass="keyword">typename IteratorT= charconst*> class <spanclass="identifier">parser_error 

+    {

+ public<spanclass="special">: <spanclass="identifier">parser_error(<spanclass="identifier">IteratorT <spanclass="identifier">where, <spanclass="identifier">ErrorDescrT <spanclass="identifier">descriptor); IteratorT <spanclass="identifier">where; ErrorDescrTdescriptor; <spanclass="special">}; </code></pre> The exception holds the iterator position where the error wasencounteredin its <tt>where</tt> member variable. In addition to the iterator,<tt>parser_error</tt>also holds information regarding the error (error descriptor) in its<tt>descriptor

-  </tt> member variable.</p>

+ </tt> member variable. 该异常将发生错误的迭代器位置保存于它的<tt>where</tt> 成员变量。除了这个迭代器，<tt>parser_error</tt>+ 还将与错误相关的信息(错误描述符)保存于它的 <tt>descriptor </tt>成员变量。 Semantic actions are free to throw parser exceptions when necessary. Autilityfunction <tt>throw_</tt> may be called. This function creates and throwsa <tt>parser_error</tt>

-  given an iterator and an error descriptor:</p>
-<pre>

- <code>template <spanclass=special><typename <spanclass=identifier>ErrorDescrT, <spanclass=keyword>typename IteratorT<spanclass=special>>- void <spanclass=identifier>throw_(<spanclass=identifier>IteratorT where, <spanclass=identifier>ErrorDescrT descriptor);

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

+ given an iterator and an error descriptor: 当需要时语义动作可随意抛出分析器异常。可以调用工具函数 <tt>throw_</tt>。该函数根据给定的一个迭代器和一个错误描述符创建并抛出一个 <tt>parser_error</tt>。+<pre> <code>template <spanclass="special"><typename <spanclass="identifier">ErrorDescrT, <spanclass="keyword">typename <spanclass="identifier">IteratorT> void <spanclass="identifier">throw_(<spanclass="identifier">IteratorT where,ErrorDescrT descriptor<spanclass="special">); </code></pre>

 <a name="the_parser_assertion"></a>
-<h2>Parser Assertions</h2>
+<h2>Parser Assertions 分析器断言</h2>

 Assertions may be put in places where we don't have any other optionotherthan expect parsing to succeed. If parsing fails, a specific type ofexception

-  is thrown.</p>

- Before declaring the grammar, we declare some assertion objects.<tt>assertion</tt>+ is thrown. 断言可以放在那些除了分析成功以外别无选择的地方。如果分析失败，特定类型的异常将被抛出。 Before declaring the grammar, wedeclare some assertion objects. <tt>assertion</tt>is a template class parameterized by the type of error that will bethrown oncethe assertion fails. The following assertions are parameterized by auser defined

-  Error enumeration.</p>

+ Error enumeration. 在声明该语法之前，我们声明了一些断言对象。<tt>assertion</tt>+ 是一个模板类，以断言失败时抛出的异常类型参数化。以下例子中的断言由一个用户自定义的

+  Error 枚举类型参数化。</p>
 <a name="examples"></a>
-<h3>Examples</h3>
-<pre>
-    <code><span class=keyword>enum </span><span class=identifier>Errors
-    </span><span class=special>{

- program_expected<spanclass=special>,- begin_expected<spanclass=special>,

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

- assertion<spanclass=special><Errors<spanclass=special>> expect_program<spanclass=special>(program_expected<spanclass=special>);- assertion<spanclass=special><Errors<spanclass=special>> expect_begin<spanclass=special>(begin_expected<spanclass=special>);- assertion<spanclass=special><Errors<spanclass=special>> expect_end<spanclass=special>(end_expected<spanclass=special>);

-</span></code></pre>
+<h3>Examples 例子</h3>

+<pre> <code>enum <spanclass="identifier">Errors { program_expected<spanclass="special">, <spanclass="identifier">begin_expected, end_expected <spanclass="special">}; <spanclass="identifier">assertion<<spanclass="identifier">Errors> <spanclass="identifier">expect_program(<spanclass="identifier">program_expected); assertion<spanclass="special"><Errors<spanclass="special">> <spanclass="identifier">expect_begin(<spanclass="identifier">begin_expected); assertion<spanclass="special"><Errors<spanclass="special">> expect_end<spanclass="special">(end_expected<spanclass="special">); </code></pre> The example above uses enums to hold the information regarding theerror,we are free to use other types such as integers and strings. Forexample, <tt>assertion<string></tt>accepts a string as its info. It is advisable to use light-weightobjects though,after all, error descriptors are usually static. Enums are convenientfor error- handlers to detect and easily catch since C++ treats enums as uniquetypes.

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

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16">+ handlers to detect and easily catch since C++ treats enums as uniquetypes. 以上例子用枚举类型来保存错误信息，我们也可以随意使用其它类型，如整数或字符串。例如，<tt>assertion<string></tt>+ 接受一个字符串作为其信息。尽管使用轻量级对象是明智的，但毕竟错误描述符通常都是静态的。枚举类型便于错误处理器进行检测，且容易捕获，因为C++将枚举类型视为单独的类型。

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

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

       The assertive_parser</b><br>
       <br>

- Actually, the expression<tt>expect_end(str_p("end"))</tt>creates

+      Actually, the expression <tt>expect_end(str_p("end"))</tt>creates

an assertive_parser object. An assertive_parser is a parser thatthrowsan exception in response to a parsing failure. The assertive_parserthrowsa parser_error exception rather than returning an unsuccessful matchto

@@ -105,40 +89,40 @@

are given an iterator of type <tt>IteratorT</tt>. This is combinedwiththe error descriptor type <tt>ErrorDescrT</tt> of the assertion (inthiscase enum <tt>Errors</tt>). Both are used to create a<tt>parser_error<Errors,- IteratorT></tt> which is then thrown to signal the exception.</td>+ IteratorT></tt> which is then thrown to signal theexception. 实际上，表达式 <tt>expect_end(str_p("end"))</tt>创

+建一个 assertive_parser 对象。一个 assertive_parser
+是一个在分析失败时抛出异常的分析器。assertive_parser 抛出 parser_error

+异常而不是返回一个不成功匹配来表示分析器与输入匹配失败。在分析过程中，分析器被给定一个类型为 <tt>IteratorT</tt> 的迭代器。它与断言的错误描述符(在这个例子中是枚举类型 <tt>Errors</tt>)类型 <tt>ErrorDescrT</tt> 相组合。这两者均被用于创建 <tt>parser_error<Errors,

+      IteratorT&gt;</tt>，然后抛出以表示异常。 </td>
   </tr>
-</table>
+</tbody></table>

 The predeclared <tt>expect_end</tt> assertion object may now be usedin the

-  grammar as wrappers around parsers. For example:</p>
-<pre>

- <code>expect_end<spanclass=special>(str_p<spanclass=special>("end"<spanclass=special>))

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

- This will throw an exception if it fails to see "end" fromthe input.+ grammar as wrappers around parsers. For example: 现在，预先声明的<tt>expect_end</tt> 断言对象可在语法中用作分析器之外的包装。例如：+<pre> <code>expect_end<spanclass="special">(str_p<spanclass="special">("end"<spanclass="special">)) </code></pre>+ This will throw an exception if it fails to see "end" from theinput. 如果未能从输入中遇到 "end"，将抛出一个异常。

 <a name="the_guard"></a>
-<h2>The Guard</h2>
+<h2>The Guard 防护</h2>

 The <tt>guard</tt> is used to catch a specific type of<tt>parser_error</tt>.guards are typically predeclared just like assertions. Extending ourprevious

-  example:</p>
-<pre>

- <code>guard<spanclass=special><Errors<spanclass=special>> my_guard<spanclass=special>;

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

+ example: <tt>guard</tt> 用于捕获一个特定类型的 <tt>parser_error</tt>。防护通常象断言一样预先声明。扩展一下我们前面的例子：+<pre> <code>guard<spanclass="special"><Errors<spanclass="special">> my_guard<spanclass="special">; </code></pre> <tt>Errors</tt>, in this example is the error descriptor type we wantto detect.This is the same enum as above. <tt>my_guard</tt> may now be used in agrammar

-  declaration:</p>

-<pre> <code>my_guard<spanclass=special>(p<spanclass=special>)[error_handler<spanclass=special>]</code></pre>+ declaration: <tt>Errors</tt>, 在本例中是我们想要检测的错误描述符类型。它与前面的枚举类型一样。<tt>my_guard</tt> 可以被用在语法声明中：+<pre> <code>my_guard<spanclass="special">(p<spanclass="special">)[error_handler<spanclass="special">]</code></pre> where <tt>p</tt> is an expression that evaluates to a parser.Somewhere inside<tt>p</tt>, a parser may throw a parser exception.<tt>error_handler</tt> is- the error handler which may be a function or functor compatible with theinterface:-<pre> <code>error_status<T<spanclass=special>>- f(ScannerT const& scan, ErrorTerror);

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

+ the error handler which may be a function or functor compatible with theinterface: 其中 <tt>p</tt> 是一个被求值为分析器的表达式。在+ <tt>p</tt> 内部，分析器可以抛出分析器异常。<tt>error_handler</tt> 是错误处理器，它可以是兼容于以下接口的函数或仿函数：+<pre> <code>error_status<T<spanclass="special">>+ f(ScannerT const& scan, ErrorTerror); </code></pre> Where scan points to the scanner state prior to parsing and error isthe errorthat arose. The handler is allowed to move the scanner position as itsees fit,possibly in an attempt to perform error correction. The handler mustthen return

-  an <tt>error_status&lt;T&gt;</tt> object. </p>
-<table width="80%" border="0" align="center">
-  <tr>

- <td class="note_box"> <img src="theme/lens.gif" width="15"height="16">+ an <tt>error_status<T></tt> object. 其中 scan 指向分析前的扫描器状态，而 error 则是发生的错误。这个处理器允许将扫描器位置移至它认为合适的地方，可以试图执行错误纠正。该处理器必须返回一个<tt>error_status<T></tt> 对象。 

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

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

       The fallback_parser </b><br>
       <br>

The expression <tt>my_guard(expr, error_handler)</tt>creates afallback_parser

@@ -146,67 +130,53 @@

type. Since <tt>my_guard</tt> is declared as<tt>guard<Errors></tt>,the fallback_parser catches <tt>Errors</tt> specific parser errors:<tt>parser_error<Errors,IteratorT></tt>. The class sets up a try block. When an exceptionis

-      caught, the catch block then calls the error_handler. </td>

+ caught, the catch block then calls the error_handler. 表达式<tt>my_guard(expr, error_handler)</tt> 创建一个 fallback_parser+ 对象。fallback_parser 处理特定类型的parser_error 异常。由于<tt>my_guard</tt> 被声明为 <tt>guard<Errors></tt>，所以fallback_parser 捕获 <tt>Errors</tt> 指定的分析器错误：<tt>parser_error<Errors,+ IteratorT></tt>。该类设置一个 try 块。捕捉到一个异常后，catch 块将调用该 error_handler. </td>

   </tr>
-</table>
+</tbody></table>
 <h2>error_status&lt;T&gt;</h2>
-<pre>

- <code>template <spanclass=special><typename <spanclass=identifier>T = <spanclass=identifier>nil_t>- struct <spanclass=identifier>error_status

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

- enum <spanclass=identifier>result_t { <spanclass=identifier>fail, <spanclass=identifier>retry, <spanclass=identifier>accept, <spanclass=identifier>rethrow };

- error_status<spanclass=special>(- result_t result = <spanclass=identifier>fail,- int <spanclass=identifier>length = -<spanclass=number>1,- T <spanclass=keyword>const& <spanclass=identifier>value = <spanclass=identifier>T());

-</span>

- result_t result<spanclass=special>;- int <spanclass=identifier>length;- T value<spanclass=special>;

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

+<pre> <code>template <spanclass="special"><typename <spanclass="identifier">T = <spanclass="identifier">nil_t> struct <spanclass="identifier">error_status <spanclass="special">{ enum <spanclass="identifier">result_t { <spanclass="identifier">fail, <spanclass="identifier">retry, <spanclass="identifier">accept, <spanclass="identifier">rethrow }; error_status<spanclass="special">(+ result_t result = <spanclass="identifier">fail, int <spanclass="identifier">length = -<spanclass="number">1, <spanclass="identifier">T const<spanclass="special">& value <spanclass="special">= T<spanclass="special">()); <spanclass="identifier">result_t result<spanclass="special">; intlength<spanclass="special">; Tvalue; };</code></pre>Where <tt>T</tt> is an attribute type compatible with the matchattribute ofthe <tt>fallback_parser</tt>'s subject (defaults to <tt>nil_t</tt>). Theclass<tt>error_status</tt> reports the result of an error handler. Thisresult can

-  be one of: </p>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td class="table_title" colspan="8"> error_status result </td>

+ be one of: 其中 <tt>T</tt> 为一个属性类型，兼容于<tt>fallback_parser</tt> 的主题的匹配属性(缺省为 <tt>nil_t</tt>)。类+ <tt>error_status</tt> 报告错误处理器的结果。该结果为以下之一：<tablealign="center" border="0" width="90%"><tbody><tr><td class="table_title"colspan="8">error_status result </td>

   </tr>
   <tr>
-  <tr>
+  </tr><tr>
     <td class="table_cells"><b>fail</b></td>
-    <td class="table_cells">quit and fail. Return a <tt>no_match</tt></td>

+ <td class="table_cells">quit and fail. Return a <tt>no_match </tt>退出并失败。返回 <tt>no_match</tt></td>

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

- <td class="table_cells">attempt error recovery, possibly moving thescanner</td>

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

+ <td class="table_cells">attempt error recovery, possibly moving thescanner 试图修复错误，可能移动扫描器</td>

   </tr>
-    <td class="table_cells"><b>accept</b></td>
+    <tr><td class="table_cells"><b>accept</b></td>

<td class="table_cells">force success returning a matching length,moving the

-    scanner appropriately and returning an attribute value</td>

+ scanner appropriately and returning an attribute value 强制成功返回一个匹配长度，正确移动扫描器并返回一个属性值</td>

   </tr>
-    <td class="table_cells"><b>rethrow</b></td>
-  <td class="table_cells">rethrows the error</td>
+    <tr><td class="table_cells"><b>rethrow</b></td>
+  <td class="table_cells">rethrows the error<br>重新抛出该错误</td>
   </tr>
-</table>

-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/error_handling.cpp">error_handling.cpp</a> fora compilable example. This is part of the Spirit distribution.

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

+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/error_handling.cpp">error_handling.cpp</a> fora compilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译示例请见 <ahref="../example/fundamental/error_handling.cpp">error_handling.cpp</a>。这是Spirit发布包的一部分。

+<table align="center" border="0" width="80%">
 </table>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

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

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/faq.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/faq.html     Mon Oct 12 20:27:43 2009
@@ -1,60 +1,56 @@
-<html>
-<head>
-<title>FAQ</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>FAQ</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%"> FAQ</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%"> FAQ 常见问题</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="techniques.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="rationale.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <ul>
-  <li><a href="#scanner_business">The Scanner Business</a></li>
-  <li><a href="#left_recursion">Eliminating Left Recursion</a> </li>

- <li><a href="#right_associativity">Implementing RightAssociativity</a></li>

-  <li><a href="#lexeme_and_rules">The lexeme_d directive and rules</a></li>
-  <li><a href="#kleene_star">Kleene Star infinite loop</a></li>
+  <li><a href="#scanner_business">The Scanner Business 扫描器事务</a></li>

+ <li><a href="#left_recursion">Eliminating Left Recursion 消除左递归</a></li>+ <li><a href="#right_associativity">Implementing Right Associativity 实现右关联</a></li>+ <li><a href="#lexeme_and_rules">The lexeme_d directive and rules  lexeme_d指示符和规则</a></li>+ <li><a href="#kleene_star">Kleene Star infinite loop 克林星无限循环</a></li>

   <li><a href="#CVS">Boost CVS and Spirit CVS</a></li>

<li><a href="#compilation_times">How to reduce compilation times withcomplex

-    Spirit grammars</a></li>

- <li><a href="#frame_assertion">Closure frameassertion</a></li>

-  <li><strong><a href="#greedy_rd">Greedy RD</a></strong></li>
+    Spirit grammars 如何减少复杂Spirit语法的编译时间</a></li>

+ <li><a href="#frame_assertion">Closure frame assertion 闭包帧断言</a></li>

+  <li><strong><a href="#greedy_rd">Greedy RD 贪心RD</a></strong></li>

<li><a href="#referencing_a_rule_at_construction">Referencing arule

-    at construction time</a></strong></li>
-  <li><strong><a href="#storing_rules">Storing Rules</a></strong></li>

- <li><a href="#parsing_ints_and_reals">Parsing ints and reals</a></li>

+    at construction time 在构造期引用规则</a></strong></li>

+ <li><a href="#storing_rules">Storing Rules 保存规则</a></li>+ <li><a href="#parsing_ints_and_reals">Parsing ints and reals 分析整数和实数</a> </li><li><a href="#output_operator">BOOST_SPIRIT_DEBUG and missing<tt>operator<<</tt></a></li>- <li><a href="#repository">Applications that used to be part ofspirit</a></li>+ <li><a href="#repository">Applications that used to be part ofspirit 以前作为spirit一部分的应用程序</a></li>

 </ul>

- <a name="scanner_business" id="scanner_business"></a> The ScannerBusiness

-<p><font color="#FF0000">Question:</font> Why doesn't this compile?</p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>r = /*...*/;- parse<spanclass=special>("hello world"<spanclass=special>, r,space_p);// BAD [attempts phrase levelparsing]</code></pre>+ <a name="scanner_business" id="scanner_business"></a> The ScannerBusiness 扫描器事务+Question: Why doesn't thiscompile? 问题：为什么以下程序不能编译？+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">r = /*...*/; parse(<spanclass="string">"hello world", <spanclass="identifier">r, <spanclass="identifier">space_p); <spanclass="comment">// BAD [attempts phrase levelparsing]</code></pre>But if I remove the skip-parser, everything goesback

-  to normal again:<code></code></font></p>

-<pre><code> <spanclass=identifier>rule<> <spanclass=identifier>r = *<spanclass=identifier>anychar_p;- parse<spanclass=special>("hello world"<spanclass=special>, r<spanclass=special>); // OK [character levelparsing]</code></pre>+ to normal again: 但如果去掉跳读分析器，则一切又恢复正常：<code></code>+<pre><code> <spanclass="identifier">rule<> <spanclass="identifier">r = *<spanclass="identifier">anychar_p; parse<spanclass="special">("hello world"<spanclass="special">, r<spanclass="special">); // OK [character levelparsing]</code></pre>Sometimes you'll want to pass in a rule to one of the functions parsefunctionsthat Spirit provides. The problem is that the rule is a template classthatis parameterized by the scanner type. This is rather awkward butunavoidable:the rule is tied to a scanner. What's not obvious isthat thisscanner must be compatible with the scanner that is ultimately passed tothe

-  rule's parse member function. Otherwise, the compiler will complain. </p>

+ rule's parse member function. Otherwise, the compiler willcomplain. 有时，你想将一个规则传入某个由Spirit提供的 parse 函数。问题是，规则是一个模板类，它以扫描器类型为参数。这是尴尬而不可避免的：规则被绑定至某个扫描器。有一点不太明显，即这个扫描器必须兼容于最终传递给该规则的 parse 成员函数的扫描器。否则，编译器将会抗议。Why does the first call to parse not compile? Because of scannerincompatibility.Behind the scenes, the free parse function creates a scanner from theiteratorspassed in. In the first call to parse, the scanner created is a plainvanilla

@@ -62,151 +58,126 @@

<tt>rule<></tt> [see default template parameters of <ahref="rule.html">therule</a>]. The second call creates a scanner of type <tt><ahref="scanner.html#phrase_scanner_t">phrase_scanner_t</a></tt>.Thus, in order for the second call to succeed, the rule must beparameterized

-  as <tt>rule&lt;phrase_scanner_t&gt;</tt>:</p>

-<pre><code> <spanclass=identifier>rule<<spanclass=identifier>phrase_scanner_t>r = <spanclass=special>*anychar_p<spanclass=special>;- parse<spanclass=special>("hello world"<spanclass=special>, r,space_p);// OK [phrase levelparsing]</code></pre>+ as <tt>rule<phrase_scanner_t></tt>: 为什么第一个对 parse 的调用不能编译？因为扫描器不兼容。在其表象之后，这个 parse 函数从传入的迭代器构造一个扫描器。在第一个对 parse 的调用中，创建的扫描器是一个普通的

+  <tt>scanner&lt;&gt;</tt>。它兼容于

+ <tt>rule<></tt> 的缺省扫描器类型[请见 <a href="rule.html">规则</a>的缺省模板参数]。而第二个调用则创建一个类型为 <tt><ahref="scanner.html#phrase_scanner_t">phrase_scanner_t</a></tt> 的扫描器。因此，为了第二次调用的成功，该规则必须被参数化为<tt>rule<phrase_scanner_t></tt>:+<pre><code> <spanclass="identifier">rule<<spanclass="identifier">phrase_scanner_t>r =*<spanclass="identifier">anychar_p; parse<spanclass="special">("hello world"<spanclass="special">, r<spanclass="special">, space_p<spanclass="special">); // OK [phrase levelparsing]</code></pre>Take note however that <tt>phrase_scanner_t</tt> is compatible onlywhen youare using <tt>char const*</tt> iterators and <tt>space_p</tt> as theskip parser.Other than that, you'll have to find the right type of scanner. This istediousto do correctly. In light of this issue, it is best to avoidrules asarguments to the parse functions. Keep in mind that thishappens onlywith rules. The rule is the only parser that has to be tied to aparticular

-  scanner type. For instance:</p>

-<pre> <spanclass=identifier>parse(<spanclass=string>"hello world", *<spanclass=identifier>anychar_p);<code><spanclass=comment>// OK [character level parsing]</code>- parse<spanclass=special>("hello world"<spanclass=special>, *anychar_p<spanclass=special>, space_p<spanclass=special>); // OK [phrase levelparsing]</pre>

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

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

-      Multiple Scanner Support</strong><br>

+ scanner type. For instance: 不过请注意，<tt>phrase_scanner_t</tt> 仅当你使用 <tt>char const*</tt> 迭代器并以 <tt>space_p</tt> 作为跳读分析器时是兼容的。否则，你必须找出扫描器的正确类型。要正确实现是很乏味的。由此问题可见，最好避免将规则作为参数传给 parse 函数。留意，这只发生在规则上。规则是唯一一种必须绑定至特定扫描器类型的分析器。例如：+<pre> <spanclass="identifier">parse(<spanclass="string">"hello world", *<spanclass="identifier">anychar_p);<code><spanclass="comment">// OK [character level parsing]</code>+ parse<spanclass="special">("hello world"<spanclass="special">, *anychar_p<spanclass="special">, space_p<spanclass="special">); // OK [phrase levelparsing]</pre>

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

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

+      Multiple Scanner Support 多扫描器支持</strong><br>
       <br>

As of v1.8.0, rules can use one or more scanner types. There arecases,for instance, where we need a rule that can work on the phrase andcharacterlevels. Rule/scanner mismatch has been a source of confusion and istheno. 1 <a href="faq.html#scanner_business">FAQ</a>. To address thisissue,we now have <a href="rule.html#multiple_scanner_support">multiplescanner

-      support</a>. <br>
-      <br>

- <img src="theme/bulb.gif" width="13" height="18"> See the techniquessection+ support</a>. 截止至 v1.8.0，规则可以使用一个或多个扫描器类型。有些情况下，例如，当我们需要一个可以工作在短语和字符层面的规则时。规则/扫描器失配是导致混乱的主要来源，且是首要的 <ahref="faq.html#scanner_business">FAQ</a>。为了解决该问题，我们现在有了 <ahref="rule.html#multiple_scanner_support">多扫描器支持</a> + <img src="theme/bulb.gif" height="18" width="13"> See the techniquessectionfor an <ahref="techniques.html#multiple_scanner_support">example</a> ofa <a href="grammar.html">grammar</a> using a multiple scannerenabled rule,- <a href="scanner.html#lexeme_scanner">lexeme_scanner</a> and <ahref="scanner.html#as_lower_scanner">as_lower_scanner.</a></td>+ <a href="scanner.html#lexeme_scanner">lexeme_scanner</a> and <ahref="scanner.html#as_lower_scanner">as_lower_scanner.</a> <imgsrc="theme/bulb.gif" height="18" width="13"> 有关多扫描器规则 <ahref="grammar.html">语法</a>+ 、<a href="scanner.html#lexeme_scanner">lexeme_scanner</a> 和 <ahref="scanner.html#as_lower_scanner">as_lower_scanner</a> 的 <ahref="techniques.html#multiple_scanner_support">例子</a>，请见"技术"一节。</td>

   </tr>
-</table>
-<p><b> <a name="left_recursion"></a> Eliminating Left Recursion </b></p>

-Question: I ported a grammar from YACC.It's "kinda"

+</tbody></table>

+ <a name="left_recursion"></a> Eliminating Left Recursion 消除左递归+Question: I ported a grammar from YACC.It's "kinda"working - the parser itself compiles with no errors. But when I try toparse,- it gives me an "invalid page fault". I tracked down theproblem to

-  this grammar snippet:</p>

-<pre> or_expr =xor_expr |(or_expr >>VBAR >>xor_expr<spanclass=special>);</pre>

+  it gives me an "invalid page fault". I tracked down the problem to

+ this grammar snippet: 问题：我从YACC移植过来一个语法。它只能"部分"工作 - 分析器本身可通过编译。但是当我尝试分析时，它给出了一个 "invalid page fault"。我跟踪了该问题，至以下语法片段：+<pre> or_expr =xor_expr |(or_expr <spanclass="special">>> VBAR <spanclass="special">>> <spanclass="identifier">xor_expr);</pre>What you should do is to eliminate direct and indirect left-recursion.Thiscauses the invalid page fault because the program enters an infiniteloop. Thecode above is good for bottom up parsers such as YACC but not for LLparsers

-  such as Spirit.</p>

+ such as Spirit. 你要做的是，消除直接或间接的左递归。它会引起无效页错误，因为程序陷入了无限循环。以上代码对于象YACC这样的由底而上分析器是好的，而对于象Spirit这样的LL分析器则非如此。

 <p>This is similar to a rule in Hartmut Kaiser's C

- parser (this should be available for download from <ahref="http://spirit.sf.net";>Spirit's site</a> as soon as you read this).

-<pre>
-    <span class=identifier>inclusive_or_expression

- = <spanclass=identifier>exclusive_or_expression- | <spanclass=identifier>inclusive_or_expression <spanclass=special>>> OR <spanclass=special>>> exclusive_or_expression

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

-Transforming left recursion to rightrecursion,

-  we have:</p>
-<pre>    <span class=identifier>inclusive_or_expression

- = <spanclass=identifier>exclusive_or_expression <spanclass=special>>> <spanclass=identifier>inclusive_or_expression_helper

-    </span><span class=special>;
-
-    </span><span class=identifier>inclusive_or_expression_helper

- = OR>> <spanclass=identifier>exclusive_or_expression <spanclass=special>>> <spanclass=identifier>inclusive_or_expression_helper

-    </span><span class=special>| </span><span class=identifier>epsilon_p
-    </span><span class=special>;</span></pre>
-<p><span class=special></span>I'd go further. Since:</p>

-<pre> r =a | <spanclass=identifier>epsilon_p;</pre>

-<p><span class=special></span>is equivalent to:<span class=special><br>

+ parser (this should be available for download from <ahref="http://spirit.sf.net/";>Spirit's site</a> as soon as you readthis). 这类似于 Hartmut Kaiser 的 C+ 分析器中的一个规则(当你读到这里时，它应该可以由 <ahref="http://spirit.sf.net";>Spirit's 站点</a> 下载得到)。+<pre> inclusive_or_expression = <spanclass="identifier">exclusive_or_expression <spanclass="special">| inclusive_or_expression>> OR>> <spanclass="identifier">exclusive_or_expression <spanclass="special">;</pre>+Transforming left recursion to rightrecursion,

+  we have:<br>将左递归转换为右递归，我们有：</p>

+<pre> inclusive_or_expression = <spanclass="identifier">exclusive_or_expression <spanclass="special">>> <spanclass="identifier">inclusive_or_expression_helper <spanclass="special">; <spanclass="identifier">inclusive_or_expression_helper <spanclass="special">= OR <spanclass="special">>> <spanclass="identifier">exclusive_or_expression <spanclass="special">>> <spanclass="identifier">inclusive_or_expression_helper <spanclass="special">| epsilon_p ;</pre>+I'd go further. Since: 更进一步。因为：+<pre> r =a |epsilon_p<spanclass="special">;</pre>+is equivalent to: <spanclass="special">相当于： 

   </span></p>

-<pre> r <spanclass=special>= !a<spanclass=special>;</pre>

-<p>we can simplify <tt>inclusive_or_expression_helper</tt> thus:</p>
-<pre>    <span class=identifier>inclusive_or_expression_helper

- = !(OR>> <spanclass=identifier>exclusive_or_expression <spanclass=special>>> <spanclass=identifier>inclusive_or_expression_helper)

-    ;</span></pre>
-<p><span class=special></span>Now, since:</p>

-<pre> r <spanclass=special>= !(a <spanclass=special>>> r<spanclass=special>);</pre>

-<p><span class=special></span>is equivalent to:</p>

-<pre> r =*a;</pre>

-<p><span class=special></span>we have:</p>
-<pre>    <span class=identifier>inclusive_or_expression_helper

- = *(OR>> <spanclass=identifier>exclusive_or_expression)

-    ;</span></pre>

-Now simplifying<tt>inclusive_or_expression</tt>

-  fully, we have:</p>
-<pre>    <span class=identifier>inclusive_or_expression

- = <spanclass=identifier>exclusive_or_expression <spanclass=special>>> *(OR <spanclass=special>>> <spanclass=identifier>exclusive_or_expression)

-    ;</span></pre>

-Reminds me of the calculators. So inshort:-<pre> a =b | <spanclass=identifier>a >> <spanclass=identifier>op >> <spanclass=identifier>b;</pre>-in <spanclass=identifier>pseudo-YACC

-  </span><span class=identifier>is</span><span class=special>:</span></p>

-<pre> a =b >>*(op >>b);</pre>-in Spirit. What could be simpler? Look Ma,no recursion,

-  just iteration.</p>

- <a name="right_associativity" id="right_associativity"></a>Implementing Right Associativity - Question: I tried adding <tt>'^'</tt> asan operator to compute the power to a calculator grammer. The following code+<pre> r <spanclass="special">= !a<spanclass="special">;</pre>+we can simplify <tt>inclusive_or_expression_helper</tt> thus: 所以我们可以简化 <tt>inclusive_or_expression_helper</tt> 为：+<pre> inclusive_or_expression_helper = !(OR>> <spanclass="identifier">exclusive_or_expression <spanclass="special">>> <spanclass="identifier">inclusive_or_expression_helper<spanclass="special">) ;</pre>

+<p><span class="special"></span>Now, since:<br>现在，由于：</p>

+<pre> r <spanclass="special">= !(a <spanclass="special">>> r<spanclass="special">);</pre>

+<p><span class="special"></span>is equivalent to:<br>相当于：</p>

+<pre> r =*a<spanclass="special">;</pre>

+<p><span class="special"></span>we have:<br>我们有：</p>

+<pre> inclusive_or_expression_helper = *(OR>> <spanclass="identifier">exclusive_or_expression<spanclass="special">) ;</pre>+Now simplifying<tt>inclusive_or_expression</tt>

+  fully, we have:<br>现在对 <tt>inclusive_or_expression</tt>
+  完全简化，我们有：</p>

+<pre> inclusive_or_expression = <spanclass="identifier">exclusive_or_expression <spanclass="special">>> *(OR <spanclass="special">>> <spanclass="identifier">exclusive_or_expression<spanclass="special">) ;</pre>+Reminds me of the calculators. So inshort: 记住我们的计算器。所以用伪-YACC可缩写为：+<pre> a =b |a >>op >>b;</pre>+in <spanclass="identifier">pseudo-YACC+ is<spanclass="special">: 在Spirit中则是：+<pre> a =b >>*(op >>b<spanclass="special">);</pre>

+<p>in Spirit. What could be simpler? Look Ma, no recursion,

+ just iteration. 还有什么可以更简单？看，没有递归，只有循环。+ <a name="right_associativity" id="right_associativity"></a>Implementing Right Associativity 实现右关联 + Question: I tried adding <tt>'^'</tt> asan operator to compute the power to a calculator grammer. The followingcode 问题：我尝试为计算器语法增加一个操作符<tt>'^'</tt> 以计算幂数。以下代码

 </p>
-<pre>    <span class=identifier>pow_expression

- = pow_operand>> *('^' >>pow_operand [& do_pow]

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

+<pre> pow_expression <spanclass="special">= pow_operand <spanclass="special">>> *( <spanclass="literal">'^' >> <spanclass="identifier">pow_operand [ <spanclass="special">& do_pow <spanclass="special">] <spanclass="special">) ;

 </pre>

-parses the input correctly, but I want the operator to be evalutatedfrom right to left. In other words, the expression <tt>2^3^4</tt> issupposed to have the same semantics as <tt>2^(3^4)</tt> instead of<tt>(2^3)^4</tt>. How do I do it?+parses the input correctly, but I want the operator to be evalutatedfrom right to left. In other words, the expression <tt>2^3^4</tt> issupposed to have the same semantics as <tt>2^(3^4)</tt> instead of<tt>(2^3)^4</tt>. How do I do it? 可以正确地分析输入，但是我希望这个操作符是从右向左求值的。换句话说，表达式 <tt>2^3^4</tt> 应具有与<tt>2^(3^4)</tt> 相同的语义，而不是 <tt>(2^3)^4</tt>。我要怎么做呢？

 </p>

- The "textbook recipe" for Right Associativity is Right Recursion. InBNF that means:-<pre> <pow_expression> ::= <pow_operand> '^'<pow_expression> | <pow_operand>

-</pre>

-But we better don't take the theory too literally here, because if thefirst alternative fails, the semantic actions within <tt>pow_operand</tt>might have been executed already and will then be executed again whentrying the second alternative. So let's apply Left Factorization to factorout <tt>pow_operand</tt>:-<pre> <pow_expression> ::= <pow_operand><pow_expression_helper>- <pow_expression_helper> ::= '^' <pow_expression> |ε

-</pre>

-The production <tt>pow_expression_helper</tt> matches the empty stringε, so we can replace the alternative with the optional operatorin Spirit code.+ The "textbook recipe" for Right Associativity is Right Recursion. InBNF that means: 解决右关联的"教科书方法"是右递归。在BNF中，意味着：+<pre> <pow_expression> ::= <pow_operand> '^'<pow_expression> | <pow_operand> </pre>+But we better don't take the theory too literally here, because if thefirst alternative fails, the semantic actions within <tt>pow_operand</tt>

+might have been executed already and will then be executed again when
+trying the second alternative. So let's apply Left Factorization to

+factor out <tt>pow_operand</tt>: 但我们最好不要过于从字面理解这个理论，因为如果第一个选择失败，那么 <tt>pow_operand</tt>+内的语义动作可能已经被执行，而在尝试第二个选择时可能会被再次执行。因此，我们应用左分解来实现 <tt>pow_operand</tt>:+<pre> <pow_expression> ::= <pow_operand><pow_expression_helper> <pow_expression_helper> ::= '^'<pow_expression> | ε </pre>+The production <tt>pow_expression_helper</tt> matches the empty stringε, so we can replace the alternative with the optional operator inSpirit code. 工具 <tt>pow_expression_helper</tt> 匹配空字符串 ε,因此我们在Spirit代码中可以用可选操作符来替换这一选择。

 </p>
-<pre>    <span class=identifier>pow_expression

- = pow_operand>> !('^' >>pow_expression [& do_pow]

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

+<pre> pow_expression <spanclass="special">= pow_operand <spanclass="special">>> !( <spanclass="literal">'^' >> <spanclass="identifier">pow_expression [& do_pow] <spanclass="special">) ;

 </pre>

-Now any semantic actions within <tt>pow_operand</tt> can safely beexecuted. For stack-based evaluation that means that each match of<tt>pow_operand</tt> will leave one value on the stack and the recursionmakes sure there are (at least) two values on the stack when<tt>do_pow</tt> is fired to reduce these two values to their power.+Now any semantic actions within <tt>pow_operand</tt> can safely beexecuted. For stack-based evaluation that means that each match of<tt>pow_operand</tt> will leave one value on the stack and the recursionmakes sure there are (at least) two values on the stack when<tt>do_pow</tt> is fired to reduce these two values to their power. 现在<tt>pow_operand</tt> 内的任何语义动作均可安全执行。对于基于栈的求值，这意味着 <tt>pow_operand</tt> 的每次匹配将留下一个值在栈中，且这个递归将确保当<tt>do_pow</tt> 被触发时栈中(至少)有两个值，通过这两个值计算得到它们的幂。

 </p>

-In cases where this technique isn't applicable, such as C-styleassignment

-<pre>    <span class=identifier>assignment

- = lvalue>> '='>> assignment- | <spanclass=identifier>ternary_conditional

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

+In cases where this technique isn't applicable, such as C-styleassignment 某些情况下这种技术并不适用，如在C-风格的赋值中+<pre> assignment <spanclass="special">= lvalue <spanclass="special">>> '=' <spanclass="special">>> assignment | <spanclass="identifier">ternary_conditional <spanclass="special">;

 </pre>

-you can append <tt>| epsilon_p [ action ] >>nothing_p</tt> to a parser to correct the semantic context whenbacktracking occurs (in the example case that would be dropping the addresspushed by <tt>lvalue</tt> off the evaluation stack):

+<p>you can append <tt>| epsilon_p [ <i>action</i> ] &gt;&gt; nothing_p</tt>
+to a parser to correct the semantic context when backtracking occurs

+(in the example case that would be dropping the address pushed by<tt>lvalue</tt> off the evaluation stack): 你可以往分析器中增加 <tt>|epsilon_p [ action ] >> nothing_p</tt>，以更正回溯发生时的语义语境(在此例中，将把由<tt>lvalue</tt> 压入的地址从求值栈中删除):

 </p>
-<pre>    <span class=identifier>assignment

- = lvalue>> ('=' >>assignment <spanclass=special>[ & <spanclass=identifier>do_store ]- | <spanclass=identifier>epsilon_p [& do_drop]- >> <spanclass=identifier>nothing_p

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

- | <spanclass=identifier>ternary_conditional

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

+<pre> assignment <spanclass="special">= lvalue <spanclass="special">>> ( <spanclass="literal">'=' >> <spanclass="identifier">assignment [& do_store] <spanclass="special">| epsilon_p[ &do_drop <spanclass="special">] <spanclass="special">>> <spanclass="identifier">nothing_p <spanclass="special">) | <spanclass="identifier">ternary_conditional <spanclass="special">;

 </pre>

-However, this trick compromises the clear separation of syntax andsemantics, so you also might want to consider using an <ahref="trees.html">AST</a> instead of semantic actions so you can just gowith the first definition of <tt>assignment</tt>.+However, this trick compromises the clear separation of syntax andsemantics, so you also might want to consider using an <ahref="trees.html">AST</a> instead of semantic actions so you can just gowith the first definition of <tt>assignment</tt>. 然而，这种方法是以语法与语义的清晰分离为代价的，所以你也可能会考虑使用 <ahref="trees.html">AST</a> 来替代语义动作，这样你可以只需要<tt>assignment</tt> 的第一个定义。

 </p>

 <a name="lexeme_and_rules" id="lexeme_and_rules"></a> The lexeme_ddirective

-  and rules</b></p>

- Question: Does lexeme_d not supportexpressions- which include rules? In the example below, the definition of atomicRulecompiles,

+  and rules &nbsp; lexeme_d指示符与规则</b></p>

+ Question: Does lexeme_d not supportexpressions+ which include rules? In the example below, the definition of atomicRulecompiles, 问题：lexeme_d 不支持含有规则的表达式吗？在以下例子中，atomicRule 的定义可以编译，

 </p>

-<pre> <spanclass=identifier>rule<<spanclass=identifier>phrase_scanner_t>atomicRule- = <spanclass=identifier>lexeme_d[(<spanclass=identifier>alpha_p | <spanclass=literal>'_') >> *(<spanclass=identifier>alnum_p | <spanclass=literal>'.' | <spanclass=literal>'-' | <spanclass=literal>'_')];</pre>+<pre> <spanclass="identifier">rule<<spanclass="identifier">phrase_scanner_t>atomicRule+ = <spanclass="identifier">lexeme_d[(<spanclass="identifier">alpha_p | <spanclass="literal">'_') >> *(<spanclass="identifier">alnum_p | <spanclass="literal">'.' | <spanclass="literal">'-' | <spanclass="literal">'_')];</pre>but if I move <tt>alnum_p | '.' | '-' | '_'</tt> into its own rule, thecompilercomplains about conversion from <tt>const scanner<...></tt> to<tt>const

-  phrase_scaner_t&amp;</tt>. </p>

-<pre> rule<spanclass=special><<spanclass=identifier>phrase_scanner_t>ch - = alnum_p <spanclass=special>| '.' |'-' | <spanclass=literal>'_';

- rule<<spanclass=identifier>phrase_scanner_t>compositeRule- = <spanclass=identifier>lexeme_d[(<spanclass=identifier>alpha_p | <spanclass=literal>'_') >> *(<spanclass=identifier>ch)]; <spanclass="comment">// <- error source</pre>+ phrase_scaner_t&</tt>. 不过，如果我将 <tt>alnum_p | '.' | '-'| '_'</tt> 移入它的规则中，编译器就会对从 <tt>const scanner<...></tt>到 <tt>const

+  phrase_scaner_t&amp;</tt> 的转化提出异议。 </p>

+<pre> rule<spanclass="special"><<spanclass="identifier">phrase_scanner_t>ch + = alnum_p <spanclass="special">| '.' <spanclass="special">| '-' <spanclass="special">| '_'<spanclass="special">;

+ rule<spanclass="special"><<spanclass="identifier">phrase_scanner_t>compositeRule+ = <spanclass="identifier">lexeme_d[(<spanclass="identifier">alpha_p | <spanclass="literal">'_') >> *(<spanclass="identifier">ch)]; <spanclass="comment">// <- error source</pre>You might get the impression that the <tt>lexeme_d</tt> directive andrulesdo not mix. Actually, this problem is related to the first FAQ entry:The ScannerBusiness. More precisely, the <tt>lexeme_d</tt> directive and rules withincompatible

@@ -214,96 +185,102 @@

incompatibility is the directive itself. The <tt>lexeme_d</tt> directivetransformsthe scanner it receives into something that disables the skip parser.This non-skippingscanner, unfortunately, is incompatible with the original scanner beforetransformation

-  took place.</p>

+ took place. 你可能有这样的印象，<tt>lexeme_d</tt> 指示符和规则不能混用。实际上，这个问题与第一个FAQ：扫描器事务，是相关的。更准确地说，<tt>lexeme_d</tt> 指示符与带有不兼容扫描器类型的规则不能混用。这个问题更为微妙。导致扫描器不兼容的就是这个指示符本身。<tt>lexeme_d</tt> 指示符将所接受的扫描器转换为禁止了跳读分析器的某种类型。很不幸，这个无跳读的扫描器与转换之前的原扫描器是不兼容的。The simplest solution is not to use rules in the <tt>lexeme_d</tt>.Instead,you can definitely apply <tt>lexeme_d</tt> to subrules and grammars ifyou reallyneed more complex parsers inside the <tt>lexeme_d</tt>. If you reallymust usea rule, you need to know the exact scanner used by the directive. The<tt>lexeme_scanner</tt>metafunction is your friend here. The example above will work asexpected once

-  we give the <tt>ch</tt> rule a correct scanner type:</p>

-<pre> rule<spanclass=special><lexeme_scanner<spanclass="special"><<spanclass=identifier>phrase_scanner_t<spanclass=special>>::type<spanclass=special>> ch <spanclass=special>- = alnum_p <spanclass=special>| '.' |'-' | <spanclass=literal>'_';</pre>-Note: make sure to add "<tt>typename</tt>" before<tt>lexeme_scanner</tt>

-  when this is used inside a template class or function.</p>

+ we give the <tt>ch</tt> rule a correct scanner type: 最简单的解决方法是，不要在 <tt>lexeme_d</tt> 中使用规则。如果你真的需要在 <tt>lexeme_d</tt>中使用较复杂的分析器，你可以明确地将 <tt>lexeme_d</tt> 应用于子规则和语法。此时，<tt>lexeme_scanner</tt>+ 元函数可以帮忙。上述例子可以正确工作，只要我们给定 <tt>ch</tt> 规则一个正确的扫描器类型：+<pre> rule<spanclass="special"><<spanclass="identifier">lexeme_scanner<spanclass="special"><<spanclass="identifier">phrase_scanner_t<spanclass="special">>::type<spanclass="special">> ch <spanclass="special">+ = alnum_p <spanclass="special">| '.' <spanclass="special">| '-' <spanclass="special">| '_'<spanclass="special">;</pre>+Note: make sure to add "<tt>typename</tt>" before<tt>lexeme_scanner</tt>+ when this is used inside a template class or function. 注意：当被用于模板类或模板函数内部时，请确认在 <tt>lexeme_scanner</tt>

+  之前加上 "<tt>typename</tt>"。</p>

The same thing happens when rules are used inside the<tt>as_lower_d</tt> directive.- In such cases, you can use the <tt>as_lower_scanner</tt>. See the <spanclass=identifier><tt><ahref="scanner.html#lexeme_scanner">lexeme_scanner</a></tt>- and <tt><ahref="scanner.html#as_lower_scanner">as_lower_scanner</a></tt>.

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

- <td class="note_box"><img src="theme/bulb.gif" width="13" height="18">See+ In such cases, you can use the <tt>as_lower_scanner</tt>. See the <spanclass="identifier"><tt><ahref="scanner.html#lexeme_scanner">lexeme_scanner</a></tt>+ and <tt><ahref="scanner.html#as_lower_scanner">as_lower_scanner</a></tt>. 在<tt>as_lower_d</tt> 指示符内使用规则时，也会发生同样的事情。此时，你可以使用 <tt>as_lower_scanner</tt>。请见 <tt><ahref="scanner.html#lexeme_scanner">lexeme_scanner</a></tt> 和 <tt><ahref="scanner.html#as_lower_scanner">as_lower_scanner</a></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">multiple+ scanner enabled rule </a><a href="grammar.html">语法</a><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="techniques.html#multiple_scanner_support">例子</a>，请参见"技术"一节。<a href="scanner.html#as_lower_scanner"></a></td>

   </tr>
-</table>
-<p><strong><a name="kleene_star"></a>Kleene Star infinite loop</strong></p>
-<p><font color="#FF0000">Question</font>: Why Does This Loop Forever?</p>

-<pre> rule<>optional <spanclass=special>= !(str_p(<spanclass="string">"optional"));- rule<>list_of_optional <spanclass=special>= *optional<spanclass="special">;</pre>

+</tbody></table>

+<a name="kleene_star"></a>Kleene Star infinite loop 克林星无限循环+Question: Why Does This LoopForever? 问题：为何以下例子会无限循环？+<pre> rule<spanclass="special"><> optional= !(str_p<spanclass="special">("optional"<spanclass="special">)); rule<spanclass="special"><> list_of_optional= *<spanclass="identifier">optional;</pre>The problem with this is that the kleene star will continue loopinguntil itgets a no-match from it's enclosed parser. Because the <tt>optional</tt>ruleis optional, it will always return a match. Even if the input doesn'tmatch- "optional" it will return a zero length match.<tt>list_of_optional</tt>

+  "optional" it will return a zero length match. <tt>list_of_optional</tt>

will keep calling optional forever since optional will never return ano-match.- So in general, any rule that can be "nullable" (meaning it canreturn

-  a zero length match) must not be put inside a kleene star.</p>
+  So in general, any rule that can be "nullable" (meaning it can return

+ a zero length match) must not be put inside a kleene star. 这里的问题是，克林星会持续地循环，直至它从内嵌分析器中获得一个不匹配。因为<tt>optional</tt> 规则是可选的，它总是返回匹配。即使输入并不匹配 "optional"，它还是会返回一个零长度的匹配。<tt>list_of_optional</tt>+ 将不停地调用 optional，由于 optional 永远不会返回一个不匹配。所以一般来说，任何可能为 "nullable" (即可以返回零长度匹配)的规则都不能置于克林星之内。

 <p><strong><a name="CVS"></a>Boost CVS and Spirit CVS</strong></p>

-Question: There is Boost CVS and SpiritCVS. Which

-  is used for further development of Spirit?</p>

+Question: There is Boost CVS and SpiritCVS. Which+ is used for further development of Spirit? 问题：现在既有 Boost CVS 又有 Spirit CVS。Spirit 后续的开发将使用哪一个? Generally, development takes place in Spirit's CVS. However, from timetotime a new version of Spirit will be integrated in Boost. When thishappensdevelopment takes place in the Boost CVS. There will be announcements onthe

-  Spirit mailing lists whenever the status of the Spirit CVS changes.<br>

+ Spirit mailing lists whenever the status of the Spirit CVS changes. 通常，开发是在Spirit的CVS中进行的。但是，时不时要将Spirit的新版本集成到Boost中。这时就需要在Boost CVS中进行开发了。当Spirit CVS的状态改变时，在Spirit邮件列表中会有通知。 

 </p>
-<table width="80%" border="0" align="center">
-  <tr>
-    <td class="note_box"><img src="theme/alert.gif" width="16" height="16">
+<table align="center" border="0" width="80%">
+  <tbody><tr>
+    <td class="note_box"><img src="theme/alert.gif" height="16" width="16">

During development of Spirit v1.8.1 (released as part of boost-1.32.0)and

     v1.6.2, Spirit's developers decided to stop maintaining Spirit CVS for

BRANCH_1_8 and BRANCH_1_6. This was necessary to reduce the added workofmaintaining and synch'ing two repositories. The maintenance of thesebrancheswill take place on Boost CVS. At this time, new developments towardsSpirit

     v2 and other experimental developments are expected to happen in Spirit
-    CVS.</td>
+    CVS.<br><img src="theme/alert.gif" height="16" width="16">
+    在Spirit v1.8.1 (作为boost-1.32.0的组成部分发布)和
+    v1.6.2 的开发期间，Spirit的开发者决定停止为

+ BRANCH_1_8 和 BRANCH_1_6 维护Spirit CVS。为了减少维护和同步两个版本库的工作量，这是必须的。这些分支的维护将在Boost CVS中进行。此时，Spirit

+    v2的新开发以及其它试验性质的开发工作仍在Spirit
+    CVS中。</td>
   </tr>
-</table>
+</tbody></table>

<a name="compilation_times"></a>How to reduce compilation timeswith

-  complex Spirit grammars </strong></p>

-Question: Are there any techniques tominimize

+  complex Spirit grammars 如何减少复杂的Spirit语法的编译时间 </strong></p>

+Question: Are there any techniques tominimizecompile times using spirit? For simple parsers compile time doesn't seemto

   be a big issue, but recently I created a parser with about 78 rules

and it took about 2 hours to compile. I would like to break the grammarup intosmaller chunks, but it is not as easy as I thought it would be becauserules- in two grammar capsules are defined in terms of each other. Anythoughts?

-<p> The only way to reduce compile times is </p>

+ in two grammar capsules are defined in terms of each other. Anythoughts? 问题：有+没有什么技术可以最小化使用spirit的编译时间？对于较为简单的分析器，编译时间不是什么大的问题，但最近我创建了一个约有78个规则的分析器，它差+不多需要2小时才编译完。我很想将此语法分解为小块，但这并非我所想的那么容易，因为分在两个语法中的规则要相互根据对方来定义。有别的方法吗？+ The only way to reduce compile times is 减少编译时间的唯一方法是

 <ul>
-  <li> to split up your grammars into smaller chunks</li>

+ <li> to split up your grammars into smaller chunks 将你的语法分为更小的块</li><li> prevent the compiler from seeing all grammar definitions at thesame time

-    (in the same compilation unit)</li>

+ (in the same compilation unit) 阻止编译器在同一时间(在同一个编译单元中)看到所有的语法定义</li>

 </ul>

-The first task is merely logistical, the second is rather a technicalone. +The first task is merely logistical, the second is rather a technicalone. 第一项任务很明显，第二项才是技术活。 A good example of solving the first task is given in the Spiritcpp_lexer example- written by JCAB (you may find it on the <ahref="http://spirit.sourceforge.net/repository/applications/show_contents.php";>applications'repository</a>).+ written by JCAB (you may find it on the <ahref="http://spirit.sourceforge.net/repository/applications/show_contents.php";>applications'repository</a>). 由JCAB编写的Spirit cpp_lexer 例子中给出了解决第一项任务的一个好例子(你可以在 <ahref="http://spirit.sourceforge.net/repository/applications/show_contents.php";>应用程序仓库</a> 中找到它)。

 </p>

The cross referencing problems may be solved by some kind of forwarddeclaration,or, if this does not work, by introducing some dummy template argumentto thenon-templated grammars. Thus allows the instantiation time to be defereduntil the

-  compiler has seen all the defintions:</p>

-<pre> template <<spanclass="keyword">typename T = <spanclass="keyword">int> grammar2;

- template <<spanclass="keyword">typename T = <spanclass="keyword">int> structgrammar1 : publicgrammar<grammar1> {

-    <span class="comment">// refers to grammar2&lt;&gt;</span>

+ compiler has seen all the defintions: 交叉引用的问题可以通过一些前向声明来解决，或者，如果这样不行的话，也可以通过向非模板语法引入一些伪模板参数来解决。这样可以将实例化时间推迟至编译器见到所有定义为止：+<pre> template <<spanclass="keyword">typename T = <spanclass="keyword">int> grammar2;

+ template <<spanclass="keyword">typename T = <spanclass="keyword">int> structgrammar1 : publicgrammar<grammar1> { // refers togrammar2<> 引用grammar2<>

     };

-    <span class="keyword">template</span> &lt;typename T&gt;

- struct grammar2 : <spanclass="keyword">public grammar<grammar2>

-    {
-    <span class="comment">// refers to grammar1&lt;&gt;</span>

+ template <typename T> <spanclass="keyword">struct grammar2 : <spanclass="keyword">public grammar<grammar2> { <spanclass="comment">// refers to grammar1<> 引用grammar1<>

     };

     //...

- grammar1<> g; // both grammarsinstantiated here+ grammar1<> g; // both grammarsinstantiated here 两个语法均在此实例化

 </pre>

The second task is slightly more complex. You must ensure that in thefirstcompilation unit the compiler sees only some function/templatedeclaration

@@ -312,17 +289,19 @@

you need to manually (explicitly) instantiate these templates with thecorrecttemplate parameters inside a separate compilation unit. This way thecompilation

   time is split between several compilation units, reducing the overall
-  required time drastically too. </p>

+ required time drastically too. 第二个任务要复杂些。你必须确保在第一个编译单元中编译器只见到一些函数/模板的声明，而在第二个编译单元中是函数/模板的定义。如果没有涉及模板，这没有问题。如果涉及到模板，你就需要手工(显式)地在各个编译单元中以正确的模板参数实例化这些模板。使用这种方法，编译时间被几个编译单元分割，从而大大减少所需的总时间。For a sample, showing how to achieve this, you may want to look at the<tt>Wave</tt>- preprocessor library, where this technique is used extensively. (thisshould be available for download from <ahref="http://spirit.sf.net";>Spirit's site</a> as soon as you read this).-<a name="frame_assertion" id="frame_assertion"></a>Closureframe assertion-Question: When I run the parser I get anassertion- "frame.get() != 0 in fileclosures.hpp".

-  What am I doing wrong?</p>

+ preprocessor library, where this technique is used extensively. (thisshould be available for download from <ahref="http://spirit.sf.net/";>Spirit's site</a> as soon as you readthis). 作为一个示范如何实现这一点的例子，你可以看一下 <tt>Wave</tt>+ 预处理器库，其中广泛使用了此技术(在你阅读本文时，该库应可从 <ahref="http://spirit.sf.net";>Spirit's 站点</a> 开载了)。+<a name="frame_assertion" id="frame_assertion"></a>Closureframe assertion 闭包帧断言+Question: When I run the parser I get anassertion

+  <span class="string">"frame.get() != 0 in file closures.hpp"</span>.

+ What am I doing wrong? 问题：当我运行一个分析器时，获得了一个+ "frame.get() != 0 in file closures.hpp" 的断言。我做错了什么？Basically, the assertion fires when you are accessing a closurevariable thatis not constructed yet. Here's an example. We have three rules<tt>a</tt>, <tt>b</tt>and <tt>c</tt>. Consider that the rule <tt>a</tt> has a closure member<tt>m</tt>.

-  Now:</p>

+ Now: 基本上，这个断言在你访问一个尚未构造的闭包变量时触发。以下是一个例子。我们有三个规则 <tt>a</tt>, <tt>b</tt> 和 <tt>c</tt>。假设规则<tt>a</tt> 有一个闭包成员 <tt>m</tt>。现在：<pre> a =b;b = <spanclass="identifier">int_p[<spanclass="identifier">a.<spanclass="identifier">m = 123<spanclass="special">];c = <spanclass="identifier">b;</pre>

@@ -332,40 +311,44 @@

<tt>m</tt>. On the other hand, when <tt>c</tt> is invoked, and<tt>c</tt> attemptsto call <tt>b</tt>, no frame for <tt>a</tt> is set. Thus, when<tt>b</tt> iscalled from <tt>c</tt>, the semantic action <tt>[a.m = 123]</tt>willfire the- "frame.get() != 0 in fileclosures.hpp"

-  assertion.</p>
-<p><strong><a name="greedy_rd" id="greedy_rd"></a>Greedy RD</strong></p>

-Question: I'm wondering why the this won'twork

-  when parsed:</p>
-<pre>

- a =+anychar_p<spanclass="special">;

+  <span class="string">"frame.get() != 0 in file closures.hpp"</span>
+  assertion.<br>当规则 <tt>a</tt> 被调用时，它的帧被设置，其中含有它的成员
+  <tt>m</tt>。因此，当从 <tt>a</tt> 调用 <tt>b</tt> 时，语义动作<tt></tt>
+  <tt>[a.m = 123]</tt>将把 <tt>123</tt> 保存在 <tt>a</tt> 的闭包成员

+ <tt>m</tt> 中。另一方面，当 <tt>c</tt> 被调用且 <tt>c</tt> 试图调用<tt>b</tt> 时，并没有为 <tt>a</tt> 设置帧。因此，当从 <tt>c</tt> 调用<tt>b</tt> <tt></tt>时，语义动作 <tt>[a.m = 123]</tt>将触发

+  <span class="string">"frame.get() != 0 in file closures.hpp"</span>
+  断言。</p>

+<a name="greedy_rd" id="greedy_rd"></a>Greedy RD  贪心RD+Question: I'm wondering why the this won'twork+ when parsed: 问题：我很奇怪为什么在进行分析时，以下语法不能工作：+<pre> a =+anychar_p<spanclass="special">;b = '('>> a>> ')'<spanclass="special">;</pre>

-<p>Try this:</p>
-<pre>

- a =+(anychar_p - <spanclass="string">')');

+<p>Try this:<br>试一下这个：</p>

+<pre> a =+(anychar_p - <spanclass="string">')');b = <spanclass="string">'(' >> <spanclass="identifier">a >> <spanclass="string">')';</pre>David Held writes: That's because it's like the langoliers--it eatseverythingup. You usually want to say what it shouldn't eat up by subtracting theterminatingcharacter from the parser. The moral being: Using <tt>*anychar_p</tt> or<tt>+anychar_p</tt>

-  all by itself is usually a <em>Bad Thing</em>&#8482;.</p>

+ all by itself is usually a Bad Thing™. David Held 写道：这是因为它象langoliers--它把一切都吃掉了。通常你想通过从分析器中去掉一些终止符来说明分析器不应吃掉什么。规则是：使用 <tt>*anychar_p</tt> 或<tt>+anychar_p</tt>

+  通常是一件坏事。</p>

In other words: Recursive Descent is inherently greedy (however, see <ahref="rationale.html#exhaustive_rd">Exhaustive

-  backtracking and greedy RD</a>).</p>

+ backtracking and greedy RD</a>). 换句话说：递归下降本身就是贪心的(不过，请看 <a href="rationale.html#exhaustive_rd">完全回溯和贪心RD</a>)。<aname="referencing_a_rule_at_construction"id="referencing_a_rule_at_construction"></a>Referencing

-  a rule at construction time</strong></p>

-Question: The code below terminates with asegmentation

-  fault, but I'm (obviously) confused about what I'm doing wrong.</p>
+  a rule at construction time 在构造期引用规则</strong></p>

+Question: The code below terminates with asegmentation+ fault, but I'm (obviously) confused about what I'm doing wrong. <fontcolor="#ff0000">问题：以下代码导致了段错误，但我(显然)没弄明白自己错在哪里。<pre> rule<ScannerT<spanclass="special">, clos::context_t<spanclass="special">> id = int_p<spanclass="special">[id.i <spanclass="special">= arg1];</pre>You have a rule <tt>id</tt> being constructed. Before it isconstructed, youreference <tt>id.i</tt> in the RHS of the constructor. It's a chickenand eggthing. The closure member <tt>id.i</tt> is not yet constructed at thatpoint.

-  Using assignment will solve the problem. Try this instead:</p>

+ Using assignment will solve the problem. Try this instead: 你有一个规则 <tt>id</tt> 正被构造。在它构造完成之前，你在其构造函数的RHS中引用了<tt>id.i</tt>。这是鸡和蛋的问题。闭包成员 <tt>id.i</tt> 在此时尚未构造。使用赋值可以解决这个问题。试试这个：<pre> rule<ScannerT<spanclass="special">, clos::context_t<spanclass="special">> id;id = int_p<spanclass="special">[id.i <spanclass="special">= arg1];</pre><a name="storing_rules"id="storing_rules"></a>Storing

-  Rules </strong></p>

-Question: Why can't I store rules in STLcontainers

+  Rules 保存规则 </strong></p>

+Question: Why can't I store rules in STLcontainersfor later use and why can't I pass and return rules to and fromfunctions by

-  value? </p>

+ value? 问题：为什么我不能将规则保存在STL容器中以备后用，还有，为什么我不能以传值的方式向函数传入或从函数返回规则？ EBNF is primarily declarative. Like in functional programming, It's astaticrecipe and there's no notion of do this then that. However, in Spirit,we managedto coax imperative C++ to take in declarative EBNF. Hah! Fun!... We didthat

@@ -375,68 +358,89 @@

constructor) a different meaning and semantics. Doing so made the ruleunlikeany other C++ object. You can't copy it. You can't assign it. You can'tplaceit in a container (vector, stack, etc).Heck, you can't even return itfrom a

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

- <td class="note_box"><img src="theme/alert.gif" width="16"height="16"> The+ function *by value*. EBNF是声明式的。类似于函数式编程，它是一些静态的声明，且没有这样做的概念。但是，在Spirit中，我们必须设法让C++参与到声明式的EBNF中。哈！有趣！... 我们通过伪装C++的赋值操作符以模仿EBNF的<tt>::=</tt>，其它东西外(如 <tt>>></tt>, <tt>|</tt>, <tt>&</tt>+等等)除外。我们使用 rule 类来实现这一点，通过给予其赋值操作符(及复制构造函数)一个不同的意义和语义。这样做使得 rule+与其它C++对象不一样。你不能复制它。你不能赋值它。你不能把它放入容器(vector, stack,

+等等)中。哎呀，你甚至不能从一个函数返回它 *以传值的方式*。</p>
+<table align="center" border="0" width="80%">
+  <tbody><tr>

+ <td class="note_box"><img src="theme/alert.gif" height="16"width="16"> Therule is a weird object, unlike any other C++ object. It does nothave theproper copy and assignment semantics and cannot be stored and passedaround

-      by value.</td>

+ by value. <img src="theme/alert.gif" height="16" width="16"> 规则是一种奇怪的对象，与其它C++对象不一样。它没有正确的复制和赋值语义，也不能被保存或以值方式传递。</td>

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

However nice declarative EBNF is, the dynamic nature of C++ can be anadvantage.We've seen this in action here and there. There are indeed someinterestingapplications of dynamic parsers using Spirit. Yet, we haven't fullyutilizedthe power of dynamic parsing, unless(!), we have a rule that's not soaliento C++ (i.e. behaves as a good C++ object). With such a beast, we canwrite

-  parsers that's defined at run time, as opposed to at compile time.</p>
+  parsers that's defined at run time, as opposed to at compile time.<br>虽

+然声明式EBNF是好，但C++的动态特性也可以是一种优势。我们已经各处的动作中见过这一咪。确有一些使用Spirit的动态分析器的有趣应用。然而，

+我们还没有充分利用动态分析的力量，除非(!)我们有一个对于C++不那么陌生的 rule

+(即其行为是一个好的C++对象)。有了这样一个东西，我们就可以写出在运行期而非编译期定义的分析器了。Now that I started focusing on rules (hey, check out the hunky new rulefeatures),it might be a good time to implement the rule-holder. It is basicallyjust arule, but with C++ object semantics. Yet it's not as simple. Withouttrue garbagecollection, the implementation will be a bit tricky. We can't simply usereferencecounting because a rule-holder (hey, anyone here has a better name?)*is-a*rule, and rules are typically recursive and thus cyclic. The problem iswhich

-  will own which.</p>
+  will own which.<br>现

+在，我开始关注于规则(嘿，找出hunky新规则特性)，它可能是实现规则保存器的好时机。基本上它只是一个规则，但具有C++对象的语义。然而事情并非+这么简单。没有真正的垃圾回收机制，这个实现将会有些棘手。我们不能只是使用引用计数，因为规则保存器(嘿，其它人有更好的名字吗？)*is-a*规则，

+而规则典型是递归的，这会导致循环。问题是谁将拥有谁。</p>

Ok... this will do for now. You'll definitely see more of therule-holder in

-  the coming days.</p>

-<a name="parsing_ints_and_reals"></a>Parsing Ints andReals- Question: I was trying to parse an intor float value with the <tt>longest_d</tt> directive and put some actors onthe alternatives to visualize the results. When I parse"123.456", the output reports:+ the coming days. Ok... 现在将要开始实现它。你肯定在不久就会看到更多关于规则保存器的东西。+<a name="parsing_ints_and_reals"></a>Parsing Ints and Reals 分析整数和实数+ Question: I was trying to parse an intor float value with the <tt>longest_d</tt> directive and put some actors onthe alternatives to visualize the results. When I parse "123.456", theoutput reports: 问题：我尝试用<tt>longest_d</tt> 指示符分析一个整数或浮点数，并在选择中置入一些动作以得到结果。当我分析 "123.456" 时，输出：

 <ol>
   <li>(int) has been matched: full match = false</li>
   <li> (double) has been matched: full match = true</li>
 </ol>
-<p>That is not what I expected. What am I missing? </p>

- Actually, the problem is that both semantic actions of the int andreal branch will be triggered because both branches will be tried. Thisdoesn't buy us much. What actually wins in the end is what you expected.But there's no easy way to know which one wins. The problem stems from theambiguity. +That is not what I expected. What am I missing? 这不是我想要的。我哪里搞错了？ 

+<p> Actually, the problem is that both semantic actions of the int and
+real branch will be triggered because both branches will be tried. This
+doesn't buy us much. What actually wins in the end is what you
+expected. But there's no easy way to know which one wins. The problem

+stems from the ambiguity. 实际上，问题是整数和实数分支的语义动作都被触发了，因为两个分支均被尝试。这对我们没什么意义。最后哪个分支胜出才是你想要的。不过却没有简单的方法来获知哪一个胜出。这个问题源自于歧义性。 

 <blockquote>

- Case1: Consider this input: "2". Is it an int or a real?They are both (strictly following the grammar of a real). - Case2 : Now how about "1.0"? Is it an int or a real? Theyare both, albeit the int part gets a partial match: "1". That iswhy you are getting a (partial) match for your int rule (fullmatch = false). + Case1: Consider this input: "2". Is it an int or a real? They areboth (strictly following the grammar of a real). Case1: 考虑输入 "2"。它是一个整数还是一个实数？两者都是(严格符合实数的语法)。 

+  <p>Case2
+: Now how about "1.0"? Is it an int or a real? They are both, albeit
+the int part gets a partial match: "1". That is why you are getting a
+(partial) match for your <em>int</em> rule (full match = false).<br>Case2

+: 那么输入 "1.0" 又如何？它是一个整数还是一个实数？两者都是，虽然整数部分只获得部分匹配："1"。这就是为什么你从 int 规则获得一个(部分)匹配的原因(full match = false)。 

 </blockquote>

- Instead of using the <tt>longest_d</tt> to parse ints and reals, whatI suggest is to remove the ambiguity and use the plain short-circuitingalternatives. The first step is to use <tt><ahref="numerics.html#strict_reals">strict_real_p</a> </tt>to make the firstcase unambiguous. Unlike

+<p>  Instead of using the <tt>longest_d</tt> to parse ints and reals,
+what I suggest is to remove the ambiguity and use the plain

+short-circuiting alternatives. The first step is to use <tt><ahref="numerics.html#strict_reals">strict_real_p</a> </tt>to make the firstcase unambiguous. Unlike

<tt>real_p</tt>, <tt>strict_real_p</tt> requires a dot to be present fora number to be considered a successful match.


-Your grammar can be written unambiguously as:</p>

+Your grammar can be written unambiguously as: 不要使用<tt>longest_d</tt> 来分析整数和实数，我的建议是，去掉歧义性，使用普通的短路选择。第一步是使用 <tt><ahref="numerics.html#strict_reals">strict_real_p</a> </tt>来令第一种情况没有歧义。与

+
+

+ <tt>real_p</tt> 不同，<tt>strict_real_p</tt> 要求数字要有一个小数点才被认为是成功的匹配。你的语法可以无歧义地写为：

 <pre>    strict_real_p<span class="special"> | </span>int_p</pre>

- Note that because ambiguity is resolved, attaching actions to bothbranches is safe. Only one will be triggered:+ Note that because ambiguity is resolved, attaching actions to bothbranches is safe. Only one will be triggered: 注意，因为歧义性得到解决，向两个分支附加动作是安全的了。只有一个会被触发：<pre> strict_real_p[R<spanclass="special">] | int_p[I<spanclass="special">]</pre>

 <blockquote>
-  <p> &quot;1.0&quot; ---&gt; triggers R<br>
-&quot;2&quot; ---&gt; triggers I</p>
+  <p> "1.0" ---&gt; triggers R<br>
+"2" ---&gt; triggers I</p>
 </blockquote>

- Again, as a rule of thumb, it is always best to resolve as muchambiguity as possible. The best grammars are those which involve nobacktracking at all: an LL(1) grammar. Backtracking and semantic actions donot mix well.

+<p> Again, as a rule of thumb, it is always best to resolve as much
+ambiguity as possible. The best grammars are those which involve no
+backtracking at all: an LL(1) grammar. Backtracking and semantic

+actions do not mix well. 同样，作为一个经验法则，最好总是解决尽可能多的歧义性。最好的语法是那些不需要回溯的语法：一个 LL(1) 语法。回溯和语义动作混用不是太好。<a name="output_operator"id="output_operator"></a>BOOST_SPIRIT_DEBUG and missing<tt>operator<<</tt>-Question: My code compiles fine in releasemode but when I try to define <tt>BOOST_SPIRIT_DEBUG</tt> the compilercomplains about a missing <tt>operator<spanclass="special"><<</tt>.+Question: My code compiles fine in releasemode but when I try to define <tt>BOOST_SPIRIT_DEBUG</tt> the compilercomplains about a missing <tt>operator<spanclass="special"><<</tt>. 问题：我们代码在发布模式下可正常编译，但当我尝试定义<tt>BOOST_SPIRIT_DEBUG</tt> 时，编译器投诉缺少 <tt><spanclass="keyword">operator<<</tt>。When <tt>BOOST_SPIRIT_DEBUG</tt> is defined debug output is generatedforspirit parsers. To this end it is expected that each closure member hasthe

-  default output operator defined.</p>

+ default output operator defined. 当 <tt>BOOST_SPIRIT_DEBUG</tt> 被定义时，将为spirit分析器生成调试输出。为此，要求每一个闭包成员都带有缺省的输出操作符定义。

 <p>You may provide the operator overload either in the namespace where the

class is declared (will be found through Argument Dependent Lookup) ormake it visible where it is

-  used, that is <tt><span class="keyword">namespace</span> <span
-  class="identifier">boost</span><span class="special">::</span><span
-  class="identifier">spirit</span></tt>. Here's an example for <tt><span
-  class="identifier">std</span><span class="special">::</span><span
-  class="identifier">pair</span></tt>:</p>

+ used, that is <tt>namespace <spanclass="identifier">boost::<spanclass="identifier">spirit</tt>. Here's an example for <tt><spanclass="identifier">std::<spanclass="identifier">pair</tt>: 你可以在该类被定义的名字空间中提供这个操作符(可通过ADL查找得到)，或者在使用它的地方，即 <tt><spanclass="keyword">namespace boost<spanclass="special">::spirit</tt> 处令其可见。以下是一个关于 <tt>std<spanclass="special">::pair</tt> 的例子：

 <pre><code>

#include <spanclass="string"><iosfwd>#include <spanclass="string"><utility>

@@ -460,47 +464,47 @@
     <span class="special">}</span>

 </code></pre>

-<a name="repository" id="repository"></a>Applications that used tobe part of spirit-Question: Where can I find <insertgreat application>, that used to be part of the Spiritdistribution?+<a name="repository" id="repository"></a>Applications that used tobe part of spirit 以前作为spirit一部分的应用程序+Question: Where can I find <insertgreat application>, that used to be part of the Spiritdistribution? 问题：我可以在哪里找到<insert great application>，被用作Spirit发布包的一部分的？

 <p>Old versions of Spirit used to include applications built with it.
   In order to streamline the distribution they were moved to a separate

<ahref="http://spirit.sourceforge.net/repository/applications/show_contents.php";>applicationsrepository</a>.

   In that page you'll find links to full applications that use the Spirit
   parser framework. We encourage you to send in your own applications for
-  inclusion (see the page for instructions).</p>

- You may also check out the <ahref="http://spirit.sourceforge.net/repository/grammars/show_contents.php";>grammars'repository</a>.

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

+ inclusion (see the page for instructions). Spirit的旧版本通常会包含一些用spirit来构建的应用程序。为了简化发布包，它们被移至了单独的+ <ahref="http://spirit.sourceforge.net/repository/applications/show_contents.php";>应用程序仓库</a>。在那里，你可以找到一些链接，链至一些使用了Spirit分析器框架的完整的应用程序。我们鼓励你将你自己的应用程序也发至此处(请见指示页)。+ You may also check out the <ahref="http://spirit.sourceforge.net/repository/grammars/show_contents.php";>grammars'repository</a>. 你也可以检查一下 <ahref="http://spirit.sourceforge.net/repository/grammars/show_contents.php";>语法仓库</a>。

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

- <img src="theme/note.gif" width="16" height="16"> You'll still findthe+ <img src="theme/note.gif" height="16" width="16"> You'll still findthe

       example applications that complement (actually are part of) the

- documentation in the usual place:<code>libs/spirit/example</code>. + documentation in the usual place:<code>libs/spirit/example</code>. <img src="theme/note.gif" height="16"width="16"> 你仍然可以在老地方 <code>libs/spirit/example</code> 找到作为文档补充(其实是文档的一部分)的例子应用程序。 

       <br>

- <img src="theme/alert.gif" width="16" height="16"> The applicationsand+ <img src="theme/alert.gif" height="16" width="16"> The applicationsandgrammars listed in the repositories are works of the respectiveauthors.

       It is the author's responsibility to provide support and maintenance.
-      Should you have any questions, please send the author an email.

+ Should you have any questions, please send the author anemail. <img src="theme/alert.gif" height="16" width="16"> 在仓库中列出的应用程序和语法是各个作者的作品。提供支持和维护是各位作者的责任。如果你有任何问题，请给作者发送email。

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

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

+<p class="copyright">Copyright © 1998-2003 Joel de Guzman<br>
+<span class="copyright">Copyright © 2002-2003 Hartmut Kaiser </span><br>
+<span class="copyright">Copyright © 2006-2007 Tobias Schwinger </span><br>
   <br>

Use, modification and distribution is subject to theBoost SoftwareLicense, Version 1.0. (See accompanying file LICENSE_1_0.txt or copyat

 http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================

--- /trunk/libs/spirit/classic/doc/file_iterator.html Tue Mar 31 01:07:162009+++ /trunk/libs/spirit/classic/doc/file_iterator.html Mon Oct 12 20:27:432009

@@ -1,97 +1,76 @@
-<html>
-<head>
-<title>File Iterator</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>File Iterator</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%">

- FileIterator+ FileIterator 文件迭代器

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

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

Since Spirit is a back-tracking parser, it requires at least a forwarditerator.In particular, an input iterator is not sufficient. Many times it isconvenientto read the input to a parser from a file, but the STL file iteratorsare inputiterators. To get around this limitation, Spirit has a utility class<tt>file_iterator</tt>,

-  which is a read-only random-access iterator for files.</p>

+ which is a read-only random-access iterator for files. 由于Spirit是一个后向跟踪分析器，它要求至少一个前向迭代器。特别是，输入迭代器是不够的。很多时候从一个文件读入数据至分析器是很方便的，但是STL的文件迭代器是输入迭代器。为了避开这个限制，Spirit有一个工具类 <tt>file_iterator</tt>，它是文件的只读随机访问迭代器。To use the Spirit file iterator, simply create a file iterator with thepath- to the file you wish to parse, and then create an EOF iterator for thefile:-<pre> #include<<spanclass=identifier>boost/<spanclass=identifier>spirit/<spanclass=identifier>iterator/<spanclass=identifier>file_iterator.<spanclass=identifier>hpp> <spanclass=comment>// the header file</pre>-<pre> file_iterator<spanclass=special><> first<spanclass=special>("input.dat"<spanclass=special>);

- if <spanclass=special>(!first<spanclass=special>)

-    {

- std<spanclass=special>::cout <spanclass=special><< "Unable to openfile!\n";

-
-       </span><span class=comment>// Clean up, throw an exception, whatever

- return <spanclass=special>-1;

-    }
-

- file_iterator<spanclass=special><> last <spanclass=special>= first<spanclass=special>.make_end<spanclass=special>();</pre>+ to the file you wish to parse, and then create an EOF iterator for thefile: 要使用Spirit的文件迭代器，只需用你想要分析的文件的路径名去创建一个文件迭代器即可，然后为该文件创建一个EOF迭代器：+<pre> <spanclass="preprocessor">#include <<spanclass="identifier">boost/<spanclass="identifier">spirit/<spanclass="identifier">iterator/<spanclass="identifier">file_iterator.<spanclass="identifier">hpp> <spanclass="comment">// the header file 头文件</pre>+<pre> file_iterator<spanclass="special"><> first<spanclass="special">("input.dat"<spanclass="special">); if <spanclass="special">(!first<spanclass="special">) { <spanclass="identifier">std::<spanclass="identifier">cout << <spanclass="string">"Unable to open file!\n"<spanclass="special">; // Clean up,throw an exception, whatever 清除，抛出一个异常，或其它 return <spanclass="special">-1<spanclass="special">; } <spanclass="identifier">file_iterator<>last =first<spanclass="special">.make_end<spanclass="special">();</pre>You now have a pair of iterators to use with Spirit . If your parser isfullyparametrized (no hard-coded <tt><char const *></tt>), it is asimple matter

-  of redefining the iterator type to <tt>file_iterator</tt>:<br>

+ of redefining the iterator type to <tt>file_iterator</tt>: 现在你有了一对迭代器用于Spirit。如果你的分析器是完全参数化的(没有硬编码的<tt><char const *></tt>)，那么重新定义迭代器类型为<tt>file_iterator</tt> 只是一件很简单的事情： 

 </p>

-<pre> typedef char <spanclass="identifier">char_t;- typedef <spanclass=identifier>file_iterator <<spanclass=keyword>char_t<spanclass=special>> iterator_t<spanclass=special>;- typedef <spanclass=identifier>scanner<<spanclass=identifier>iterator_t> <spanclass=identifier>scanner_t;- typedef rule<<spanclass=identifier>scanner_t>rule_t;

- rule_t my_rule<spanclass=special>;

-
-    </span><span class=comment>// Define your rule
-

- parse_info<spanclass=special><iterator_t<spanclass=special>> info <spanclass=special>= parse<spanclass=special>(first<spanclass=special>, last<spanclass=special>, my_rule<spanclass=special>);</pre>+<pre> typedef charchar_t; typedef <spanclass="identifier">file_iterator <spanclass="special"><char<spanclass="identifier">_t> <spanclass="identifier">iterator_t; typedef <spanclass="identifier">scanner<<spanclass="identifier">iterator_t>scanner_t<spanclass="special">; typedef <spanclass="identifier">rule <<spanclass="identifier">scanner_t>rule_t<spanclass="special">; rule_tmy_rule; <spanclass="comment">// Define your rule 定义你的规则 <spanclass="identifier">parse_info<<spanclass="identifier">iterator_t> <spanclass="identifier">info = <spanclass="identifier">parse(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">my_rule);</pre>Of course, you don't have to deal with the <ahref="faq.html#scanner_business">scanner-business</a>at all if you use grammars rather than rules as arguments to the parsefunctions.- You simply pass the iterator pairs and the grammar as is:<spanclass=special> + You simply pass the iterator pairs and the grammar as is: 当然，你根本不必处理 <a href="faq.html#scanner_business">扫描器事务</a>，如果你用语法而不是规则作为 parse 函数的参数。你只要传入迭代器对和语法如下：<spanclass="special"> 

   </span></p>

-<pre> my_grammar <spanclass=identifier>g;- parse_info<spanclass=special><iterator_t<spanclass=special>> info <spanclass=special>= parse<spanclass=special>(first<spanclass=special>, last<spanclass=special>, g<spanclass=special>);</pre>

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

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

-      Generic iterator</b><br>

+<pre> my_grammar <spanclass="identifier">g; <spanclass="identifier">parse_info<<spanclass="identifier">iterator_t> <spanclass="identifier">info = <spanclass="identifier">parse(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">g);</pre>

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

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

+      Generic iterator 泛型迭代器</b><br>
       <br>

The Spirit file iterator can be parameterized with any type that isdefaultconstructible and assignable. It transparently supports large files(greaterthan 2GB) on systems that provide an appropriate interface. The fileiteratorcan be useful outside of Spirit as well. For instance, theBoost.Tokenizer- package requires a bidirectional iterator, which is provided byfile_iterator.</td>+ package requires a bidirectional iterator, which is provided byfile_iterator. + Spirit文件迭代器可以按任何可缺省构造及可赋值的类型参数化。在提供了适当接口的系统上，它透明地支持大文件(大于2GB)。该文件迭代器也可以在Spirit之外使用。例如，Boost.Tokenizer

+      包要求一个双向迭代器，就是由 file_iterator 提供的。</td>
   </tr>
-</table>

-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/file_parser.cpp">file_parser.cpp</a> for acompilable example. This is part of the Spirit distribution.

+</tbody></table>

+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/file_parser.cpp">file_parser.cpp</a> for acompilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译的例子请见 <ahref="../example/fundamental/file_parser.cpp">file_parser.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; 2002 Jeff Westfahl</p>
+<p class="copyright">Copyright © 2002 Jeff Westfahl</p>

 Use, modification and distribution issubject to the Boost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)
  </font> </p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/includes.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/includes.html        Mon Oct 12 20:27:43 2009
@@ -1,56 +1,53 @@
-<html>
-<head>
-<title>Includes</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>Includes</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%"> Includes+ <td width="85%"> Includes 头文件

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

   </tr>
-</table>
-<h2>Modules</h2>

-Spirit is designed to be header only. Generally, there are no librariesto build

+</tbody></table>

+<h2>Modules 模块</h2>Spirit is designed to be header only. Generally,there are no libraries to buildand link against. Certain features, however, require additional libraries;in particularthe <a href="regular_expression_parser.html">regular expression parser</a>requires<a href="http://www.boost.org/libs/regex/index.html";>Boost.Regex</a> and<a href="grammar.html#multithreading">multithreading support</a>-requires <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads.</a>

-<p>Using Spirit is as easy as including the main header file:</p>

+requires <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads.</a> Spirit被设计为只带头文件的。通常，没有库需要构建和链接。但是，某些特定的特性需要其它的库；如 <a href="regular_expression_parser.html">正则表达式分析器</a> 需要+<a href="http://www.boost.org/libs/regex/index.html";>Boost.Regex</a>，而<a href="grammar.html#multithreading">多线程支持</a>+则需要 <ahref="http://www.boost.org/libs/thread/doc/index.html";>Boost.Threads。</a>+Using Spirit is as easy as including the main header file: 使用Spirit很容易，只要包含以下主头文件即可：<pre> #include <spanclass="special"><boost/spirit<spanclass="special">.hpp></pre>Doing so will include all the header files. This might not bedesirable. Alow cholesterol alternative is to include only the module that you need.Eachof the modules has its own header file. The master spirit header fileactuallyincludes all the module files. To avoid unnecessary inclusion offeatures that- you do not need, it is better to include only the modules that youneed.-<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/actor.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/attribute.hpp<spanclass="special">>- #include <boost<spanclass="special">/spirit/core<spanclass="special">.hpp><spanclass="special">+ you do not need, it is better to include only the modules that youneed. 这样做将包含所有头文件。这可能不是你想要的。较为瘦身一点的选择是，只包含你所需的头文件。每个模块都有它自己的头文件。spirit的主头文件其实就是包含所有的模块文件。为了避免包含你不需要的特性的头文件，最好只包含你所要的模块。+<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/actor.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/attribute.hpp<spanclass="special">> #include<boost/spirit<spanclass="special">/core.hpp<spanclass="special">> <spanclass="preprocessor">#include <boost<spanclass="special">/spirit/debug<spanclass="special">.hpp><spanclass="special"> <spanclass="preprocessor">#include <boost<spanclass="special">/spirit/dynamic<spanclass="special">.hpp><spanclass="special">#include <boost<spanclass="special">/spirit<spanclass="special">/error_handling<spanclass="special">.hpp><spanclass="special">- #include <boost<spanclass="special">/spirit/iterator<spanclass="special">.hpp>- #include <boost<spanclass="special">/spirit/meta<spanclass="special">.hpp><spanclass="special">+ #include <boost<spanclass="special">/spirit/iterator<spanclass="special">.hpp> <spanclass="preprocessor">#include <boost<spanclass="special">/spirit/meta<spanclass="special">.hpp><spanclass="special"> <spanclass="preprocessor">#include <boost<spanclass="special">/spirit/symbols<spanclass="special">.hpp><spanclass="special">#include <boost<spanclass="special">/spirit/tree<spanclass="special">.hpp><spanclass="special">#include <boost<spanclass="special">/spirit/utility<spanclass="special">.hpp><spanclass="special"></pre>

-<h2>Sub-Modules</h2>
+<h2>Sub-Modules 子模块</h2>

 For even finer control over header file inclusion, you can includeonly the- specific files that you need. Each module is in its ownsub-directory:

-<h3>actor</h3>

+ specific files that you need. Each module is in its ownsub-directory: 为了更好地控制对头文件的包含，你可以只包含所需的专用文件。每个模块都位于各自的子目录中：

+<h3>actor 动作器</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">assign_actor<spanclass="special">.hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">assign_key.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">clear_actor.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">decrement_actor<spanclass="special">.hpp><spanclass="special">

@@ -58,57 +55,43 @@

#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">push_back_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">push_front_actor<spanclass="special">.hpp><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/actor/<spanclass="identifier">swap_actor.hpp<spanclass="special">><spanclass="special"></pre>

-<h3>attribute</h3>
+<h3>attribute 属性</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/attribute/<spanclass="identifier">closure.<spanclass="identifier">hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/attribute<spanclass="special">/closure_context.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/attribute<spanclass="special">/parametric.hpp<spanclass="special">></pre>

-<h3>debug</h3>

-<img src="theme/alert.gif" width="16" height="16"> The debug moduleshould

+<h3>debug 调试</h3>

+<img src="theme/alert.gif" height="16" width="16"> The debug moduleshouldnot be directly included. See <a href="debugging.html">Debugging</a> formore

-  info on how to use Spirit's debugger. </p>
-<h3>dynamic</h3>

+ info on how to use Spirit's debugger. <img src="theme/alert.gif"height="16" width="16"> 调试模块不应直接包含。有关如何使用Spirit的调试器的更多信息，请见 <a href="debugging.html">Debugging</a>。 

+<h3>dynamic 动态</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic/<spanclass="identifier">for.<spanclass="identifier">hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/dynamic/if.hpp<spanclass="special">><spanclass="special">- #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/lazy.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/rule_alias.hpp>- #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/select.hpp>- #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/stored_rule.hpp>- #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/switch.hpp>- #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/while.hpp> </pre>

-<h3>error_handling</h3>

+ #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/lazy.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/rule_alias.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/select.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/stored_rule.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/switch.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/dynamic<spanclass="special">/while.hpp> </pre>

+<h3>error_handling 错误处理</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/error_handling/<spanclass="identifier">exceptions.<spanclass="identifier">hpp></pre>

-<h3>iterator</h3>
+<h3>iterator 迭代器</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/iterator/<spanclass="identifier">file_iterator.<spanclass="identifier">hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/iterator<spanclass="special">/fixed_size_queue.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/iterator<spanclass="special">/multi_pass.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/iterator<spanclass="special">/position_iterator.hpp<spanclass="special">></pre>

-<h3>meta</h3>
+<h3>meta 元</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/meta/<spanclass="identifier">as_parser.<spanclass="identifier">hpp> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/meta<spanclass="special">/fundamental.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/meta<spanclass="special">/parser_traits.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/meta<spanclass="special">/refactoring.hpp> #include <spanclass="special"><boost/spirit<spanclass="special">/meta<spanclass="special">/traverse.hpp></pre>

-<h3>tree</h3>
+<h3>tree 树</h3>

<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/tree<spanclass="special">/ast<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/tree<spanclass="special">/parse_tree.hpp<spanclass="special">><spanclass="special">#include <spanclass="special"><boost/spirit<spanclass="special">/tree<spanclass="special">/parse_tree_utils.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/tree<spanclass="special">/tree_to_xml.hpp<spanclass="special">></pre>

-<h3>utility</h3>

-<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/chset<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/<spanclass="identifier">chset_operators<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/confix<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/distinct<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/escape_char<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/<spanclass="identifier">flush_multi_pass<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/functor_parser<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/lists<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/loops<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/regex<spanclass="special">.hpp<spanclass="special">>- #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/scoped_lock<spanclass="special">.hpp<spanclass="special">>

-</span></pre>
+<h3>utility 工具</h3>

+<pre> #include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/chset<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/<spanclass="identifier">chset_operators<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/confix<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/distinct<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/escape_char<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/<spanclass="identifier">flush_multi_pass<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/functor_parser<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/lists<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/loops<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/regex<spanclass="special">.hpp<spanclass="special">> <spanclass="preprocessor">#include <spanclass="special"><boost/spirit<spanclass="special">/utility<spanclass="special">/scoped_lock<spanclass="special">.hpp<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 © 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/multi_pass.html      Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/multi_pass.html      Mon Oct 12 20:27:43 2009
@@ -1,16 +1,17 @@

-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01Transitional//EN"><html><head><title>The multi_pass</title>

-
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><title>The multi_pass</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">
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
   <tbody><tr>
     <td width="10">
     <br>
 </td>

- <td width="85%"> The+ <td width="85%"> The

       multi_pass</b></font> </td>

   </tr>
 </tbody></table>
 <br>
@@ -28,16 +29,19 @@

cannot be used. Therefore, the standard library classesistreambuf_iteratorand istream_iterator, that fall under the category of input iterators,cannotbe used. Another input iterator that is of interest is one that wraps alexer,

-  such as LEX.</p>
-<table width="80%" border="0" align="center">
+  such as LEX.<br>Spirit

+中的回溯要求使用以下迭代器类型：前向迭代器、双向迭代器或随机访问迭代器。因为要回溯，所以输入迭代器不能使用。因此，标准库类+istreambuf_iterator 和 istream_iterator 均属于输入迭代器类别，都不能使用。另一个感兴趣的输入迭代器是

+lexer 的封装，如 LEX.</p>
+<table align="center" border="0" width="80%">
   <tbody><tr>

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

-      Iterators</b> <br>

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

+      Iterators</b> 输入迭代器 <br>
       <br>

In general, Spirit is a backtracking parser. This is not an absoluterequirementthough. In the future, we shall see more deterministic parsers thatrequireno more than 1 character (token) of lookahead. Such parsers allow usto

-      use input iterators such as the istream_iterator as is. </td>

+ use input iterators such as the istream_iterator as is. 通常，Spirit是一个回溯分析器。但这不是绝对的要求。未来我们将会看到更为确定的分析器，要求前向环视不超过1个字符(记号)。这样的分析器允许我们使用输入迭代器，如 istream_iterator 等等。 </td>

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

 Unfortunately, with an input iterator, there is no way to save aniterator

@@ -45,48 +49,58 @@

One solution to this problem is to simply load all the data to be parsedintoa container, such as a vector or deque, and then pass the begin and endof thecontainer to Spirit. This method can be too memory intensive for certainapplications,

-  which is why the multi_pass iterator was created.</p>
+  which is why the multi_pass iterator was created.<br>不

+幸的是，使用输入迭代器没有办法保存迭代器的位置，因此输入迭代器不能用于Spirit中的回溯。这个问题的一个解决办法是，将要分析的所有数据导入到一

+个容器中，如 vector 或 deque，然后将该容器的 begin 和 end 传给

+Spirit。这个方法对于某个应用可能要耗费大量内存，这正是为什么要创建multi_pass 迭代器的原因。 The multi_pass iterator will convert any input iterator into a forwarditeratorsuitable for use with Spirit. multi_pass will buffer data when neededand will

-  discard the buffer when only one copy of the iterator exists.</p>

+ discard the buffer when only one copy of the iteratorexists. multi_pass 迭代器可以将任意输入迭代器转换为适合Spirit使用的前向迭代器。multi_pass 会在需要时缓冲数据，也会在只有一份迭代器拷贝时略过缓冲。 A grammar must be designed with care if the multi_pass iterator isused. Any rule that mayneed to backtrack, such as one that contains an alternative, will causedata to be buffered. The rules that are optimal touse are sequence and repetition. Sequences of the form <tt>a >>b</tt>will not buffer data at all. Any rule that repeats, such as kleene_star(<tt>*a</tt>)or positive such as (<tt>+a</tt>), will only buffer the data for thecurrent

-  repetition.</p>

+ repetition. 如果要使用 multi_pass 迭代器，语法就必须小心地设计。任何规则都可能需要回溯，例如一个含有选择的规则，这将导致数据被缓存。这些规则最好使用序列和重复。形如 <tt>a >> b</tt>

+  的序列根本不会缓存数据。任何带有重复的规则，如 kleene_star (<tt>*a</tt>)
+  或加号如 (<tt>+a</tt>)，则只缓存当前重复的数据。</p>

 In typical grammars, ambiguity and therefore lookahead is oftenlocalized.In fact, many well designed languages are fully deterministic andrequire nolookahead at all. Peeking at the first character from the input willimmediatelydetermine the alternative branch to take. Yet, even with highlyambiguous grammars,alternatives are often of the form <tt>*(a | b | c | d)</tt>. The inputiteratormoves on and is never stuck at the beginning. Let's look at a Pascalsnippet

-  for example:</p>

+ for example: 在典型的语法中，模糊性以及所引起的前向环视通常是局部性的。事实上，许多精心设计的语言是完全确定性的，根本不需要前向环视。从读进输入的第一个字符开始，并立即决定选择哪个分支。然而，即使是非常模糊的语法，选择通常也是 <tt>*(a | b | c | d)</tt> 这样的形式。输入迭代器向前移动，永远不会停留在开始处。我们看一个Pascal片断的例子：<pre> <code>program <spanclass="special">= programHeading>> block>> <spanclass="literal">'.' ; block <spanclass="special">= *( <spanclass="identifier">labelDeclarationPart <spanclass="special">| <spanclass="identifier">constantDefinitionPart <spanclass="special">| <spanclass="identifier">typeDefinitionPart <spanclass="special"> | <spanclass="identifier">variableDeclarationPart <spanclass="special">| procedureAndFunctionDeclarationPart ) >> <spanclass="identifier">statementPart <spanclass="special">; </code></pre> Notice the alternatives inside the Kleene star in the rule block . Therulegobbles the input in a linear manner and throws away the past historywith eachiteration. As this is fully deterministic LL(1) grammar, each failedalternativeonly has to peek 1 character (token). The alternative that consumes morethan1 character (token) is definitely a winner. After which, the Kleene starmoves

-  on to the next.</p>
+  on to the next.<br>留

+意规则块中在 Kleene 星内部的多项选择。该规则以线性方式吞进输入，并丢掉每次迭代的历史。因为这是完全确定性的 LL(1)+语法，每个失败的选择都只需检查1个字符(记号)。消耗1个以上字符(记号)的选择项肯定是胜者。之后，Kleene 星前移至下一个。

 <p>Be mindful if you use the free parse functions.
-  All of these make a copy of the iterator passed to them.<br>

+ All of these make a copy of the iterator passed to them. 紧记，如果你使用自由的 parse 函数。所有这些会对传给它们的迭代器复制一份拷贝。 

 </p>

-Now, after the lecture on the features to be careful with when usingmulti_pass,

-you may think that multi_pass is way too restrictive to use. &nbsp;That's

-not the case.  If your grammar is deterministic, you can make use offlush_multi_pass in your grammar to ensure that data is not buffered whenunnecessary. 

+<p>Now, after the lecture on the features to be careful with when using
+multi_pass,
+you may think that multi_pass is way too restrictive to use.
+&nbsp;That's
+not the case. &nbsp;If your grammar is deterministic, you can make use
+of flush_multi_pass in your grammar to ensure that data is not buffered
+when unnecessary.<br>现在，在介绍了使用

+multi_pass 时应注意的特性之后，你可能认为 multi_pass 过多限制难以使用。其实不然。如果你的语法是确定性的，你就可以在你的语法中使用 flush_multi_pass 来确保数据在不需要的时候不会被缓冲。 

 </p>

 Again, following up the example we started to use in the section onthe scanner. Here's an example using the multi_pass: This time around we areextracting

-  our input from the input stream using an istreambuf_iterator.</p>

-<pre> #include <spanclass="special"><boost<spanclass="special">/spirit<spanclass="special">/core<spanclass="special">.hpp<spanclass="special">>-<code> #include <spanclass="special"><boost<spanclass="special">/spirit<spanclass="special">/iterator<spanclass="special">/multi_pass<spanclass="special">.hpp<spanclass="special">>

- using namespace <spanclass="identifier">boost::<spanclass="identifier">spirit;- using namespace <spanclass="identifier">std;

- ifstream in<spanclass="special">("input_file.txt"<spanclass="special">); // we get our input fromthis file typedef char <spanclass="identifier">char_t;+ our input from the input stream using an istreambuf_iterator. 同样，跟着我们在扫描器一章中的例子。以下是一个使用 multi_pass 的例子：这次我们使用一个 istreambuf_iterator 从输入流中取出我们的输入。+<pre> #include <spanclass="special"><boost<spanclass="special">/spirit<spanclass="special">/core<spanclass="special">.hpp<spanclass="special">> <code>#include <<spanclass="identifier">boost/<spanclass="identifier">spirit/<spanclass="identifier">iterator/<spanclass="identifier">multi_pass.<spanclass="identifier">hpp><spanclass="comment">

+ using namespace <spanclass="identifier">boost::<spanclass="identifier">spirit; <spanclass="keyword">using namespace <spanclass="identifier">std;

+ ifstream in<spanclass="special">("input_file.txt"<spanclass="special">); // we get our input fromthis file 我们从这个文件中输入 <spanclass="keyword">typedef char <spanclass="identifier">char_t;typedef <spanclass="identifier">multi_pass<<spanclass="identifier">istreambuf_iterator<spanclass="special"><char_t<spanclass="special">> > <spanclass="identifier">iterator_t;

typedef <spanclass="identifier">skip_parser_iteration_policy<spanclass="special"><<spanclass="identifier">space_parser>iter_policy_t;

@@ -102,48 +116,51 @@

scanner_t scan<spanclass="special">(first,make_multi_pass(std::istreambuf_iterator<spanclass="special"><char_t<spanclass="special">>()),- policies<spanclass="special">);- rule_tn_list = <spanclass="identifier">real_p >>*(',' >>real_p<spanclass="special">); match<spanclass="special"><> m <spanclass="special">= n_list<spanclass="special">.parse<spanclass="special">(scan<spanclass="special">); </code></pre>+ policies<spanclass="special">); <spanclass="identifier">rule_t n_list =real_p <spanclass="special">>> *(',' <spanclass="special">>> real_p<spanclass="special">); match<spanclass="special"><> m <spanclass="special">= n_list<spanclass="special">.parse<spanclass="special">(scan<spanclass="special">); </code></pre>

 <a name="flush_multi_pass"></a>
 <h2>flush_multi_pass</h2>

 There is a predefined pseudo-parser called flush_multi_pass. When thisparseris used with multi_pass, it will call multi_pass::clear_queue(). Thiswill causeany buffered data to be erased. This also will invalidate all othercopies ofmulti_pass and they should not be used. If they are, anboost::illegal_backtracking

-  exception will be thrown.</p>

+ exception will be thrown. 有一个预定义的伪分析器，名为flush_multi_pass。当你将这个分析器用于 multi_pass 时，它将调用multi_pass::clear_queue()。这将导致所有缓冲数据被删除。同时令+ multi_pass 的所有其它拷贝失效并不能再使用。如果它们再被使用，将抛出一个boost::illegal_backtracking

+  异常。</p>
 <a name="multi_pass_policies"></a>
 <h2>multi_pass Policies</h2>

- multi_pass is a templated policy driven class. The description ofmulti_pass+multi_pass is a templated policy driven class. The description ofmulti_passabove is how it was originally implemented (before it used policies),and isthe default configuration now. But, multi_pass is capable of much more.Becauseof the open-ended nature of policies, you can write your own policy tomake

-  multi_pass behave in a way that we never before imagined.</p>
-<p> The multi_pass class has five template parameters:</p>

+ multi_pass behave in a way that we never before imagined. multi_pass是一个模板化的策略驱动类。以上对于 multi_pass+ 的说明是它原先是如何被实现的(在使用策略之前)，也是现在的缺省配置。但是，multi_pass 具有更多的能力。因为策略的 open-ended 特点，你可以编写你自己的策略来令

+  multi_pass 以我们从未想过的方式来工作。</p>

+ The multi_pass class has five template parameters: multi_pass 类有五个模板参数：

 <ul>

<li>InputT - The type multi_pass uses to acquire it's input. This istypically

-    an input iterator, or functor.</li>

+ an input iterator, or functor. InputT - multi_pass 用于获取输入的类型。典型是一个输入迭代器或仿函数。</li><li>InputPolicy - A class that defines how multi_pass acquires it'sinput. The

-    InputPolicy is parameterized by InputT.</li>

+ InputPolicy is parameterized by InputT. InputPolicy - 定义multi_pass 如何获取其输入的类。InputPolicy 按 InputT 参数化。</li><li>OwnershipPolicy - This policy determines how multi_pass deals withit's

-    shared components.</li>

+ shared components. OwnershipPolicy - 这个策略决定 multi_pass 如何处理它的共享组件。</li><li>CheckingPolicy - This policy determines how checking for invaliditerators

-    is done.</li>
+    is done.<br>CheckingPolicy - 这个策略决定如何检查无效迭代器。</li>

<li>StoragePolicy - The buffering scheme used by multi_pass isdetermined and

-    managed by the StoragePolicy.</li>

+ managed by the StoragePolicy. StoragePolicy - multi_pass 所使用的缓冲机制由 StoragePolicy 确定及管理。</li>

 </ul>
 <a name="predefined_policies"></a>
-<h2>Predefined policies</h2>

- All predefined multi_pass policies are in the namespaceboost::spirit::multi_pass_policies.

+<h2>Predefined policies 预定义策略</h2>

+ All predefined multi_pass policies are in the namespaceboost::spirit::multi_pass_policies. 所有预定义的 multi_pass 策略位于名字空间 boost::spirit::multi_pass_policies。

 <a name="predefined_inputpolicy_classes"></a>
-<h3>Predefined InputPolicy classes</h3>
+<h3>Predefined InputPolicy classes 预定义的InputPolicy类</h3>
 <a name="input_iterator"></a>
 <h4>input_iterator</h4>

- This policy directs multi_pass to read from an input iterator of typeInputT.+ This policy directs multi_pass to read from an input iterator of typeInputT. 这个策略指示 multi_pass 从一个类型为 InputT 的输入迭代器读入。

 <a name="lex_input"></a>
 <h4>lex_input</h4>

 This policy obtains it's input by calling yylex(), which wouldtypically beprovided by a scanner generated by LEX. If you use this policy your codemust

-  link against a LEX generated scanner.</p>

+ link against a LEX generated scanner. 这个策略通过调用 yylex() 获得其输入，该函数通常是由LEX所生成的扫描器提供的。如果你使用了该策略，则你的代码必须与某个LEX生成的扫描器相链接。

 <a name="functor_input"></a>
 <h4>functor_input</h4>

 This input policy obtains it's data by calling a functor of typeInputT. The

@@ -151,24 +168,31 @@

which should be the type returned from operator(). Also, since an inputpolicyneeds a way to determine when the end of input has been reached, thefunctormust contain a static variable named eof which is comparable to avariable of

-  result_type.</p>
+  result_type.<br>这

+种输入策略通过调用类型为 InputT 仿函数获得其数据。该仿函数必须满足某些要求。它必须有一个名为 result_type 的

+typedef，是从

+operator() 返回的类型。此外，由于输入策略需要一种方法来确定输入何时到达结尾，所以该仿函数必须包含一个名为 eof

+的静态变量，它应该可以与 result_type 变量相比较。</p>
 <a name="predefined_ownershippolicy_classes"></a>
-<h3>Predefined OwnershipPolicy classes</h3>
+<h3>Predefined OwnershipPolicy classes 预定义的所有权策略类</h3>
 <a name="ref_counted"></a>
 <h4>ref_counted</h4>

 This class uses a reference counting scheme. multi_pass will deleteit's shared

-  components when the count reaches zero.</p>

+ components when the count reaches zero. 这个类使用一个引用计数机制。multi_pass 将在该计数为零时删除其共享组件。

 <a name="first_owner"></a>
 <h4>first_owner</h4>

 When this policy is used, the first multi_pass created will be the onethatdeletes the shared data. Each copy will not take ownership of the shareddata.This works well for spirit, since no dynamic allocation of iterators isdone.- All copies are made on the stack, so the original iterator has thelongest lifespan.+ All copies are made on the stack, so the original iterator has thelongest lifespan. 使

+用这个策略时，第一个创建的 multi_pass&nbsp;将是负责删除共享数据的
+multi_pass。每个副本不会获取共享数据的所有权。这种方法在 spirit

+行之有效，因为没有迭代器的动态分配要做。所有副本都是基于堆栈，所以原来的迭代器具有最长的寿命。

 <a name="predefined_checkingpolicy_classes"></a>
-<h3>Predefined CheckingPolicy classes</h3>
+<h3>Predefined CheckingPolicy classes 预定义的检查策略类</h3>
 <a name="no_check"></a>
 <h4>no_check</h4>
-<p> This policy does no checking at all.</p>
+<p> This policy does no checking at all.<br>该策略不进行检查。</p>
 <a name="buf_id_check"></a>
 <h4>buf_id_check</h4>

 buf_id_check keeps around a buffer id, or a buffer age. Every timeclear_queue()

@@ -178,19 +202,21 @@

of the iterator matches the shared buffer id. This policy is mosteffectivewhen used together with the std_deque StoragePolicy. It should not beused withthe fixed_size_queue StoragePolicy, because it will not detect iteratordereferences

-  that are out of range.</p>

+ that are out of range. buf_id_check 保持一个缓冲区 id，或一个缓冲区寿命。每次对一个 multi_pass 迭代器调用 clear_queue()，有可能所有其它的迭代器都变为无效。在调用 clear_queue() 时，buf_id_check 递增该缓冲区

+  id。当一个迭代器被提领时，该策略检查该迭代器的缓冲区 id

+ 是否与共享缓冲区 id 相匹配。在与 std_deque 存储策略一起使用时，该策略是最高效的。但它不能与 fixed_size_queue 存储策略共用，因为它不检查迭代器的提领是否超界。

 <a name="full_check"></a>
 <h4>full_check</h4>

 This policy has not been implemented yet. When it is, it will keeptrack of

-  all iterators and make sure that they are all valid.</p>

+ all iterators and make sure that they are all valid. 这个策略还未实现。当它实现时，它会跟踪所有迭代器，并确保他们都是有效的。

 <a name="predefined_storagepolicy_classes"></a>
-<h3>Predefined StoragePolicy classes</h3>
+<h3>Predefined StoragePolicy classes 预定义的存储策略类</h3>
 <a name="std_deque"></a>
 <h4>std_deque</h4>

 This policy keeps all buffered data in a std::deque. All data isstored aslong as there is more than one iterator. Once the iterator count goesdown toone, and the queue is no longer needed, it is cleared, freeing upmemory. The- queue can also be forcibly cleared by callingmulti_pass::clear_queue().+ queue can also be forcibly cleared by callingmulti_pass::clear_queue(). 这个策略将所有缓冲数据保存在一个 std::deque中。只要有一个以上的迭代器，所有数据都要保存。一旦迭代器计数下降为一，这个队列就不再需要了，它将被清除并释放内存。该队列也可以通过调用multi_pass::clear_queue() 强行清除。

 <a name="fixed_size_queue_lt_n_gt_"></a>
 <h4>fixed_size_queue&lt;N&gt;</h4>

 fixed_size_queue keeps a circular buffer that is size N+1 and stores Nelements.

@@ -201,60 +227,80 @@

iterator is trailing too far behind and has become invalid. No dynamicallocationis done by this policy during normal iterator operation, only on initialconstruction.The memory usage of this StoragePolicy is set at N+1 bytes, unlikestd_deque,

-  which is unbounded.</p>
+  which is unbounded.<br>fixed_size_queue

+保持一个大小这 N+1 的循环缓冲区，保存 N 个元素。fixed_size_queue 是一个模板，有一个 std::size_t

+参数用于指定队列大小。你要负责确保 N

+对于你的分析器足够大。当最前的迭代器被递增时，缓冲区的最后字符将被自动删除。当前没有办法得知一个迭代器是否落后得太多而变为无效。在普通的迭代器操+作期间，该策略没有动态分配，除了在初始化构造期间。这个存储策略的内存开销被设定为 N+1 字节，不象 std_deque 那样是无界的。

 <a name="combinations__how_to_specify_your_own_custom_multi_pass"></a>
-<h2>Combinations: How to specify your own custom multi_pass</h2>

+<h2>Combinations: How to specify your own custom multi_pass 组合：如何指定你自己的multi_pass</h2> The beauty of policy based designs is that you can mix and matchpoliciesto create your own custom class by selecting the policies you want.Here's anexample of how to specify a custom multi_pass that wraps anistream_iterator<char>,and is slightly more efficient than the default because it uses thefirst_owner

-  OwnershipPolicy and the no_check CheckingPolicy:</p>
+  OwnershipPolicy and the no_check CheckingPolicy:<br>基

+于策略的设计的好处在于，你可以混合及匹配不同的策略，通过选择你想要的策略来创建你自己的定制策略。以下是一个关于如何指定一个定制+multi_pass 的例子，它封装了一个 istream_iterator<char>，而且比缺省的要高效一点，因为它使用了

+first_owner 所有权策略和 no_check 检查策略：</p>

<pre> <code>typedef <spanclass="identifier">multi_pass< istream_iterator<spanclass="special"><char<spanclass="special">>, <spanclass="identifier">multi_pass_policies<spanclass="special">::<spanclass="identifier">input_iterator, multi_pass_policies<spanclass="special">::first_owner<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::no_check<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::std_deque > <spanclass="identifier">first_owner_multi_pass_t<spanclass="special">; </code></pre> The default template parameters for multi_pass are: input_iteratorInputPolicy,ref_counted OwnershipPolicy, buf_id_check CheckingPolicy and std_dequeStoragePolicy.So if you use multi_pass<istream_iterator<char> > you willget those

-  pre-defined behaviors while wrapping an istream_iterator&lt;char&gt;.</p>

+ pre-defined behaviors while wrapping anistream_iterator<char>. multi_pass+的缺省模板参数是：input_iterator 输入策略，ref_counted 所有权策略，buf_id_check 检查策略和+std_deque 存储策略。所以，如果你使用multi_pass<istream_iterator<char>+>，那么你将得到一个具有以上预定义行为的封装istream_iterator<char>。 There is one other pre-defined class called look_ahead. look_ahead hastwotemplate parameters: InputT, the type of the input iterator to wrap, anda std::size_tN, which specifies the size of the buffer to the fixed_size_queuepolicy. Whilethe default multi_pass configuration is designed for safey, look_aheadis designedfor speed. look_ahead is derived from a multi_pass with the followingpolicies:input_iterator InputPolicy, first_owner OwnershipPolicy, no_checkCheckingPolicy,

-  and fixed_size_queue&lt;N&gt; StoragePolicy.</p>
+  and fixed_size_queue&lt;N&gt; StoragePolicy.<br>还

+有一个名为 look_ahead 的预定义类。look_ahead 有两个模板参数：InputT 是要封装的输入迭代器的类型，以及一个+std::size_t N 用于指定 fixed_size_queue 策略所用的缓冲区的大小。缺省的multi_pass+配置是为安全而设计的，而 look_ahead 则是为速度而设计的。look_ahead 派生自带有以下策略的+multi_pass：input_iterator 输入策略，first_owner 所有权策略，no_check 检查策略和

+fixed_size_queue&lt;N&gt; 存储策略。</p>

<aname="how_to_write_a_functor_for_use_with_the_functor_input_inputpolicy"></a>

-<h3>How to write a functor for use with the functor_input InputPolicy</h3>

+<h3>How to write a functor for use with the functor_input InputPolicy 如何编写一个与functor_input输入策略共用的仿函数</h3> If you want to use the functor_input InputPolicy, you can write yourown functorthat will supply the input to multi_pass. The functor must satisfy tworequirements.It must have a typedef result_type which specifies the return type ofoperator().This is standard practice in the STL. Also, it must supply a staticvariablecalled eof which is compared against to know whether the input hasreached the

-  end. Here is an example:</p>
+  end. Here is an example:<br>如
+果你想使用 functor_input 输入策略，你可以编写你自己的仿函数向 multi_pass

+提供输入。该仿函数必须满足两个条件。它必须有一个 typedef result_type 用于指定 operator()+的返回类型。这是STL中的标准实践。另外，它必须提供一个名为 eof 的静态变量用于比较以获知输入是否已到结尾。以下是一个例子：<pre> <code>class <spanclass="identifier">my_functor { public<spanclass="special">: typedef charresult_type<spanclass="special">; <spanclass="identifier">my_functor() :c(<spanclass="literal">'A') {} char operator()()const <spanclass="special">{ if(c== <spanclass="literal">'M') return <spanclass="identifier">eof; else return <spanclass="identifier">c++; } static <spanclass="identifier">result_type eof; private<spanclass="special">: charc; }; my_functor<spanclass="special">::result_typemy_functor::<spanclass="identifier">eof = <spanclass="literal">'\0'; <spanclass="keyword">typedef <spanclass="identifier">multi_pass< my_functor<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::functor_input<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::first_owner<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::no_check<spanclass="special">, <spanclass="identifier">multi_pass_policies<spanclass="special">::std_deque > <spanclass="identifier">functor_multi_pass_t<spanclass="special">; <spanclass="identifier">functor_multi_pass_t first <spanclass="special">= <spanclass="identifier">functor_multi_pass_t<spanclass="special">(my_functor<spanclass="special">()); <spanclass="identifier">functor_multi_pass_t last<spanclass="special">; </code></pre>

 <a name="how_to_write_policies_for_use_with_multi_pass"></a>
-<h3>How to write policies for use with multi_pass</h3>

+<h3>How to write policies for use with multi_pass 如何编写用于multi_pass的策略</h3>

 <a name="inputpolicy"></a>
-<h4>InputPolicy</h4>
-<p> An InputPolicy must have the following interface:</p>

-<pre> <code>class <spanclass="identifier">my_input_policy // yourpolicy name { <spanclass="keyword">public: // class inner will be instantiated with thetype given // as the InputT parameter to multi_pass. template <spanclass="special"><typename <spanclass="identifier">InputT> class <spanclass="identifier">inner <spanclass="special">{ <spanclass="keyword">public: // these typedefs determine theiterator_traits for multi_pass <spanclass="keyword">typedef x <spanclass="identifier">value_type; typedef xdifference_type<spanclass="special">; typedefx <spanclass="identifier">pointer; typedef xreference<spanclass="special">; <spanclass="keyword">protected: inner<spanclass="special">(); <spanclass="identifier">inner(<spanclass="identifier">InputT x<spanclass="special">); <spanclass="identifier">inner(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">); // delete orclean up any state voiddestroy<spanclass="special">(); // returntrue if *this and x have the same input <spanclass="keyword">bool same_input<spanclass="special">(inner <spanclass="keyword">const& <spanclass="identifier">x) <spanclass="keyword">const; void <spanclass="identifier">swap(<spanclass="identifier">inner& <spanclass="identifier">x); public<spanclass="special">: // get aninstance from the input <spanclass="identifier">result_type <spanclass="identifier">get_input() <spanclass="keyword">const; // advance the input void <spanclass="identifier">advance_input<spanclass="special">(); // returntrue if the input is at the end <spanclass="keyword">bool <spanclass="identifier">input_at_eof() <spanclass="keyword">const; <spanclass="special">}; <spanclass="special">}; </code></pre>

+<h4>InputPolicy 输入策略</h4>

+ An InputPolicy must have the following interface: 输入策略必须具有以下接口：+<pre> <code>class <spanclass="identifier">my_input_policy // yourpolicy name 你的策略名 { public<spanclass="special">: // class innerwill be instantiated with the type given // as the InputT parameterto multi_pass. // 类inner以给定为multi_pass的InputT参数的类型进行实例化 template <spanclass="special"><typename <spanclass="identifier">InputT> class <spanclass="identifier">inner <spanclass="special">{ <spanclass="keyword">public: // these typedefs determine theiterator_traits for multi_pass // 以下typedef决定multi_pass的iterator_traits <spanclass="keyword">typedef x <spanclass="identifier">value_type; typedef xdifference_type<spanclass="special">; typedefx <spanclass="identifier">pointer; typedef xreference<spanclass="special">; <spanclass="keyword">protected: inner<spanclass="special">(); <spanclass="identifier">inner(<spanclass="identifier">InputT x<spanclass="special">); <spanclass="identifier">inner(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">); // delete orclean up any state 删除或清除所有状态 <spanclass="keyword">void destroy<spanclass="special">(); // returntrue if *this and x have the same input 如果*this和x具有相同输入则返回true bool <spanclass="identifier">same_input(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">) const<spanclass="special">; voidswap<spanclass="special">(inner<spanclass="special">& x<spanclass="special">); <spanclass="keyword">public: // get an instance from the input 从输入取出一个实例 result_typeget_input()const<spanclass="special">; // advancethe input 步进输入 voidadvance_input<spanclass="special">(); // returntrue if the input is at the end 如果输入到尾则返回true bool <spanclass="identifier">input_at_eof() <spanclass="keyword">const; <spanclass="special">}; <spanclass="special">}; </code></pre> Because of the way that multi_pass shares a buffer and input amongmultiplecopies, class inner should keep a pointer to it's input. The copyconstructorshould simply copy the pointer. destroy() should delete it. same_inputshouldcompare the pointers. For more details see the various implementationsof InputPolicy

-  classes.</p>
+  classes.<br>由

+于 multi_pass 共享一个缓冲区并输入多份拷贝的方式，类 inner 应持有指向其输入的指针。复制构造函数只需复制该指针。而+destroy() 则 delete 它。 same_input 应比较这些指针。更多的细节请见InputPolicy 类的各个实现。

 <a name="ownershippolicy"></a>
-<h4>OwnershipPolicy</h4>
-<p> The OwnershipPolicy must have the following interface:</p>

-<pre> <code>class <spanclass="identifier">my_ownership_policy <spanclass="special">{ protected<spanclass="special">: <spanclass="identifier">my_ownership_policy<spanclass="special">(); <spanclass="identifier">my_ownership_policy<spanclass="special">(my_ownership_policyconst&x); // clone is called when a copy of the iteratoris made void <spanclass="identifier">clone(); // called when a copy is deleted. Return trueto indicate // resources should be released bool <spanclass="identifier">release(); void <spanclass="identifier">swap(<spanclass="identifier">my_ownership_policy&x); public<spanclass="special">: // returns trueif there is only one iterator in existence. // std_dequeueStoragePolicy will free it's buffered data if this // returnstrue. bool <spanclass="identifier">unique() <spanclass="keyword">const; <spanclass="special">}; </code></pre>

+<h4>OwnershipPolicy 所有权策略</h4>

+ The OwnershipPolicy must have the following interface: 所有权策略必须具有以下接口：+<pre> <code>class <spanclass="identifier">my_ownership_policy <spanclass="special">{ protected<spanclass="special">: <spanclass="identifier">my_ownership_policy<spanclass="special">(); <spanclass="identifier">my_ownership_policy<spanclass="special">(my_ownership_policyconst&x); // clone is called when a copy of the iteratoris made 复制迭代器时调用clone voidclone<spanclass="special">(); // called whena copy is deleted. Return true to indicate // resources shouldbe released // 删除一个拷贝时调用。返回true表示资源应被释放 bool <spanclass="identifier">release(); void <spanclass="identifier">swap(<spanclass="identifier">my_ownership_policy&x); public<spanclass="special">: // returns trueif there is only one iterator in existence. // std_dequeueStoragePolicy will free it's buffered data if this // returnstrue. // 如果只有一个迭代器存在则返回true。如果返回true则std_dequeue存储策略将释放期缓冲数据 <spanclass="keyword">bool unique<spanclass="special">() const<spanclass="special">; <spanclass="special">}; </code></pre>

 <a name="checkingpolicy"></a>
-<h4>CheckingPolicy</h4>
-<p> The CheckingPolicy must have the following interface:</p>

-<pre> <code>class <spanclass="identifier">my_check { protected<spanclass="special">: <spanclass="identifier">my_check(); my_check<spanclass="special">(my_check <spanclass="keyword">const& <spanclass="identifier">x); <spanclass="keyword">void destroy<spanclass="special">(); voidswap<spanclass="special">(my_check<spanclass="special">& x<spanclass="special">); // check shouldmake sure that this iterator is valid <spanclass="keyword">void check<spanclass="special">() const<spanclass="special">; void <spanclass="identifier">clear_queue(); }; </code></pre>

+<h4>CheckingPolicy 检查策略</h4>

+ The CheckingPolicy must have the following interface: 检查策略必须具有以下接口：+<pre> <code>class <spanclass="identifier">my_check { protected<spanclass="special">: <spanclass="identifier">my_check(); my_check<spanclass="special">(my_check <spanclass="keyword">const& <spanclass="identifier">x); <spanclass="keyword">void destroy<spanclass="special">(); voidswap<spanclass="special">(my_check<spanclass="special">& x<spanclass="special">); // check shouldmake sure that this iterator is valid 检查以确认该迭代器有效 void <spanclass="identifier">check() <spanclass="keyword">const; <spanclass="keyword">void <spanclass="identifier">clear_queue(); }; </code></pre>

 <a name="storagepolicy"></a>
-<h4>StoragePolicy</h4>
-<p> A StoragePolicy must have the following interface:</p>

-<pre> <code>class <spanclass="identifier">my_storage_policy <spanclass="special">{ public<spanclass="special">: // class innerwill be instantiated with the value_type from theInputPolicy template<typenameValueT<spanclass="special">> classinner <spanclass="special">{ <spanclass="keyword">protected: inner<spanclass="special">(); <spanclass="identifier">inner(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">); // will becalled from the destructor of the last iterator. void <spanclass="identifier">destroy(); void <spanclass="identifier">swap(<spanclass="identifier">inner& <spanclass="identifier">x); // This is called when the iterator isdereferenced. It's a template // method so we can recoverthe type of the multi_pass iterator // and accessit. template <spanclass="special"><typename <spanclass="identifier">MultiPassT<spanclass="special">> staticValueT <spanclass="identifier">dereference(<spanclass="identifier">MultiPassT <spanclass="keyword">const& <spanclass="identifier">mp); // This is called when the iterator isincremented. It's a template // method so we can recover thetype of the multi_pass iterator // and accessit. template <spanclass="special"><typename <spanclass="identifier">MultiPassT<spanclass="special">> staticvoid <spanclass="identifier">increment(<spanclass="identifier">MultiPassT&mp<spanclass="special">); voidclear_queue<spanclass="special">(); // calledto determine whether the iterator is an eof iterator template <spanclass="special"><typename <spanclass="identifier">MultiPassT<spanclass="special">> staticbool <spanclass="identifier">is_eof(<spanclass="identifier">MultiPassT <spanclass="keyword">const& <spanclass="identifier">mp); // called by operator== bool <spanclass="identifier">equal_to(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">) const<spanclass="special">; // called byoperator< bool <spanclass="identifier">less_than(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">) const<spanclass="special">; }; <spanclass="comment"> // class inner <spanclass="special">}; </code></pre>

+<h4>StoragePolicy 存储策略</h4>

+ A StoragePolicy must have the following interface: 存储策略必须具有以下接口：+<pre> <code>class <spanclass="identifier">my_storage_policy <spanclass="special">{ public<spanclass="special">: // class innerwill be instantiated with the value_type from the InputPolicy // 类inner将以输入策略的value_type来实例化 <spanclass="keyword">template <<spanclass="keyword">typename ValueT<spanclass="special">> classinner <spanclass="special">{ <spanclass="keyword">protected: inner<spanclass="special">(); <spanclass="identifier">inner(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">); // will becalled from the destructor of the last iterator. 从最后一个迭代器的析构函数调用。 void <spanclass="identifier">destroy(); void <spanclass="identifier">swap(<spanclass="identifier">inner& <spanclass="identifier">x); // This is called when the iterator isdereferenced. It's a template // method so we can recoverthe type of the multi_pass iterator // and accessit. // 在迭代器被提领时调用。它是一个模板方法，我们可以找回multi_pass迭代器的类型并访问它。 <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">MultiPassT<spanclass="special">> staticValueT <spanclass="identifier">dereference(<spanclass="identifier">MultiPassT <spanclass="keyword">const& <spanclass="identifier">mp); // This is called when the iterator isincremented. It's a template // method so we can recover thetype of the multi_pass iterator // and accessit. // 在迭代器</code><code>被递增时调用。它是一个模板方法，我们可以找回multi_pass迭代器的类型并访问它。</code><code> <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">MultiPassT<spanclass="special">> staticvoid <spanclass="identifier">increment(<spanclass="identifier">MultiPassT&mp<spanclass="special">); voidclear_queue<spanclass="special">(); // calledto determine whether the iterator is an eof iterator 调用以确定迭代器是否eof template <spanclass="special"><typename <spanclass="identifier">MultiPassT<spanclass="special">> staticbool <spanclass="identifier">is_eof(<spanclass="identifier">MultiPassT <spanclass="keyword">const& <spanclass="identifier">mp); // called by operator== 由operator==调用 bool <spanclass="identifier">equal_to(<spanclass="identifier">inner const<spanclass="special">& x<spanclass="special">) const<spanclass="special">; // called byoperator< 由operator<调用 <spanclass="keyword">bool less_than<spanclass="special">(inner <spanclass="keyword">const& <spanclass="identifier">x) <spanclass="keyword">const; <spanclass="special">}; // class inner }; </code></pre> A StoragePolicy is the trickiest policy to write. You should study andunderstand

-  the existing StoragePolicy classes before you try and write your own.</p>

+ the existing StoragePolicy classes before you try and write yourown. 存储策略是最难编写的策略。你应该在尝试编写你自己的存储策略之前，认真学习和弄明白已有的存储策略类。

 <table border="0">
   <tbody><tr>
     <td width="10"><br>
@@ -266,7 +312,7 @@
 </tbody></table>
 <br>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2001-2002 Daniel C. Nuffer<br>
+<p class="copyright">Copyright © 2001-2002 Daniel C. Nuffer<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
=======================================
--- /trunk/libs/spirit/classic/doc/portability.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/portability.html     Mon Oct 12 20:27:43 2009
@@ -1,48 +1,55 @@
-<html>
-<head>
-<title>Portability</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>Portability</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%"> Portability</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%"> Portability 可移植性</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="includes.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="style_guide.html"><img src="theme/r_arr.gif"border="0"></a></td>

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

Historically, Spirit supported a lot of compilers, including (to someextent)poorly conforming compilers such as VC6. Spirit v1.6.x will be the lastreleasethat will support older poorly conforming compilers. Starting fromSpirit v1.8.0,ill conforming compilers will not be supported. If you are still usingone of

-  these older compilers, you can still use Spirit v1.6.x.</p>
+  these older compilers, you can still use Spirit v1.6.x.<br>从

+历史上看，Spirit支持的编译器很多，包括（在某种程度上）对标准符合度较差的编译器，如VC6。Spirit

+v1.6.x将是最后一个支持标准符合度差的编译器的版本。从Spirit

+v1.8.0起，将不再支持标准符合度差的编译器。如果您仍在使用这些旧的编译器之一，您仍然可以使用Spirit v1.6.x.The reason why Spirit v1.6.x worked on old non-conforming compilers isthatthe authors laboriously took the trouble of searching for workarounds tomakethese compilers happy. The process takes a lot of time and energy,especially- when one encounters the dreaded ICE or "Internal CompilerError".

+  when one encounters the dreaded ICE or "Internal Compiler Error".

Sometimes searching for a single workaround takes days or even weeks.Sometimes,there are no known workarounds. This stifles progress a lot. And, as thelibrarygets more progressive and takes on more advanced C++ techniques, thedifficulty

-  is escalated to even new heights.</p>
+  is escalated to even new heights.<br>Spirit

+v1.6.x能与不符合标准的编译器一起工作的原因是，作者很辛苦地寻找解决方法来使这些编译器接受。这个过程需要大量的时间和精力，尤其是当遇到可怕的+ICE或“内部编译器错误”时。有时为了一个解决办法寻找需要几天甚至几个星期。有时候甚至没有可变通的办法。这扼杀许多进步。此外，由于本库的进一步发

+展以及更先进的C++技术的需要，这种困难升级到了新的高度。</p>

Spirit v1.6.x will still be supported. Maintenance will still happenand bugfixes will still be applied. There will still be active development fortheback-porting of new features introduced in Spirit v1.8.0 (and Spirit1.9.0)to lesser able compilers; hopefully, fueled by contributions from thecommunity.We welcome active support from the C++ community, especially those withspecial

-  expertise on compilers such as older Borland and MSVC++ compilers.</p>

-Spirit 1.8 has been tested to compile and run properly on thesecompilers:+ expertise on compilers such as older Borland and MSVC++compilers. Spirit+v1.6.x仍然会得到支持。维护仍然会继续，漏洞修补仍然适用。仍然会有积极发展的Spirit v1.8.0（以及Spirit+1.9.0）中引入的新功能向后移植至能力较差的编译器；我们希望并得到了来自社会各界的捐款。我们欢迎C++社区的积极支持，尤其是在那些老的

+Borland和MSVC等C++编译器方面有特殊专长的。</p>

+Spirit 1.8 has been tested to compile and run properly on thesecompilers: Spirit 1.8 已在以下编译器上通过测试并正确运行：

 <ol>
   <li>g++ 3.1 and above</li>
   <li>Comeau 4.24.5 </li>
@@ -53,22 +60,21 @@

as it is or with minimal portability fixes here and there. Please informusif your compiler is known to be ISO/ANSI conforming and is not in thislistabove. Feel free to post feedback to <ahref="https://lists.sourceforge.net/lists/listinfo/spirit-general";>Spirit-general

-  mailing list</a> [Spirit-general@xxxxxxxxxxxxxxxxxxxxx].</p>

+ mailing list</a> [Spirit-general@xxxxxxxxxxxxxxxxxxxxx]. 如果你的编译器充分地符合标准，你就有机会只需要在这里或那里做最少的移植修改，就可以编译Spirit。如果你的编译器已知是符合ISO/ANSI标准而没有在上面列出，请通知我们。请随时将反馈发送到 <ahref="https://lists.sourceforge.net/lists/listinfo/spirit-general";>Spirit-通用邮件列表</a> [Spirit-general@xxxxxxxxxxxxxxxxxxxxx]。

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

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

Use, modification and distribution is subject to theBoost Software

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

--- /trunk/libs/spirit/classic/doc/position_iterator.html Tue Mar 3101:07:16 2009+++ /trunk/libs/spirit/classic/doc/position_iterator.html Mon Oct 1220:27:43 2009

@@ -1,119 +1,106 @@
-<html>
-<head>
-<title>Position Iterator</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>Position Iterator</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%"> Position

-      Iterator</b></font> </td>

+      Iterator 位置迭代器</b></font> </td>

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

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

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

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

Often, when writing a parser that is able to detect errors in theformat ofthe input stream, we want it to communicate to the user where the errorhappenedwithin that input. The classic example is when writing a compiler orinterpreterthat detects syntactical errors in the parsed program, indicating theline number- and maybe even the position within the line where the error wasfound.+ and maybe even the position within the line where the error wasfound. 通常，在编写一个可以检测输入流的格式错误的分析器时，我们会希望它可以告知用户，错误发生于输入的何处。典型的例子是，在编写一个编译器或解释器，检测到被分析程序中的语法错误时，可以指出错误发生的行号甚至在行中的位置。 The class position_iterator is a tool provided within Spirit thatallows parserwriters to easily implement this functionality. The concept is quitesimple:this class is an iterator wrapper that keeps track of the currentposition withinthe file, including current file, line and column. It requires a singletemplate- parameter, which should be the type of the iterator that is to bewrapped.

-<p> To use it, you'll need to add the following include:</p>
-<pre>

-<p> Or include all the iterators in Spirit:</p>
-<pre>

- <code>#include <spanclass=special><boost<spanclass=special>/spirit<spanclass=special>/iterator<spanclass=special>.hpp<spanclass=special>></code></pre>+ parameter, which should be the type of the iterator that is to bewrapped. 类 position_iterator 是Spirit内部提供的一个工具，它允许分析器作者可以很轻易地实现以上功能。这个概念很简单：这个类是一个迭代器包装，它跟踪文件中的当前位置，包含当前文件、行号和列数。它要求单个模板参数，即被封装的迭代器类型。+ To use it, you'll need to add the following include: 要使用它，你需要添加以下头文件：+<pre> <code>#include <spanclass="special"><boost<spanclass="special">/spirit<spanclass="special">/iterator<spanclass="special">/<spanclass="identifier">position_iterator<spanclass="special">.hpp<spanclass="special">></code></pre>+ Or include all the iterators in Spirit: 或包含Spirit的所有迭代器：+<pre> <code>#include <spanclass="special"><boost<spanclass="special">/spirit<spanclass="special">/iterator<spanclass="special">.hpp<spanclass="special">></code></pre> To construct the wrapper, it needs both the begin and end iterators oftheinput sequence, and the file name of the input sequence. Optionally, youcanalso specify the starting line and column numbers, which default to 1.Defaultconstruction, with no parameters, creates a generic end-of-sequenceiterator,in a similar manner as it's done in the stream operators of the standardC++

-  library.</p>

+ library. 为了构造该包装，它需要输入序列的 begin 和 end 迭代器，以及输入序列的文件名。可选地，你也可以指定开始行号和列数，它们缺省为1。不带参数的缺省构造将创建一个泛型的序列结束迭代器，这与标准C++库的流操作符中的方法类似。 The wrapped iterator must belong to the input or forward iteratorcategory,

-  and the position_iterator just inherits that category.</p>

+ and the position_iterator just inherits that category. 被封装的迭代器必须属于输入迭代器或前向迭代器种类，且 position_iterator 只是继承其种类。 For example, to create begin and end positional iterators from aninput C-

-  string, you'd use:</p>
-<pre>

- <code>char <spanclass=keyword>const* <spanclass=identifier>inputstring = <spanclass=string>"...";- typedef <spanclass=identifier>position_iterator<spanclass=special><char <spanclass=keyword>const*> <spanclass=identifier>iterator_t;

- iterator_t <spanclass=identifier>begin(<spanclass=identifier>inputstring, <spanclass=identifier>inputstring+<spanclass=identifier>strlen(<spanclass=identifier>inputstring));- iterator_t <spanclass=identifier>end;</code></pre>+ string, you'd use: 例如，从一个输入的C字符串创建 begin 和 end 位置迭代器，你要用：+<pre> <code>char <spanclass="keyword">const* <spanclass="identifier">inputstring = <spanclass="string">"..."; <spanclass="keyword">typedef <spanclass="identifier">position_iterator<spanclass="special"><char <spanclass="keyword">const*> <spanclass="identifier">iterator_t; iterator_t <spanclass="identifier">begin(<spanclass="identifier">inputstring, <spanclass="identifier">inputstring+<spanclass="identifier">strlen(<spanclass="identifier">inputstring)); iterator_t <spanclass="identifier">end;</code></pre>

 <a name="operations"></a>
-<h2>Operations</h2>
-<pre>

- <code>void <spanclass=identifier>set_position(<spanclass=identifier>file_position const<spanclass=special>&);</code></pre>

+<h2>Operations 操作</h2>

+<pre> <code>void <spanclass="identifier">set_position(<spanclass="identifier">file_position <spanclass="keyword">const<spanclass="special">&);</code></pre> Call this function when you need to change the current position storedinthe iterator. For example, if parsing C-style #include directives, theincludedfile's input must be marked by restarting the file and column to 1 and 1and

-  the name to the new file's name.<br>

+ the name to the new file's name. 当你需要改变保存在迭代器中的位置时，调用这个函数。例如，如果要分析C风格的 #include 指示符，被包含的文件必须被标记为重新开始一个文件，且行号、列数为1，文件名为新的文件名。 

 </p>
-<pre>

- <code>file_position <spanclass=keyword>const& <spanclass=identifier>get_position() <spanclass=keyword>const;</code></pre>

-<p> Call this function to retrieve the current position.</p>
-<pre>

- <code>void <spanclass=identifier>set_tabchars(<spanclass=keyword>int);</code></pre>+<pre> <code>file_position <spanclass="keyword">const& <spanclass="identifier">get_position() <spanclass="keyword">const;</code></pre>+ Call this function to retrieve the current position. 调用该函数以取出当前位置。+<pre> <code>void <spanclass="identifier">set_tabchars(<spanclass="keyword">int);</code></pre> Call this to set the number of tabs per character. This value isnecessary

-  to correctly track the column number.<br>

+ to correctly track the column number. 调用此函数以设置制表符的字符数量。该值对于正确跟踪列数是必需的。 

 </p>
 <p> <a name="file_position"></a> </p>
 <h2>file_position</h2>

 file_position is a structure that holds the position within a file.Its fields

-  are:</p>
-<table width="90%" border="0" align="center">
-  <tr>
+  are:<br>file_position 是一个保存了文件内部位置的结构。它的字段有：</p>
+<table align="center" border="0" width="90%">
+  <tbody><tr>
     <td class="table_title" colspan="2">file_position fields</td>
   </tr>
   <tr>

- <td class="table_cells" width="26%"><code><spanclass=identifier>std::<spanclass=identifier>string- file<spanclass=special>;</code></td>- <td class="table_cells" width="74%">Name of the file. Hopefully a fullpathname</td>+ <td class="table_cells" width="26%"><code><spanclass="identifier">std::<spanclass="identifier">string+ file<spanclass="special">;</code></td>+ <td class="table_cells" width="74%">Name of the file. Hopefully a fullpathname 文件名。希望是全路径名</td>

   </tr>
   <tr>

- <td class="table_cells" width="26%"><code><spanclass=keyword>int

-      line</span><span class=special>;</span></code></td>

+ <td class="table_cells" width="26%"><code><spanclass="keyword">int

+      line</span><span class="special">;</span></code></td>

<td class="table_cells" width="74%">Line number within the file. Bydefault,

-      the first line is number 1</td>

+ the first line is number 1 文件内的行号。缺省地，第一行行号为1</td>

   </tr>
   <tr>

- <td class="table_cells" width="26%"><code>intcolumn<spanclass=special>;</code></td>+ <td class="table_cells" width="26%"><code>intcolumn<spanclass="special">;</code></td><td class="table_cells" width="74%">Column position within the file.The first

-      column is 1</td>
+      column is 1<br>文件内的列位置。第一列为1</td>
   </tr>
-</table>

-<img src="theme/lens.gif" width="15" height="16"> See <ahref="../example/fundamental/position_iterator/position_iterator.cpp">position_iterator.cpp</a>for a compilable example. This is part of the Spirit distribution.

+</tbody></table>

+<img src="theme/lens.gif" height="16" width="15"> See <ahref="../example/fundamental/position_iterator/position_iterator.cpp">position_iterator.cpp</a>for a compilable example. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 可编译的例子请见 <ahref="../example/fundamental/position_iterator/position_iterator.cpp">position_iterator.cpp</a>。这是Spirit发布包的一部分。

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

   </tr>
-</table>
+</tbody></table>
 <hr size="1">
-<p class="copyright">Copyright &copy; 2002 Juan Carlos Arevalo-Baeza<br>
+<p class="copyright">Copyright © 2002 Juan Carlos Arevalo-Baeza<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>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/quickref.html        Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/quickref.html        Mon Oct 12 20:27:43 2009
@@ -1,253 +1,249 @@
-<html>
-
-<head>
-<title>Quick Reference</title>
-<link rel="stylesheet" href="theme/style.css" type="text/css">
-</head>
-
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

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

+<title>Quick Reference</title><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%"> Quick

-      Reference </b></font></td>

+      Reference 快速参考 </b></font></td>

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

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

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

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

This isn't intended to be a full, detailed reference; nor is itintended tobe of any use to readers who aren't already familiar with Spirit. It'sjusta brief reminder of the syntax and behaviour of each component, withlinks to

-  the full documentation. </p>

+ the full documentation. 本章的目的不是给出一个完整、详尽的参考手册；也不是给那些对Spirit还不熟悉的读者使用的。它只是对语法及各个组件行为的简要提醒，以及到完整文档的链接。 

 <ul>

<li>Primitive parser generators (action argumentsare listed

-    on the right)</i>

+ on the right) 基本分析器生成器(动作参数在右侧列出)

     <ul>
-      <li><a href="quickref.html#null_parsers">Null parsers</a></li>

- <li><a href="quickref.html#character_parsers">Characterparsers</a></li>

-      <li><a href="quickref.html#number_parsers">Number parsers</a></li>

- <li><a href="quickref.html#otherlexeme_parsers">Other lexemeparsers</a></li>

-      <li><a href="quickref.html#text_parsers">Text parsers</a><br>

+ <li><a href="quickref.html#null_parsers">Null parsers 空分析器</a></li>+ <li><a href="quickref.html#character_parsers">Character parsers 字符分析器</a></li>+ <li><a href="quickref.html#number_parsers">Number parsers 数字分析器</a></li>+ <li><a href="quickref.html#otherlexeme_parsers">Other lexeme parsers其它词位分析器</a></li>+ <li><a href="quickref.html#text_parsers">Text parsers 文本分析器</a> 

         <br>
       </li>
     </ul>
   </li>
-  <li><strong>Other parser elements</strong>
+  <li><strong>Other parser elements 其它分析器元素</strong>
     <ul>

- <li><a href="quickref.html#compound_parsers">Compoundparsers</a></li>- <li><a href="quickref.html#general_directives">Generaldirectives</a></li>- <li><a href="quickref.html#tree_specific_directives">Tree-specificdirectives</a> + <li><a href="quickref.html#compound_parsers">Compound parsers 复合分析器</a></li>+ <li><a href="quickref.html#general_directives">General directives 通用指示符</a></li>+ <li><a href="quickref.html#tree_specific_directives">Tree-specificdirectives 树专用的指示符</a> 

         <br>
       </li>
     </ul>
   </li>
-  <li><strong>Operators</strong>
+  <li><strong>Operators 操作符</strong>
     <ul>
-      <li><a href="quickref.html#unary_operators">Unary operators</a></li>

- <li><a href="quickref.html#binary_operators">Binary operators</a>(in order of precedence) 

-        </i></li>

+ <li><a href="quickref.html#unary_operators">Unary operators 单参操作符</a></li>+ <li><a href="quickref.html#binary_operators">Binary operators</a>(in order of precedence) <a href="quickref.html#binary_operators">二元操作符</a>(按优先级顺序排)</li>

     </ul>
   </li>
 </ul>

 <table>

-    <tr>
+    <tbody><tr>

         <td valign="top">

             <table>

-                <tr>

- <td class="table_title" colspan="3"id="null_parsers"><a name="null_parsers"></a>Null parsers</td>

+                <tbody><tr>

+ <td class="table_title" colspan="3"id="null_parsers"><a name="null_parsers"></a>Null parsers 空分析器</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">end_p</a></code></td>

-                    <td class="table_cells">Matches EOF</td>
+                    <td class="table_cells">Matches EOF<br>匹配EOF</td>
                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="primitives.html">eps_p</a> + <td class="table_cells"><code><ahref="primitives.html">eps_p</a> 

             <a href="primitives.html">eps_p</a>(P)</code></td>

- <td class="table_cells">Matches without consumingtext</td>+ <td class="table_cells">Matches without consumingtext 匹配且不消耗文本</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="primitives.html">epsilon_p</a> + <td class="table_cells"><code><ahref="primitives.html">epsilon_p</a> 

             <a href="primitives.html">epsilon_p</a>(P)</code></td>
-                    <td class="table_cells">Synonym for <b>eps_p</b></td>

+ <td class="table_cells">Synonym for eps_p eps_p的同义词</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">nothing_p</a></code></td>

-                    <td class="table_cells">Always fails</td>

+ <td class="table_cells">Always fails 总是匹配失败</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>

                 <tr>

- <td class="table_title" colspan="3"id="character_parsers"><a name="character_parsers"id="character_parsers"></a>Character parsers</td>+ <td class="table_title" colspan="3"id="character_parsers"><a name="character_parsers"id="character_parsers"></a>Character parsers 字符分析器</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">alnum_p</a></code></td>- <td class="table_cells">Matches any alphanumericcharacter</td>+ <td class="table_cells">Matches any alphanumericcharacter 匹配任意字母和数字</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">alpha_p</a></code></td>

-                    <td class="table_cells">Matches any letter</td>

+ <td class="table_cells">Matches any letter 匹配任意字母</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">anychar_p</a></code></td>

-                    <td class="table_cells">Matches any character</td>

+ <td class="table_cells">Matches any character 匹配任意字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">blank_p</a></code></td>

-                    <td class="table_cells">Matches a space or tab</td>

+ <td class="table_cells">Matches a space or tab 匹配一个空格或制表符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">ch_p</a>(char)</code></td>

-                    <td class="table_cells">Matches a character</td>

+ <td class="table_cells">Matches a character 匹配一个字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="character_sets.html">chset_p</a>(charset)</code></td>- <td class="table_cells">Matches a character in theset</td>+ <td class="table_cells">Matches a character in theset 匹配字符集中的某个字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">cntrl_p</a></code></td>- <td class="table_cells">Matches any controlcharacter</td>+ <td class="table_cells">Matches any controlcharacter 匹配任意控制字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">digit_p</a></code></td>

-                    <td class="table_cells">Matches any digit</td>

+ <td class="table_cells">Matches any digit 匹配任意数字</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="parametric_parsers.html">f_ch_p</a>(func)</code></td>

-                    <td class="table_cells">Matches a character</td>

+ <td class="table_cells">Matches a character 匹配一个字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="parametric_parsers.html">f_range_p</a>(func1,

             func2)</code></td>

- <td class="table_cells">Matches any character in theinclusive range</td>+ <td class="table_cells">Matches any character in theinclusive range 匹配闭区间内的任意字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">graph_p</a></code></td>- <td class="table_cells">Matches any non-spaceprintable character</td>+ <td class="table_cells">Matches any non-spaceprintable character 匹配任意非空可打印字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">lower_p</a></code></td>- <td class="table_cells">Matches any lower-caseletter</td>+ <td class="table_cells">Matches any lower-caseletter 匹配任意小写字母</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">print_p</a></code></td>- <td class="table_cells">Matches any printablecharacter</td>+ <td class="table_cells">Matches any printablecharacter 匹配任意可打印字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">punct_p</a></code></td>- <td class="table_cells">Matches any punctuationmark</td>+ <td class="table_cells">Matches any punctuationmark 匹配任意标点符号</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">range_p</a>(char1,

             char2)</code></td>

- <td class="table_cells">Matches any character in theinclusive range</td>+ <td class="table_cells">Matches any character in theinclusive range 匹配闭区间内的任意字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">sign_p</a></code></td>- <td class="table_cells">Matches a plus or minussign</td>+ <td class="table_cells">Matches a plus or minussign 匹配正号或负号</td>

                     <td class="table_cells"><i>bool</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">space_p</a></code></td>- <td class="table_cells">Matches any whitespacecharacter</td>+ <td class="table_cells">Matches any whitespacecharacter 匹配任意空白字符</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">upper_p</a></code></td>- <td class="table_cells">Matches any upper-caseletter</td>+ <td class="table_cells">Matches any upper-caseletter 匹配任意大写字母</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">xdigit_p</a></code></td>- <td class="table_cells">Matches any hexadecimaldigit</td>+ <td class="table_cells">Matches any hexadecimaldigit 匹配任意十六进制数字</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>

                 <tr>

- <td class="table_title" colspan="3"id="number_parsers"><a name="number_parsers"></a>Number parsers</td>+ <td class="table_title" colspan="3"id="number_parsers"><a name="number_parsers"></a>Number parsers 数字分析器</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">bin_p</a></code></td>- <td class="table_cells">Matches an unsigned binaryinteger</td>+ <td class="table_cells">Matches an unsigned binaryinteger 匹配一个无符号二进制整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">hex_p</a></code></td>- <td class="table_cells">Matches an unsignedhexadecimal integer</td>+ <td class="table_cells">Matches an unsignedhexadecimal integer 匹配一个无符号十六进制整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">int_p</a></code></td>- <td class="table_cells">Matches a signed decimalinteger</td>+ <td class="table_cells">Matches a signed decimalinteger 匹配一个有符号十进制整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">int_parser</a><type,

             base, min, max&gt;</code></td>

- <td class="table_cells">Matches a signed integer withmin to max digits</td>+ <td class="table_cells">Matches a signed integer withmin to max digits 匹配 min 至 max 间的有符号整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">oct_p</a></code></td>- <td class="table_cells">Matches an unsigned octalinteger</td>+ <td class="table_cells">Matches an unsigned octalinteger 匹配一个无符号八进制整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">real_p</a></code></td>- <td class="table_cells">Matches a floating pointnumber</td>+ <td class="table_cells">Matches a floating pointnumber 匹配一个浮点数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">real_parser</a><type,

             policy&gt;</code></td>

- <td class="table_cells">Matches a floating pointnumber</td>+ <td class="table_cells">Matches a floating pointnumber 匹配一个浮点数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">strict_real_p</a></code></td>- <td class="table_cells">Matches a floating pointnumber (requires decimal point)</td>+ <td class="table_cells">Matches a floating pointnumber (requires decimal point) 匹配一个浮点数(要求小数点)</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">strict_ureal_p</a></code></td>- <td class="table_cells">Matches an unsigned FP number(requires decimal point)</td>+ <td class="table_cells">Matches an unsigned FP number(requires decimal point) 匹配一个无符号浮点数(要求小数点)</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>
@@ -259,80 +255,80 @@

<td class="table_cells"><code><ahref="numerics.html">uint_parser</a><type,

             base, min, max&gt;</code></td>

- <td class="table_cells">Matches an unsigned integerwith min to max digits</td>+ <td class="table_cells">Matches an unsigned integerwith min to max digits 匹配 min 至 max 间的无符号整数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="numerics.html">ureal_p</a></code></td>- <td class="table_cells">Matches an unsigned FPnumber</td>+ <td class="table_cells">Matches an unsigned FPnumber 匹配一个无符号浮点数</td>

                     <td class="table_cells"><i>numeric</i></td>
                 </tr>

                 <tr>

- <td class="table_title" colspan="3"id="other_lexeme_parsers"><a name="otherlexeme_parsers"></a>Other lexemeparsers</td>+ <td class="table_title" colspan="3"id="other_lexeme_parsers"><a name="otherlexeme_parsers"></a>Other lexemeparsers 其它词位分析器</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="escape_char_parser.html">c_escape_ch_p</a></code></td>

-                    <td class="table_cells">Matches a C escape code</td>

+ <td class="table_cells">Matches a C escape code 匹配一个C的转义代码</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="confix.html">comment_p</a>(string) + <td class="table_cells"><code><ahref="confix.html">comment_p</a>(string) <a href="confix.html">comment_p</a> (string1,string2)</code></td>- <td class="table_cells">Matches C++ or C-stylecomments</td>+ <td class="table_cells">Matches C++ or C-stylecomments 匹配C++或C风格的注释</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">eol_p</a></code></td>- <td class="table_cells">Matches CR, LF, or anycombination</td>+ <td class="table_cells">Matches CR, LF, or anycombination 匹配 CR, LF 或其任意组合</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="parametric_parsers.html">f_str_p</a>(func1,

             func2)</code></td>
-                    <td class="table_cells">Matches a string</td>

+ <td class="table_cells">Matches a string 匹配一个字符串</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="escape_char_parser.html">lex_escape_ch_p</a></code></td>- <td class="table_cells">Matches a C escape code or anybackslash escape</td>+ <td class="table_cells">Matches a C escape code or anybackslash escape 匹配一个C的转义代码或任意反斜杠转义</td>

                     <td class="table_cells"><i>char</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="regular_expression_parser.html">regex_p</a>(regex)</code></td>- <td class="table_cells">Matches a regularexpression</td>+ <td class="table_cells">Matches a regularexpression 匹配一个正则表达式</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="primitives.html">str_p</a>(string) + <td class="table_cells"><code><ahref="primitives.html">str_p</a>(string) 

             <a href="primitives.html">str_p</a>(iter1, iter2)</code></td>
-                    <td class="table_cells">Matches a string</td>

+ <td class="table_cells">Matches a string 匹配一个字符串</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>

                 <tr>

- <td class="table_title" colspan="3"id="text_parsers"><a name="text_parsers"></a>Text parsers</td>+ <td class="table_title" colspan="3"id="text_parsers"><a name="text_parsers"></a>Text parsers 文本分析器</td>

                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="primitives.html">chseq_p</a>(string) + <td class="table_cells"><code><ahref="primitives.html">chseq_p</a>(string) 

             <a href="primitives.html">chseq_p</a>(iter1, iter2)</code></td>

- <td class="table_cells">Matches a string, possiblywith embedded whitespace</td>+ <td class="table_cells">Matches a string, possiblywith embedded whitespace 匹配一个字符串，可以带有内嵌的空白</td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="parametric_parsers.html">f_chseq_p</a>(func1,

             func2)</code></td>

                     <td class="table_cells"><i>iter,iter</i></td>
                 </tr>

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

         </td>

@@ -342,261 +338,259 @@

             <table>

-                <tr>

- <td class="table_title" colspan="2"id="compound_parsers"><a name="compound_parsers"></a>Compound parsers</td>

+                <tbody><tr>

+ <td class="table_title" colspan="2"id="compound_parsers"><a name="compound_parsers"></a>Compound parsers 复合分析器</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="confix.html">confix_p</a>(open,

             exp, close)</code></td>

- <td class="table_cells">Matches open >> (exp- close) >> close</td>+ <td class="table_cells">Matches open >> (exp- close) >> close 匹配 open >> (exp - close) >>close</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="dynamic_parsers.html">do_p</a>[P].<ahref="dynamic_parsers.html">while_p</a>(cond)</code></td>- <td class="table_cells">Matches while a condition istrue (at least once)</td>+ <td class="table_cells">Matches while a condition istrue (at least once) 当条件为真时匹配(至少一次)</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="dynamic_parsers.html">for_p</a>(init,

             cond, step)[P]</code></td>
-                    <td class="table_cells">Matches in a loop</td>

+ <td class="table_cells">Matches in a loop 在循环中匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="functor_parser.html">functor_parser</a><func></code></td>

-                    <td class="table_cells">Wraps an external parser</td>

+ <td class="table_cells">Wraps an external parser 封装一个外部分析器</td>

                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="dynamic_parsers.html">if_p</a>(cond)[P] + <td class="table_cells"><code><ahref="dynamic_parsers.html">if_p</a>(cond)[P] <a href="dynamic_parsers.html">if_p</a>(cond)[P].<ahref="dynamic_parsers.html">else_p</a>[P]</code></td>- <td class="table_cells">Matches depending on acondition</td>+ <td class="table_cells">Matches depending on acondition 根据条件进行匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="the_lazy_parser.html">lazy_p</a>(P)</code></td>- <td class="table_cells">Evaluates a parser at runtime</td>+ <td class="table_cells">Evaluates a parser at runtime 运行期对分析器求值</td>

                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="list_parsers.html">list_p</a> 

-            <a href="list_parsers.html">list_p</a>(del)<br />
-            <a href="list_parsers.html">list_p</a>(item, del)<br />

+ <td class="table_cells"><code><ahref="list_parsers.html">list_p</a> 

+            <a href="list_parsers.html">list_p</a>(del)<br>
+            <a href="list_parsers.html">list_p</a>(item, del)<br>

<a href="list_parsers.html">list_p</a>(item, del,end)</code></td>

-                    <td class="table_cells">Matches a delimited list</td>

+ <td class="table_cells">Matches a delimited list 匹配一个带分隔符的列表</td>

                 </tr>
                 <tr>

- <td class="table_cells"><code><ahref="loops.html">repeat_p</a>(num)[P] 

-            <a href="loops.html">repeat_p</a>(min, max)[P]<br />

+ <td class="table_cells"><code><ahref="loops.html">repeat_p</a>(num)[P] 

+            <a href="loops.html">repeat_p</a>(min, max)[P]<br>

<a href="loops.html">repeat_p</a>(min, <ahref="loops.html">more</a>)[P]</code></td>

-                    <td class="table_cells">Matches multiple times</td>

+ <td class="table_cells">Matches multiple times 多次匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="dynamic_parsers.html">while_p</a> (cond) [P]</code></td>- <td class="table_cells">Matches while a condition istrue</td>+ <td class="table_cells">Matches while a condition istrue 当条件为真时匹配</td>

                 </tr>

                 <tr>

- <td class="table_title" colspan="2"id="general_directives"><a name="general_directives"></a>Generaldirectives</td>+ <td class="table_title" colspan="2"id="general_directives"><a name="general_directives"></a>General directives通用指示符</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">as_lower_d</a>[P]</code></td>- <td class="table_cells">Converts text to lower casebefore matching</td>+ <td class="table_cells">Converts text to lower casebefore matching 在匹配前将文本转换为小写</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="refactoring.html">attach_action_d</a>[(P1

             op P2)[act]]</code></td>

- <td class="table_cells">Transforms to P1 [act] opP2 [act]</td>+ <td class="table_cells">Transforms to P1 [act] opP2 [act] 变换为 P1 [act] op P2 [act]</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">lexeme_d</a>[P]</code></td>- <td class="table_cells">Turns off whitespaceskipping</td>+ <td class="table_cells">Turns off whitespaceskipping 关闭空白符跳过</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">limit_d</a>[P](min,

             max)</code></td>

- <td class="table_cells">Matches only if the value iswithin the range</td>+ <td class="table_cells">Matches only if the value iswithin the range 仅当值在区间内匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">longest_d</a>[P]</code></td>- <td class="table_cells">Matches the longest ofalternatives</td>+ <td class="table_cells">Matches the longest ofalternatives 匹配最长的选择</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">max_limit_d</a>[P](max)</code></td>- <td class="table_cells">Matches only if value <=max</td>+ <td class="table_cells">Matches only if value <=max 仅当 value <= max 时匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">min_limit_d</a>[P](min)</code></td>- <td class="table_cells">Matches only if value >=min</td>+ <td class="table_cells">Matches only if value >=min 仅当 value >= min 时匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="refactoring.html">refactor_action_d</a>[P1

             [act] op P2]</code></td>

- <td class="table_cells">Transforms to (P1 op P2)[act]</td>+ <td class="table_cells">Transforms to (P1 op P2)[act] 变换为 (P1 op P2) [act]</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="refactoring.html">refactor_unary_d</a>[op1

             P1 op2 P2]</code></td>

- <td class="table_cells">Transforms to op1 (P1 op2P2)</td>+ <td class="table_cells">Transforms to op1 (P1 op2P2) 变换为 op1 (P1 op2 P2)</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="scoped_lock.html">scoped_lock_d</a>[P](mutex)</code></td>- <td class="table_cells">Locks a mutex whilematching</td>+ <td class="table_cells">Locks a mutex whilematching 匹配时锁住一个互斥体</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="directives.html">shortest_d</a>[P]</code></td>- <td class="table_cells">Matches the shortest ofalternatives</td>+ <td class="table_cells">Matches the shortest ofalternatives 匹配最短的选择</td>

                 </tr>

                 <tr>

- <td class="table_title" colspan="2"id="tree_specific_directives"><aname="tree_specific_directives"></a>Tree-specific directives</td>+ <td class="table_title" colspan="2"id="tree_specific_directives"><aname="tree_specific_directives"></a>Tree-specific directives 树专用的指示符</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">access_node_d</a>[P]</code></td>- <td class="table_cells">Passes node value toaction</td>+ <td class="table_cells">Passes node value toaction 传递节点值至动作</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">discard_first_node_d</a>[P]</code></td>

-                    <td class="table_cells">Discards first node</td>

+ <td class="table_cells">Discards first node 丢弃第一个节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">discard_last_node_d</a>[P]</code></td>

-                    <td class="table_cells">Discards last node</td>

+ <td class="table_cells">Discards last node 丢弃最后一个节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">discard_node_d</a>[P]</code></td>- <td class="table_cells">Discards the generatednode</td>+ <td class="table_cells">Discards the generatednode 丢弃生成的节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">infix_node_d</a>[P]</code></td>- <td class="table_cells">Discards even-positionnodes</td>+ <td class="table_cells">Discards even-positionnodes 丢弃偶数位置的节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">inner_node_d</a>[P]</code></td>- <td class="table_cells">Discards first and lastnodes</td>+ <td class="table_cells">Discards first and lastnodes 丢弃第一个和最后一个节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">leaf_node_d</a>[P]</code></td>- <td class="table_cells">Generates a single node withno children</td>+ <td class="table_cells">Generates a single node withno children 生成不带子节点的单个节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">no_node_d</a>[P]</code></td>

-                    <td class="table_cells">Does not generate a node</td>

+ <td class="table_cells">Does not generate a node 不生成节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">root_node_d</a>[P]</code></td>- <td class="table_cells">Identifies root nodes for anAST</td>+ <td class="table_cells">Identifies root nodes for anAST 为AST标识根节点</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="trees.html">token_node_d</a>[P]</code></td>- <td class="table_cells">Synonym forleaf_node_d</td>+ <td class="table_cells">Synonym forleaf_node_d leaf_node_d 的同义词</td>

                 </tr>

                 <tr>

- <td class="table_title" colspan="2"id="unary_operators"><a name="unary_operators"></a>Unary operators</td>+ <td class="table_title" colspan="2"id="unary_operators"><a name="unary_operators"></a>Unary operators 单参操作符</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">!P</a></code></td>- <td class="table_cells">Matches P or an emptystring</td>+ <td class="table_cells">Matches P or an emptystring 匹配 P 或空串</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">*P</a></code></td>- <td class="table_cells">Matches P zero or moretimes</td>+ <td class="table_cells">Matches P zero or moretimes 匹配 P 零次或多次</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">+P</a></code></td>- <td class="table_cells">Matches P one or moretimes</td>+ <td class="table_cells">Matches P one or moretimes 匹配 P 一次或多次</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="primitives.html">~P</a></code></td>- <td class="table_cells">Matches anything that does notmatch P</td>+ <td class="table_cells">Matches anything that does notmatch P 匹配任何不匹配 P 的文本</td>

                 </tr>

                 <tr>

- <td class="table_title" colspan="2"id="binary_operators"><a name="binary_operators"></a>Binary operators</td>+ <td class="table_title" colspan="2"id="binary_operators"><a name="binary_operators"></a>Binary operators 二元操作符</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 % P2</a></code></td>- <td class="table_cells">Matches one or more P1separated by P2</td>+ <td class="table_cells">Matches one or more P1separated by P2 匹配一次或多次 P1，以 P2 分隔</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 - P2</a></code></td>- <td class="table_cells">Matches P1 but notP2</td>+ <td class="table_cells">Matches P1 but notP2 匹配 P1 但不匹配 P2</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 >> P2</a></code></td>- <td class="table_cells">Matches P1 followed byP2</td>+ <td class="table_cells">Matches P1 followed byP2 匹配 P1 后随 P2</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 & P2</a></code></td>- <td class="table_cells">Matches both P1 andP2</td>+ <td class="table_cells">Matches both P1 andP2 同时匹配 P1 和 P2</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 ^ P2</a></code></td>- <td class="table_cells">Matches P1 orP2, but not both</td>+ <td class="table_cells">Matches P1 orP2, but not both 匹配 P1 或 P2，但不能同时匹配</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 | P2</a></code></td>- <td class="table_cells">Matches P1 orP2</td>+ <td class="table_cells">Matches P1 orP2 匹配 P1 或 P2</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 && P2</a></code></td>- <td class="table_cells">Synonym for P1 >>P2</td>+ <td class="table_cells">Synonym for P1 >>P2 P1 >> P2 的同义词</td>

                 </tr>
                 <tr>

<td class="table_cells"><code><ahref="operators.html">P1 || P2</a></code></td>- <td class="table_cells">Matches P1 | P2 | P1>> P2</td>+ <td class="table_cells">Matches P1 | P2 | P1>> P2 匹配 P1 | P2 | P1 >> P2</td>

                 </tr>

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

         </td>

     </tr>

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

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

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

Use, modification and distribution is subject to theBoost SoftwareLicense, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy athttp://www.boost.org/LICENSE_1_0.txt)

 <p>&nbsp;</p>
-</body>
-
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/rationale.html       Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/rationale.html       Mon Oct 12 20:27:43 2009
@@ -1,88 +1,87 @@
-<html>
-<head>
-<title>Rationale</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>Rationale</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%"> Rationale</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%"> Rationale 基本原理</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="faq.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="acknowledgments.html"><imgsrc="theme/r_arr.gif" border="0"></a></td>

    </tr>
-</table>

-<img src="theme/lens.gif" width="15" height="16"> Virtualfunctions:

-  From static to dynamic C++</strong></p>
+</tbody></table>

+<img src="theme/lens.gif" height="16" width="15"> Virtualfunctions:

+  From static to dynamic C++ &nbsp;虚拟函数：从静态到动态的C++</strong></p>

Rules straddle the border between static and dynamic C++. In effect, aruletransforms compile-time polymorphism (using templates) into run-timepolymorphism(using virtual functions). This is necessary due to C++'s inability toautomaticallydeclare a variable of a type deduced from an arbitrarily complexexpressionin the right-hand side (rhs) of an assignment. Basically, we want to dosomething

-  like:</p>

-<pre><code> T <spanclass=identifier>rule = <spanclass=identifier>an_arbitrarily_complex_expression<spanclass=special>;</code></pre>

+  like:<br>规

+则跨越了静态与动态C++的边界。实际上，规则将编译期的多态(使用模板实现)转换为运行期的多态(使用虚拟函数实现)。这是必要的，因为C++无法自动+声明由一个赋值操作的右操作数(rhs)中某个任意复杂的表达式所推导出来的某种类型的一个变量。基本上，我们想做的事情就象：+<pre><code> Trule =<spanclass="identifier">an_arbitrarily_complex_expression<spanclass="special">;</code></pre>without having to know or care about the resulting type of theright-hand side(rhs) of the assignment expression. Apart from this, we also need afacility

-  to forward declare an unknown type:</p>

-<pre><code> <spanclass=identifier>T rule<spanclass=special>;

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

- rule =a | <spanclass=identifier>b;</code></pre>+ to forward declare an unknown type: 而不必知道或关心赋值表达式右侧(rhs)的结果类型。此外，我们还需要一种方法来前向声明一个未知的类型：+<pre><code> <spanclass="identifier">T rule<spanclass="special">; ... rule =a |b<spanclass="special">;</code></pre>These limitations lead us to this implementation of rules. This comesat theexpense of the overhead of a virtual function call, once through eachinvocation

-  of a rule.</p>

-<img src="theme/lens.gif" width="15" height="16"> Multipledeclaration+ of a rule. 这些限制使我们有了这种规则的实现。其代价是规则的每次调用都有一次虚拟函数调用的开销。+<img src="theme/lens.gif" height="16" width="15"> Multipledeclaration 多次声明

   </strong> </p>

Some BNF variants allow multiple declarations of a <tt>rule</tt>. Thedeclarations

-  are taken as alternatives. Example:</p>
-<pre>

- <code>r </code><code><spanclass=special>= a<spanclass=special>; - r = <spanclass=identifier>b;</code></pre>

-<p> is equivalent to: </p>
-<pre>

- <code>r </code><code><spanclass=special>= a <spanclass=special>| b<spanclass=special>;</code></pre>+ are taken as alternatives. Example: 有些BNF变体允许一个 <tt>rule</tt>的多次声明。这些声明的结果是多选。例如：+<pre> <code>r </code><code><spanclass="special">= a<spanclass="special">; + r = <spanclass="identifier">b;</code></pre>

+<p> is equivalent to:<br>相当于： </p>

+<pre> <code>r </code><code><spanclass="special">= a <spanclass="special">| b<spanclass="special">;</code></pre>Spirit v1.3 allowed this behavior. However, the current version ofSpirit nolonger allows this because experience shows that this behavior leadstounwanted gotchas (for instance, it does not allow rules to be held incontainers).In the current release of Spirit, a second assignment to a rule willsimplyredefine it. The old definition is destructed. This follows more closelyC++- semantics and is more in line with what the user expects the rule tobehave.-<img src="theme/lens.gif" width="15" height="16"> SequencingSyntax

-  <br>

+ semantics and is more in line with what the user expects the rule tobehave. Spirit v1.3 允许此种行为。但是，当前版本的Spirit不再允许此种行为，因为经验显示，该行为会导致不必要的陷阱(例如，它不允许将规则保存于容器之中)。在当前的Spirit版本中，对规则的第二次赋值只会重新定义它。旧的定义被析构。这更接近于C++的语义，并与用户所期望的规则行为更为一致。+<img src="theme/lens.gif" height="16" width="15"> Sequencing Syntax表示顺序的语法 

   <br>

The comma operator as in a, b seems to be a better candidate,syntax-wise. Butthen the problem is with its precedence. It has the lowest precedence inC/C++,

-  which makes it virtually useless. <br>

+ which makes it virtually useless.  逗号操作符如 a, b 似乎是一种更好的选择，语法更明晰。但问题是它的优先级。在C/C++中它的优先级最低，这使得它变得毫无用处。 

   <br>

- Bjarne Stroustrup, in his article <ahref="references.html#generalized_overloading">"Generalizing- Overloading for C++2000"</a> talks about overloading whitespace.Such a+ Bjarne Stroustrup, in his article <ahref="references.html#generalized_overloading">"Generalizing

+  Overloading for C++2000"</a> talks about overloading whitespace. Such a

feature would allow juxtapositioning of parser objects exactly as we doin (E)BNF(e.g. a b | c instead of a >> b | c). Unfortunately, the articlewas dated

-  April 1, 1998. Oh well.</p>

-<img src="theme/lens.gif" width="15" height="16"> Forwarditerators + April 1, 1998. Oh well. Bjarne Stroustrup在它的文章 <ahref="references.html#generalized_overloading">"Generalizing+ Overloading for C++2000"</a> 中讨论了重载的空白。这种特性将允许分析器对象的juxtapositioning正如我们在(E)BNF+ 所做的一样(如以 a b | c 替代 a >> b | c)。不幸的是，文章的日期是1998年4月1日。哦。+<img src="theme/lens.gif" height="16" width="15"> Forward iterators前向迭代器 

   <br>

In general, the scanner expects at least a standard conforming forwarditerator.Forward iterators are needed for backtracking where the iterator needsto besaved and restored later. Generally speaking, Spirit is a backtrackingparser.The implication of this is that at some point, the iterator positionwill haveto be saved to allow the parser to backtrack to a previous point. Thus,for- backtracking to work, the framework requires at least a forwarditerator. + backtracking to work, the framework requires at least a forwarditerator. 一+般来说，扫描器至少需要一个符合标准的前向迭代器。前向迭代器是回溯所需的，因为迭代器需要被保存且稍后恢复。通常来说，Spirit是一个回溯分析器。+其含义是，在某些时候，迭代器的位置必须被保存以允许分析器回溯至以前的点。因此，为了可以回溯，本框架至少要求一个前向迭代器。 

   <br>

Some parsers might require more specialized iterators (bi-directional orevenrandom access). Perhaps in the future, deterministic parsers when addedto theframework, will perform no backtracking and will need just a singletoken lookahead,

-  hence will require input iterators only.</p>

-<img src="theme/lens.gif" width="15" height="16"> Why are subrulesimportant? + hence will require input iterators only. 有些分析器可能要求更为特殊的迭代器(双向的甚至是随机访问的)。也许在将来，确定性的分析器被增加到本框架中时，将不再执行回溯，只需要前瞻一个记号，这时只需要输入迭代器即可。+<img src="theme/lens.gif" height="16" width="15"> Why are subrulesimportant? 为什么子规则是重要的？ 

   <br>

Subrules open up the oportunity to do aggressive meta programming aswell becausethey do not rely on virtual functions. The virtual function is themeta-programmer's

@@ -90,8 +89,10 @@

call, it is also an opaque wall where no metaprogram can get past. Itkillsall meta-information beyond the virtual function call. Worse, thevirtual functioncannot be templated. Which means that its arguments have to be tied to aactual

-  types. Many problems stem from this limitation. <br>
-  <br>
+  types. Many problems stem from this limitation.&nbsp;<br>子

+规则提供了元编程的机会，因为它们不依赖于虚拟函数。虚拟函数是元编程者的地狱。它不仅因为虚拟函数的间接调用降低了程序的速度，它还是一堵不透明的墙，+元编程无法穿过它。它在虚拟函数调用之前去掉了所有元信息。更糟的是，虚拟函数不能被模板化。这意味着它的参数必须绑定至实际的类型。许多问题正是源于这

+个限制。<br></p><p>

While Spirit is a currently classified as a non-deterministicrecursive-descentparser, Doug Gregor first noted that other parsing techniques apart fromtop-downrecursive descent may be applied. For instance, apart fromnon-deterministic

@@ -99,29 +100,35 @@

using the same expression template front end. Spirit rules use virtualfunctionsto encode the RHS parser expression in an opaque abstract parser type.Whileit serves its purpose well, the rule's virtual functions are thestumbling blocks- to more advanced metaprogramming. Subrules are free from virtualfunctions.-<img src="theme/lens.gif" width="15" height="16"> <aname="exhaustive_rd"></a>Exhaustive

-  backtracking and greedy RD</b></p>

+ to more advanced metaprogramming. Subrules are free from virtualfunctions. 虽

+然目前Spirit被分类为非确定性的递归下降分析器，但Doug

+Gregor首先注意到，除了自顶而下的递归下降法以外的其它分析技术也是可以适用的。例如，除了非确定性的递归下降法，确定性的 LL(1) 和

+LR(1)

+理论上也可以被实现为使用相同的表达式模板前端。Spirit的规则使用了虚拟函数来将RHS分析器表达式编码为一个不透明的抽象分析器类型。虽然它很好+地达到其目的，但是规则所用的虚拟函数是进一步使用元编程的绊脚石。子规则则不受虚拟函数的限制。+<img src="theme/lens.gif" height="16" width="15"> <aname="exhaustive_rd"></a>Exhaustive

+  backtracking and greedy RD 穷举回溯和贪心RD</b></p>

Spirit doesn't do exhaustive backtracking like regular expressions areexpected

-  to. For example:</p>

+ to. For example: Spirit并不象正则表达式所期望的那样进行穷举回溯。例如：<pre> *chlit_p<spanclass="special">('a'<spanclass="special">) >> chlit_p<spanclass="special">('a'<spanclass="special">);</pre>will always fail to match because Spirit's Kleene star does not backoff when

-  the rest of the rule fails to match. </p>

+ the rest of the rule fails to match. 总是匹配失败，因为当规则的其余部分匹配失败时，Spirit的克林星不会回退。 Actually, there's a solution to this greedy RD problem. Such a schemeis discussed

-  in section 6.6.2 of <a

-href="http://www.cs.vu.nl/%7Edick/PTAPG.html";>Parsing Techniques: APractical+ in section 6.6.2 of <ahref="http://www.cs.vu.nl/%7Edick/PTAPG.html";>Parsing Techniques: APracticalGuide</a>. The trick involves passing a tail parser (inaddition tothe scanner) to each parser. The start parser will then simply be:<tt>start

-  &gt;&gt; end_p;</tt> (end_p is the start's tail). </p>

+ >> end_p;</tt> (end_p is the start's tail). 实际上，这个贪心RD的问题有一个解决方法。该机制在 <ahref="http://www.cs.vu.nl/%7Edick/PTAPG.html";>Parsing Techniques: APractical+ Guide</a> 的第6.6.2节中讨论。该诀窍包含了传递一个 tail 分析器(除了扫描器以外)给每一个分析器。然后起始分析器只需写成：<tt>start

+  &gt;&gt; end_p;</tt> (end_p 是 start 的 tail)。 </p>

Spirit is greedy --using straight forward, naive RD. It is certainlypossibleto implement the fully backtracking scheme presented above, but therewill bealso certainly be a performance hit. The scheme will always try to matchallpossible parser paths (full parser hierarchy traversal) until it reachesa point

-  of certainty, that the whole thing matches or fails to match. </p>
-<table border="0" width="80%" align="center">
-  <tr>

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

-        and Greedy RD </b><br>

+ of certainty, that the whole thing matches or fails to match. Spirit是贪心的--使用简单、自然的RD。当然，它可以实现以上所说的全回溯机制，但是显然这也是一个性能上的挑战。该机制总是尝试匹配所有可能的分析器路径(完全的分析器层次遍历)，直至到达某个可以确定完全匹配或匹配失败的点。 

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

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

+        and Greedy RD 回溯与贪心RD </b><br>
         <br>

Spirit is quite consistent and intuitive about when it backtracksandto where, although it may not be obvious to those coming fromdifferent

@@ -130,33 +137,36 @@

This means that Spirit is inherently greedy. Spirit will onlybacktrackwhen a (sub)parser fails to match the input, and it will alwaysbacktrackto the next choice point upward (not backward) in the parserstructure.- In other words abb|ab will match "ab", as will a(bb|b),but

+        In other words abb|ab will match "ab", as will a(bb|b), but

(ab|a)b won't because the (ab|a) subparser will always matchthe 'b' after

-        the 'a' if it is available.</p>
+        the 'a' if it is available.</p><p>Spirit

+对于何时回溯以及回溯至何处是相当连贯和直观的，虽然对于来自不同的背景它可能不是很明显。通常，任何(子)分析器，给定相同的输入，总是匹配相同的部分+输入(或者根本就匹配失败)。这意味着Spirit本身就是贪心的。Spirit仅当一个(子)分析器匹配输入失败时才进行回溯，而且它总是回溯至分析器+结构中向上的(不是向后)下一个选择点。换句话说，abb|ab 将匹配 "ab"，a(bb|b)也一样，但 (ab|a)b

+则非如此，因为子分析器 (ab|a) 只要可能就总是在 'a' 之后匹配一个 'b'。</p>
       <p>--Rainer Deyke</p>
       </td>
   </tr>
-</table>

-There's a strong preference on "simplicity with all the knobs whenyou- need them" approach, right now. On the other hand, the flexibilityof Spirit

+</tbody></table>
+<p>There's a strong preference on "simplicity with all the knobs when you

+ need them" approach, right now. On the other hand, the flexibility ofSpiritmakes it possible to have different optional schemes available. It mightbepossible to implement an exhaustive backtracking RD scheme as anoptional feature

-  in the future. </p>

+ in the future. 对于"需要时就使用所有旋钮"这一方法，现在有一种强烈的偏好。另一方面，Spirit的灵活性令它可以有不同的可选机制。将来它也许可以实现一个穷举回溯的RD机制作为可选的特性。 

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

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

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/references.html      Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/references.html      Mon Oct 12 20:27:43 2009
@@ -1,188 +1,176 @@
-<html>
-<head>
-<title>References</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>References</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%">

- References+ References 参考资料

     </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="acknowledgments.html"><imgsrc="theme/l_arr.gif" border="0"></a></td>- <td width="30"><img src="theme/r_arr_disabled.gif" width="20"height="19"></td>+ <td width="30"><img src="theme/r_arr_disabled.gif" height="19"width="20"></td>

   </tr>
-</table>
+</tbody></table>
 <br>
-<table width="90%" border="0" align="center">
-  <tr>
-    <td width="36" class="table_cells"> 1.</td>

- <td width="236" class="table_cells"> <aname="expression_templates"></a>Todd

+<table align="center" border="0" width="90%">
+  <tbody><tr>
+    <td class="table_cells" width="36"> 1.</td>

+ <td class="table_cells" width="236"> <aname="expression_templates"></a>Todd

       Veldhuizen</td>
-    <td width="520" class="table_cells"> "<a
-href="http://www.extreme.indiana.edu/%7Etveldhui/papers/Expression-Templates/exprtmpl.html";>Expression

+ <td class="table_cells" width="520"> "<ahref="http://www.extreme.indiana.edu/%7Etveldhui/papers/Expression-Templates/exprtmpl.html";>Expression

       Templates</a>". <br>
       C++ Report, June 1995.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells"> 2.</td>

- <td width="236" class="table_cells"> <a name="bnf"></a>Peter Naur(ed.)</td>- <td width="520" class="table_cells"> "<ahref="http://www.masswerk.at/algol60/report.htm";>Report

+    <td class="table_cells" width="36"> 2.</td>

+ <td class="table_cells" width="236"> <a name="bnf"></a>Peter Naur(ed.)</td>+ <td class="table_cells" width="520"> "<ahref="http://www.masswerk.at/algol60/report.htm";>Report

       on the Algorithmic Language ALGOL 60</a>". <br>
       CACM, May 1960.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells"> 3.</td>
-    <td width="236" class="table_cells"> ISO/IEC</td>
-    <td width="520" class="table_cells"> "<a
-href="http://www.cl.cam.ac.uk/%7Emgk25/iso-14977.pdf";>ISO-EBNF</a>", <br>
+    <td class="table_cells" width="36"> 3.</td>
+    <td class="table_cells" width="236"> ISO/IEC</td>

+ <td class="table_cells" width="520"> "<ahref="http://www.cl.cam.ac.uk/%7Emgk25/iso-14977.pdf";>ISO-EBNF</a>", 

       ISO/IEC 14977: 1996(E).</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells"> 4.</td>

- <td width="236" class="table_cells"> <aname="intersections"></a>Richard J.

+    <td class="table_cells" width="36"> 4.</td>

+ <td class="table_cells" width="236"> <aname="intersections"></a>Richard J.

       Botting, Ph.D. </td>
-    <td width="520" class="table_cells"> "<a

-href="http://www.csci.csusb.edu/dick/maths/intro_ebnf.html";>XBNF</a>"(citing+ <td class="table_cells" width="520"> "<ahref="http://www.csci.csusb.edu/dick/maths/intro_ebnf.html";>XBNF</a>"(citing

       Leu-Weiner, 1973). <br>
       California State University, San Bernardino, 1998. </td>
   </tr>
   <tr>
-    <td width="36" class="table_cells"> 5.</td>

- <td width="236" class="table_cells"> <aname="curious_recurring"></a>James

+    <td class="table_cells" width="36"> 5.</td>

+ <td class="table_cells" width="236"> <aname="curious_recurring"></a>James

       Coplien. </td>

- <td width="520" class="table_cells"> "Curiously Recurring TemplatePattern".+ <td class="table_cells" width="520"> "Curiously Recurring TemplatePattern".

       <br>
       C++ Report, Feb. 1995.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells"> 6.</td>

- <td width="236" class="table_cells"> <aname="generic_patterns"></a>Thierry

-      G&eacute;raud and <br>
+    <td class="table_cells" width="36"> 6.</td>

+ <td class="table_cells" width="236"> <aname="generic_patterns"></a>Thierry

+      Géraud and <br>
       Alexandre Duret-Lutz</td>
-    <td width="520" class="table_cells"> <a
-href="http://www.coldewey.com/europlop2000/papers/geraud%2Bduret.zip";>Generic

+ <td class="table_cells" width="520"> <ahref="http://www.coldewey.com/europlop2000/papers/geraud%2Bduret.zip";>Generic

       Programming Redesign of Patterns</a><br>

Proceedings of the 5th European Conference on Pattern Languages ofPrograms

       <br>
       (EuroPLoP'2000) Irsee, Germany, July 2000. </td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">7.</td>
-    <td width="236" class="table_cells">Geoffrey Furnish</td>

- <td width="520" height="53" class="table_cells"><ahref="http://www.adtmag.com/joop/crarticle.asp?ID=627";>"Disambiguated

-      Glommable Expression Templates Reintroduced&quot;</a><br>
+    <td class="table_cells" width="36">7.</td>
+    <td class="table_cells" width="236">Geoffrey Furnish</td>

+ <td class="table_cells" height="53" width="520"><ahref="http://www.adtmag.com/joop/crarticle.asp?ID=627";>"Disambiguated

+      Glommable Expression Templates Reintroduced"</a><br>
       C++ Report, May 2000</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">8.</td>
-    <td width="236" height="53" class="table_cells"> Erich Gamma, <br>
+    <td class="table_cells" width="36">8.</td>
+    <td class="table_cells" height="53" width="236"> Erich Gamma, <br>
       Richard Helm, <br>
       Ralph Jhonson, <br>
       and John Vlissides</td>

- <td width="520" height="53" class="table_cells"> Design Patterns,Elements+ <td class="table_cells" height="53" width="520"> Design Patterns,Elements

       of Reusable Object-Oriented Software</b>. <br>
       Addison-Wesley, 1995.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">9. </td>
-    <td width="236" class="table_cells">Alfred V. Aho<br>
+    <td class="table_cells" width="36">9. </td>
+    <td class="table_cells" width="236">Alfred V. Aho<br>
       Revi Sethi<br>
       Feffrey D. Ulman</td>

- <td width="520" class="table_cells">Compilers, Principles,Techniques and+ <td class="table_cells" width="520">Compilers, Principles,Techniques and

       Tools</b><br>
       Addison-Wesley, June 1987. </td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">10. </td>
-    <td width="236" class="table_cells"> Dick Grune and <br>
+    <td class="table_cells" width="36">10. </td>
+    <td class="table_cells" width="236"> Dick Grune and <br>
       Ceriel Jacobs</td>
-    <td width="520" class="table_cells"> <a

-href="http://www.cs.vu.nl/%7Edick/PTAPG.html";>Parsing Techniques: APractical+ <td class="table_cells" width="520"> <ahref="http://www.cs.vu.nl/%7Edick/PTAPG.html";>Parsing Techniques: APractical

       Guide</a>. <br>

Ellis Horwood Ltd.: West Sussex, England, 1990. (electronic copy,1998).</td>

   </tr>
   <tr>
-    <td width="36" class="table_cells">11. </td>
-    <td width="236" class="table_cells"> T. J. Parr, H. G. Dietz, and<br>
+    <td class="table_cells" width="36">11. </td>
+    <td class="table_cells" width="236"> T. J. Parr, H. G. Dietz, and<br>
       W. E. Cohen</td>
-    <td width="520" class="table_cells"> <a

-href="http://www.antlr.org/papers/pcctsbk.pdf";>PCCTS Reference Manual(Version+ <td class="table_cells" width="520"> <ahref="http://www.antlr.org/papers/pcctsbk.pdf";>PCCTS Reference Manual(Version

       1.00)</a>. <br>

School of Electrical Engineering, Purdue University, West Lafayette,August

       1991.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">12. </td>

- <td width="236" class="table_cells"> Adrian Johnstone and ElizabethScott.</td>

-    <td width="520" class="table_cells"> <a

-href="ftp://ftp.cs.rhul.ac.uk/pub/rdp";>RDP, A Recursive Descent CompilerCompiler</a>.

+    <td class="table_cells" width="36">12. </td>

+ <td class="table_cells" width="236"> Adrian Johnstone and ElizabethScott.</td>+ <td class="table_cells" width="520"> <ahref="ftp://ftp.cs.rhul.ac.uk/pub/rdp";>RDP, A Recursive Descent CompilerCompiler</a>.

       <br>

Technical Report CSD TR 97 25, Dept. of Computer Science, Egham,Surrey,

       England, Dec. 20, 1997. </td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">13. </td>

- <td width="236" class="table_cells"> <aname="back_tracking_parsers"></a>Adrian

+    <td class="table_cells" width="36">13. </td>

+ <td class="table_cells" width="236"> <aname="back_tracking_parsers"></a>Adrian

       Johnstone</td>
-    <td width="520" class="table_cells"> <a
-href="http://www.cs.rhul.ac.uk/research/languages/projects/lookahead_backtrack.shtml";>Languages

+ <td class="table_cells" width="520"> <ahref="http://www.cs.rhul.ac.uk/research/languages/projects/lookahead_backtrack.shtml";>Languages

       and Architectures, <br>

Parser generators with backtrack or extended lookaheadcapability</a> Department of Computer Science, Royal Holloway, University ofLondon, Egham,

       Surrey, England</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">14. </td>

- <td width="236" class="table_cells"> <aname="damian_conway"></a>Damian Conway</td>- <td width="520" class="table_cells"><ahref="http://www.csse.monash.edu.au/%7Edamian/papers/#Embedded_Input_Parsing_for_C";>Parsing

+    <td class="table_cells" width="36">14. </td>

+ <td class="table_cells" width="236"> <aname="damian_conway"></a>Damian Conway</td>+ <td class="table_cells" width="520"><ahref="http://www.csse.monash.edu.au/%7Edamian/papers/#Embedded_Input_Parsing_for_C";>Parsing

       with C++ Classes.</a><br>
       ACM SIGPLAN Notices, 29:1, 1994.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">15. </td>
-    <td width="236" class="table_cells"> Joel de Guzman</td>

- <td width="520" class="table_cells"><ahref="http://spirit.sourceforge.net/index.php?doc=docs/v1_3/index.html";>"Spirit

-      Version 1.3&quot;</a>. <br>
+    <td class="table_cells" width="36">15. </td>
+    <td class="table_cells" width="236"> Joel de Guzman</td>

+ <td class="table_cells" width="520"><ahref="http://spirit.sourceforge.net/index.php?doc=docs/v1_3/index.html";>"Spirit

+      Version 1.3"</a>. <br>
       http://spirit.sourceforge.net/, November 2001.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">16. </td>

- <td width="236" class="table_cells"> <a name="combinators"></a>S.Doaitse

+    <td class="table_cells" width="36">16. </td>

+ <td class="table_cells" width="236"> <a name="combinators"></a>S.Doaitse

       Swierstra and <br>
       Luc Duponcheel</td>
-    <td width="520" class="table_cells"> <a

-href="http://www.cs.uu.nl/groups/ST/Publications/AFP2.pdf";>Deterministic,Error-Correcting+ <td class="table_cells" width="520"> <ahref="http://www.cs.uu.nl/groups/ST/Publications/AFP2.pdf";>Deterministic,Error-Correcting

       Combinator Parsers </a><br>

Dept. of Computer Science, Utrecht University P.O.Box 80.089, 3508TB Utrecht,

       The Netherland</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">17.</td>

- <td width="236" class="table_cells"> <aname="generalized_overloading"></a>Bjarne

+    <td class="table_cells" width="36">17.</td>

+ <td class="table_cells" width="236"> <aname="generalized_overloading"></a>Bjarne

       Stroustrup</td>
-    <td width="520" class="table_cells"> <a

-href="http://www.research.att.com/%7Ebs/whitespace98.pdf";>GeneralizingOverloading+ <td class="table_cells" width="520"> <ahref="http://www.research.att.com/%7Ebs/whitespace98.pdf";>GeneralizingOverloading

       for C++2000</a><br>
       Overload, Issue 25. April 1, 1998.</td>
   </tr>
   <tr>
-    <td width="36" class="table_cells">18.</td>

- <td width="236" class="table_cells"><a name="regex_boost_doc"></a>Dr.John

+    <td class="table_cells" width="36">18.</td>

+ <td class="table_cells" width="236"><a name="regex_boost_doc"></a>Dr.John

       Maddock</td>

- <td width="520" class="table_cells"><ahref="http://www.boost.org/libs/regex/index.html";>Regex+++ <td class="table_cells" width="520"><ahref="http://www.boost.org/libs/regex/index.html";>Regex++

       Documentation</a><br>
       http://www.boost.org/libs/regex/index.htm </td>
   </tr>
@@ -217,24 +205,23 @@

<td class="table_cells"> <ahref="ftp://ftp.cs.indiana.edu/pub/techreports/TR542.pdf";>Techniques

       for Scientic C++.</a></td>
   </tr>
-</table>
+</tbody></table>
 <br>
 <table border="0">
-  <tr>
+  <tbody><tr>
     <td width="10"></td>

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

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p>&nbsp;</p>
 <p>&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/style_guide.html     Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/style_guide.html     Mon Oct 12 20:27:43 2009
@@ -1,124 +1,95 @@
-<html>
-<head>
-<title>Style Guide</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>Style Guide</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%"> Style

-      Guide </b></font></td>

+      Guide 风格指南 </b></font></td>

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

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

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

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

 At some point, especially when there are lots of semantic actionsattachedto various points, the grammar tends to be quite difficult to follow. Inorderto keep an easy-to-read, consistent en aesthetically pleasing look tothe Spirit

-  code, the following coding styleguide is advised. </p>

+ code, the following coding styleguide is advised. 有些时候，尤其是当有大量语义动作附着于各个地方时，语法会变得非常难以理解。为了保持易读性，风格一致的Spirit代码会更美观，以下是我们建议的代码风格。 This coding style is adapted and extended from the ANTLR/PCCTS style(TerrenceParr) and <ahref="http://groups.yahoo.com/group/boost/files/coding_guidelines.html";>Boostcoding guidelines</a> (David Abrahams and Nathan Myers) and is thecombined

-  work of Joel de Guzman, Chris Uzdavinis and Hartmut Kaiser.</p>

+ work of Joel de Guzman, Chris Uzdavinis and Hartmut Kaiser. 这些代码风格是从 ANTLR/PCCTS 风格(Terrence+ Parr)和 <ahref="http://groups.yahoo.com/group/boost/files/coding_guidelines.html";>Boost+ 编码指导方针</a>(David Abrahams 和 Nathan Myers)修改和扩展而来的，并结合了 Joel de Guzman, Chris Uzdavinis 和 Hartmut Kaiser 的工作。

 <ul>

- <li> Rule names use std C++ (Boost) convention. The rule name may bevery long.</li>+ <li> Rule names use std C++ (Boost) convention. The rule name may bevery long. 规则名使用 std C++ (Boost) 命名约定。规则名可能非常长。</li><li>The '=' is neatly indented 4 spaces below. Like Boost, use spacesinstead

-    of tabs. </li>

+ of tabs. '=' 如下缩入4个空格。和Boost一样，用空格符替代制表符。</li><li>Breaking the operands into separate lines puts the semantic actionsneatly

-    to the right. </li>
-  <li>Semicolon at the last line terminates the rule. </li>

+ to the right. 将操作数分开到不同的行，将相应的语义动作放在右边。</li>+ <li>Semicolon at the last line terminates the rule. 最后一行用分号结束该规则。 </li><li>The adjacent parts of a sequence should be indented accordingly tohave

-    all, what belongs to one level, at one indentation level.</li>

+ all, what belongs to one level, at one indentation level. 一个序列的相邻部分应根据层级缩入，属于同一级的采用相同的缩入。</li>

 </ul>
-<pre><span class=identifier>    program

- = <spanclass=identifier>program_heading [<spanclass=identifier>heading_action]- >> block <spanclass=special>[block_action<spanclass=special>]- >> '.'- |another_sequence- >> <spanclass=identifier>etc- <spanclass=special>;</pre>+<pre> program <spanclass="special">= program_heading[<spanclass="identifier">heading_action] >> block <spanclass="special">[block_action<spanclass="special">] <spanclass="special"> >> '.' |another_sequence >> <spanclass="identifier">etc ;</pre>

 <ul>

- <li>Prefer literals in the grammar instead of identifiers. e.g.<tt>"program"</tt>+ <li>Prefer literals in the grammar instead of identifiers. e.g.<tt>"program"</tt>instead of <tt>PROGRAM</tt>, <tt>'>='</tt> instead of <tt>GTE</tt>and<tt>'.' </tt>instead of <tt>DOT</tt>. This makes it much easier toread. Ifthis isn't possible (for instance where the used tokens must beidentified

-    through integers) capitalized identifiers should be used instead. </li>

+ through integers) capitalized identifiers should be used instead. 在语法中优先使用字面量而不是标识符，如，用 <tt>"program"</tt> 替代<tt>PROGRAM</tt>, 用 <tt>'>='</tt> 替代 <tt>GTE</tt> 以及用+ <tt>'.' </tt>替代 <tt>DOT</tt>。这样可以令语法更易读。如果不可能这么做(如被用的记号必须通过整数来标识)，则将标识符大写。 </li><li> Breaking the operands may not be needed for short expressions. e.g.<tt>*(','- >> file_identifier)</tt> as long as the line does not exceed 80characters.+ >> file_identifier)</tt> as long as the line does not exceed 80characters. 对于较短的表达式，如 <tt>*(','+ >> file_identifier)</tt>，只要该行不超出80个字符，就不需要将操作数分拆。

   </li>

<li> If a sequence fits on one line, put spaces inside the parenthesesto clearly

-    separate them from the rules. </li>

+ separate them from the rules. 如果一个序列可放入一行，则将空格放在括号中将它们与规则明确分隔开。 </li>

 </ul>
-<pre>    <span class=identifier>program_heading

- = <spanclass=identifier>as_lower_d[<spanclass=string>"program"]

-            &gt;&gt; </span><span class=identifier>identifier

- >> <spanclass=literal>'('- >> <spanclass=identifier>file_identifier- >> *( <spanclass=literal>',' >> <spanclass=identifier>file_identifier )

-            &gt;&gt; </span><span class=literal>')'

- >> <spanclass=literal>';'

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

+<pre> program_heading <spanclass="special">= as_lower_d<spanclass="special">["program"<spanclass="special">] >> <spanclass="identifier">identifier <spanclass="special">>> '(' >> <spanclass="identifier">file_identifier <spanclass="special">>> *( ',' <spanclass="special">>> file_identifier) >> <spanclass="literal">')' >>';' <spanclass="special">;</pre>

 <ul>

<li> Nesting directives: If a rule does not fit on one line (80characters)

-    it should be continued on the next line intended by one level. </li>

+ it should be continued on the next line intended by one level. 嵌套指示符：如果一个规则不适合放在一行中(80个字符)，则应在下一行缩入一级继续。</li><li>The brackets of directives, semantic expressions (using Phoenix orLL lambda

-    expressions) or parsers should be placed as follows. </li>

+ expressions) or parsers should be placed as follows. 指示符、语义表达式(使用 Phoenix 或 LL lambda 表达式)或分析器的括号应如下放置。 </li>

 </ul>
-<pre>    <span class=identifier>identifier
-        </span><span class=special>=   </span><span class=identifier>nocase
-            </span><span class=special>[
-                </span><span class=identifier>lexeme
-                </span><span class=special>[

- alpha <spanclass=special>>> *(alnum <spanclass=special>| '_')[id_action]

-                ]
-            ]
-        ;</span></pre>

+<pre> identifier <spanclass="special">= nocase [ <spanclass="identifier">lexeme <spanclass="special">[ <spanclass="identifier">alpha >>*(alnum |'_')[id_action<spanclass="special">] ] ] ;</pre>

 <ul>
-  <li> Nesting unary operators (e.g.Kleene star) </li>

+ <li> Nesting unary operators (e.g.Kleene star) 嵌套的单参操作符(如克林星) </li><li>Unary rule operators (Kleene star, <tt>'!'</tt>, <tt>'+'</tt> etc.)shouldbe moved out one space before the corresponding indentation level, ifthisrule has a body or a sequence after it, which does not fit on on line.Thismakes the formatting more consistent and moves the rule 'body' at thesame- indentation level as the rule itself, highlighting the unaryoperator.</li>+ indentation level as the rule itself, highlighting the unaryoperator. 单参规则操作符(克林星, <tt>'!'</tt>, <tt>'+'</tt> 等等)应比相应的缩入级前移一格，如果该规则之后有一个规则体或序列且不能在一行中写完。这样格式更为统一且将规则体移至与规则本身相同的缩入级，突出了单参操作符。</li>

 </ul>
-<pre><span class=special>    </span><span class=identifier>block

- = *( <spanclass=identifier>label_declaration_part- | <spanclass=identifier>constant_definition_part- | <spanclass=identifier>type_definition_part- | <spanclass=identifier>variable_declaration_part- | <spanclass=identifier>procedure_and_function_declaration_part

-            </span><span class=special>)
-            &gt;&gt; </span><span class=identifier>statement_part
-        </span><span class=special>;</span></pre>

+<pre> <spanclass="identifier">block = *(label_declaration_part | <spanclass="identifier">constant_definition_part <spanclass="special">| <spanclass="identifier">type_definition_part <spanclass="special">| <spanclass="identifier">variable_declaration_part <spanclass="special">| <spanclass="identifier">procedure_and_function_declaration_part ) >> <spanclass="identifier">statement_part <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; 2001-2003 Joel de Guzman<br>
-  Copyright &copy; 2001-2002 Hartmut Kaiser<br>
-  Copyright &copy; 2001-2002 Chris Uzdavinis<br>
+<p class="copyright">Copyright © 2001-2003 Joel de Guzman<br>
+  Copyright © 2001-2002 Hartmut Kaiser<br>
+  Copyright © 2001-2002 Chris Uzdavinis<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/symbols.html Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/symbols.html Mon Oct 12 20:27:43 2009
@@ -1,35 +1,34 @@
-<html>
-<head>
-<title>Symbols</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>Symbols</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%">

- Symbols+ Symbols 符号表

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

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

This class symbols implements a symbol table. The symbol table holds adictionaryof symbols where each symbol is a sequence of CharTs (a <tt>char</tt>,<tt>wchar_t</tt>,<tt>int</tt>, enumeration etc.) . The template class, parameterized bythe charactertype (CharT), can work efficiently with 8, 16, 32 and even 64 bitcharacters.

-  Mutable data of type T is associated with each symbol.<br>

+ Mutable data of type T is associated with each symbol. 这个类 symbols实现了一个符号表。该符号表保存一个符号字典，其中每个符号是一个 CharTs (一个<tt>char</tt>, <tt>wchar_t</tt>,+ <tt>int</tt>, 或枚举值等等)的序列。这是一个模板类，按字符类型(CharT)参数化，可以有效地工作于 8, 16, 32 甚至 64 位字符。可变数据类型 T 被关联到每个符号。 

 </p>

Traditionally, symbol table management is maintained seperately outsidetheBNF grammar through semantic actions. Contrary to standard practice, theSpirit

@@ -37,29 +36,25 @@

used anywhere in the EBNF grammar specification. It is an example of adynamicparser. A dynamic parser is characterized by its ability to modify itsbehaviorat run time. Initially, an empty symbols object matches nothing. At anytime,

-  symbols may be added, thus, dynamically altering its behavior.</p>

+ symbols may be added, thus, dynamically altering its behavior. 传统上，符号表管理是通过语义动作分离到BNF语法之外的。与标准的做法相反，Spirit的符号表类 <tt>symbols</tt> 本身就是一个分析器。它的实例可以被用于EBNF语法规范的任何地主。它是一个动态分析器的例子。动态分析器的特点是它能够修改其在运行期的行为。起初，一个空的 symbols 对象不匹配任何东西。符合可以在任何时候被加入，以动态地改变其行为。Each entry in a symbol table has an associated mutable data slot. Inthis regard,one can view the symbol table as an associative container (or map) ofkey-value

-  pairs where the keys are strings. </p>

+ pairs where the keys are strings. 符号表中的每一项都有一个相关联的可变数据插槽。在这方面，你可以将符号表视为一个键-值对的关联容器(或映射)，其键为字符串。 The symbols class expects two template parameters (actually there is athird,see detail box). The first parameter <tt>T</tt> specifies the data typeassociatedwith each symbol (defaults to <tt>int</tt>) and the second parameter<tt>CharT</tt>- specifies the character type of the symbols (defaults to <tt>char</tt>).

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

- typename <spanclass=identifier>T = <spanclass=keyword>int,- typename <spanclass=identifier>CharT = <spanclass=keyword>char,- typename <spanclass=identifier>SetT = <spanclass=identifier>impl::<spanclass=identifier>tst<<spanclass=identifier>T, <spanclass=identifier>CharT>

-    </span><span class=special>&gt;

- class <spanclass=identifier>symbols;</pre>

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

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

-      State Trees</b><br>

+ specifies the character type of the symbols (defaults to<tt>char</tt>). symbols 类有两个模板参数(实际上还有第三个，请见详细说明)。第一个参数 <tt>T</tt> 指定与每个符号相关联的数据类型(缺省为<tt>int</tt>)，而第二个参数 <tt>CharT</tt>

+  则指定符号的字符类型(缺省为 <tt>char</tt>)。 </p>

+<pre> <spanclass="keyword">template <spanclass="special">< typenameT =int, typename CharT= <spanclass="keyword">char, <spanclass="keyword">typename SetT <spanclass="special">= impl<spanclass="special">::tst<spanclass="special"><T<spanclass="special">, CharT<spanclass="special">> > class <spanclass="identifier">symbols;</pre>

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

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

+      State Trees 三元状态树</b><br>
       <br>

The actual set implementation is supplied by the SetT templateparameter(3rd template parameter of the symbols class) . By default, thisuses the

-      tst class which is an implementation of the Ternary Search Tree. <br>

+ tst class which is an implementation of the Ternary Search Tree. 实际的集合实现由模板参数 SetT 提供(即 symbols 类的第3个模板参数)。缺省地，它使用一个三元状态树

+      tst 类。<br>
       <br>

Ternary Search Trees are faster than hashing for many typical searchproblemsespecially when the search interface is iterator based. Searchingfor a

@@ -67,138 +62,109 @@

at most O(log n+k) character comparisons. TSTs are many times fasterthanhash tables for unsuccessful searches since mismatches arediscovered earlierafter examining only a few characters. Hash tables always examine anentire

-      key when searching.<br>
+      key when searching.<br>三

+元状态树在许多典型的搜索问题中要快于散列，特别是当搜索接口是基于迭代器的时候。在一个带有 n 个字符串的三元状态树中搜索一个长度为 k

+的字符串，至多需要 O(log n+k) 次字符比较。对于不成功的搜索，TSTs

+要比散列表快出许多倍，因为失配的情况可以在只比较少量几个字符之后，就更早地被察觉。散列表在搜索时则总是测试整个键值。 

       <br>

- For details see <ahref="http://www.cs.princeton.edu/%7Ers/strings/";>http://www.cs.princeton.edu/~rs/strings/</a>.</td>+ For details see <ahref="http://www.cs.princeton.edu/%7Ers/strings/";>http://www.cs.princeton.edu/~rs/strings/</a>. 详情请见 <ahref="http://www.cs.princeton.edu/%7Ers/strings/";>http://www.cs.princeton.edu/~rs/strings/</a>.</td>

   </tr>
-</table>
-<p>Here are some sample declarations:</p>

-<pre> <spanclass=identifier>symbols<> <spanclass=identifier>sym;- symbols<spanclass=special><short<spanclass=special>, wchar_t<spanclass=special>> sym2<spanclass=special>;

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

- int <spanclass=identifier>id;- double <spanclass=identifier>value;

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

- symbols<spanclass=special><my_info<spanclass=special>> sym3<spanclass=special>;</pre>

+</tbody></table>
+<p>Here are some sample declarations<br>以下是一些声明的例子</p>

+<pre> <spanclass="identifier">symbols<>sym; symbols<spanclass="special"><short<spanclass="special">, wchar_t<spanclass="special">> sym2<spanclass="special">; structmy_info <spanclass="special">{ intid; double <spanclass="identifier">value; <spanclass="special">}; <spanclass="identifier">symbols<<spanclass="identifier">my_info> <spanclass="identifier">sym3;</pre>After having declared our symbol tables, symbols may be addedstatically using

-  the construct:</p>

-<pre> sym =a, <spanclass=identifier>b, <spanclass=identifier>c, <spanclass=identifier>d ...;</pre>-where <tt>sym</tt> is a symbol table and <tt>a..d</tt> etc. arestrings. <img src="theme/note.gif" width="16" height="16">Note

+  the construct:<br>定义了我们的符号表之后，就可以用以下结构添加符号：</p>

+<pre> sym =a,b,c,d <spanclass="special">...;</pre>+where <tt>sym</tt> is a symbol table and <tt>a..d</tt> etc. arestrings. <img src="theme/note.gif" height="16" width="16">Notethat the comma operator is separating the items being added to thesymbol table,through an assignment. Due to operator overloading this is possible andcorrect(though it may take a little getting used to) and is a concise way toinitializethe symbol table with many symbols. Also, it is perfectly valid to makemultipleassignments to a symbol table to iteratively add symbols (or groups ofsymbols)

-  at different times.</p>
-<p>Simple example:<br>

+ at different times. 其中 <tt>sym</tt> 是一个符号表，<tt>a..d</tt> 等等则是字符串。<img src="theme/note.gif" height="16" width="16">注意，多个符号用逗号操作符分开，再通过赋值添加到符号表中。得益于操作符重载，使得这成为可能，且正确实现(尽管可能需要一些习惯)，而且这也是以多个符号初始化一个符号表的简单方法。此外，也完全可以对一个符号表多次赋值，在不同的时间反复添加符号(或符号组)。

+<p>Simple example:<br>简单例子：<br>
 </p>

-<pre> sym ="pineapple","orange","banana","apple","mango"<spanclass=special>;</pre>+<pre> sym ="pineapple","orange","banana","apple","mango"<spanclass="special">;</pre>Note that it is invalid to add the same symbol multiple times to asymbol table,- though you may modify the value associated with a symbol artibrarilymany times.

-<p>Now, we may use sym in the grammar. Example:</p>

-<pre> fruits =sym >>*(',' <spanclass=special>>> sym<spanclass=special>);</pre>+ though you may modify the value associated with a symbol artibrarilymany times. 注意，将同一个符号多次添加到一个符号表中是无效的，虽然你可以任意多次地修改与某个符号相关联的值。+Now, we may use sym in the grammar. Example: 现在，我们可以在语法中使用 sym 了。例如：+<pre> fruits =sym >>*(','>> <spanclass="identifier">sym);</pre>Alternatively, symbols may be added dynamically through the memberfunctor- <tt>add</tt> (see <tt><ahref="#symbol_inserter">symbol_inserter</a></tt> below).+ <tt>add</tt> (see <tt><ahref="symbols.html#symbol_inserter">symbol_inserter</a></tt> below).The member functor <tt>add</tt> may be attached to a parser as asemantic action

-  taking in a begin/end pair:</p>

-<pre> p[<spanclass=identifier>sym.<spanclass=identifier>add]</pre>

+  taking in a begin/end pair:<br>另外，符号也可以通过成员仿函数

+ <tt>add</tt> (见下文的 <tt><ahref="#symbol_inserter">symbol_inserter</a></tt>)来动态添加。成员仿函数<tt>add</tt> 可以被作为接受一对 begin/end 的语义动作附加到一个分析器：+<pre> p<spanclass="special">[sym<spanclass="special">.add<spanclass="special">]</pre>where p is a parser (and sym is a symbol table). On success, thematching portion

-  of the input is added to the symbol table.</p>
-<p><tt>add</tt> may also be used to directly initialize data. Examples:</p>

-<pre> sym<spanclass=special>.add<spanclass=special>("hello"<spanclass=special>, 1<spanclass=special>)("crazy"<spanclass=special>, 2<spanclass=special>)("world"<spanclass=special>, 3<spanclass=special>);</pre>-Assuming of course that the data slot associated with <tt>sym</tt> isan integer.+ of the input is added to the symbol table. 其中 p 为一个分析器(且 sym为一个符号表)。成功时，输入的匹配部分被添加到符号表中。+<tt>add</tt> may also be used to directly initialize data.Examples: <tt>add</tt> 也可以被用于直接初始化数据。例如：+<pre> sym<spanclass="special">.add<spanclass="special">("hello"<spanclass="special">, 1<spanclass="special">)("crazy"<spanclass="special">, 2<spanclass="special">)("world"<spanclass="special">, 3<spanclass="special">);</pre>+Assuming of course that the data slot associated with <tt>sym</tt> isan integer. 当然，这要假设与 <tt>sym</tt> 关联的数据插槽是一个整数。The data associated with each symbol may be modified any time. The mostobviousway of course is through <a href="semantic_actions.html">semanticactions</a>.A function or functor, as usual, may be attached to the symbol table.The symbol

-  table expects a function or functor compatible with the signature:</p>
-<p><b>Signature for functions:</b></p>

-<pre><code> <spanclass=keyword>void func<spanclass=special>(T<spanclass="special">& data<spanclass=special>);</code></pre>

-<p><b>Signature for functors:</b><br>

+ table expects a function or functor compatible with the signature: 与每个符号相关联的数据可以随时被修改。当然，最明显的方法是通过 <ahref="semantic_actions.html">语义动作</a> 来修改。通常，可以将一个函数或仿函数附加至符号表。符号表要求该函数或仿函数兼容于以下签名：

+<p><b>Signature for functions:&nbsp; 函数的签名：</b></p>

+<pre><code> <spanclass="keyword">void func<spanclass="special">(T<spanclass="special">& data<spanclass="special">);</code></pre>

+<p><b>Signature for functors: &nbsp;仿函数的签名：</b><br>
 </p>

-<pre><code> <spanclass=keyword>struct ftor

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

- void <spanclass=keyword>operator()(<spanclass=identifier>T&<spanclass=identifier> data) <spanclass=keyword>const;

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

+<pre><code> <spanclass="keyword">struct ftor { voidoperator<spanclass="special">()(T<spanclass="special">& data<spanclass="special">) const<spanclass="special">; <spanclass="special">};</code></pre>Where <tt>T</tt> is the data type of the symbol table (the <tt>T</tt>in itstemplate parameter list). When the symbol table successfully matchessomethingfrom the input, the data associated with the matching entry in thesymbol table

-  is reported to the semantic action.</p>
-<h2>Symbol table utilities</h2>

+ is reported to the semantic action. 其中 <tt>T</tt> 为符号表的数据类型(即模板参数列表中的 <tt>T</tt>)。当符号表从输入中成功匹配出某些东西时，符号表中与匹配项相关联的数据将被报告至语义动作。

+<h2>Symbol table utilities 符号表工具</h2>

Sometimes, one may wish to deal with the symbol table directly.Provided are

-  some symbol table utilities.</p>
-<p><b>add</b></p>

-<pre> template<typenameT, <spanclass=keyword>typename CharT<spanclass=special>, typename <spanclass=identifier>SetT>- T*add(<spanclass=identifier>symbols<<spanclass=identifier>T, <spanclass=identifier>CharT, <spanclass=identifier>SetT>& <spanclass=identifier>table, <spanclass=identifier>CharT const<spanclass=special>* sym<spanclass=special>, T <spanclass=keyword>const& <spanclass=identifier>data = <spanclass=identifier>T());</pre>+ some symbol table utilities. 有时，你可能希望直接处理符号表。我们提供了一些符号表工具。

+<p><b>add 添加</b></p>

+<pre> template<typenameT,typename <spanclass="identifier">CharT, <spanclass="keyword">typename SetT<spanclass="special">> T<spanclass="special">* add<spanclass="special">(symbols<spanclass="special"><T<spanclass="special">, CharT<spanclass="special">, SetT<spanclass="special">>& table<spanclass="special">, CharT <spanclass="keyword">const* <spanclass="identifier">sym, <spanclass="identifier">T const<spanclass="special">& data <spanclass="special">= T<spanclass="special">());</pre>adds a symbol <tt>sym</tt> (C string) to a symbol table <tt>table</tt>plusan optional data <tt>data</tt> associated with the symbol. Returns apointerto the data associated with the symbol or <tt>NULL</tt> if add failed(e.g.

-  when the symbol is already added before).<br>

+ when the symbol is already added before). 将符号 <tt>sym</tt> (C字符串)添加到符号表 <tt>table</tt> 并附加一个可选的数据 <tt>data</tt> 关联至该符号。返回一个指向关联到该符号的数据的指针，如果失败(例如，该符号之前已被添加)则返回 <tt>NULL</tt>。 

   <br>
-  <b>find</b></p>

-<pre> template<typenameT, <spanclass=keyword>typename CharT<spanclass=special>, typename <spanclass=identifier>SetT>- T*find(<spanclass=identifier>symbols<<spanclass=identifier>T, <spanclass=identifier>CharT, <spanclass=identifier>SetT> <spanclass=keyword>const& <spanclass=identifier>table, <spanclass=identifier>CharT const<spanclass=special>* sym<spanclass=special>);</pre>

+  <b>find 查找</b></p>

+<pre> template<typenameT,typename <spanclass="identifier">CharT, <spanclass="keyword">typename SetT<spanclass="special">> T<spanclass="special">* find<spanclass="special">(symbols<spanclass="special"><T<spanclass="special">, CharT<spanclass="special">, SetT<spanclass="special">> const<spanclass="special">& table<spanclass="special">, CharT <spanclass="keyword">const* <spanclass="identifier">sym);</pre>finds a symbol <tt>sym</tt> (C string) from a symbol table<tt>table</tt>.Returns a pointer to the data associated with the symbol or<tt>NULL</tt> if

-  not found</p>

+ not found 从符号表 <tt>table</tt> 中查找一个符号 <tt>sym</tt> (C字符串)。返回一个指向关联到该符号的数据的指针，如果查找失败则返回 <tt>NULL</tt>。

 <h2><a name="symbol_inserter"></a>symbol_inserter</h2>

The symbols class holds an instance of this class named <tt>add</tt>.Thiscan be called directly just like a member function, passing in afirst/last

-  iterator and optional data:<br>

+ iterator and optional data: symbols 类中持有该类的一个名为<tt>add</tt> 的实例。它可以象一个成员函数那样被直接调用，传入一对 first/last

+  迭代器以及可选的数据：<br>
   <br>
 </p>

-<pre> sym<spanclass=special>.add<spanclass=special>(first<spanclass=special>, last<spanclass=special>, data<spanclass=special>);</pre>

-<p>Or, passing in a C string and optional data:<br>

+<pre> sym<spanclass="special">.add<spanclass="special">(first<spanclass="special">, last<spanclass="special">, data<spanclass="special">);</pre>+Or, passing in a C string and optional data: 或者，传入一个C字符串和可选的数据： 

 </p>

-<pre> sym<spanclass=special>.add<spanclass=special>(c_string<spanclass=special>, data<spanclass=special>);</pre>+<pre> sym<spanclass="special">.add<spanclass="special">(c_string<spanclass="special">, data<spanclass="special">);</pre>where <tt>sym</tt> is a symbol table. The <tt>data</tt> argument isoptional.The nice thing about this scheme is that it can be cascaded. We've seenthis

-  applied above. Here's a snippet from the roman numerals parser</p>

-<pre> // Parse roman numerals (1..9) using thesymbol table.

- struct ones: <spanclass=identifier>symbols<<spanclass=keyword>unsigned>

-    </span><span class=special>{
-       </span><span class=identifier>ones</span><span class=special>()
-       </span><span class=special>{
-            </span><span class=identifier>add

- (<spanclass=string>"I" , <spanclass=number>1)- (<spanclass=string>"II" , <spanclass=number>2)- (<spanclass=string>"III" , <spanclass=number>3)- (<spanclass=string>"IV" , <spanclass=number>4)- (<spanclass=string>"V" , <spanclass=number>5)- (<spanclass=string>"VI" , <spanclass=number>6)- (<spanclass=string>"VII" , <spanclass=number>7)- (<spanclass=string>"VIII" , <spanclass=number>8)- (<spanclass=string>"IX" , <spanclass=number>9)

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

- } <spanclass=identifier>ones_p;</pre>+ applied above. Here's a snippet from the roman numerals parser 其中<tt>sym</tt> 是一个符号表。参数 <tt>data</tt> 是可选的。这种机制的好处是，它可以级联。前面我们已经见过它的应用。以下是来自罗马数字分析器的代码片断+<pre> // Parse roman numerals (1..9) using thesymbol table. struct <spanclass="identifier">ones : <spanclass="identifier">symbols<<spanclass="keyword">unsigned> { <spanclass="identifier">ones() <spanclass="special">{ <spanclass="identifier">add <spanclass="special">("I" <spanclass="special">, 1<spanclass="special">) <spanclass="special">("II" <spanclass="special">, 2<spanclass="special">) <spanclass="special">("III" <spanclass="special">, 3<spanclass="special">) <spanclass="special">("IV" <spanclass="special">, 4<spanclass="special">) <spanclass="special">("V" <spanclass="special">, 5<spanclass="special">) <spanclass="special">("VI" <spanclass="special">, 6<spanclass="special">) <spanclass="special">("VII" <spanclass="special">, 7<spanclass="special">) <spanclass="special">("VIII" <spanclass="special">, 8<spanclass="special">) <spanclass="special">("IX" <spanclass="special">, 9<spanclass="special">) ; } }ones_p<spanclass="special">;</pre>Notice that a user defined struct <tt>ones</tt> is subclassed from<tt>symbols</tt>.- Then at construction time, we added all the symbols using the<tt>add</tt> symbol_inserter.- <img height="16" width="15" src="theme/lens.gif"> The full source codecan be <a href="../example/fundamental/roman_numerals.cpp">viewed here</a>.This is part of the Spirit distribution.+ Then at construction time, we added all the symbols using the<tt>add</tt> symbol_inserter. 注意，用户自定义的结构 <tt>ones</tt> 是<tt>symbols</tt> 的子类。在构造的时候，我们用 <tt>add</tt> symbol_inserter添加所有符号。+ <img src="theme/lens.gif" height="16" width="15"> The full source codecan be <a href="../example/fundamental/roman_numerals.cpp">viewed here</a>.This is part of the Spirit distribution. <img src="theme/lens.gif"height="16" width="15"> 完整的源代码可以 <ahref="../example/fundamental/roman_numerals.cpp">在此查看</a>。这是Spirit发布包的一部分。Again, <tt>add</tt> may also be used as a semantic action since itconforms

-  to the action interface (see semantic actions):<br>

+ to the action interface (see semantic actions): 同样，<tt>add</tt> 也可以被用作语义动作，因为它符合动作的接口(见语义动作)： 

 </p>

-<pre> p<spanclass=special>[sym<spanclass=special>.add<spanclass=special>]</pre>

-<p>where p is a parser of course.<span class=special><br>

+<pre>p[<spanclass="identifier">sym.<spanclass="identifier">add]</pre>+where p is a parser of course. 其中 p 当然是一个分析器了。<spanclass="special"> 

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

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

Use, modification and distribution is subject to 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/techniques.html      Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/techniques.html      Mon Oct 12 20:27:43 2009
@@ -1,100 +1,76 @@
-<html>
-<head>
-<title>Techniques</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>Techniques</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%"> Techniques</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%"> Techniques 技术</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="style_guide.html"><img src="theme/l_arr.gif"border="0"></a></td><td width="30"><a href="faq.html"><img src="theme/r_arr.gif"border="0"></a></td>

   </tr>
-</table>
+</tbody></table>
 <ul>
-  <li><a href="#templatized_functors">Templatized Functors</a></li>

- <li><a href="#multiple_scanner_support">Rule With MultipleScanners</a></li>+ <li><a href="#templatized_functors">Templatized Functors 模板化仿函数</a></li>+ <li><a href="#multiple_scanner_support">Rule With Multiple Scanners 带多个扫描器的规则</a></li>

   <li><a href="#no_rules">Look Ma' No Rules!</a></li>
   <li><a href="#typeof">typeof</a></li>
   <li><a href="#nabialek_trick">Nabialek trick</a></li>
 </ul>
-<h3><a name="templatized_functors"></a> Templatized Functors</h3>

+<h3><a name="templatized_functors"></a> Templatized Functors 模板化仿函数</h3>For the sake of genericity, it is often better to make the functor'smember<tt>operator()</tt> a template. That way, we do not have to concernourselveswith the type of the argument to expect as long as the behavior isappropriate.For instance, rather than hard-coding <tt>char const*</tt> as theargument ofa generic semantic action, it is better to make it a template memberfunction.

-  That way, it can accept any type of iterator:</p>

-<pre><code> <spanclass=keyword>struct my_functor

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

- template <spanclass=special><typename <spanclass=identifier>IteratorT>- 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>

+ That way, it can accept any type of iterator: 从泛型的角度看，令仿函数的+ <tt>operator()</tt> 成员模板化往往是较好的做法。这样，我们不必关心参数的类型，只要其行为是适当的即可。例如，不要硬编码 <tt>char const*</tt> 作为一个通用的语义动作的参数，最好是使它成为一个模板成员函数。这样，它就可以接受任意的迭代器类型：+<pre><code> <spanclass="keyword">struct my_functor { <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">IteratorT> void <spanclass="keyword">operator()(<spanclass="identifier">IteratorT <spanclass="identifier">first, <spanclass="identifier">IteratorT <spanclass="identifier">last) <spanclass="keyword">const; <spanclass="special">};</code></pre>Take note that this is only possible with functors. It is not possibleto passin template functions as semantic actions unless you cast it to thecorrectfunction signature; in which case, you monomorphize thefunction. This

-  clearly shows that functors are superior to plain functions.</p>

+ clearly shows that functors are superior to plain functions. 注意，这只对仿函数是可能的。不可能将模板函数作为语义动作传入，除非您将它转换为正确的函数签名；在这种情况下，你monomorphize了该函数。这清楚地表明了，仿函数优于普通的函数。<h3><a name="multiple_scanner_support"id="multiple_scanner_support"></a> Rule

-  With Multiple Scanners</b></h3>
+  With Multiple Scanners 带多个扫描器的规则</b></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 <ahref="rule.html#multiple_scanner_support">multiple

-  scanner support</a>. </p>

+ scanner support</a>. 截至 v1.8.0，规则可以使用一个或多个扫描器类型。在某些情况下，例如，我们需要一个可以工作于短语和字符层面的规则时。规则/扫描器间的失配已一直是混乱的源头，也是首当其冲的 <ahref="faq.html#scanner_business">FAQ</a>。为解决此问题，我们需要 <ahref="rule.html#multiple_scanner_support">多扫描器支持</a>。 Here is an example of a grammar with a rule <tt>r</tt> that can becalled with3 types of scanners (phrase-level, lexeme, and lower-case). See the <ahref="rule.html">rule</a>,<a href="grammar.html">grammar</a>, <ahref="scanner.html#lexeme_scanner">lexeme_scanner</a>- and <a href="scanner.html#as_lower_scanner">as_lower_scanner </a>formore information.+ and <a href="scanner.html#as_lower_scanner">as_lower_scanner </a>formore information. 以下是一个语法例子，其中有一个规则 <tt>r</tt> 可用3个扫描器类型调用(短语级别的、词位的和小写的)。更多信息请见 <ahref="rule.html">规则</a>,+ <a href="grammar.html">语法</a>, <ahref="scanner.html#lexeme_scanner">lexeme_scanner</a> 和 <ahref="scanner.html#as_lower_scanner">as_lower_scanner</a>。

 </p>

-Here's the grammar (see <ahref="../example/techniques/multiple_scanners.cpp">multiple_scanners.cpp</a>):+Here's the grammar (see <ahref="../example/techniques/multiple_scanners.cpp">multiple_scanners.cpp</a>): 以下就是这个语法(见 <ahref="../example/techniques/multiple_scanners.cpp">multiple_scanners.cpp</a>):

 </p>

-<pre> structmy_grammar :grammar<spanclass=special><my_grammar<spanclass=special>>

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

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

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

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

- r <spanclass=special>= lower_p<spanclass=special>;- rr <spanclass=special>= +(<spanclass=identifier>lexeme_d[<spanclass=identifier>r] <spanclass=special>>> as_lower_d<spanclass=special>[r]>> <spanclass=identifier>r);

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

- typedef <spanclass=identifier>scanner_list<

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

- , <spanclass=keyword>typename <spanclass=identifier>lexeme_scanner<<spanclass=identifier>ScannerT>::<spanclass=identifier>type- , <spanclass=keyword>typename <spanclass=identifier>as_lower_scanner<spanclass=special><ScannerT<spanclass=special>>::type- > <spanclass=identifier>scanners;

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

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

+<pre> structmy_grammar :grammar<spanclass="special"><my_grammar<spanclass="special">> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">definition(<spanclass="identifier">my_grammar <spanclass="keyword">const& <spanclass="identifier">self) { <spanclass="identifier">r = <spanclass="identifier">lower_p; rr =+(<spanclass="identifier">lexeme_d[<spanclass="identifier">r] <spanclass="special">>> <spanclass="identifier">as_lower_d[<spanclass="identifier">r] <spanclass="special">>> r<spanclass="special">); <spanclass="special">} typedefscanner_list<spanclass="special">< <spanclass="identifier">ScannerT ,typename <spanclass="identifier">lexeme_scanner<spanclass="special"><ScannerT<spanclass="special">>::type , typenameas_lower_scanner<spanclass="special"><ScannerT<spanclass="special">>::type > <spanclass="identifier">scanners<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">scanners> <spanclass="identifier">r; rule<spanclass="special"><ScannerT<spanclass="special">> rr<spanclass="special">; <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="keyword">const& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return rr<spanclass="special">; } <spanclass="special">}; };</pre>

 <p>By default support for multiple scanners is disabled.  The macro
   <tt>BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT</tt> must be defined to the
   maximum number of scanners allowed in a scanner_list.  The value must
   be greater than 1 to enable multiple scanners.  Given the
   example above, to define a limit of three 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 中允许的最大扫描器数量。该值必须大于1才能激活多扫描器。在以上例子中，要定义扫描器列表中最多可有3个扫描器，以下一行必须插入到源文件中包含Spirit头文件之前：

 </p>

-<pre> #defineBOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT3</pre>-<h3> <a name="no_rules" id="no_rules"></a>Look

-  Ma' No Rules</b></h3>

+<pre> #defineBOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT3</pre>+<h3> <a name="no_rules" id="no_rules"></a>Look

+  Ma' No Rules 看，不使用规则</b></h3>

You use grammars and you use lots of 'em? Want a fly-weight,no-cholesterol,

-  super-optimized grammar? Read on...</p>

+ super-optimized grammar? Read on... 你使用语法且经常使用吗？想要一个轻量级的、没有多余部分、超级优化的语法吗？继续读下去...I have a love-hate relationship with rules. I guess you know thereasons why.A lot of problems stem from the limitation of rules. Dynamicpolymorphism andstatic polymorphism in C++ do not mix well. There is no notion ofvirtual template

@@ -102,272 +78,153 @@

specific scanner type. This results in problems such as the <ahref="faq.html#scanner_business">scannerbusiness</a>, our no. 1 FAQ. Apart from that, the virtual functions inrulesslow down parsing, kill all meta-information, and kills inlining, hencebloating

-  the generated code, especially for very tiny rules such as:</p>

+ the generated code, especially for very tiny rules such as: 我对规则是又爱又恨。我猜你应该知道其中的原因。许多问题是源于对规则的限制。动态多态性和静态多态性在C++中未能很好地混合。在C++中，没有虚拟模板函数的概念；至少目前还没有。因此，规则是针对某一特定的扫描器类型的。这导致了 <ahref="faq.html#scanner_business">扫描器事务</a> 此类问题，我们第一的FAQ。此外，规则中的虚拟函数降低了分析的速度，消灭了所有元信息，也消灭了内联，因此生成的代码极度膨胀，尤其是对于非常微型的规则，如：<pre> r = ch_p<spanclass="special">('x'<spanclass="special">) >> uint_p;</pre> The rule's limitation is the main reason why the grammar is designedthe wayit is now, with a nested template definition class. The rule'slimitation isalso the reason why subrules exists. But do we really need rules? Ofcourse!Before C++ adopts some sort of auto-type deduction, such as thatproposed by

-  David Abrahams in clc++m:</p>
-<pre>

- <code>auto r= ...definition...</code></pre>+ David Abrahams in clc++m: 这个规则的限制是语法为何以现有方式，嵌套模板定义类，来设计的主要原因。这个规则的限制也是子规则为何存在的原因。但是，我们真的需要规则吗？当然！在C++采用某各种自动类型推演，正如

+  David Abrahams 在 clc++m 中所建议的那样：</p>

+<pre> <code>auto <spanclass="identifier">r = ...<spanclass="identifier">definition <spanclass="special">...</code></pre> we are tied to the rule as RHS placeholders. However.... in someoccasions

-  we can get by without rules! For instance, rather than writing:</p>
-<pre>

- <code>rule<>x = <spanclass=identifier>ch_p(<spanclass=literal>'x');</code></pre>

-<p> It's better to write:</p>
-<pre>

- <code>chlit<>x = <spanclass=identifier>ch_p(<spanclass=literal>'x');</code></pre>+ we can get by without rules! For instance, rather than writing: 之前，我们只能绑定在规则上，作为RHS占位符。但是....在某些场合，我们可以不需要规则！例如，与其这样写：+<pre> <code>rule<spanclass="special"><> x <spanclass="special">= ch_p<spanclass="special">('x'<spanclass="special">);</code></pre>

+<p> It's better to write:<br>不如这样写更好：</p>

+<pre> <code>chlit<spanclass="special"><> x <spanclass="special">= ch_p<spanclass="special">('x'<spanclass="special">);</code></pre> That's trivial. But what if the rule is rather complicated? Ok, let'sproceedstepwise... I'll investigate a simple skip_parser based on the C grammarfrom- Hartmut Kaiser. Basically, the grammar is written as (see <ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a>):-<pre><code> struct <spanclass=identifier>skip_grammar : <spanclass=identifier>grammar<<spanclass=identifier>skip_grammar>

-    {

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

- definition<spanclass=special>(skip_grammar <spanclass=keyword>const& /*<spanclass=identifier>self*/)

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

- = <spanclass=identifier>space_p- | <spanclass=string>"//" >>*(anychar_p -'\n') >>'\n'- | <spanclass=string>"/*" >>*(anychar_p -"*/")>> "*/"

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

- rule<spanclass=special><ScannerT<spanclass=special>> skip<spanclass=special>;

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

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

+ Hartmut Kaiser. Basically, the grammar is written as (see <ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a>): 这很平常。不过，如果规则比较复杂呢？好的，我们继续向前... 我将探讨一个基于C语法的简单 skip_parser，它来自+ Hartmut Kaiser。基本上，这个语法可以写成(见 <ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a>)：+<pre><code> struct <spanclass="identifier">skip_grammar : <spanclass="identifier">grammar<<spanclass="identifier">skip_grammar> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">definition(<spanclass="identifier">skip_grammar <spanclass="keyword">const& /*<spanclass="identifier">self*/) { <spanclass="identifier">skip <spanclass="special">= <spanclass="identifier">space_p <spanclass="special">| "//" <spanclass="special">>> *(anychar_p- <spanclass="literal">'\n') >> <spanclass="literal">'\n' <spanclass="special">| "/*" <spanclass="special">>> *(anychar_p- "*/"<spanclass="special">) >> <spanclass="string">"*/" <spanclass="special">; } <spanclass="identifier">rule<<spanclass="identifier">ScannerT> <spanclass="identifier">skip; rule<spanclass="special"><ScannerT<spanclass="special">> const<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return skip<spanclass="special">; } }; };</code></pre> Ok, so far so good. Can we do better? Well... since there are norecursiverules there (in fact there's only one rule), you can expand the type ofrule's- RHS as the rule type (see <ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a>):-<pre><code> structskip_grammar :grammar<spanclass=special><skip_grammar<spanclass=special>>

-    {

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

- definition<spanclass=special>(skip_grammar <spanclass=keyword>const& /*<spanclass=identifier>self*/)

-            : </span><span class=identifier>skip</span><span class=special>
-                (       </span><span class=identifier>space_p

- | <spanclass=string>"//" >>*(anychar_p -'\n') >>'\n'- | <spanclass=string>"/*" >>*(anychar_p -"*/")>> "*/"

-                </span><span class=special>)
-            {
-            }
-
-            </span><span class=keyword>typedef

- alternative<spanclass=special><alternative<spanclass=special><space_parser<spanclass=special>, sequence<spanclass=special><sequence<spanclass=special><- strlit<spanclass=special><const <spanclass=keyword>char*>, <spanclass=identifier>kleene_star<<spanclass=identifier>difference<<spanclass=identifier>anychar_parser,- chlit<spanclass=special><char<spanclass=special>> > > >, <spanclass=identifier>chlit<<spanclass=keyword>char> > >, <spanclass=identifier>sequence<<spanclass=identifier>sequence<- strlit<spanclass=special><const <spanclass=keyword>char*>, <spanclass=identifier>kleene_star<<spanclass=identifier>difference<<spanclass=identifier>anychar_parser,- strlit<spanclass=special><const <spanclass=keyword>char*> > > >,strlit<spanclass=special><const <spanclass=keyword>char*> > >- skip_t<spanclass=special>;- <spanclass=identifier>skip_t skip<spanclass=special>;

- skip_t <spanclass=keyword>const&- start<spanclass=special>() const <spanclass=special>{ return <spanclass=identifier>skip; }

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

+ RHS as the rule type (see <ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a>): 好的，不错。我们可以做得更好吗？嗯... 由于这里没有递归的规则(事实上只有一个规则)，你可以将规则的RHS类型扩展为规则的类型(见 <ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a>)：+<pre><code> structskip_grammar :grammar<spanclass="special"><<spanclass="identifier">skip_grammar> { template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">definition <spanclass="special">{ <spanclass="identifier">definition(<spanclass="identifier">skip_grammar <spanclass="keyword">const& /*<spanclass="identifier">self*/) :skip+ ( <spanclass="identifier">space_p <spanclass="special">| "//" <spanclass="special">>> *(anychar_p- <spanclass="literal">'\n') >> <spanclass="literal">'\n' <spanclass="special">| "/*" <spanclass="special">>> *(anychar_p- "*/"<spanclass="special">) >> <spanclass="string">"*/" <spanclass="special">) { } typedef <spanclass="identifier">alternative<<spanclass="identifier">alternative<<spanclass="identifier">space_parser, <spanclass="identifier">sequence<<spanclass="identifier">sequence<spanclass="special">< <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*>, <spanclass="identifier">kleene_star<<spanclass="identifier">difference<<spanclass="identifier">anychar_parser<spanclass="special">, <spanclass="identifier">chlit<<spanclass="keyword">char> > > >,chlit<spanclass="special"><char<spanclass="special">> > >, <spanclass="identifier">sequence<<spanclass="identifier">sequence<spanclass="special">< <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*>, <spanclass="identifier">kleene_star<<spanclass="identifier">difference<<spanclass="identifier">anychar_parser<spanclass="special">, <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*> > > >, <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*> > > <spanclass="identifier">skip_t; <spanclass="special"> skip_tskip<spanclass="special">; skip_tconst<spanclass="special">& <spanclass="identifier">start() <spanclass="keyword">const { <spanclass="keyword">return skip<spanclass="special">; } }; };</code></pre> Ughhh! How did I do that? How was I able to get at the complextypedef? AmI insane? Well, not really... there's a trick! What you do is define thetypedef

-  <tt>skip_t</tt> first as int:</p>
-<pre>

- <code>typedef intskip_t<spanclass=special>;</code></pre>+ <tt>skip_t</tt> first as int: Ughhh! 我是怎么做的呢？我怎么能得到这个复杂的 typedef? 我疯了吗？嗯，这不是真的... 这里有个诀窍！你要做的就是首先定义 typedef

+  <tt>skip_t</tt> 为 int:</p>

+<pre> <code>typedef <spanclass="keyword">int skip_t<spanclass="special">;</code></pre> Try to compile. Then, the compiler will generate an obnoxious errormessage

-  such as:</p>
-<pre>

- <code>"cannot convertboost::spirit::alternative<... blah blah...to int"<spanclass=special>.</code></pre>

+  such as:<br>试着编译一下。然后，编译器会生成一个可恶的错误信息如下：</p>

+<pre> <code>"cannot convertboost::spirit::alternative<... blah blah...to int"<spanclass="special">.</code></pre> THERE YOU GO! You got it's type! I just copy andpaste the

-  correct type (removing explicit qualifications, if preferred).</p>

+ correct type (removing explicit qualifications, ifpreferred). 做到了！你得到了它的类型！我只需复制并粘贴这个正确的类型即可(删去显式的限定符，如果愿意的话)。 Can we still go further? Yes. Remember that the grammar was designedfor rules.The nested template definition class is needed to get around the rule'slimitations.Without rules, I propose a new class called <tt>sub_grammar</tt>, thegrammar's

-  low-fat counterpart:</p>

-<pre><code> namespaceboost {namespace spirit

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

- template <spanclass=special><typename <spanclass=identifier>DerivedT>- struct <spanclass=identifier>sub_grammar : <spanclass=identifier>parser<<spanclass=identifier>DerivedT>

-        {

- typedef <spanclass=identifier>sub_grammar <spanclass=identifier>self_t;- typedef <spanclass=identifier>DerivedT const<spanclass=special>& embed_t<spanclass=special>;

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

- typedef <spanclass=keyword>typename <spanclass=identifier>parser_result<- typename <spanclass=identifier>DerivedT::<spanclass=identifier>start_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- type<spanclass=special>;

-            };
-

- DerivedT <spanclass=keyword>const& <spanclass=identifier>derived() <spanclass=keyword>const- { return*<spanclass=keyword>static_cast<<spanclass=identifier>DerivedT const<spanclass=special>*>(this<spanclass=special>); }

- template <spanclass=special><typename <spanclass=identifier>ScannerT>- typename <spanclass=identifier>parser_result<<spanclass=identifier>self_t, <spanclass=identifier>ScannerT>::<spanclass=identifier>type- parse<spanclass=special>(ScannerT <spanclass=keyword>const& <spanclass=identifier>scan) <spanclass=keyword>const

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

- return <spanclass=identifier>derived().<spanclass=identifier>start.<spanclass=identifier>parse(<spanclass=identifier>scan);

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

+ low-fat counterpart: 我们还可以走得更远吗？是的。记住，语法是为规则而设计的。内嵌的模板定义类是必需的，以绕过规则的限制。没有规则，我提议一个名为 <tt>sub_grammar</tt> 的新类，该语法的轻量级方式：+<pre><code> <spanclass="keyword">namespace boost{ namespacespirit <spanclass="special">{ template<typenameDerivedT<spanclass="special">> structsub_grammar :parser<spanclass="special"><DerivedT<spanclass="special">> { <spanclass="keyword">typedef sub_grammarself_t<spanclass="special">; typedefDerivedT <spanclass="keyword">const& <spanclass="identifier">embed_t; template <spanclass="special"><typename <spanclass="identifier">ScannerT> struct <spanclass="identifier">result <spanclass="special">{ typedeftypename <spanclass="identifier">parser_result<spanclass="special">< <spanclass="keyword">typename <spanclass="identifier">DerivedT::<spanclass="identifier">start_t, <spanclass="identifier">ScannerT>::<spanclass="identifier">type <spanclass="identifier">type; }; DerivedT <spanclass="keyword">const& <spanclass="identifier">derived() <spanclass="keyword">const {return <spanclass="special">*static_cast<spanclass="special"><DerivedT <spanclass="keyword">const*>(<spanclass="keyword">this); } template <spanclass="special"><typename <spanclass="identifier">ScannerT> typename <spanclass="identifier">parser_result<spanclass="special"><self_t<spanclass="special">, ScannerT<spanclass="special">>::type parse<spanclass="special">(ScannerT <spanclass="keyword">const& <spanclass="identifier">scan) <spanclass="keyword">const <spanclass="special">{ returnderived<spanclass="special">().start<spanclass="special">.parse<spanclass="special">(scan<spanclass="special">); } }; }}</code></pre>With the <tt>sub_grammar</tt> class, we can define our skipper grammarthis- way (see <ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a>):-<pre><code> structskip_grammar :sub_grammar<spanclass=special><skip_grammar<spanclass=special>>

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

-        </span><span class=identifier>start_t</span><span class=special>;
-

- skip_grammar<spanclass=special>()

-        : </span><span class=identifier>start
-            </span><span class=special>(
-                </span><span class=identifier>space_p

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

- start_t <spanclass=identifier>start;

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

+ way (see <ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a>): 有了这个 <tt>sub_grammar</tt> 类，我们可以按以下方式定义我们的跳读语法(见 <ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a>)：+<pre><code> structskip_grammar :sub_grammar<spanclass="special"><<spanclass="identifier">skip_grammar> { typedef alternative<spanclass="special"><alternative<spanclass="special"><<spanclass="identifier">space_parser, <spanclass="identifier">sequence<<spanclass="identifier">sequence< strlit<spanclass="special"><const <spanclass="keyword">char*>, <spanclass="identifier">kleene_star<<spanclass="identifier">difference<<spanclass="identifier">anychar_parser<spanclass="special">, <spanclass="identifier">chlit<<spanclass="keyword">char> > > >,chlit<spanclass="special"><char<spanclass="special">> > >, <spanclass="identifier">sequence<<spanclass="identifier">sequence< strlit<spanclass="special"><const <spanclass="keyword">char*>, <spanclass="identifier">kleene_star<<spanclass="identifier">difference<<spanclass="identifier">anychar_parser<spanclass="special">, <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*> > > >, <spanclass="identifier">strlit<<spanclass="keyword">const char<spanclass="special">*> > > <spanclass="identifier">start_t; skip_grammar<spanclass="special">() : <spanclass="identifier">start <spanclass="special">( <spanclass="identifier">space_p |"//" >>*(anychar_p -'\n') >>'\n' <spanclass="special">| "/*" <spanclass="special">>> *(anychar_p- "*/"<spanclass="special">) >> "*/" ) {} <spanclass="identifier">start_t <spanclass="identifier">start; };</code></pre>But what for, you ask? You can simply use the <tt>start_t</tt> typeabove as-is.

-  It's already a parser! We can just type:</p>
-<pre>

- <code>skipper_t <spanclass=identifier>skipper =

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

- | <spanclass=string>"//" >>*(anychar_p -'\n') >>'\n' <spanclass=special>| "/*" <spanclass=special>>> *(anychar_p- <spanclass=string>"*/") >>"*/"

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

+ It's already a parser! We can just type: 但是这该怎么用，你会问？你可以如上只使用 <tt>start_t</tt> 类型。它已经是一个分析器了！我们可以只输入：+<pre> <code>skipper_t <spanclass="identifier">skipper = space_p <spanclass="special">| "//" <spanclass="special">>> *(anychar_p- <spanclass="literal">'\n') >> <spanclass="literal">'\n' |"/*" >>*(anychar_p -"*/") >>"*/"

+    <span class="special">    ;</span></code></pre>

 and use <tt>skipper</tt> just as we would any parser? Well, a subtledifferenceis that <tt>skipper</tt>, used this way will be embedded byvalue whenyou compose more complex parsers using it. That is, if we use<tt>skipper</tt>inside another production, the whole thing will be stored in thecomposite.

-  Heavy!</p>

- The proposed <tt>sub_grammar</tt> OTOH will be held by reference.Note:-<pre><code> typedef <spanclass=identifier>DerivedT const<spanclass=special>& embed_t<spanclass=special>;</code></pre>+ Heavy! 仅将 <tt>skipper</tt> 用作我们所需的分析器？那么，一个微妙的区别在于，以该方式使用 <tt>skipper</tt>，当你用它组成更复杂的分析器时它是以值方式嵌入的。即，如果我们在另一个分析器中使用<tt>skipper</tt>，整个东西都将被保存在组合物中。这有点太沉重了！+ The proposed <tt>sub_grammar</tt> OTOH will be held by reference.Note: 另一方面，这个建议的 <tt>sub_grammar</tt> 应该以引用方式保存。如：+<pre><code> typedef <spanclass="identifier">DerivedT const<spanclass="special">& embed_t<spanclass="special">;</code></pre>The proposed <tt>sub_grammar</tt> does not have the inherentlimitations ofrules, is very lighweight, and should be blazingly fast (can be fullyinlinedand does not use virtual functions). Perhaps this class will be part ofa future

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

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

-      no-rules result</strong><br> <br>

+ spirit release. 这个建议的 <tt>sub_grammar</tt> 没有规则的固有限制，非常轻量，也应极其快速(完全可以内联且不使用虚拟函数)。也许这个类会是未来版本的spirit的一部分。 

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

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

+      no-rules result 无规则的结果</strong><br> <br>

So, how much did we save? On MSVCV7.1, the original code: <ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a>compiles to 28k. Eliding rules, <ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a>,we got 24k. Not bad, we shaved off 4k amounting toa 14%reduction. But you'll be in for a surprise. The last version, usingthesub-grammar: <ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a>,- compiles to 5.5k! That's a whopping 80%reduction. + compiles to 5.5k! That's a whopping 80%reduction. 那么，我们节省了多少呢？在MSVCV7.1上，原来的代码 <ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a>+ 编译后有 28k。不用规则的 <ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a> 则是24k。不错，我们砍掉了4k，减小了14%。不过你会更加惊讶。最后一个版本，使用子语法的 <ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a>

+      编译后只有 <strong>5.5k</strong>! 高达80%的缩减。<br>
       <br>
-      <table width="100%" border="1">
-        <tr>
+      <table border="1" width="100%">
+        <tbody><tr>

<td><ahref="../example/techniques/no_rules/no_rule1.cpp">no_rule1.cpp</a></td>

           <td><strong>28k</strong></td>
-          <td>standard rule and grammar</td>
+          <td>standard rule and grammar 标准规则和语法</td>
         </tr>
         <tr>

<td><ahref="../example/techniques/no_rules/no_rule2.cpp">no_rule2.cpp</a></td>

           <td><strong>24k</strong></td>
-          <td>standard grammar, no rule</td>
+          <td>standard grammar, no rule 标准语法，无规则</td>
         </tr>
         <tr>

<td><ahref="../example/techniques/no_rules/no_rule3.cpp">no_rule3.cpp</a></td>

           <td><strong>5.5k</strong></td>
-          <td>sub_grammar, no rule, no grammar</td>
+          <td>sub_grammar, no rule, no grammar 子语法，无规则，无语法</td>
         </tr>
-      </table> </td>
+      </tbody></table> </td>
   </tr>
-</table>
+</tbody></table>
 <h3><b> <a name="typeof" id="typeof"></a> typeof</b></h3>

Some compilers already support the <tt>typeof</tt> keyword. Examplesare g++and Metrowerks CodeWarrior. Someday, <tt>typeof</tt> will becomecommonplace.It is worth noting that we can use <tt>typeof</tt> to definenon-recursive ruleswithout using the rule class. To give an example, we'll use the skipperexampleabove; this time using <tt>typeof</tt>. First, to avoid redundancy,we'll introduce

-  a macro <tt>RULE</tt>: </p>

-<pre><code> #define <spanclass=identifier>RULE(<spanclass=identifier>name, <spanclass=identifier>definition) <spanclass="keyword">typeof(<spanclass=identifier>definition) <spanclass=identifier>name = <spanclass=identifier>definition</code></pre>

-<p>Then, simply:</p>

-<pre><code> <spanclass=identifier>RULE(

-        </span><span class=identifier>skipper</span><span class=special>,
-        (       </span><span class=identifier>space_p

-        </span><span class=special>)
-    );</span></code></pre>
-<p>(see <a href="../example/techniques/typeof.cpp">typeof.cpp</a>)</p>

+ a macro <tt>RULE</tt>: 有些编译器已经支持 <tt>typeof</tt> 关键字。例如 g++ 和 Metrowerks CodeWarrior。迟早，<tt>typeof</tt> 会被广泛支持。值得注意的是，我们可以用 <tt>typeof</tt> 来定义非递归规则而无需使用规则类。举个例子，我们将使用前面的跳读器例子；这次使用 <tt>typeof</tt>。首先，为了避免重复，我们引入一个宏 <tt>RULE</tt>: +<pre><code> #define <spanclass="identifier">RULE(<spanclass="identifier">name, <spanclass="identifier">definition) <spanclass="keyword">typeof(<spanclass="identifier">definition) <spanclass="identifier">name = <spanclass="identifier">definition</code></pre>

+<p>Then, simply:<br>然后，只需：</p>

+<pre><code> <spanclass="identifier">RULE( skipper<spanclass="special">, ( <spanclass="identifier">space_p |"//" >>*(anychar_p -'\n') >>'\n' <spanclass="special">| "/*" <spanclass="special">>> *(anychar_p- "*/"<spanclass="special">) >> "*/" ) );</code></pre>+(see <a href="../example/techniques/typeof.cpp">typeof.cpp</a>) (见<a href="../example/techniques/typeof.cpp">typeof.cpp</a>)That's it! Now you can use skipper just as you would any parser. Bereminded,however, that <tt>skipper</tt> above will be embedded by valuewhen- you compose more complex parsers using it (see<tt>sub_grammar</tt> rationale above). You can use the <tt>sub_grammar</tt>class to avoid this problem.+ you compose more complex parsers using it (see<tt>sub_grammar</tt> rationale above). You can use the <tt>sub_grammar</tt>class to avoid this problem. 就是这样！现在你可以象任意分析器那样使用skipper。不过要记住，当你使用以上的 <tt>skipper</tt> 来合成更为复杂的分析器时，它是以值方式嵌入的(见前文的 <tt>sub_grammar</tt> 原理)。你可以使用<tt>sub_grammar</tt> 类来避免这个问题。

 <h3><a name="nabialek_trick"></a> Nabialek trick</h3>

-This technique, I'll call the "Nabialek trick"(from the name of its inventor, Sam Nabialek), can improvethe rule dispatch from linear non-deterministic to deterministic. The trickapplies to grammars where a keyword (operator, etc), precedes a production.There are lots of grammars similar to this:

-<pre>    <span class=identifier>r </span><span class=special>=

- keyword1 <spanclass=special>>> production1- | <spanclass=identifier>keyword2 >> <spanclass=identifier>production2- | <spanclass=identifier>keyword3 >> <spanclass=identifier>production3- | <spanclass=identifier>keyword4 >> <spanclass=identifier>production4- | <spanclass=identifier>keyword5 >> <spanclass=identifier>production5

-        </span><span class=comment>/*** etc ***/
-        </span><span class=special>;</span></pre>

-The cascaded alternatives are tried one at a time through trial anderror until something matches. The Nabialek trick takes advantage of the <ahref="symbols.html">symbol table</a>'s search properties to optimize thedispatching of the alternatives. For an example, see <ahref="../example/techniques/nabialek.cpp">nabialek.cpp</a>. The grammarworks as follows. There are two rules (<tt>one</tt> and <tt>two</tt>). When"one" is recognized, rule <tt>one</tt> is invoked. When"two" is recognized, rule <tt>two</tt> is invoked. Here's thegrammar:-<pre> one= name<spanclass=special>;- two =name >>',' >>name;

- continuations<spanclass=special>.add- (<spanclass=string>"one", &<spanclass=identifier>one)- (<spanclass=string>"two", &<spanclass=identifier>two)

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

- line =continuations<spanclass=special>[set_rest<spanclass=special><rule_t<spanclass=special>>(rest<spanclass=special>)] >> <spanclass=identifier>rest;</pre>-where continuations is a <a href="symbols.html">symbol table</a> withpointer to rule_t slots. one, two, name, line and rest are rules:-<pre> rule_tname;- rule_t <spanclass=identifier>line;- rule_t <spanclass=identifier>rest;- rule_t <spanclass=identifier>one;- rule_t <spanclass=identifier>two;

- symbols<spanclass=special><rule_t<spanclass=special>*> continuations<spanclass=special>;</pre>

-<p>set_rest, the semantic action attached to continuations is:</p>

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

- set_rest<spanclass=special>(Rule<spanclass=special>& the_rule<spanclass=special>)- : <spanclass=identifier>the_rule(<spanclass=identifier>the_rule) <spanclass=special>{}

- void <spanclass=keyword>operator()(<spanclass=identifier>Rule* <spanclass=identifier>newRule) <spanclass=keyword>const- { <spanclass=identifier>m_theRule = <spanclass=special>*newRule<spanclass=special>; }

- Rule&the_rule;

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

-Notice how the rest <tt>rule</tt> gets set dynamically when theset_rule action is called. The dynamic grammar parses inputs such as:

-<p> &quot;one only&quot;<br>
-&quot;one again&quot;<br>
-&quot;two first, second&quot;</p>

-The cool part is that the <tt>rest</tt> rule is set (by the<tt>set_rest</tt> action) depending on what the symbol table got. If it gota "one" then rest = one. If it got"two", then rest = two. Very nifty! This techniqueshould be very fast, especially when there are lots of keywords. It wouldbe nice to add special facilities to make this easy to use. I imagine:-<pre> r <spanclass=special>= keywords <spanclass=special>>> rest<spanclass=special>;</pre>-where <tt>keywords</tt> is a special parser (based on the symbol table)that automatically sets its RHS (rest) depending on the acquired symbol.This, I think, is mighty cool! Someday perhaps... -<img src="theme/note.gif" width="16" height="16"> Also, see the <ahref="switch_parser.html">switch parser</a> for another deterministicparsing trick for character/token prefixes. 

-<span class=special></span>

+This technique, I'll call the "Nabialek trick"(from

+the name of its inventor, Sam Nabialek), can improve the rule dispatch
+from linear non-deterministic to deterministic. The trick applies to
+grammars where a keyword (operator, etc), precedes a production. There

+are lots of grammars similar to this: 这个技术我称之为"Nabialek诀窍" (来自它的发明者 Sam Nabialek)，可以将规则的分派由线性非确定性改进为确定性的。该诀窍适用于关键字(操作符等)语法，生成一个结果。有许多语法类似于：+<pre> r <spanclass="special">= keyword1>> <spanclass="identifier">production1 |keyword2 <spanclass="special">>> <spanclass="identifier">production2 |keyword3 <spanclass="special">>> <spanclass="identifier">production3 |keyword4 <spanclass="special">>> <spanclass="identifier">production4 |keyword5 <spanclass="special">>> <spanclass="identifier">production5 /***etc ***/ ;</pre>

+<p>The cascaded alternatives are tried one at a time through trial and
+error until something matches. The Nabialek trick takes advantage of

+the <a href="symbols.html">symbol table</a>'s search properties tooptimize the dispatching of the alternatives. For an example, see <ahref="../example/techniques/nabialek.cpp">nabialek.cpp</a>. The grammarworks as follows. There are two rules (<tt>one</tt> and <tt>two</tt>).When "one" is recognized, rule <tt>one</tt> is invoked. When "two" isrecognized, rule <tt>two</tt> is invoked. Here's the grammar: 这个级联的多选是通过反复的试错，直至有某个选项匹配。Nabialek诀窍利用 <ahref="symbols.html">符号表</a> 的查找特性来优化多个选项的分派。相关例子请见<a href="../example/techniques/nabialek.cpp">nabialek.cpp</a>. 该语法工作如下。有两个规则(<tt>one</tt> 和 <tt>two</tt>)。当识别出 "one" 时，调用规则<tt>one</tt>。当识别出 "two" 时，则调用规则 <tt>two</tt>。语法如下：+<pre> one= <spanclass="identifier">name; <spanclass="identifier">two = <spanclass="identifier">name >> <spanclass="literal">',' >> <spanclass="identifier">name; continuations<spanclass="special">.add ("one"<spanclass="special">, &one<spanclass="special">) (<spanclass="string">"two", &<spanclass="identifier">two) <spanclass="special">; line= <spanclass="identifier">continuations[<spanclass="identifier">set_rest<<spanclass="identifier">rule_t>(<spanclass="identifier">rest)] <spanclass="special">>> rest<spanclass="special">;</pre>+where continuations is a <a href="symbols.html">symbol table</a> withpointer to rule_t slots. one, two, name, line and rest are rules: 其中continuations 是一个 <a href="symbols.html">符号表</a>，带有指向 rule_t 项的指针。one, two, name, line 和 rest 均为规则：+<pre> rule_tname; rule_t <spanclass="identifier">line; <spanclass="identifier">rule_t rest<spanclass="special">; rule_tone; rule_t <spanclass="identifier">two; symbols<spanclass="special"><rule_t<spanclass="special">*> <spanclass="identifier">continuations;</pre>+set_rest, the semantic action attached to continuations is: set_rest是附加至 continuations 的语义动作，如下：+<pre> template<typenameRule<spanclass="special">> structset_rest <spanclass="special">{ <spanclass="identifier">set_rest(<spanclass="identifier">Rule& <spanclass="identifier">the_rule) : <spanclass="identifier">the_rule(<spanclass="identifier">the_rule) <spanclass="special">{} voidoperator<spanclass="special">()(Rule<spanclass="special">* newRule<spanclass="special">) const { m_theRule= *<spanclass="identifier">newRule; <spanclass="special">} <spanclass="identifier">Rule& <spanclass="identifier">the_rule; };</pre>+Notice how the rest <tt>rule</tt> gets set dynamically when theset_rule action is called. The dynamic grammar parses inputs such as: 注意，在 set_rule 动作被调用时，rest <tt>rule</tt> 是如何被动态设置。该动态语法分析如下的输入：

+<p> "one only"<br>
+"one again"<br>
+"two first, second"</p>

+The cool part is that the <tt>rest</tt> rule is set (by the<tt>set_rest</tt> action) depending on what the symbol table got. If it gota "one" then rest = one. If it got "two",

+then rest = two. Very nifty! This technique should be very fast,
+especially when there are lots of keywords. It would be nice to add

+special facilities to make this easy to use. I imagine: 最酷的部分是，<tt>rest</tt> 规则被依据所获得的符号表而设置(通过 <tt>set_rest</tt> 动作)。如果它获得一个 "one" 则 rest = one。如果它获得 "two",+则 rest = two。1多漂亮！这种技术应该非常快，尤其是有大量关键字的时候。应该增加一些特殊的工具令之更为易用。我想：+<pre> r= keywords>> <spanclass="identifier">rest;</pre>

+<p>where <tt>keywords</tt> is a special parser (based on the symbol
+table) that automatically sets its RHS (rest) depending on the acquired

+symbol. This, I think, is mighty cool! Someday perhaps... 其中<tt>keywords</tt> 是一个特殊的分析器(基于符号符)，它自动根据所获得的符号设置其右操作数(rest)。我想，这真的很酷！也许有一天... +<img src="theme/note.gif" height="16" width="16"> Also, see the <ahref="switch_parser.html">switch parser</a> for another deterministicparsing trick for character/token prefixes. <img src="theme/note.gif"height="16" width="16"> 另外，还有一个用于字符/记号前缀的确定性分析技巧，请见 <a href="switch_parser.html">跳转分析器</a>。 

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

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

Use, modification and distribution is subject to the BoostSoftware

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)</font></p>
 <p class="copyright">&nbsp;</p>
-</body>
-</html>
+</body></html>
=======================================
--- /trunk/libs/spirit/classic/doc/trees.html   Tue Mar 31 01:07:16 2009
+++ /trunk/libs/spirit/classic/doc/trees.html   Mon Oct 12 20:27:43 2009
@@ -1,16 +1,17 @@

-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01Transitional//EN"><html><head><title>Trees</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>Trees</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">
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
   <tbody><tr>
     <td width="10">
     <br>
 </td>

- <td width="85%"> Trees+ <td width="85%"> Trees 树

     </td>

   </tr>
 </tbody></table>
 <br>
@@ -23,23 +24,23 @@

<td width="30"><a href="multi_pass.html"><img src="theme/r_arr.gif"border="0"></a></td>

    </tr>
 </tbody></table>
-<h2>Why use parse trees</h2>
+<h2>Why use parse trees 为什么要用分析树</h2>

 Parse trees are an in-memory representation of the input with astructure

-  that conforms to the grammar.</p>
-<p> The advantages of using parse trees instead of semantic actions:</p>

+ that conforms to the grammar. 分析树是输入在内存中的一个表示法，它带有与语法相符合的结构。+ The advantages of using parse trees instead of semantic actions: 使用分析树替代语义动作的优点：

 <ul>

<li>You can make multiple passes over the data without having tore-parse the

-    input.</li>
-  <li>You can perform transformations on the tree.</li>
+    input.<br>你可以多次遍历数据，而无需对输入进行重新分析。</li>

+ <li>You can perform transformations on the tree. 你可以在树上执行变换。</li><li>You can evaluate things in any order you want, whereas withattribute schemes

-    you have to process in a begin to end fashion.</li>

+ you have to process in a begin to end fashion. 你可以按任意顺序对你想要的东西求值，而使用属性机制则你必须从头到尾来处理。</li><li>You do not have to worry about backtracking and action side effectsthat

-    may occur with an ambiguous grammar.</li>

+ may occur with an ambiguous grammar. 你不需要担心一个模糊语法可能的回溯和动作的副作用。</li>

 </ul>
-<p> <b>Example</b></p>
+<p> <b>Example 例子</b></p>

 Now that you think you may want to use trees, I'll give an example ofhowto use them and you can see how easy they are to use. So, following withtradition- (and the rest of the documentation) we'll do a calculator. Here's thegrammar:+ (and the rest of the documentation) we'll do a calculator. Here's thegrammar: 现在假设你想使用分析树，我将给出一个关于如何使用它们的例子，你会看到使用它们是多容易。嗯，根据传统(以及本文档的其余部分)，我们要实现一个计算器。以下是语法：<pre> <code>integer <spanclass="special">= <fontcolor="#ff0000">token_node_d[(!ch_p<spanclass="special">('-'<spanclass="special">) >> +<spanclass="identifier">digit_p)] ; factor = <spanclass="identifier">integer |'(' >>expression <spanclass="special">>> ')' | ('-'>> <spanclass="identifier">factor<spanclass="special">) ; <spanclass="identifier">term =factor >> *( ('*' <spanclass="special">>> factor<spanclass="special">) | ('/'>> <spanclass="identifier">factor) ) ; <spanclass="identifier">expression =term <spanclass="special">>> *( ('+'>> <spanclass="identifier">term) | ('-' >>term<spanclass="special">) ) ;</code></pre>

@@ -49,28 +50,30 @@
   Further note that <tt>token_node_d</tt> is an implicit lexeme (that means
   no <tt>lexeme_d</tt> is needed to switch to character level parsing).
   As you'll soon see, it's easier to convert the input into an int when all

- the characters are in one node. Here is how the parse is done to createa tree:+ the characters are in one node. Here is how the parse is done to createa tree: 现在，你会留意到，在这个语法中不同的仅仅是 <tt>token_node_d</tt>+ 指示符。它导致这个 integer 规则在一个节点处结束。没有<tt>token_node_d</tt>，则每个字符都会有自己的节点。进一步，留意<tt>token_node_d</tt> 是一个隐式的词位(这意味着，不需要 <tt>lexeme_d</tt> 来切换至字符层面的分析)。正如你即将看到的，如果所有字符在一个节点中，则更容易将输入转换为一个 int。以下是如何在分析完成后创建一棵树：<pre> <code>tree_parse_info<spanclass="special"><> info <spanclass="special">= <fontcolor="#ff0000">pt_parse<spanclass="special">(first<spanclass="special">, expression<spanclass="special">);</code></pre> <tt>pt_parse()</tt> is similar to <tt>parse()</tt>. There are fouroverloads:two for pairs of first and last iterators and two for character strings.Two

-  of the functions take a skipper parser and the other two do not.</p>

+ of the functions take a skipper parser and the other two donot. <tt>pt_parse()</tt> 类似于 <tt>parse()</tt>。它有四个重载：两个使用first 和 last 迭代器对，两个使用字符串。两个接受一个跳过分析器，另两个则不接受。 The <tt>tree_parse_info</tt> struct contains the same information as a<tt>parse_info</tt>struct as well as one extra data member called trees. When the parsefinishes,

-  trees will contain the parse tree.</p>
-<p> Here is how you can use the tree to evaluate the input:</p>

+ trees will contain the parse tree. 结构 <tt>tree_parse_info</tt>包含与 <tt>parse_info</tt>+ 结构相同的信息，以及一个额外的数据成员，名为 trees。当分析完成时，trees中将包含该分析树。+ Here is how you can use the tree to evaluate the input: 以下是如何使用这棵树来对输入求值：<pre> <code>if <spanclass="special">(info<spanclass="special">.full<spanclass="special">) { cout<< "parsingsucceeded\n"; <spanclass="identifier">cout << <spanclass="string">"result = " <<<fontcolor="#ff0000">evaluate<spanclass="special">(info<spanclass="special">) << "\n\n"<spanclass="special">; }</code></pre> Now you ask, where did <tt>evaluate()</tt> come from? Is it part ofspirit?Unfortunately, no, <tt>evaluate()</tt> is only a part of the sample.Here it

-  is:</p>

+ is: 现在你会问，<tt>evaluate()</tt> 是从哪来的？它是spirit的一部分吗？很不幸，它不是，<tt>evaluate()</tt> 只是本例的一部分。以下就是它：<pre> <code>long <spanclass="identifier">evaluate(<spanclass="keyword">const <spanclass="identifier">tree_parse_info<spanclass="special"><>& <spanclass="identifier">info) <spanclass="special">{ returneval_expression<spanclass="special">(info<spanclass="special">.trees<spanclass="special">.begin<spanclass="special">()); <spanclass="special">}</code></pre> So here you see evaluate() simply calls <tt>eval_expression()</tt>passing- the begin() iterator of info.trees. Now here's the rest of theexample:-<pre> <code>// Here's some typedefs to simplifythings typedef char const<spanclass="special">* <spanclass="identifier">iterator_t; typedef <spanclass="identifier">tree_match<<spanclass="identifier">iterator_t> parse_tree_match_t<spanclass="special">; typedef <spanclass="identifier">parse_tree_match_t<spanclass="special">::const_tree_iteratoriter_t; <spanclass="comment">// Here's the function prototypes that we'll use. Onefunction for each // grammar rule<spanclass="special">. long <spanclass="identifier">evaluate(<spanclass="keyword">const <spanclass="identifier">tree_parse_info<spanclass="special"><>& <spanclass="identifier">info); <spanclass="keyword">long <spanclass="identifier">eval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i); <spanclass="keyword">long eval_term<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i); <spanclass="keyword">long <spanclass="identifier">eval_factor(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">); long <spanclass="identifier">eval_integer(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">); // i should bepointing to a node created by the expression rule <spanclass="keyword">long <spanclass="identifier">eval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i) { // first child points to a term, so calleval_term on it iter_t chi= <spanclass="identifier">i-><spanclass="identifier">children.<spanclass="identifier">begin(); long lhs= <spanclass="identifier">eval_term(<spanclass="identifier">chi); for <spanclass="special">(++chi<spanclass="special">; chi <spanclass="special">!= i<spanclass="special">->children<spanclass="special">.end<spanclass="special">(); ++chi<spanclass="special">) { <spanclass="comment">// next node points to the operator. The text of theoperator is // stored in value (avector<char>) charop =*(chi<spanclass="special">->value<spanclass="special">.begin<spanclass="special">()); ++<spanclass="identifier">chi; long rhs= <spanclass="identifier">eval_term(<spanclass="identifier">chi); if (<spanclass="identifier">op == <spanclass="literal">'+') lhs +=rhs<spanclass="special">; else if(op== <spanclass="literal">'-') lhs -=rhs<spanclass="special">; <spanclass="keyword">else <spanclass="identifier">assert(<spanclass="number">0); } return <spanclass="identifier">lhs; } long <spanclass="identifier">eval_term(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">) { // ...see <ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a>for complete example // (it's rather similar toeval_expression() ) ... } long <spanclass="identifier">eval_factor(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">) { // ...again, see <ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a>if you want all the details ... <spanclass="special">} long <spanclass="identifier">eval_integer(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">) { // use the range constructor for astring string <spanclass="identifier">integer(<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin(), <spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">end()); // convert the string to an integer return <spanclass="identifier">strtol(<spanclass="identifier">integer.<spanclass="identifier">c_str(), <spanclass="number">0, <spanclass="number">10); <spanclass="special">} </code></pre>- <img height="16" width="15" src="theme/lens.gif"> The full sourcecode can be <a href="../example/fundamental/parse_tree_calc1.cpp">viewedhere</a>. This is part of the Spirit distribution.-So, you like what you see, but maybe you think that the parse tree istoo+ the begin() iterator of info.trees. Now here's the rest of theexample: 你可以看到 evaluate() 只是调用 <tt>eval_expression()</tt> 而已，传入 info.trees 的 begin() 迭代器。以下是该例子的其它部分：+<pre> <code>// Here's some typedefs to simplifythings 这是一些typedef，用于简化 <spanclass="keyword">typedef char const<spanclass="special">* <spanclass="identifier">iterator_t; typedef <spanclass="identifier">tree_match<<spanclass="identifier">iterator_t> parse_tree_match_t<spanclass="special">; typedef <spanclass="identifier">parse_tree_match_t<spanclass="special">::const_tree_iteratoriter_t; <spanclass="comment">// Here's the function prototypes that we'll use. Onefunction for each // grammar rule.这是要用的函数原型。每个语法规则一个函数。 long <spanclass="identifier">evaluate(<spanclass="keyword">const <spanclass="identifier">tree_parse_info<spanclass="special"><>& <spanclass="identifier">info); <spanclass="keyword">long <spanclass="identifier">eval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i); <spanclass="keyword">long eval_term<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i); <spanclass="keyword">long <spanclass="identifier">eval_factor(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">); long <spanclass="identifier">eval_integer(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">); // i should bepointing to a node created by the expression rule // i 应指向一个由expression规则创建的节点 longeval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i) { // first child points to a term, so calleval_term on it 第一个子节点指向一个term，因此对它调用eval_term iter_t chi =i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">(); longlhs =eval_term<spanclass="special">(chi<spanclass="special">); for <spanclass="special">(++chi<spanclass="special">; chi <spanclass="special">!= i<spanclass="special">->children<spanclass="special">.end<spanclass="special">(); ++chi<spanclass="special">) { <spanclass="comment">// next node points to the operator. The text of theoperator is // stored in value (a vector<char>) 下一个节点指向操作符。操作符的文本保存在vector<char>中 char op= *(<spanclass="identifier">chi-><spanclass="identifier">value.<spanclass="identifier">begin()); ++chi<spanclass="special">; longrhs =eval_term<spanclass="special">(chi<spanclass="special">); if(op== <spanclass="literal">'+') lhs +=rhs<spanclass="special">; else if(op== <spanclass="literal">'-') lhs -=rhs<spanclass="special">; <spanclass="keyword">else <spanclass="identifier">assert(<spanclass="number">0); } return <spanclass="identifier">lhs; } long <spanclass="identifier">eval_term(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">) { // ...see <ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a>for complete example // (it's rather similar toeval_expression() ) ... </code><code><spanclass="special"> // ... 完整的例子见<ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a>,(与eval_expression()相似) </code><code>} longeval_factor<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i) { // ... again, see <ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a>if you want all the details ... // ... 同样，如果想知道细节，请见</code><code> <ahref="../example/fundamental/parse_tree_calc1.cpp">parse_tree_calc1.cpp</a></code><code> <spanclass="special">} long <spanclass="identifier">eval_integer(<spanclass="identifier">iter_t const<spanclass="special">& i<spanclass="special">) { // use the range constructor for a string 对字符串使用区间构造器 stringinteger<spanclass="special">(i<spanclass="special">->value<spanclass="special">.begin<spanclass="special">(), i<spanclass="special">->value<spanclass="special">.end<spanclass="special">()); // convert thestring to an integer 将字符串转换为整数 <spanclass="keyword">return strtol<spanclass="special">(integer<spanclass="special">.c_str<spanclass="special">(), 0<spanclass="special">, 10<spanclass="special">); <spanclass="special">} </code></pre>

+ <img src="theme/lens.gif" height="16" width="15"> The full sourcecode can be <a href="../example/fundamental/parse_tree_calc1.cpp">viewedhere</a>. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 完整的源代码可以 <ahref="../example/fundamental/parse_tree_calc1.cpp">在此查看</a>。这是Spirit发布包的一部分。So, you like what you see, but maybe you thinkthat the parse tree is toohard to process? With a few more directives you can generate anabstract syntaxtree (ast) and cut the amount of evaluation code by at least50%. So

-    without any delay, here's the ast calculator grammar:</p>

+ without any delay, here's the ast calculator grammar: 就象你所看到的，也许你认为这个分析树很难处理？只要一点点指示符，你就可以生成一个抽象语法树(ast)并缩减至少50%的求值代码数量。因此，不要拖延了，以下就是这个ast 计算器语法：<pre> <code>integer <spanclass="special">= <fontcolor="#ff0000">leaf_node_d[(!<spanclass="identifier">ch_p(<spanclass="literal">'-') >> +<spanclass="identifier">digit_p)] ; factor = <spanclass="identifier">integer |<fontcolor="#ff0000">inner_node_d<spanclass="special">[ch_p<spanclass="special">('('<spanclass="special">) >> expression>> <spanclass="identifier">ch_p(<spanclass="literal">')')] |(<fontcolor="#ff0000">root_node_d<spanclass="special">[ch_p<spanclass="special">('-'<spanclass="special">)] >> <spanclass="identifier">factor<spanclass="special">) ; <spanclass="identifier">term =factor >> *( (<fontcolor="#ff0000">root_node_d<spanclass="special">[ch_p<spanclass="special">('*'<spanclass="special">)] >> <spanclass="identifier">factor) | (<fontcolor="#ff0000">root_node_d<spanclass="special">[ch_p<spanclass="special">('/'<spanclass="special">)] >> <spanclass="identifier">factor) ) ; <spanclass="identifier">expression =term <spanclass="special">>> *( (<fontcolor="#ff0000">root_node_d<spanclass="special">[ch_p<spanclass="special">('+'<spanclass="special">)] >> <spanclass="identifier">term) |(<fontcolor="#ff0000">root_node_d<spanclass="special">[ch_p<spanclass="special">('-'<spanclass="special">)] >> <spanclass="identifier">term) ) ;</code></pre> The differences from the parse tree grammar are hi-lighted in <fontcolor="#ff0000">bold-red.

@@ -79,34 +82,32 @@

parentheses when evaluating the expression. The <tt>root_node_d</tt>directiveis the key to ast generation. A node that is generated by the parserinsideof <tt>root_node_d</tt> is marked as a root node. When a root node iscreated,- it becomes a root or parent node of the other nodes generated by thesame rule.+ it becomes a root or parent node of the other nodes generated by thesame rule. 与分析树语法的差异用 <fontcolor="#ff0000">bold-red 高亮显示。指示符 <tt>inner_node_d</tt>令内层分析器生成的第一个和最后一个节点被忽略，因为我们在对表达式求值时不关心其括号。指示符 <tt>root_node_d</tt> 是生成 ast 的关键。由<tt>root_node_d</tt> 内部的分析器所生成的节点被标记为根节点。当一个根节点被创建时，它会成为同一个规则所生成的其它节点的根节点或父节点。 To start the parse and generate the ast, you must use the ast_parsefunctions,

-  which are similar to the pt_parse functions.</p>

+ which are similar to the pt_parse functions. 要开始分析和生成 ast，你必须使用 ast_parse 函数，它类似于 pt_parse 函数。<pre> <code>tree_parse_info<spanclass="special"><> info <spanclass="special">= ast_parse<spanclass="special">(first<spanclass="special">, expression<spanclass="special">);</code></pre> Here is the eval_expression function (note that to process the ast weonly

-  need one function instead of four):</p>

-<pre> <code>long <spanclass="identifier">eval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i) <spanclass="special">{ if <spanclass="special">(i<spanclass="special">->value<spanclass="special">.id<spanclass="special">() == <spanclass="identifier">parser_id(&<spanclass="identifier">integer)) { <spanclass="comment">// convert string to integer <spanclass="identifier">string <spanclass="identifier">integer(<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin(), <spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">end()); return <spanclass="identifier">strtol(<spanclass="identifier">integer.<spanclass="identifier">c_str(), <spanclass="number">0, <spanclass="number">10); <spanclass="special">} else <spanclass="keyword">if (<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">id() <spanclass="special">== parser_id<spanclass="special">(&factor<spanclass="special">)) { // factor can only be unaryminus return <spanclass="special">- <spanclass="identifier">eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()); } else if(i<spanclass="special">->value<spanclass="special">.id<spanclass="special">() == <spanclass="identifier">parser_id(&<spanclass="identifier">term)) { <spanclass="keyword">if (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '*'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) * eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); <spanclass="special">} elseif (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '/'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) / eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); } } elseif (<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">id() <spanclass="special">== parser_id<spanclass="special">(&<spanclass="identifier">expression)) { <spanclass="keyword">if (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '+'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) + eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); <spanclass="special">} elseif (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '-'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) - eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); } } <spanclass="keyword">return 0<spanclass="special">; <spanclass="special">} </code></pre>- <img src="theme/lens.gif" width="15" height="16"> An entire workingexample is <a href="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a>.Hopefully this example has been enough to whet your appetite for- trees. For more nitty-gritty details, keep on reading the rest of thischapter.+ need one function instead of four): 以下是 eval_expression 函数(注意，处理 ast 我们只需要一个函数，而不是四个)：+<pre> <code>long <spanclass="identifier">eval_expression<spanclass="special">(iter_t <spanclass="keyword">const& <spanclass="identifier">i) <spanclass="special">{ if <spanclass="special">(i<spanclass="special">->value<spanclass="special">.id<spanclass="special">() == <spanclass="identifier">parser_id(&<spanclass="identifier">integer)) { <spanclass="comment">// convert string to integer 将字符串转换为整数 string <spanclass="identifier">integer(<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin(), <spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">end()); return <spanclass="identifier">strtol(<spanclass="identifier">integer.<spanclass="identifier">c_str(), <spanclass="number">0, <spanclass="number">10); <spanclass="special">} else <spanclass="keyword">if (<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">id() <spanclass="special">== parser_id<spanclass="special">(&factor<spanclass="special">)) { // factor can only be unary minus factor只能是单参减法 return <spanclass="special">- <spanclass="identifier">eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()); } else if(i<spanclass="special">->value<spanclass="special">.id<spanclass="special">() == <spanclass="identifier">parser_id(&<spanclass="identifier">term)) { <spanclass="keyword">if (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '*'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) * eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); <spanclass="special">} elseif (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '/'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) / eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); } } elseif (<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">id() <spanclass="special">== parser_id<spanclass="special">(&<spanclass="identifier">expression)) { <spanclass="keyword">if (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '+'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) + eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); <spanclass="special">} elseif (*<spanclass="identifier">i-><spanclass="identifier">value.<spanclass="identifier">begin() <spanclass="special">== '-'<spanclass="special">) <spanclass="special">{ returneval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()) - eval_expression<spanclass="special">(i<spanclass="special">->children<spanclass="special">.begin<spanclass="special">()+1<spanclass="special">); } } <spanclass="keyword">return 0<spanclass="special">; <spanclass="special">} </code></pre>+ <img src="theme/lens.gif" height="16" width="15"> An entire workingexample is <a href="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a>.Hopefully this example has been enough to whet your appetite for+ trees. For more nitty-gritty details, keep on reading the rest of thischapter. <img src="theme/lens.gif" height="16" width="15"> 整个可用的例子在 <a href="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a>。希望该例子足以满足你对分析树的欲望。更具体的细节，请继续阅读本章剩余部分。

 <a name="usage"></a>
-<h2>Usage</h2>
+<h2>Usage 用法</h2>
 <a name="pt_parse"></a>
 <h3>pt_parse</h3>

- To create a parse tree, you can call one of the five freefunctions:-<pre> template <spanclass=special><typename <spanclass=identifier>FactoryT, <spanclass=keyword>typename IteratorT<spanclass=special>, typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>IteratorT, <spanclass=identifier>FactoryT> pt_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last_, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip_,- FactoryT<spanclass=special> const<spanclass=special> & <spanclass="identifier">factory_ = <spanclass="identifier">FactoryT()); template <spanclass=special><typename <spanclass=identifier>IteratorT, <spanclass=keyword>typename ParserT<spanclass=special>, typename <spanclass=identifier>SkipT> tree_parse_info<spanclass=special><IteratorT<spanclass=special>> <spanclass=identifier>pt_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last_, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip_); template <spanclass=special><typename <spanclass=identifier>IteratorT, <spanclass=keyword>typename ParserT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>IteratorT> pt_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last_, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>); template<typenameCharT,typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>CharT const<spanclass=special>*> <spanclass=identifier>pt_parse( CharT <spanclass=keyword>const* <spanclass=identifier>str, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip); template <spanclass=special><typename <spanclass=identifier>CharT, <spanclass=keyword>typename ParserT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>CharT const<spanclass=special>*> <spanclass=identifier>pt_parse( CharT <spanclass=keyword>const* <spanclass=identifier>str, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>); </pre>+ To create a parse tree, you can call one of the five freefunctions: 要创建一个分析树，你可以调用以下五个自由函数之一：+<pre> template <spanclass="special"><typename <spanclass="identifier">FactoryT, <spanclass="keyword">typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><IteratorT<spanclass="special">, FactoryT<spanclass="special">> <spanclass="identifier">pt_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last_, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip_, FactoryTconst& factory_<spanclass="special"> = FactoryT<spanclass="special">()); template<typenameIteratorT,typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><IteratorT<spanclass="special">> <spanclass="identifier">pt_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last_, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip_); template <spanclass="special"><typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT> tree_parse_info<spanclass="special"><IteratorT<spanclass="special">> <spanclass="identifier">pt_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last_, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">); template<typenameCharT,typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><CharT <spanclass="keyword">const*> pt_parse<spanclass="special">( CharTconst*str, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip); template <spanclass="special"><typename <spanclass="identifier">CharT, <spanclass="keyword">typename <spanclass="identifier">ParserT> tree_parse_info<spanclass="special"><CharT <spanclass="keyword">const*> pt_parse<spanclass="special">( CharTconst*str, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">); </pre>

 <a name="ast_parse"></a>
 <h3>ast_parse</h3>

 To create an abstract syntax tree (ast for short) you call one of thefive

-  free functions:</p>

-<pre> template <spanclass=special><typename <spanclass=identifier>FactoryT, <spanclass=keyword>typename IteratorT<spanclass=special>, typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>IteratorT, <spanclass=identifier>FactoryT> ast_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last_, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip_,- FactoryT<spanclass=special> const<spanclass=special> & <spanclass="identifier">factory_ = <spanclass="identifier">FactoryT()<spanclass=special>); template<typenameIteratorT,typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>IteratorT> ast_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last_, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip_); template <spanclass=special><typename <spanclass=identifier>IteratorT, <spanclass=keyword>typename ParserT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>IteratorT> ast_parse( IteratorT <spanclass=keyword>const& <spanclass=identifier>first_, IteratorT <spanclass=keyword>const& <spanclass=identifier>last, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>); template<typenameCharT,typename <spanclass=identifier>ParserT, <spanclass=keyword>typename SkipT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>CharT const<spanclass=special>*> <spanclass=identifier>ast_parse( CharT <spanclass=keyword>const* <spanclass=identifier>str, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>, SkipTconst&skip); template <spanclass=special><typename <spanclass=identifier>CharT, <spanclass=keyword>typename ParserT<spanclass=special>> <spanclass=identifier>tree_parse_info<<spanclass=identifier>CharT const<spanclass=special>*> <spanclass=identifier>ast_parse( CharT <spanclass=keyword>const* <spanclass=identifier>str, parser<spanclass=special><ParserT<spanclass=special>> const<spanclass=special>& parser<spanclass=special>); </pre>+ free functions: 要创建一个抽象语法树(缩写为ast)，你可以调用以下五个自由函数之一：+<pre> template <spanclass="special"><typename <spanclass="identifier">FactoryT, <spanclass="keyword">typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><IteratorT<spanclass="special">, FactoryT<spanclass="special">> <spanclass="identifier">ast_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last_, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip_, FactoryTconst& factory_<spanclass="special"> = FactoryT<spanclass="special">()); <spanclass="keyword">template <<spanclass="keyword">typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><IteratorT<spanclass="special">> <spanclass="identifier">ast_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last_, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip_); template <spanclass="special"><typename <spanclass="identifier">IteratorT, <spanclass="keyword">typename <spanclass="identifier">ParserT> tree_parse_info<spanclass="special"><IteratorT<spanclass="special">> <spanclass="identifier">ast_parse( IteratorT <spanclass="keyword">const& <spanclass="identifier">first_, IteratorT <spanclass="keyword">const& <spanclass="identifier">last, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">); template<typenameCharT,typename <spanclass="identifier">ParserT, <spanclass="keyword">typename SkipT<spanclass="special">> <spanclass="identifier">tree_parse_info<spanclass="special"><CharT <spanclass="keyword">const*> ast_parse<spanclass="special">( CharTconst*str, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">, SkipTconst<spanclass="special">& <spanclass="identifier">skip); template <spanclass="special"><typename <spanclass="identifier">CharT, <spanclass="keyword">typename <spanclass="identifier">ParserT> tree_parse_info<spanclass="special"><CharT <spanclass="keyword">const*> ast_parse<spanclass="special">( CharTconst*str, parser<spanclass="special"><ParserT<spanclass="special">> const<spanclass="special">& parser<spanclass="special">); </pre>

 <a name="tree_parse_info"></a>
 <h3>tree_parse_info</h3>

 The <tt>tree_parse_info</tt> struct returned from pt_parse andast_parse contains

-  information about the parse:</p>

+ information about the parse: 从 pt_parse 和 ast_parse 返回的<tt>tree_parse_info</tt> 结构含有本次分析的信息：<pre> <code>template <spanclass="special"><typename <spanclass="identifier">IteratorT = <spanclass="keyword">char const<spanclass="special">*> structtree_parse_info <spanclass="special">{ IteratorTstop<spanclass="special">; boolmatch<spanclass="special">; boolfull<spanclass="special">; std::size_tlength<spanclass="special">; typenametree_match<spanclass="special"><IteratorT<spanclass="special">>::container_ttrees; }; </code></pre>

-<table width="90%" border="0" align="center">
+<table align="center" border="0" width="90%">
   <tbody><tr>
     <td class="table_title" colspan="10"> tree_parse_info </td>
   </tr>
@@ -114,23 +115,23 @@
   </tr><tr>
     <td class="table_cells"><b>stop</b></td>

<td class="table_cells">points to the final parse position (i.e.parsing processed

-      the input up to this point).</td>

+ the input up to this point). 指向最后的分析位置(即此点之前的输入已完成分析)</td>

   </tr>
   <tr><td class="table_cells"><b>match</b></td>

<td class="table_cells">true if parsing is successful. This may be full(theparser consumed all the input), or partial (the parser consumed only aportion

-    of the input.)</td>

+ of the input.) 如果分析成功则为 true。可能是完整的(分析器消耗了所有输入)，或部分的(分析器只消耗了部分输入)。</td>

   </tr>
   <tr><td class="table_cells"><b>full</b></td>

<td class="table_cells">true when we have a full match (when the parserconsumed

-    all the input).</td>
+    all the input).<br>完全匹配(分析器消耗了所有输入)时为 true。</td>
   </tr>
   <tr><td class="table_cells"><b>length</b></td>

<td class="table_cells">The number of characters consumed by the parser.This- is valid only if we have a successful match (either partial orfull).</td>+ is valid only if we have a successful match (either partial orfull). 分析器所消耗的字符数量。仅当匹配成功(部分或全部)时有效。</td>

   </tr>
   <tr><td class="table_cells"><b>trees</b></td>
-  <td class="table_cells">Contains the root node(s) of the tree.</td>

+ <td class="table_cells">Contains the root node(s) of the tree. 包含树的根节点。</td>

   </tr>
 </tbody></table>
 <a name="tree_match"></a>
@@ -138,54 +139,64 @@

 When Spirit is generating a tree, the parser's parse() member functionwillreturn a tree_match object, instead of a match object. tree_match hasthreetemplate parameters. The first is the Iterator type which defaults to<tt>char- const*</tt>. The second is the node factory, which defaults to <ahref="#node_val_data_factory">node_val_data_factory</a>.+ const*</tt>. The second is the node factory, which defaults to <ahref="trees.html#node_val_data_factory">node_val_data_factory</a>.The third is the attribute type stored in the match. A tree_match has amember- variable which is a container (a <tt>std::vector</tt>) of <ahref="#tree_node">tree_node</a>+ variable which is a container (a <tt>std::vector</tt>) of <ahref="trees.html#tree_node">tree_node</a>objects named trees. For efficiency reasons, when a tree_match iscopied, thetrees are not copied, they are moved to the new object, and thesourceobject is left with an empty tree container. tree_match supports thesame interfaceas the match class: it has an operator bool() so you can test it for asucessfulmatch: if (matched), and you can query the match length via the length()function.

-  The class has this interface:</p>

+ The class has this interface: 当Spirit生成一棵树时，分析器的 parse()成员函数将返回一个 tree_match 对象，而不是一个 match 对象。tree_match 有三个模板参数。第一个是 Iterator 类型，缺省为 <tt>char+ const*</tt>。第二个是节点工厂，缺省为 <ahref="#node_val_data_factory">node_val_data_factory</a>。第三个是保存在匹配中的属性类型。tree_match 有一个名为 trees 的成员变量，它是一个 <ahref="#tree_node">tree_node</a>

+  容器(一个 <tt>std::vector</tt>)。
+由于效率原因，当一个 tree_match 被复制时，将不复制这个

+trees，而是把它移至新对象中，而源对象中则只留下一个空的树容器。tree_match支持与 match 类相同的接口：它有一个+operator bool()，因此你可以测试它是否一个成功的匹配：如果是(已匹配的)，则你可以通过 length()

+函数查询该匹配的长度。该类具有以下接口：</p>

<pre> <code>template <spanclass="special"><typename <spanclass="identifier">IteratorT = <spanclass="keyword">char const<spanclass="special">*, typename <spanclass="identifier">NodeFactoryT = <spanclass="identifier">node_val_data_factory<spanclass="special"><> > struct <spanclass="identifier">tree_match <spanclass="special">{ typedeftypename <spanclass="identifier">NodeFactoryT::<spanclass="keyword">template <spanclass="identifier">factory<<spanclass="identifier">IteratorT> <spanclass="identifier">node_factory_t; typedef typenamenode_factory_t<spanclass="special">::node_tparse_node_t<spanclass="special">; typedeftree_node<spanclass="special"><<spanclass="identifier">parse_node_t<spanclass="special">> <spanclass="identifier">node_t; typedef typenamenode_t<spanclass="special">::<spanclass="identifier">children_t <spanclass="identifier">container_t; typedef typenamecontainer_t<spanclass="special">::<spanclass="identifier">iterator <spanclass="identifier">tree_iterator; typedef typenamecontainer_t<spanclass="special">::<spanclass="identifier">const_iterator <spanclass="identifier">const_tree_iterator<spanclass="special">; <spanclass="identifier">tree_match(); tree_match<spanclass="special">(std::size_t <spanclass="identifier">length, <spanclass="identifier">parse_node_t <spanclass="keyword">const& <spanclass="identifier">n); <spanclass="identifier">tree_match(<spanclass="identifier">tree_match <spanclass="keyword">const& <spanclass="identifier">x); <spanclass="keyword">explicit <spanclass="identifier">tree_match(<spanclass="identifier">match const<spanclass="special">& x<spanclass="special">); <spanclass="identifier">tree_match&operator<spanclass="special">=(tree_match <spanclass="keyword">const& <spanclass="identifier">x); <spanclass="keyword">void swap<spanclass="special">(tree_match<spanclass="special">& x<spanclass="special">); operatorbool()const; int <spanclass="identifier">length() <spanclass="keyword">const; container_t <spanclass="identifier">trees; <spanclass="special">};</code></pre> When a parse has sucessfully completed, the trees data member willcontain

-  the root node of the tree. </p>
-<table width="80%" border="0" align="center">

+ the root node of the tree. 当一次分析成功完成，数据成员 trees 将包含树的根节点。 

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

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

       <br>

You may wonder, why is it a vector then? The answer is that it ispartlyfor implementation purposes, and also if you do not use any rules inyourgrammar, then trees will contain a sequence of nodes that will nothave

-      any children.</td>

+ any children. 你可能会奇怪，为什么要用vector？答案是，这部分是为了实现的目的，而且如果你在你的语法中没有使用任何规则，那么 trees 将包含一系列没有子节点的节点。</td>

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

- Having spirit create a tree is similar to how a normal parse isdone:-<pre> <code>tree_match<spanclass="special"><> hit <spanclass="special">= expression<spanclass="special">.parse<spanclass="special">(tree_scanner<spanclass="special">); if <spanclass="special">(hit<spanclass="special">) <spanclass="identifier">process_tree_root<spanclass="special">(hit<spanclass="special">.trees<spanclass="special">[0<spanclass="special">]); // do something with thetree</code></pre>+ Having spirit create a tree is similar to how a normal parse isdone: spirit 创建分析树类似于进行普通的分析：+<pre> <code>tree_match<spanclass="special"><> hit <spanclass="special">= expression<spanclass="special">.parse<spanclass="special">(tree_scanner<spanclass="special">); if <spanclass="special">(hit<spanclass="special">) <spanclass="identifier">process_tree_root<spanclass="special">(hit<spanclass="special">.trees<spanclass="special">[0<spanclass="special">]); // do something with thetree 对分析树做操作</code></pre>

 <a name="tree_node"></a>
 <h3>tree_node</h3>

- Once you have created a tree by calling <ahref="#pt_parse">pt_parse</a>- or <a href="#ast_parse">ast_parse</a>, you have a <ahref="#tree_parse_info">tree_parse_info</a>+ Once you have created a tree by calling <ahref="trees.html#pt_parse">pt_parse</a>+ or <a href="trees.html#ast_parse">ast_parse</a>, you have a <ahref="trees.html#tree_parse_info">tree_parse_info</a>which contains the root node of the tree, and now you need to dosomething with- the tree. The data member trees of <ahref="#tree_parse_info">tree_parse_info</a>+ the tree. The data member trees of <ahref="trees.html#tree_parse_info">tree_parse_info</a>is a std::vector<tree_node>. tree_node provides the treestructure. Theclass has one template parameter named T. tree_node contains an instanceoftype T. It also contains a std::vector<tree_node<T> > whichare

-  the node's children. The class looks like this:</p>

+ the node's children. The class looks like this: 一旦你通过调用 <ahref="#pt_parse">pt_parse</a> 或 <a href="#ast_parse">ast_parse</a> 创建了分析树，你就有了一个 <a href="#tree_parse_info">tree_parse_info</a>，它包含了树的根节点，而现在你需要对这棵树做一些操作。<ahref="#tree_parse_info">tree_parse_info</a>

+的数据成员 tress 是一个 std::vector&lt;tree_node&gt;。tree_node

+提供了这个树结构。这个类有一个名为 T 的模板参数。tree_node 包含一个类型为T 的实例。它还包含有一个+std::vector<tree_node<T> > 作为该节点的子节点。该类看起来就象：<pre> <code>template <spanclass="special"><typename <spanclass="identifier">T> <spanclass="keyword">struct tree_node { <spanclass="keyword">typedef T <spanclass="identifier">parse_node_t; typedef <spanclass="identifier">std::<spanclass="identifier">vector<<spanclass="identifier">tree_node<<spanclass="identifier">T> <spanclass="special">> children_t<spanclass="special">; typedeftypename <spanclass="identifier">children_t::<spanclass="identifier">iterator <spanclass="identifier">tree_iterator; typedef typenamechildren_t<spanclass="special">::const_iteratorconst_tree_iterator<spanclass="special">; Tvalue<spanclass="special">; children_tchildren<spanclass="special">; <spanclass="identifier">tree_node(); explicit <spanclass="identifier">tree_node(<spanclass="identifier">T const<spanclass="special">& v<spanclass="special">); <spanclass="identifier">tree_node(<spanclass="identifier">T const<spanclass="special">& v<spanclass="special">, children_t <spanclass="keyword">const& <spanclass="identifier">c); <spanclass="keyword">void swap<spanclass="special">(tree_node<spanclass="special"><T<spanclass="special">>& x<spanclass="special">); <spanclass="special">};</code></pre> This class is simply used to separate the tree framework from the datastoredin the tree. It is a generic node and any type can be stored inside itand acessed- via the data member value. The default type for T is<tt>node_val_data</tt>.+ via the data member value. The default type for T is<tt>node_val_data</tt>. 该类只是被用于将分析树框架与树中所存数据分离开。它是一个泛型的节点，任意类型都可以保存在其之内且通过数据成员 value 来访问。T 的缺省类型是 <tt>node_val_data</tt>.

 <a name="node_val_data"></a>
 <h3>node_val_data</h3>

 The <tt>node_val_data</tt> class contains the actual information abouteachnode. This includes the text or token sequence that was parsed, an<tt>id</tt>that indicates which rule created the node, a boolean flag thatindicates whetherthe node was marked as a root node, and an optional user-specifiedvalue. This

-  is the interface:</p>

+ is the interface: 类 <tt>node_val_data</tt> 包含了关于每个节点的实际信息。其中包含被分析的文本或记号序列，一个 <tt>id</tt>+ 用于表示是哪个规则创建了该节点，一个布尔 flag 表示该节点是否被标记为根节点，以及一个可选的用户指定的值。接口如下：<pre> <code>template <spanclass="special"><typename <spanclass="identifier">IteratorT = <spanclass="keyword">char const<spanclass="special">*, typename <spanclass="identifier">ValueT = <spanclass="identifier">nil_t> struct <spanclass="identifier">node_val_data <spanclass="special">{ typedeftypename <spanclass="identifier">std::<spanclass="identifier">iterator_traits<spanclass="special"><IteratorT<spanclass="special">>::value_typevalue_type<spanclass="special">; typedefstd<spanclass="special">::vector<spanclass="special"><value_type<spanclass="special">> <spanclass="identifier">container_t; typedef typenamecontainer_t<spanclass="special">::iterator <spanclass="identifier">iterator_t; typedef typenamecontainer_t<spanclass="special">::const_iteratorconst_iterator_t<spanclass="special">; <spanclass="identifier">node_val_data(); node_val_data<spanclass="special">(IteratorT <spanclass="keyword">const& <spanclass="identifier">_first, <spanclass="identifier">IteratorT const<spanclass="special">& _last<spanclass="special">); template<typenameIteratorT2<spanclass="special">> <spanclass="identifier">node_val_data(<spanclass="identifier">IteratorT2 <spanclass="keyword">const& <spanclass="identifier">_first, <spanclass="identifier">IteratorT2 <spanclass="keyword">const& <spanclass="identifier">_last); void <spanclass="identifier">swap(<spanclass="identifier">node_val_data&x<spanclass="special">); <spanclass="identifier">container_t::<spanclass="identifier">iterator <spanclass="identifier">begin(); container_t<spanclass="special">::const_iteratorbegin()const; container_t<spanclass="special">::iterator <spanclass="identifier">end(); container_t<spanclass="special">::const_iteratorend()const<spanclass="special">; boolis_root()const; void <spanclass="identifier">is_root(<spanclass="keyword">bool b<spanclass="special">); parser_idid()const; void <spanclass="identifier">id(<spanclass="identifier">parser_id r<spanclass="special">); ValueTconst&value()const; void <spanclass="identifier">value(<spanclass="identifier">ValueT const<spanclass="special">& v<spanclass="special">); <spanclass="special">}; </code></pre>

 <a name="parser_id__checking_and_setting"></a>
-<h3>parser_id, checking and setting</h3>
+<h3>parser_id, checking and setting 检查与设置</h3>

 If a node is generated by a rule, it will have an <tt>id</tt> set.Each rulehas an id that it sets of all nodes generated by that rule. The id is oftype<tt><a href="rule.html#tag">parser_id</a></tt>. The default id of eachrule

@@ -194,47 +205,53 @@

to the rules, and may not be able to compare addresses. So, you canoverridethe default id used by each rule by <a href="rule.html#tag">giving it aspecificID</a>. Then, when processing the tree you can call<tt>node_val_data::id()</tt>

-  to see which rule created that node.</p>

+ to see which rule created that node. 如果一个节点由一个规则生成了，它将具有一个 <tt>id</tt> 集。每个规则都有一个 id，它将被设入由该规则生成的所有规则。id 的类型为+ <tt><a href="rule.html#tag">parser_id</a></tt>。每个规则的缺省 id 被设置为该规则的地址(转换为一个整数)。这并不总是最方便的，因为处理该分析树的代码并不能访问该规则，也不可能比较该地址。因此，你可以通过 <ahref="rule.html#tag">指定特定ID</a> 来重载每个规则所使用的缺省 id。然后，在处理该分析树时，你就可以调用 <tt>node_val_data::id()</tt>

+  来查看是哪个规则创建了该节点。</p>
 <a name="structure_layout_of_a_parse_tree"></a>
-<h2>structure/layout of a parse tree</h2>
+<h2>structure/layout of a parse tree 分析树的结构/布局</h2>
 <a name="parse_tree_layout"></a>
-<h3>parse tree layout</h3>
+<h3>parse tree layout 分析树的布局</h3>

 The tree is organized by the rules. Each rule creates a new level inthe tree.All parsers attached to a rule create a node when a sucessful match ismade.These nodes become children of a node created by the rule. So, thefollowing

-  code:</p>

+ code: 分析树由规则组成。每个规则在树中创建一个新的层级。附加至某个规则的所有分析器在成功匹配时创建一个节点。这些节点成为由该规则所创建的一个节点的子节点。因此，以下代码：<pre> <code>rule_t <spanclass="identifier">myrule = <spanclass="identifier">ch_p(<spanclass="literal">'a') <spanclass="special">>> ',' <spanclass="special">>> *<spanclass="identifier">ch_p(<spanclass="literal">'b'); <spanclass="keyword">char const<spanclass="special">* input <spanclass="special">= "a,bb"<spanclass="special">; scanner_tscanner<spanclass="special">(input<spanclass="special">, input <spanclass="special">+ strlen<spanclass="special">(input<spanclass="special">)); <spanclass="identifier">tree_match<>m =myrule<spanclass="special">.parse<spanclass="special">(scanner<spanclass="special">); </code></pre> When executed, this code would return a tree_match, m.<tt>m.trees[0]</tt>

-  would contain a tree like this:</p>
-<table border="0" align="center">

+ would contain a tree like this: 在执行时，该代码将返回一个tree_match，m. <tt>m.trees[0]</tt>

+  将包含如下的一棵树：</p>
+<table align="center" border="0">
   <tbody><tr>
-    <td><img src="theme/trees1.png" width="253" height="151"></td>
+    <td><img src="theme/trees1.png" height="151" width="253"></td>
   </tr>
 </tbody></table>

 The root node would not contain any text, and it's id would be set totheaddress of myrule. It would have four children. Each child's id would besetto the address of myrule, would contain the text as shown in thediagram, and

-  would have no children.</p>

+ would have no children. 根节点不包含任何文本，其 id 被设为 myrule 的地址。它有四个子节点。每个子节点的 id 都被设为 myrule 的地址，每个子节点包含如图所示的文本，且不带子节点。

 <a name="ast_layout"></a>
-<h2>ast layout</h2>

- When calling <a href="#ast_parse">ast_parse</a>, the tree getsgenerated differently.

+<h2>ast layout &nbsp;ast的布局</h2>

+ When calling <a href="trees.html#ast_parse">ast_parse</a>, the treegets generated differently.It mostly works the same as when generating a parse tree. The differencehappens- when a rule only generated one sub-node. Instead of creating a newlevel, <a href="#ast_parse">ast_parse</a>+ when a rule only generated one sub-node. Instead of creating a newlevel, <a href="trees.html#ast_parse">ast_parse</a>will not create a new level, it will just leave the existing node. So,this

-  code:</p>

+ code: 调用 <a href="#ast_parse">ast_parse</a> 时，将以不同的方式生成分析树。该函数与生成一棵分析树几乎一样。差别在于，一个规则只生成一个子节点。<a href="#ast_parse">ast_parse</a>

+  不会创建新的层级，它只会保留已有节点。因此，以下代码：</p>

<pre> <code>rule_t <spanclass="identifier">myrule = <spanclass="identifier">ch_p(<spanclass="literal">'a'); <spanclass="keyword">char const<spanclass="special">* input <spanclass="special">= "a"<spanclass="special">; ast_scanner_tscanner<spanclass="special">(input<spanclass="special">, input<spanclass="special">+strlen<spanclass="special">(input<spanclass="special">)); <spanclass="identifier">tree_match<>m =myrule<spanclass="special">.parse<spanclass="special">(scanner<spanclass="special">); </code></pre> will generate a single node that contains 'a'. If<tt>tree_match_policy</tt>had been used instead of <tt>ast_match_policy</tt>, the tree would havelooked

-  like this:</p>
-<table border="0" align="center">

+ like this: 将生成一个包含 'a' 的单节点为。如果使用了<tt>tree_match_policy</tt>

+  来替代 <tt>ast_match_policy</tt>，则分析树看起来如下：</p>
+<table align="center" border="0">
   <tbody><tr>
-    <td><img src="theme/trees2.png" width="139" height="151"></td>
+    <td><img src="theme/trees2.png" height="151" width="139"></td>
   </tr>
 </tbody></table>

 ast_match_policy has the effect of eliminating intermediate rulelevels whichare simply pass-through rules. This is not enough to generate abstractsyntax- trees, <a href="#root_node_d_and_ast_generation">root_node_d</a> is alsoneeded. <a href="#root_node_d_and_ast_generation">root_node_d</a>

-  will be explained later.</p>

+ trees, <ahref="trees.html#root_node_d_and_ast_generation">root_node_d</a> is alsoneeded. <a href="trees.html#root_node_d_and_ast_generation">root_node_d</a>+ will be explained later. ast_match_policy 的作用是消除中间那些只是传递规则的规则层。这不足以生成抽象语法树，<ahref="#root_node_d_and_ast_generation">root_node_d</a> 也是需要的。<ahref="#root_node_d_and_ast_generation">root_node_d</a>

+  将在稍后解释。</p>
 <a name="switching__gen_pt_node_d____amp__gen_ast_node_d__"></a>
 <h2>switching: gen_pt_node_d[] &amp; gen_ast_node_d[]</h2>

 If you want to mix and match the parse tree and ast behaviors in yourapplication,

@@ -246,12 +263,14 @@
 if you use a rule inside of these    directives. &nbsp;The match policy of
 the scanner will have to correspond to the desired behavior. &nbsp;If you
 avoid rules and use primitive parsers or grammars, then you will not have
-problems.</p>

+problems. 如果你想在你的应用中混用并匹配分析树和 ast 的行为，你可以使用<tt>gen_pt_node_d[]</tt> 和 <tt>gen_ast_node_d[]</tt> 指示符。当通过<tt>gen_pt_node_d</tt> 指示符进行分析时，分析树创建的行为被打开。当使用<tt>gen_ast_node_d</tt>

+指示符时，内部的分析器将生成一棵使用

+ast 行为的树。注意，如果你在这些指示符内部使用规则，你必须留意你的规则是如何声明的。扫描器的匹配策略必须与想要的行为相对应。如果你避过规则而使用基本分析器或语法，则你没有此问题。

 <a name="directives"></a>
-<h2>Directives</h2>
+<h2>Directives 指示符</h2>

 There are a few more directives that can be used to control thegenerationof trees. These directives only effect tree generation. Otherwise, theyhave

-  no effect.<br>

+ no effect. 还有几个指示符可用于控制树的生成。这些指示符仅对树的生成起作用。其它情况下，它们没有影响。 

 </p>
 <a name="no_node_d"></a>
 <h3>no_node_d</h3>
@@ -264,7 +283,7 @@

directive has the same requirements with respect to rules as<tt>gen_pt_node_d</tt>and <tt>gen_ast_node_d</tt> do. See the example file xml_grammar.hpp (inlibs/spirit/example/application/xml

   directory) for example
-  usage of <tt>no_node_d[]</tt>.</p>

+ usage of <tt>no_node_d[]</tt>. 这个指示符类似于<tt>gen_pt_node_d</tt> 和 <tt>gen_ast_node_d</tt>，修改内部分析器所用的扫描器匹配策略。顾名思义，它不进行树生成，完全关闭。如果你的语法中有一部分不需要出现在树中，这就很有用了。例如：关键字、操作符(<tt>*</tt>, <tt>-</tt>,<tt>&&</tt>, 等等)。通过从树中消除掉这些，可以同时降低内存耗用和分析时间。这个指示符对规则的要求与 <tt>gen_pt_node_d</tt> 和<tt>gen_ast_node_d</tt> 一样。有关 <tt>no_node_d[]</tt> 的用例，请见例程xml_grammar.hpp (位于目录 libs/spirit/example/application/xml)。

 <a name="discard_node_d"></a>
 <h3>discard_node_d</h3>

 This directive has a similar purpose to <tt>no_node_d</tt>, but worksdifferently.

@@ -272,113 +291,120 @@

nodes. The generated nodes are discarded and do not appear in the tree.Using<tt>discard_node_d</tt> is slower than <tt>no_node_d</tt>, but it doesnot sufferfrom the drawback of having to specify a different rule type for anyrule inside

-  it.</p>

+ it. 这个指示符的目的与 <tt>no_node_d</tt> 类似，但工作方式不同。它不改变扫描器的匹配策略，因此内层的分析器仍旧生成节点。生成的节点被忽略，不会出现在树中。使用+ <tt>discard_node_d</tt> 要慢于 <tt>no_node_d</tt>，但它不会遇到必须为内部规则指定不同规则类型的问题。

 <a name="leaf_node_d_token_node_d"></a>
 <h3>leaf_node_d/token_node_d</h3>
 <p> Both <tt>leaf_node_t</tt> and <tt>token_node_d</tt> work the same. They
     create a single node for the match generated by the enclosed parser.
     Unlike with earlier versions of Spirit, this directive is an implicit
     lexeme and alters the scanner (see
-    <a href="faq.html#scanner_business">Scanner Business</a>). </p>

+ <a href="faq.html#scanner_business">ScannerBusiness</a>). <tt>leaf_node_t</tt> 和 <tt>token_node_d</tt> 作用相同。它们为内层分析器所生成的匹配创建单个节点。与Spirit早期的版本不同，这个指示符是一个隐式词位，并修改了扫描器(见

+    <a href="faq.html#scanner_business">扫描器业务</a>)。 </p>
 <h3>reduced_node_d</h3>

 This directive groups together all the nodes generated by the enclosedparser.For earlier versions of Spirit <tt>leaf_node_d</tt> and<tt>token_node_d</tt>were implemented this way. The new implementation of those directivesis alot faster, so <tt>reduced_node_d</tt> is primarily provided forportability

     and can be useful when using a custom node factory (see advanced tree
-    generation, below).</p>

+ generation, below). 这个指示符将内层分析器所生成的所有节点组到一起。对于早期版本的Spirit，<tt>leaf_node_d</tt> 和 <tt>token_node_d</tt>+ 也是以此方式实现。这些指示符的新实现要快不少，因此<tt>reduced_node_d</tt> 主要是为可移植性而提供，使用定制节点工厂时(见下文的高级树生成)可以使用。

 <h3>infix_node_d</h3>

 This is useful for removing separators from lists. It discards all thenodes

-  in even positions. Thus this rule:</p>

+ in even positions. Thus this rule: 用于从列表中去掉分隔符。它略过偶数位置上的所有节点。因此，以下规则：<pre> <code>rule_t <spanclass="identifier">intlist = <spanclass="identifier">infix_node_d[ <spanclass="identifier">integer >>*(','>> <spanclass="identifier">integer) <spanclass="special">];</code></pre>

-<p> would discard all the comma nodes and keep all the integer nodes.</p>

+ would discard all the comma nodes and keep all the integer nodes. 将略过所有逗号节点而保存所有整数节点。

 <a name="discard_first_node_d"></a>
 <h3>discard_first_node_d</h3>
-<p> This discards the first node generated.</p>
+<p> This discards the first node generated.<br>略过生成的第一个节点。</p>
 <a name="discard_last_node_d"></a>
 <h3>discard_last_node_d</h3>
-<p> This discards the last node generated.</p>
+<p> This discards the last node generated.<br>略过生成的最后一个节点。</p>
 <a name="inner_node_d"></a>
 <h3>inner_node_d</h3>
-<p> This discards the first and last node generated.</p>

+ This discards the first and last node generated. 略过生成的第一个和最后一个节点。

 <a name="root_node_d_and_ast_generation"></a>
-<h2>root_node_d and ast generation</h2>
+<h2>root_node_d and ast generation &nbsp;root_node_d和ast的生成</h2>

 The <tt>root_node_d</tt> directive is used to help out ast generation.Ithas no effect when generating a parse tree. When a parser is enclosed in<tt>root_node_d</tt>,the node it generates is marked as a root. This affects the way it istreated- when it's added to the list of nodes being generated. Here's anexample:+ when it's added to the list of nodes being generated. Here's anexample: 指示符 <tt>root_node_d</tt> 用于协助 ast 的生成。在生成一个分析树时没有影响。当一个分析器用 <tt>root_node_d</tt> 括起时，它生成的节点被标记为根。当它被添加到所生成的节点列表中时，这会影响它被对待的方式。以下是一个例子：<pre> <code>rule_t <spanclass="identifier">add = <spanclass="identifier">integer >>*(<spanclass="identifier">root_node_d[ <spanclass="identifier">ch_p(<spanclass="literal">'+') <spanclass="special">] >> <spanclass="identifier">integer<spanclass="special">);</code></pre>

-<p> When parsing 5+6 the following tree will be generated:</p>
-<table border="0" align="center">

+ When parsing 5+6 the following tree will be generated: 在分析 5+6时，将生成以下树：

+<table align="center" border="0">
   <tbody><tr>
     <td><img src="theme/trees3.png"></td>
   </tr>
 </tbody></table>
-<p> When parsing 1+2+3 the following will be generated:</p>
-<table border="0" align="center">

+ When parsing 1+2+3 the following will be generated: 当分析 1+2+3时，将生成以下树：

+<table align="center" border="0">
   <tbody><tr>
     <td><img src="theme/trees4.png"></td>
   </tr>
 </tbody></table>

 When a new node is created the following rules are used to determinehow the

-  tree will be generated:</p>

-<pre><code> Let a be the previously generated node. Let b bethe new node. If b is a root node then b'schildren become a + b's previous children. a is the new firstchild of b. else if a is a root node and b is not,then b becomes the last child of a. else a and b become siblings.</code></pre>+ tree will be generated: 当创建一个新节点时，以下规则将被用于确定如何生成该树：+<pre><code> Let a be the previously generated node. 令a为之前生成的节点。 Let b be the new node. 令b为新节点。 If b is a rootnode then 如果b是根节点，则 b's children become a + b'sprevious children. b的子节点变为a+b的前一个子节点。 a is thenew first child of b. a为b的新的首子节点。 else if a is a rootnode and b is not, then 否则，如果a是根节点而b不是，则 bbecomes the last child of a. b成为a的尾子节点。 else 否则 a and b become siblings. a和b变为兄弟</code></pre> After parsing leaves the current rule, the root node flag on the topnodeis turned off. This means that the root_node_d directive only affectsthe current

-  rule.</p>

- <img height="16" width="15" src="theme/lens.gif"> The example <ahref="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a> demonstratesthe use of root_node_d and <a href="#ast_parse">ast_parse</a>. The fullsource code can be <a href="../example/fundamental/ast_calc.cpp">viewedhere</a>. This is part of the Spirit distribution.+ rule. 在分析了当前规则的其余部分后，顶部节点的根节点标志被关闭。这意味着 root_node_d 指示符仅作用于当前规则。+ <img src="theme/lens.gif" height="16" width="15"> The example <ahref="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a> demonstratesthe use of root_node_d and <a href="#ast_parse">ast_parse</a>. The fullsource code can be <a href="../example/fundamental/ast_calc.cpp">viewedhere</a>. This is part of the Spirit distribution. <imgsrc="theme/lens.gif" height="16" width="15"> 例子 <ahref="../example/fundamental/ast_calc.cpp">ast_calc.cpp</a> 示范了root_node_d 和 <a href="trees.html#ast_parse">ast_parse</a> 的使用。完整的源代码可 <a href="../example/fundamental/ast_calc.cpp">在此查看</a>。这是Spirit发布包的一部分。

 <a name="parse_tree_iterator"></a>
 <h2>parse_tree_iterator</h2>

 The <tt>parse_tree_iterator</tt> class allows you to parse a treeusing spirit.The class iterates over the tokens in the leaf nodes in the same ordertheywere created. The <tt>parse_tree_iterator</tt> is templated on<tt>ParseTreeMatchT</tt>.It is constructed with a container of trees, and a position to start.Here is

-  an example usage:</p>

-<pre> <code>rule_t <spanclass="identifier">myrule = <spanclass="identifier">ch_p(<spanclass="literal">'a'); <spanclass="keyword">char const<spanclass="special">* input <spanclass="special">= "a"<spanclass="special">; // generate parsetree tree_parse_info<spanclass="special"><> i <spanclass="special">= pt_parse<spanclass="special">(input<spanclass="special">, myrule<spanclass="special">); typedefparse_tree_iterator<spanclass="special"><tree_match<spanclass="special"><> > <spanclass="identifier">parse_tree_iterator_t<spanclass="special">; // create a firstand last iterator to work off the tree <spanclass="identifier">parse_tree_iterator_t <spanclass="identifier">first(<spanclass="identifier">i.<spanclass="identifier">trees, <spanclass="identifier">i.<spanclass="identifier">trees.<spanclass="identifier">begin()); parse_tree_iterator_t <spanclass="identifier">last; // parse the tree <spanclass="identifier">rule<<spanclass="identifier">parse_tree_iterator_t>tree_parser <spanclass="special">=... <spanclass="identifier">tree_parser.<spanclass="identifier">parse(<spanclass="identifier">first, <spanclass="identifier">last<spanclass="special">); </code></pre>+ an example usage: 类 <tt>parse_tree_iterator</tt> 允许你用spirit分析一棵树。该类以创建时的相同顺序迭代叶子节点中的记号。<tt>parse_tree_iterator</tt> 按 <tt>ParseTreeMatchT</tt> 模板化。它以一个树容器和一个开始位置进行构造。以下是一个用例：+<pre> <code>rule_t <spanclass="identifier">myrule = <spanclass="identifier">ch_p(<spanclass="literal">'a'); <spanclass="keyword">char const<spanclass="special">* input <spanclass="special">= "a"<spanclass="special">; // generate parsetree 生成分析树 <spanclass="identifier">tree_parse_info<>i =pt_parse<spanclass="special">(input<spanclass="special">, myrule<spanclass="special">); typedefparse_tree_iterator<spanclass="special"><tree_match<spanclass="special"><> > <spanclass="identifier">parse_tree_iterator_t<spanclass="special">; // create a firstand last iterator to work off the tree 创建首尾迭代器，以处理该树 parse_tree_iterator_t <spanclass="identifier">first(<spanclass="identifier">i.<spanclass="identifier">trees, <spanclass="identifier">i.<spanclass="identifier">trees.<spanclass="identifier">begin()); parse_tree_iterator_t <spanclass="identifier">last; // parse the tree 分析该树 <spanclass="identifier">rule<<spanclass="identifier">parse_tree_iterator_t>tree_parser <spanclass="special">=... <spanclass="identifier">tree_parser.<spanclass="identifier">parse(<spanclass="identifier">first, <spanclass="identifier">last<spanclass="special">); </code></pre>

 <p> <a name="advanced_tree_generation"></a>
 </p>
-<h2>advanced tree generation</h2>
+<h2>advanced tree generation 高级树生成</h2>
 <a name="node_value"></a>
-<h3>node value</h3>
+<h3>node value 节点值</h3>

 The <tt>node_val_data</tt> can contain a value. By default it containsa <tt>void_t</tt>,which is an empty class. You can specify the type, using a templateparameter,which will then be stored in every node. The type must be defaultconstructible,

-  and assignable. You can get and set the value using</p>

+ and assignable. You can get and set the valueusing <tt>node_val_data</tt> 可以包含一个值。缺省情况下，它包含一个空类<tt>void_t</tt>。你可以用模板参数指定新的类型，该类型将被保存在每个节点中。该类型必须是可缺省构造和可赋值的。要获取或设置该值，你可以用<pre> <code>ValueT <spanclass="identifier">node_val_data::<spanclass="identifier">value;</code></pre>

-<p> and</p>
+<p> and<br>和</p>

<pre> <code>void <spanclass="identifier">node_val_data::<spanclass="identifier">value(<spanclass="identifier">Value const<spanclass="special">& value<spanclass="special">);</code></pre>- To specify the value type, you must use a different <ahref="#node_val_data">node_val_data- </a>factory than the default. The following example shows how to modifythe factory to store and retrieve a double inside each <spanclass="identifier">node_val_data.-<pre> typedef <spanclass=identifier>node_val_data_factory<spanclass=special><double<spanclass=special>> factory_t<spanclass=special>; my_grammargram; my_skip_grammar <spanclass=identifier>skip; <spanclass=identifier>tree_parse_info<<spanclass=identifier>iterator_t, <spanclass=identifier>factory_t> <spanclass=identifier>i = <spanclass=identifier>ast_parse<<spanclass=identifier>factory_t>(<spanclass=identifier>first, <spanclass=identifier>last, <spanclass=identifier>gram, <spanclass=identifier>skip); // access thedouble in the root node doubled = <spanclass=identifier>i.<spanclass=identifier>trees.<spanclass=identifier>begin()-><spanclass=identifier>value; </pre>

-</p>

+ To specify the value type, you must use a different <ahref="trees.html#node_val_data">node_val_data+ </a>factory than the default. The following example shows how to modifythe factory to store and retrieve a double inside each <spanclass="identifier">node_val_data. 要指定这个值类型，你必须使用一个不同与缺省值的 <a href="#node_val_data">node_val_data+ </a>工厂。以下例子示范了如何修改该工厂以保存并取出每个 <spanclass="identifier">node_val_data 中的 double 值。+<pre> typedef <spanclass="identifier">node_val_data_factory<spanclass="special"><double<spanclass="special">> factory_t<spanclass="special">; my_grammargram; my_skip_grammar <spanclass="identifier">skip; <spanclass="identifier">tree_parse_info<spanclass="special"><iterator_t<spanclass="special">, factory_t<spanclass="special">> i <spanclass="special">= <spanclass="identifier">ast_parse<<spanclass="identifier">factory_t>(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">gram, <spanclass="identifier">skip); // access thedouble in the root node 访问根节点中的double <spanclass="keyword">double d <spanclass="special">= i<spanclass="special">.trees<spanclass="special">.begin<spanclass="special">()->value<spanclass="special">; </pre>

+<p></p>
 <a name="access_node_d"></a>
 <h3>access_node_d</h3>
 <p> Now, you may be wondering, "What good does it do to have a value I can
   store in each node, but not to have any way of setting it?" Well, that's

what <tt>access_node_d</tt> is for. <tt>access_node_d</tt> is adirective. It

-  allows you to attach an action to it, like this:</p>

+ allows you to attach an action to it, like this: 现在，你可能会奇怪，“如果我只能保存一个值到每个节点中，而没有方法设置它，有什么好处？”。好的，所以需要 <tt>access_node_d</tt>。<tt>access_node_d</tt> 是一个指示符。它允许你附加一个动作，如：<pre> <code>access_node_d<spanclass="special">[...some <spanclass="identifier">parsers...][<spanclass="identifier">my_action<spanclass="special">()]</code></pre> The attached action will be passed 3 parameters: A reference to theroot nodeof the tree generated by the parser, and the current first and lastiterators.

-  The action can set the value stored in the node.</p>

+ The action can set the value stored in the node. 附加的动作有3个参数：由该分析器生成的树的根节点的一个引用、当前的 first 和 last 迭代器。该动作可以设置保存在节点中的值。

 <a name="tree_node_factories"></a>
-<h3>Tree node factories</h3>
+<h3>Tree node factories 树节点工厂</h3>

 By setting the factory, you can control what type of nodes are createdandhow they are created. There are 3 predefined factories:<tt>node_val_data_factory</tt>,<tt>node_all_val_data_factory</tt>, and <tt>node_iter_data_factory</tt>.You

-  can also create your own factory to support your own node types.</p>

- Using factories with grammars is quite easy, you just need to specifythe factory type as explicit template parameter to the free ast_parsefunction:-<pre> typedef <spanclass=identifier>node_iter_data_factory<spanclass=special><int<spanclass=special>> factory_t<spanclass=special>; my_grammargram; my_skip_grammar <spanclass=identifier>skip; <spanclass=identifier>tree_parse_info<<spanclass=identifier>iterator_t, <spanclass=identifier>factory_t> <spanclass=identifier>i = <spanclass=identifier>ast_parse<<spanclass=identifier>factory_t>(<spanclass=identifier>first, <spanclass=identifier>last, <spanclass=identifier>gram, <spanclass=identifier>skip); </pre>+ can also create your own factory to support your own node types. 通过设置工厂，你可以控制创建何种类型的节点以及如何创建它们。有3个预定义的工厂：<tt>node_val_data_factory</tt>,+ <tt>node_all_val_data_factory</tt>, 和 <tt>node_iter_data_factory</tt>。你也可以创建你自己的工厂以支持你自己的节点类型。 Using factorieswith grammars is quite easy, you just need to

+specify the factory type as explicit template parameter to the free

+ast_parse function: 和语法一起使用工厂非常容易，你只需要指定工厂类型为自由函数 ast_parse 显式的模板参数：+<pre> typedef <spanclass="identifier">node_iter_data_factory<spanclass="special"><int<spanclass="special">> factory_t<spanclass="special">; my_grammargram; my_skip_grammar <spanclass="identifier">skip; <spanclass="identifier">tree_parse_info<spanclass="special"><iterator_t<spanclass="special">, factory_t<spanclass="special">> i <spanclass="special">= <spanclass="identifier">ast_parse<<spanclass="identifier">factory_t>(<spanclass="identifier">first, <spanclass="identifier">last, <spanclass="identifier">gram, <spanclass="identifier">skip); </pre> Instead, using the factory directly with rules is slightly harderbecause thefactory is a template parameter to the scanner match policy, so you mustuse a

-  custom scanner:</p>

+ custom scanner: 相反，直接与规则一起使用工厂会稍难一些，因为工厂是扫描器匹配策略的一个模板参数，因此你必须使用定制扫描器：<pre> <code>typedef <spanclass="identifier">spirit::<spanclass="identifier">void_t <spanclass="identifier">value_t; typedef <spanclass="identifier">node_val_data_factory<spanclass="special"><value_t<spanclass="special">> factory_t<spanclass="special">; typedef <spanclass="identifier">tree_match<<spanclass="identifier">iterator_t, <spanclass="identifier">factory_t> <spanclass="identifier">match_t; typedef <spanclass="identifier">ast_match_policy<spanclass="special"><iterator_t<spanclass="special">, factory_t<spanclass="special">> <spanclass="identifier">match_policy_t; typedef <spanclass="identifier">scanner<<spanclass="identifier">iterator_t</code><code><spanclass="special">,</code><code>scanner_policies</code><code><spanclass="special"><</code><code><spanclass="identifier">iter_policy_t</code><code><spanclass="special">,</code><code>match_policy_t></code><code><spanclass="identifier">></code><code> <spanclass="identifier">scanner_t; typedef <spanclass="identifier">rule<<spanclass="identifier">scanner_t<spanclass="identifier">> <spanclass="identifier">rule_t; rule_t r=...; </code><code><spanclass="special"> scanner_t <spanclass="identifier">scan = <spanclass="identifier">scanner_t<spanclass="identifier">(<spanclass="identifier">first, <spanclass="identifier">last<spanclass="identifier"><spanclass="special">); </code><code><spanclass="special"></code><code> <spanclass="identifier">match_t hit <spanclass="special">= r<spanclass="special">.parse<spanclass="special">(<spanclass="special"><spanclass="special">scan<spanclass="special">);</code></pre>

 <a name="node_val_data_factory"></a>
 <h3>node_val_data_factory</h3>

 This is the default factory. It creates <tt>node_val_data</tt> nodes.Leafnodes contain a copy of the matched text, and intermediate nodes don't.<tt>node_val_data_factory</tt>has one template parameter: <tt>ValueT</tt>. <tt>ValueT</tt> specifiesthe type

-  of value that will be stored in the <tt>node_val_data</tt>.</p>

+ of value that will be stored in the <tt>node_val_data</tt>. 这是缺省的工厂。它创建 <tt>node_val_data</tt> 节点。叶节点包含被匹配文本的拷贝，而中间节点则不包含。<tt>node_val_data_factory</tt>+ 有一个模板参数：<tt>ValueT</tt>. <tt>ValueT</tt> 指定保存在<tt>node_val_data</tt> 中的值的类型。

 <a name="node_val_data_factory"></a>
 <h3>node_all_val_data_factory</h3>

 This factory also creates <tt>node_val_data</tt>. The differencebetween it

@@ -386,7 +412,7 @@

text that spans it. This means that the root node will contain a copy oftheentire parsed input sequence. <tt>node_all_val_data_factory</tt> has onetemplateparameter: <tt>ValueT</tt>. <tt>ValueT</tt> specifies the type of valuethat

-  will be stored in the <tt>node_val_data</tt>.</p>

+ will be stored in the <tt>node_val_data</tt>. 这个工厂也创建<tt>node_val_data</tt>。与 <tt>node_val_data_factory</tt> 不同的是，每个节点都包含与之相关的所有文本。这意味着根节点将包含整个被分析的输入序列的拷贝。<tt>node_all_val_data_factory</tt> 有一个模板参数：<tt>ValueT</tt>.<tt>ValueT</tt> 指定保存在 <tt>node_val_data</tt> 中的值的类型。

 <a name="node_iter_data_factory"></a>
 <h3>node_iter_data_factory</h3>

 This factory creates the <tt>parse_tree_iter_node</tt>. This nodestores iterators

@@ -395,11 +421,12 @@

not a good idea to use the <tt>multi_pass</tt> iterator with this typeof node.All levels of the tree will contain a begin and end iterator.<tt>node_iter_data_factory</tt>has one template parameter: <tt>ValueT</tt>. <tt>ValueT</tt> specifiesthe type

-  of value that will be stored in the node_val_data.</p>

+ of value that will be stored in the node_val_data. 这个工厂创建<tt>parse_tree_iter_node</tt>。这个节点保存输入序列的迭代器而不是拷贝。它可以占用更少的内存。但是，输入序列必须在树的整个生命周期中保存可用，而且将<tt>multi_pass</tt> 迭代器与这种节点类型一起使用也不是好的主意。树的所有层级都将包含一个 begin 和 end 迭代器。 <tt>node_iter_data_factory</tt>+ 有一个模板参数：<tt>ValueT</tt>. <tt>ValueT</tt> 指定保存在<tt>node_val_data</tt> 中的值的类型。

 <a name="custom"></a>
-<h3>custom</h3>
-<p> You can create your own factory. It should look like this:</p>

-<pre> <code>class <spanclass="identifier">my_factory { public<spanclass="special">: // This innerclass is so that the factory can simulate // a template templateparameter template <spanclass="special"><typename <spanclass="identifier">IteratorT> class <spanclass="identifier">factory <spanclass="special">{ <spanclass="keyword">public: // This is your node type typedef <spanclass="identifier">my_node_type <spanclass="identifier">node_t; static node_tcreate_node<spanclass="special">( <spanclass="identifier">IteratorT const<spanclass="special">& first<spanclass="special">, IteratorT <spanclass="keyword">const& <spanclass="identifier">last, <spanclass="keyword">bool <spanclass="identifier">is_leaf_node<spanclass="special">) <spanclass="special">{ // createa node and return it. <spanclass="special">} // Thisfunction is used by the reduced_node directive. // If youdon't use it, then you can leave this function //unimplemented. template<typenameContainerT<spanclass="special">> staticnode_t <spanclass="identifier">group_nodes(<spanclass="identifier">ContainerT <spanclass="keyword">const& <spanclass="identifier">nodes) { <spanclass="comment">// Group all the nodes into one and returnit. } <spanclass="special">}; }; // Typedefs to use my_factory typedef <spanclass="identifier">my_factory <spanclass="identifier">factory_t; typedef <spanclass="identifier">tree_match<<spanclass="identifier">iterator_t, <spanclass="identifier">factory_t> <spanclass="identifier">match_t; typedef <spanclass="identifier">tree_match_policy<spanclass="special"><iterator_t<spanclass="special">, factory_t<spanclass="special">> <spanclass="identifier">match_policy_t<spanclass="special">; </code><code> // Typedefs if you are using rules instead ofgrammars </code><code> <spanclass="keyword">typedef scanner<spanclass="special"><<spanclass="identifier">iterator_t</code><code><spanclass="special">,</code><code>scanner_policies</code><code><spanclass="special"><</code><code><spanclass="identifier">iter_policy_t</code><code><spanclass="special">,</code><code>match_policy_t></code><code><spanclass="identifier">></code><code> <spanclass="identifier">scanner_t; typedef <spanclass="identifier">rule<<spanclass="identifier">scanner_t<spanclass="identifier">> <spanclass="identifier">rule_t<spanclass="special">; </code><code><spanclass="special"> </code></pre><table border="0"><tbody><tr><tdwidth="10"> 

+<h3>custom 定制</h3>

+ You can create your own factory. It should look like this: 你可以创建自己的工厂。它应该看起来如下：+<pre> <code>class <spanclass="identifier">my_factory { public<spanclass="special">: // This innerclass is so that the factory can simulate 内层类令工厂可以模仿 // a template template parameter 一个模板模板参数 template <spanclass="special"><typename <spanclass="identifier">IteratorT> class <spanclass="identifier">factory <spanclass="special">{ <spanclass="keyword">public: // This is your node type 这是你的节点类型 typedef <spanclass="identifier">my_node_type <spanclass="identifier">node_t; static node_tcreate_node<spanclass="special">( <spanclass="identifier">IteratorT const<spanclass="special">& first<spanclass="special">, IteratorT <spanclass="keyword">const& <spanclass="identifier">last, <spanclass="keyword">bool <spanclass="identifier">is_leaf_node<spanclass="special">) <spanclass="special">{ // createa node and return it. 创建一个节点并返回它。 <spanclass="special">} // Thisfunction is used by the reduced_node directive. // If youdon't use it, then you can leave this function //unimplemented. 这个函数由reduced_node指示符使用。如果你不用它， // 那么你可以不实现该函数。 template <spanclass="special"><typename <spanclass="identifier">ContainerT<spanclass="special">> staticnode_t <spanclass="identifier">group_nodes(<spanclass="identifier">ContainerT <spanclass="keyword">const& <spanclass="identifier">nodes) { <spanclass="comment">// Group all the nodes into one and return it. 将所有节点组成一群并返回它。 } }; <spanclass="special">}; // Typedefsto use my_factory typedef <spanclass="identifier">my_factory <spanclass="identifier">factory_t; typedef <spanclass="identifier">tree_match<<spanclass="identifier">iterator_t, <spanclass="identifier">factory_t> <spanclass="identifier">match_t; typedef <spanclass="identifier">tree_match_policy<spanclass="special"><iterator_t<spanclass="special">, factory_t<spanclass="special">> <spanclass="identifier">match_policy_t<spanclass="special">; </code><code> // Typedefs if you are using rules instead ofgrammars 如果你用规则替代语法 </code><code><spanclass="special"> typedef <spanclass="identifier">scanner<<spanclass="identifier">iterator_t</code><code><spanclass="special">,</code><code>scanner_policies</code><code><spanclass="special"><</code><code><spanclass="identifier">iter_policy_t</code><code><spanclass="special">,</code><code>match_policy_t></code><code><spanclass="identifier">></code><code> <spanclass="identifier">scanner_t; typedef <spanclass="identifier">rule<<spanclass="identifier">scanner_t<spanclass="identifier">> <spanclass="identifier">rule_t<spanclass="special">; </code><code><spanclass="special"> </code></pre><table border="0"><tbody><tr><tdwidth="10"> 

 </td>

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

@@ -407,7 +434,7 @@
   </tr>
 </tbody></table>
 <hr size="1">

-Copyright © 2001-2002 Daniel C.Nuffer Revised 2007 Copyright © Tobias Schwinger +Copyright © 2001-2002 Daniel C. Nuffer Revised2007 Copyright © Tobias Schwinger 

   <br>

Use, modification and distribution is subject to theBoost Software

     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
=======================================
--- /trunk/libs/spirit/classic/index.html       Sun Sep 20 23:13:57 2009
+++ /trunk/libs/spirit/classic/index.html       Mon Oct 12 20:27:43 2009
@@ -852,7 +852,7 @@



-    <td class="toc_cells_L1"><a href="doc/multi_pass.html">多通路 </a></td>

+ <td class="toc_cells_L1"><a href="doc/multi_pass.html">多次遍历</a></td>




@@ -1033,7 +1033,7 @@

- <td class="toc_cells_L0"><a href="doc/acknowledgments.html">致谢</a></td>+ <td class="toc_cells_L0"><a href="doc/acknowledgments.html">鸣谢</a></td>

[boost-doc-zh] r336 committed - Spirit库译文，由 alai04 翻译，第三批

Other related posts: