Update of /cvsroot/boost/boost/libs/spirit/doc
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv9824/libs/spirit/doc
Modified Files:
Tag: SPIRIT_RC_1_8_5
faq.html trees.html
Log Message:
recent changes to HEAD revision
Index: faq.html
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/doc/faq.html,v
retrieving revision 1.26
retrieving revision 1.26.4.1
diff -u -d -r1.26 -r1.26.4.1
--- faq.html 8 Dec 2005 04:19:10 -0000 1.26
+++ faq.html 31 Jan 2007 11:04:11 -0000 1.26.4.1
@@ -26,6 +26,7 @@
<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 Right Associativity</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="#CVS">Boost CVS and Spirit CVS</a></li>
@@ -147,6 +148,50 @@
<pre> <span class=identifier>a </span><span class=special>= </span><span
class=identifier>b </span><span class=special>>> *(</span><span
class=identifier>op </span><span class=special>>> </span><span
class=identifier>b</span><span class=special>);</span></pre>
<p><span class=special></span>in Spirit. What could be simpler? Look Ma, no
recursion,
just iteration.</p>
+<p><b> <a name="right_associativity" id="right_associativity"></a>
Implementing Right Associativity </b></p>
+<p> <font color="#FF0000">Question:</font> I tried adding <tt>'^'</tt> as an
operator to compute the power to a calculator grammer. The following code
+</p>
+<pre> <span class=identifier>pow_expression
+ </span><span class=special>= </span><span class=identifier>pow_operand
</span><span class=special>>> </span><span class=special>*( </span><span
class=literal>'^' </span><span class=special>>> </span><span
class=identifier>pow_operand </span><span class=special>[ </span><span
class=special>& </span><span class=identifier>do_pow </span><span
class=special>]
+ </span><span class=special>)
+ </span><span class=special>;</span>
+</pre>
+<p>parses the input correctly, but I want the operator to be evalutated from
right to left. In other words, the expression <tt>2^3^4</tt> is supposed to
have the same semantics as <tt>2^(3^4)</tt> instead of <tt>(2^3)^4</tt>. How do
I do it?
+</p>
+<p> The "textbook recipe" for Right Associativity is Right Recursion. In BNF
that means:
+<pre> <pow_expression> ::= <pow_operand> '^'
<pow_expression> | <pow_operand>
+</pre>
+<p>But we better don't take the theory too literally here, because if the
first 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>:
+<pre> <pow_expression> ::= <pow_operand>
<pow_expression_helper>
+ <pow_expression_helper> ::= '^' <pow_expression> |
<i>ε</i>
+</pre>
+<p>The production <tt>pow_expression_helper</tt> matches the empty string
<i>ε</i>, so we can replace the alternative with the optional operator in
Spirit code.
+</p>
+<pre> <span class=identifier>pow_expression
+ </span><span class=special>= </span><span class=identifier>pow_operand
</span><span class=special>>> </span><span class=special>!( </span><span
class=literal>'^' </span><span class=special>>> </span><span
class=identifier>pow_expression </span><span class=special>[ </span><span
class=special>& </span><span class=identifier>do_pow </span><span
class=special>]
+ </span><span class=special>)
+ </span><span class=special>;</span>
+</pre>
+<p>Now any semantic actions within <tt>pow_operand</tt> can safely be
executed. For stack-based evaluation that means that each match of
<tt>pow_operand</tt> will leave one value on the stack and the recursion makes
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.
+</p>
+<p>In cases where this technique isn't applicable, such as C-style assignment
+<pre> <span class=identifier>assignment
+ </span><span class=special>= </span><span class=identifier>lvalue
</span><span class=special>>> </span><span class=literal>'=' </span><span
class=special>>> </span><span class=identifier>assignment
+ </span><span class=special>| </span><span
class=identifier>ternary_conditional
+ </span><span class=special>;</span>
+</pre>
+<p>you can append <tt>| epsilon_p [ <i>action</i> ] >> 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):
+</p>
+<pre> <span class=identifier>assignment
+ </span><span class=special>= </span><span class=identifier>lvalue
</span><span class=special>>> </span><span class=special>( </span><span
class=literal>'=' </span><span class=special>>> </span><span
class=identifier>assignment </span></span><span class=special>[ </span><span
class=special>& </span><span class=identifier>do_store </span><span
class=special>]
+ </span><span class=special>| </span><span
class=identifier>epsilon_p </span><span class=special>[ </span><span
class=special>& </span><span class=identifier>do_drop </span><span
class=special>]
+ </span><span class=special>>> </span><span
class=identifier>nothing_p
+ </span><span class=special>)
+ </span><span class=special>| </span><span
class=identifier>ternary_conditional
+ </span><span class=special>;</span>
+</pre>
+<p>However, this trick compromises the clear separation of syntax and
semantics, so you also might want to consider using an <a
href="trees.html">AST</a> instead of semantic actions so you can just go with
the first definition of <tt>assignment</tt>.
+</p>
<p><b> <a name="lexeme_and_rules" id="lexeme_and_rules"></a> The lexeme_d
directive
and rules</b></p>
<p> <font color="#FF0000">Question:</font> Does lexeme_d not support
expressions
@@ -451,6 +496,7 @@
<hr size="1">
<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>
<font size="2">Use, modification and distribution is subject to the Boost
Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
Index: trees.html
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/doc/trees.html,v
retrieving revision 1.9
retrieving revision 1.9.10.1
diff -u -d -r1.9 -r1.9.10.1
--- trees.html 23 Aug 2004 22:04:19 -0000 1.9
+++ trees.html 31 Jan 2007 11:04:11 -0000 1.9.10.1
@@ -41,13 +41,15 @@
to use them and you can see how easy they are to use. So, following with
tradition
(and the rest of the documentation) we'll do a calculator. Here's the
grammar:</p>
<pre> <code><span class="identifier">integer </span><span class="special">
- = </span><span class="identifier">lexeme_d</span><span
class="special">[ </span><span class="identifier"><font
color="#ff0000"><b>token_node_d</b></font></span><span class="special">[
(!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
>> +</span><span class="identifier">digit_p</span><span class="special">)
] ]<br> ;<br><br> </span><span class="identifier">factor<br>
</span><span class="special">= </span><span class="identifier">integer<br>
</span><span class="special">| </span><span class="literal">'('
</span><span class="special">>> </span><span
class="identifier">expression </span><span class="special">>>
</span><span class="literal">')'<br> </span><span class="special">|
(</span><span class="literal">'-' </span><span class="special">>>
</span><span class="identifier">factor</span><span class="special">)<br>
;<br><br
> </span><span class="identifier">term<br> </span><span
> class="special">= </span><span class="identifier">factor </span><span
> class="special">
+ = </span><span class="identifier"><font
color="#ff0000"><b>token_node_d</b></font></span><span class="special">[
(!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
>> +</span><span class="identifier">digit_p</span><span class="special">)
]<br> ;<br><br> </span><span class="identifier">factor<br>
</span><span class="special">= </span><span class="identifier">integer<br>
</span><span class="special">| </span><span class="literal">'('
</span><span class="special">>> </span><span
class="identifier">expression </span><span class="special">>>
</span><span class="literal">')'<br> </span><span class="special">|
(</span><span class="literal">'-' </span><span class="special">>>
</span><span class="identifier">factor</span><span class="special">)<br>
;<br><br> </span><span class="identifier">term<br> </span><span
class="
special">= </span><span class="identifier">factor </span><span
class="special">
>> *( (</span><span class="literal">'*' </span><span
class="special">>> </span><span class="identifier">factor</span><span
class="special">)<br> | (</span><span class="literal">'/'
</span><span class="special">>> </span><span
class="identifier">factor</span><span class="special">)<br>
)<br> ;<br><br> </span><span class="identifier">expression<br>
</span><span class="special">= </span><span class="identifier">term<br>
</span><span class="special">>> *( (</span><span
class="literal">'+' </span><span class="special">>> </span><span
class="identifier">term</span><span class="special">)<br> |
(</span><span class="literal">'-' </span><span class="special">>>
</span><span class="identifier">term</span><span class="special">)<br>
)<br> ;</span></code></pre>
<p> Now, you'll notice the only thing different in this grammar is the
<tt>token_node_d</tt>
- directive. This causes the integer rule to group all the input into one node.
- Without <tt>token_node_d</tt>, each character would get it's own node. 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 create a tree:</p>
+ directive. This causes the match of the integer rule to end up in one node.
+ Without <tt>token_node_d</tt>, each character would get it's own node.
+ 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 create a
tree:</p>
<pre> <code><span class="identifier">tree_parse_info</span><span
class="special"><> </span><span class="identifier">info </span><span
class="special">= </span><span class="identifier"><font
color="#ff0000"><b>pt_parse</b></font></span><span
class="special">(</span><span class="identifier">first</span><span
class="special">, </span><span class="identifier">expression</span><span
class="special">);</span></code></pre>
<p> <tt>pt_parse()</tt> is similar to <tt>parse()</tt>. There are four
overloads:
two for pairs of first and last iterators and two for character strings. Two
@@ -69,7 +71,7 @@
hard to process? With a few more directives you can generate an abstract
syntax
tree (ast) and cut the amount of evaluation code by at least <b>50%</b>. So
without any delay, here's the ast calculator grammar:</p>
-<pre> <code><span class="identifier">integer<br> </span><span
class="special">= </span><span class="identifier">leaf_node_d</span><span
class="special">[ </span><span class="identifier">lexeme_d</span><span
class="special">[ (!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
>> +</span><span class="identifier">digit_p</span><span class="special">)
] ]<br> ;<br><br> </span><span class="identifier">factor<br>
</span><span class="special">= </span><span class="identifier">integer<br>
</span><span class="special">| </span><span class="identifier"><font
color="#ff0000"><b>inner_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'('</span><span class="special">)
>> </span><span class="identifier">expression </span><span
class="special">>> </span><span clas
s="identifier">ch_p</span><span class="special">(</span><span
class="literal">')'</span><span class="special">)]<br> | (</span><span
class="identifier"><font color="#ff0000"><b>root_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span
class="special">)] >> </span><span class="identifier">factor</span><span
class="special">)<br> ;<br><br> </span><span
class="identifier">term<br> </span><span class="special">=
</span><span class="identifier">factor </span><span class="special">
+<pre> <code><span class="identifier">integer<br> </span><span
class="special">= </span><span class="identifier"><font
color="#ff0000"><b>leaf_node_d</b></font></span><span class="special">[
</span><span class="special">(!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
>> +</span><span class="identifier">digit_p</span><span class="special">)
]<br> ;<br><br> </span><span class="identifier">factor<br>
</span><span class="special">= </span><span class="identifier">integer<br>
</span><span class="special">| </span><span class="identifier"><font
color="#ff0000"><b>inner_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'('</span><span class="special">)
>> </span><span class="identifier">expression </span><span
class="special">>> </span><span class="ident
ifier">ch_p</span><span class="special">(</span><span
class="literal">')'</span><span class="special">)]<br> | (</span><span
class="identifier"><font color="#ff0000"><b>root_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span
class="special">)] >> </span><span class="identifier">factor</span><span
class="special">)<br> ;<br><br> </span><span
class="identifier">term<br> </span><span class="special">=
</span><span class="identifier">factor </span><span class="special">
>> *( (</span><span class="identifier"><font
color="#ff0000"><b>root_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'*'</span><span
class="special">)] >> </span><span class="identifier">factor</span><span
class="special">)<br> | (</span><span class="identifier"><font
color="#ff0000"><b>root_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'/'</span><span
class="special">)] >> </span><span class="identifier">factor</span><span
class="special">)<br> )<br> ;<br><br> </span><span
class="identifier">expression<br> </span><span class="special">=
</span><span class="identifier">term<br> </span><span
class="special">>> *( (</span><span class="identifier"><font
color="#ff0000"><b>root_node_d</b></font>
</span><span class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'+'</span><span
class="special">)] >> </span><span class="identifier">term</span><span
class="special">)<br> | (</span><span class="identifier"><font
color="#ff0000"><b>root_node_d</b></font></span><span
class="special">[</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span
class="special">)] >> </span><span class="identifier">term</span><span
class="special">)<br> )<br> ;</span></code></pre>
<p> The differences from the parse tree grammar are hi-lighted in <b><font
color="#ff0000">bold-red</font></b>.
The <tt>inner_node_d</tt> directive causes the first and last nodes generated
@@ -273,18 +275,18 @@
it.</p>
<a name="leaf_node_d_token_node_d"></a>
<h3>leaf_node_d/token_node_d</h3>
-<p> Both <tt>leaf_node_d</tt> and <tt>token_node_d</tt> work the same. They
group
- together all the nodes generated by the enclosed parser. Note that a rule
should
- not be used inside these directives.</p>
-<p> This rule:</p>
-<pre> <code><span class="identifier">rule_t </span><span
class="identifier">integer </span><span class="special">= </span><span
class="special">!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
</span><span class="special">>> </span><span
class="special">*(</span><span class="identifier">range_p</span><span
class="special">(</span><span class="literal">'0'</span><span class="special">,
</span><span class="literal">'9'</span><span
class="special">));</span></code></pre>
-<p> would generate a root node with the id of integer and a child node for each
- character parsed</p>
-<p> This:</p>
-<pre> <code><span class="identifier">rule_t </span><span
class="identifier">integer </span><span class="special">= </span><span
class="identifier">token_node_d</span><span class="special">[ </span><span
class="special">!</span><span class="identifier">ch_p</span><span
class="special">(</span><span class="literal">'-'</span><span class="special">)
</span><span class="special">>> </span><span
class="special">*(</span><span class="identifier">range_p</span><span
class="special">(</span><span class="literal">'0'</span><span class="special">,
</span><span class="literal">'9'</span><span class="special">)) </span><span
class="special">];</span></code></pre>
-<p> would generate a root node with only one child node that contained the
entire
- integer.</p>
-<a name="infix_node_d"></a>
+<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>
+<h3>reduced_node_d</h3>
+<p> This directive groups together all the nodes generated by the enclosed
parser.
+ 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 directives is a
+ lot faster, so <tt>reduced_node_d</tt> is primarily provided for
portability
+ and can be useful when using a custom node factory (see advanced tree
+ generation, below).</p>
<h3>infix_node_d</h3>
<p> This is useful for removing separators from lists. It discards all the
nodes
in even positions. Thus this rule:</p>
@@ -397,7 +399,7 @@
<a name="custom"></a>
<h3>custom</h3>
<p> You can create your own factory. It should look like this:</p>
-<pre> <code><span class="keyword">class </span><span
class="identifier">my_factory<br> </span><span class="special">{<br>
</span><span class="keyword">public</span><span class="special">:<br><br>
</span><span class="comment">// This inner class is so that the factory can
simulate<br> // a template template parameter<br><br>
</span><span class="keyword">template </span><span
class="special"><</span><span class="keyword">typename </span><span
class="identifier">IteratorT</span><span class="special">><br>
</span><span class="keyword">class </span><span class="identifier">factory<br>
</span><span class="special">{<br> </span><span
class="keyword">public</span><span class="special">:<br><br>
</span><span class="comment">// This is your node type<br>
</span><span class="keyword">typedef </span><span
class="identifier">my_node_type </span><span
class="identifier">node_t</span><span class="special">;<br><
br> </span><span class="keyword">static </span><span
class="identifier">node_t </span><span
class="identifier">create_node</span><span class="special">(<br>
</span><span class="identifier">IteratorT </span><span
class="keyword">const</span><span class="special">& </span><span
class="identifier">first</span><span class="special">, </span><span
class="identifier">IteratorT </span><span class="keyword">const</span><span
class="special">& </span><span class="identifier">last</span><span
class="special">, </span><span class="keyword">bool </span><span
class="identifier">is_leaf_node</span><span class="special">)<br>
</span><span class="special">{<br> </span><span
class="comment">// create a node and return it.<br> </span><span
class="special">}<br><br> </span><span class="comment">// This
function is used by the leaf_node and token_node directives.<br> //
If you don't use them, then you c
an leave this function<br> // unimplemented.<br><br>
</span><span class="keyword">template </span><span
class="special"><</span><span class="keyword">typename </span><span
class="identifier">ContainerT</span><span class="special">><br>
</span><span class="keyword">static </span><span class="identifier">node_t
</span><span class="identifier">group_nodes</span><span
class="special">(</span><span class="identifier">ContainerT </span><span
class="keyword">const</span><span class="special">& </span><span
class="identifier">nodes</span><span class="special">)<br>
</span><span class="special">{<br> </span><span
class="comment">// Group all the nodes into one and return it.<br>
</span><span class="special">}<br> </span><span class="special">};<br>
</span><span class="special">};<br><br><br> </span><span class="comment">//
Typedefs to use my_factory<br> </span><span class="keyword">typedef
</span><span class="identifier">my_factory </span><span
class="identifier">factory_t</span><span class="special">;<br> </span><span
class="keyword">typedef </span><span class="identifier">tree_match</span><span
class="special"><</span><span class="identifier">iterator_t</span><span
class="special">, </span><span class="identifier">factory_t</span><span
class="special">> </span><span class="identifier">match_t</span><span
class="special">;<br> </span><span class="keyword">typedef </span><span
class="identifier">tree_match_policy</span><span
class="special"><</span><span class="identifier">iterator_t</span><span
class="special">, </span><span class="identifier">factory_t</span><span
class="special">> </span><span class="identifier">match_policy_t</span><span
class="special">;<br></span></code><code><span class="special"><br>
</span><span class="comment">// Typedefs if you are using rules instead of
grammars<br></span></code><code><span class="special">
</span><span class="keyword">typedef </span><span
class="identifier">scanner</span><span class="special"><</span><span
class="identifier">iterator_t</span></code><code><span
class="special">,</span></code><code><span class="identifier">
scanner_policies</span></code><code><span class="identifier"></span><span
class="special"><</span></code><code><span
class="identifier">iter_policy_t</span></code><code><span
class="special">,</span></code><code><span class="identifier">
match_policy_t</span><span class="special">></span></code><code><span
class="identifier"></span><span class="special"> ></span></code><code><span
class="special"> </span><span class="identifier">scanner_t</span><span
class="special">;<br> </span><span class="keyword">typedef </span><span
class="identifier">rule</span><span class="special"><</span><span
class="identifier">scanner_t</span><span class="special"></span><span
class="identifier"></span><span class="special">> </span><span clas
s="identifier">rule_t</span><span
class="special">;<br></span></code><code><span class="special"></span><span
class="special"><br></span></code></pre><table border="0"><tbody><tr><td
width="10"><br>
+<pre> <code><span class="keyword">class </span><span
class="identifier">my_factory<br> </span><span class="special">{<br>
</span><span class="keyword">public</span><span class="special">:<br><br>
</span><span class="comment">// This inner class is so that the factory can
simulate<br> // a template template parameter<br><br>
</span><span class="keyword">template </span><span
class="special"><</span><span class="keyword">typename </span><span
class="identifier">IteratorT</span><span class="special">><br>
</span><span class="keyword">class </span><span class="identifier">factory<br>
</span><span class="special">{<br> </span><span
class="keyword">public</span><span class="special">:<br><br>
</span><span class="comment">// This is your node type<br>
</span><span class="keyword">typedef </span><span
class="identifier">my_node_type </span><span
class="identifier">node_t</span><span class="special">;<br><
br> </span><span class="keyword">static </span><span
class="identifier">node_t </span><span
class="identifier">create_node</span><span class="special">(<br>
</span><span class="identifier">IteratorT </span><span
class="keyword">const</span><span class="special">& </span><span
class="identifier">first</span><span class="special">, </span><span
class="identifier">IteratorT </span><span class="keyword">const</span><span
class="special">& </span><span class="identifier">last</span><span
class="special">, </span><span class="keyword">bool </span><span
class="identifier">is_leaf_node</span><span class="special">)<br>
</span><span class="special">{<br> </span><span
class="comment">// create a node and return it.<br> </span><span
class="special">}<br><br> </span><span class="comment">// This
function is used by the reduced_node directive.<br> // If you don't
use it, then you can leave this f
unction<br> // unimplemented.<br><br> </span><span
class="keyword">template </span><span class="special"><</span><span
class="keyword">typename </span><span class="identifier">ContainerT</span><span
class="special">><br> </span><span class="keyword">static
</span><span class="identifier">node_t </span><span
class="identifier">group_nodes</span><span class="special">(</span><span
class="identifier">ContainerT </span><span class="keyword">const</span><span
class="special">& </span><span class="identifier">nodes</span><span
class="special">)<br> </span><span class="special">{<br>
</span><span class="comment">// Group all the nodes into one and return
it.<br> </span><span class="special">}<br> </span><span
class="special">};<br> </span><span class="special">};<br><br><br>
</span><span class="comment">// Typedefs to use my_factory<br> </span><span
class="keyword">typedef </span><span c
lass="identifier">my_factory </span><span
class="identifier">factory_t</span><span class="special">;<br> </span><span
class="keyword">typedef </span><span class="identifier">tree_match</span><span
class="special"><</span><span class="identifier">iterator_t</span><span
class="special">, </span><span class="identifier">factory_t</span><span
class="special">> </span><span class="identifier">match_t</span><span
class="special">;<br> </span><span class="keyword">typedef </span><span
class="identifier">tree_match_policy</span><span
class="special"><</span><span class="identifier">iterator_t</span><span
class="special">, </span><span class="identifier">factory_t</span><span
class="special">> </span><span class="identifier">match_policy_t</span><span
class="special">;<br></span></code><code><span class="special"><br>
</span><span class="comment">// Typedefs if you are using rules instead of
grammars<br></span></code><code><span class="special"> </span><span c
lass="keyword">typedef </span><span class="identifier">scanner</span><span
class="special"><</span><span
class="identifier">iterator_t</span></code><code><span
class="special">,</span></code><code><span class="identifier">
scanner_policies</span></code><code><span class="identifier"></span><span
class="special"><</span></code><code><span
class="identifier">iter_policy_t</span></code><code><span
class="special">,</span></code><code><span class="identifier">
match_policy_t</span><span class="special">></span></code><code><span
class="identifier"></span><span class="special"> ></span></code><code><span
class="special"> </span><span class="identifier">scanner_t</span><span
class="special">;<br> </span><span class="keyword">typedef </span><span
class="identifier">rule</span><span class="special"><</span><span
class="identifier">scanner_t</span><span class="special"></span><span
class="identifier"></span><span class="special">> </span><span
class="identifier">
rule_t</span><span class="special">;<br></span></code><code><span
class="special"></span><span class="special"><br></span></code></pre><table
border="0"><tbody><tr><td width="10"><br>
</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>
@@ -405,7 +407,7 @@
</tr>
</tbody></table>
<hr size="1">
-<p class="copyright">Copyright © 2001-2002 Daniel C. Nuffer<br>
+<p class="copyright">Copyright © 2001-2002 Daniel C. Nuffer<br>Revised
2007 Copyright © Tobias Schwinger<br>
<br>
<font size="2">Use, modification and distribution is subject to the Boost
Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys - and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
