首頁 探索 說明
註冊 登入
devn00b
/
EQ2EMu
9
3
複刻 0
Files 問題管理 59 合併請求 0 Wiki
目錄樹: a55fda41b5
分支列表 標籤列表
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
spirit
/
classic
/
doc
/
semantic_actions.html

semantic_actions.html 23 KB
文件歷史 原始文件

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258 
  1. <html>
    2. 

  2. <head>
    3. 

  3. <title>Semantic Actions</title>
    4. 

  4. <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    5. 

  5. <link rel="stylesheet" href="theme/style.css" type="text/css">
    6. 

  6. </head>
    7. 

  7. 

  8. <body>
    9. 

  9. <table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
    10. 

  10.   <tr>
    11. 

  11.     <td width="10">
    12. 

  12.     </td>
    13. 

  13.     <td width="85%">
    14. 

  14.       <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Semantic Actions</b></font>
    15. 

  15.     </td>
    16. 

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

  17.   </tr>
    18. 

  18. </table>
    19. 

  19. <br>
    20. 

  20. <table border="0">
    21. 

  21.   <tr>
    22. 

  22.     <td width="10"></td>
    23. 

  23.     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
    24. 

  24.     <td width="30"><a href="subrules.html"><img src="theme/l_arr.gif" border="0"></a></td>
    25. 

  25.     <td width="30"><a href="indepth_the_parser.html"><img src="theme/r_arr.gif" border="0"></a></td>
    26. 

  26.    </tr>
    27. 

  27. </table>
    28. 

  28. <p>Semantic actions have the form: <b>expression[action]</b></p>
    29. 

  29. <p>Ultimately, after having defined our grammar and having generated a corresponding 
    30. 

  30.   parser, we will need to produce some output and do some work besides syntax 
    31. 

  31.   analysis; unless, of course, what we want is merely to check for the conformance 
    32. 

  32.   of an input with our grammar, which is very seldom the case. Semantic actions 
    33. 

  33.   may be attached to any expression at any level within the parser hierarchy. 
    34. 

  34.   An action is a C/C++ function or function object that will be called if a match 
    35. 

  35.   is found in the particular context where it is attached. The action function 
    36. 

  36.   serves as a hook into the parser and may be used to, for example:</p>
    37. 

  37. <blockquote>
    38. 

  38.   <p><img src="theme/bullet.gif" width="13" height="13"> Generate output from 
    39. 

  39.     the parser (ASTs, for example)<br>
    40. 

  40.     <img src="theme/bullet.gif" width="13" height="13"> Report warnings or errors<br>
    41. 

  41.     <img src="theme/bullet.gif" width="13" height="13"> Manage symbol tables</p>
    42. 

  42. </blockquote>
    43. 

  43. <h2>Generic Semantic Actions (Transduction Interface)</h2>
    44. 

  44. <p>A generic semantic action can be any free function or function object that
    45. 

  45.   is compatible with the interface:</p>
    46. 

  46. <pre><code><font color="#000000"><span class=identifier></span><span class=keyword>    void </span><span class=identifier>f</span><span class=special>(</span><span class=identifier>IteratorT </span><span class=identifier>first</span><span class=special>, </span><span class=identifier>IteratorT </span><span class=identifier>last</span><span class=special>);</span></font></code></pre>
    47. 

  47. <p>where <tt>IteratorT</tt> is the type of iterator used, <tt>first</tt> points 
    48. 

  48.   to the current input and <tt>last</tt> points to one after the end of the input 
    49. 

  49.   (identical to STL iterator ranges). A function object (functor) should have 
    50. 

  50.   a member <tt>operator()</tt> with the same signature as above:</p>
    51. 

  51. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>my_functor
    52. 

  52.     </span><span class=special>{
    53. 

  53.         </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()(</span><span class=identifier>IteratorT </span><span class=identifier>first</span><span class=special>, </span><span class=identifier>IteratorT </span><span class=identifier>last</span><span class=special>) </span><span class=keyword>const</span><span class=special>;
    54. 

  54.     </span><span class=special>};</span></font></code></pre>
    55. 

  55. <p>Iterators pointing to the matching portion of the input are passed into the 
    56. 

  56.   function/functor.</p>
    57. 

  57. <p>In general, semantic actions accept the first-last iterator pair. This is the 
    58. 

  58.   transduction interface. The action functions or functors receive the unprocessed 
    59. 

  59.   data representing the matching production directly from the input. In many cases, 
    60. 

  60.   this is sufficient. Examples are source to source translation, pre-processing, 
    61. 

  61.   etc. </p>
    62. 

  62. <h3>Example:</h3>
    63. 

  63. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>void
    64. 

  64.     </span><span class=identifier>my_action</span><span class=special>(</span><span class=keyword>char const</span><span class=special>* </span><span class=identifier>first</span><span class=special>, </span><span class=keyword>char const</span><span class=special>* </span><span class=identifier>last</span><span class=special>)
    65. 

  65.     {
    66. 

  66.         </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special> </span><span class="identifier">str</span><span class=special>(</span><span class=identifier>first</span><span class=special>, </span><span class=identifier>last</span><span class=special>);
    67. 

  67.         </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>str </span><span class=special>&lt;&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>endl</span><span class=special>;
    68. 

  68.     }
    69. 

  69. 

  70.     </span><span class=identifier>rule</span><span class=special>&lt;&gt; </span><span class=identifier>myrule </span><span class=special>= (</span><span class=identifier>a </span><span class=special>| </span><span class=identifier>b </span><span class=special>| *(</span><span class=identifier>c </span><span class=special>&gt;&gt; </span><span class=identifier>d</span><span class=special>))[&</span><span class=identifier>my_action</span><span class=special>];</span></font></code></pre>
    71. 

  71. <p>The function <tt>my_action</tt> will be called whenever the expression <tt>(a 
    72. 

  72.   | b | *(c &gt;&gt; d)</tt> matches a portion of the input stream while parsing. 
    73. 

  73.   Two iterators, <tt>first</tt> and <tt>last</tt>, are passed into the function. 
    74. 

  74.   These iterators point to the start and end, respectively, of the portion of 
    75. 

  75.   input stream where the match is found.</p>
    76. 

  76. <h3>Const-ness:</h3>
    77. 

  77. <p>With functors, take note that the <tt>operator()</tt> should be <tt>const</tt>.
    78. 

  78.   This implies that functors are immutable. One may wish to have some member variables
    79. 

  79.   that are modified when the action gets called. This is not a good idea. First
    80. 

  80.   of all, functors are preferably lightweight. Functors are passed around a lot
    81. 

  81.   and it would incur a lot of overhead if the functors are heavily laden. Second,
    82. 

  82.   functors are passed by value. Thus, the actual functor object that finally attaches
    83. 

  83.   to the parser, will surely not be the original instance supplied by the client.
    84. 

  84.   What this means is that changes to a functor's state will not affect the original
    85. 

  85.   functor that the client passed in since they are distinct copies. If a functor
    86. 

  86.   needs to update some state variables, which is often the case, it is better
    87. 

  87.   to use references to external data. The following example shows how this can
    88. 

  88.   be done:</p>
    89. 

  89. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>my_functor
    90. 

  90.     </span><span class=special>{
    91. 

  91.         </span><span class=identifier>my_functor</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>& </span><span class=identifier>str_</span><span class=special>)
    92. 

  92.         </span><span class=special>: </span><span class=identifier>str</span><span class=special>(</span><span class=identifier>str_</span><span class=special>) </span><span class=special>{}
    93. 

  93. 

  94.         </span><span class=keyword>void
    95. 

  95.         </span><span class=keyword>operator</span><span class=special>()(</span><span class=identifier>IteratorT </span><span class=identifier>first</span><span class=special>, </span><span class=identifier>IteratorT </span><span class=identifier>last</span><span class=special>) </span><span class=keyword>const
    96. 

  96.         </span><span class=special>{
    97. 

  97.             </span><span class=identifier>str</span><span class=special>.</span><span class=identifier>assign</span><span class=special>(</span><span class=identifier>first</span><span class=special>, </span><span class=identifier>last</span><span class=special>);
    98. 

  98.         </span><span class=special>}
    99. 

  99. 

  100.         </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>& </span><span class=identifier>str</span><span class=special>;
    101. 

  101.     </span><span class=special>};</span></font></code></pre>
    102. 

  102. <h3>Full Example:</h3>
    103. 

  103. <p>Here now is our calculator enhanced with semantic actions:</p>
    104. 

  104. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>namespace
    105. 

  105.     </span><span class=special>{
    106. 

  106.         </span><span class=keyword>void    </span><span class=identifier>do_int</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>* </span><span class=identifier>str</span><span class=special>, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>* </span><span class=identifier>end</span><span class=special>)
    107. 

  107.         </span><span class=special>{
    108. 

  108.             </span><span class=identifier>string  </span><span class=identifier>s</span><span class=special>(</span><span class=identifier>str</span><span class=special>, </span><span class=identifier>end</span><span class=special>);
    109. 

  109.             </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"PUSH(" </span><span class=special>&lt;&lt; </span><span class=identifier>s </span><span class=special>&lt;&lt; </span><span class=literal>')' </span><span class=special>&lt;&lt; </span><span class=identifier>endl</span><span class=special>;
    110. 

  110.         </span><span class=special>}
    111. 

  111. 

  112.         </span><span class=keyword>void    </span><span class=identifier>do_add</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*)    </span><span class=special>{ </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"ADD\n"</span><span class=special>; </span><span class=special>}
    113. 

  113.         </span><span class=keyword>void    </span><span class=identifier>do_subt</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*)   </span><span class=special>{ </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"SUBTRACT\n"</span><span class=special>; </span><span class=special>}
    114. 

  114.         </span><span class=keyword>void    </span><span class=identifier>do_mult</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*)   </span><span class=special>{ </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"MULTIPLY\n"</span><span class=special>; </span><span class=special>}
    115. 

  115.         </span><span class=keyword>void    </span><span class=identifier>do_div</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*)    </span><span class=special>{ </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"DIVIDE\n"</span><span class=special>; </span><span class=special>}
    116. 

  116.         </span><span class=keyword>void    </span><span class=identifier>do_neg</span><span class=special>(</span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*, </span><span class=keyword>char </span><span class=keyword>const</span><span class=special>*)    </span><span class=special>{ </span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>"NEGATE\n"</span><span class=special>; </span><span class=special>}
    117. 

  117.     </span><span class=special>}</span></font></code></pre>
    118. 

  118. <p>We augment our grammar with semantic actions:</p>
    119. 

  119. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>calculator </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>grammar</span><span class=special>&lt;</span><span class=identifier>calculator</span><span class=special>&gt;
    120. 

  120.     </span><span class=special>{
    121. 

  121.         </span><span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>&gt;
    122. 

  122.         </span><span class=keyword>struct </span><span class=identifier>definition
    123. 

  123.         </span><span class=special>{
    124. 

  124.             </span><span class=identifier>definition</span><span class=special>(</span><span class=identifier>calculator </span><span class=keyword>const</span><span class=special>& </span><span class=identifier>self</span><span class=special>)
    125. 

  125.             </span><span class=special>{
    126. 

  126.                 </span><span class=identifier>expression
    127. 

  127.                     </span><span class=special>=   </span><span class=identifier>term
    128. 

  128.                         </span><span class=special>&gt;&gt; </span><span class=special>*(   </span><span class=special>(</span><span class=literal>'+' </span><span class=special>&gt;&gt; </span><span class=identifier>term</span><span class=special>)[&</span><span class=identifier>do_add</span><span class=special>]
    129. 

  129.                             </span><span class=special>|   </span><span class=special>(</span><span class=literal>'-' </span><span class=special>&gt;&gt; </span><span class=identifier>term</span><span class=special>)[&</span><span class=identifier>do_subt</span><span class=special>]
    130. 

  130.                             </span><span class=special>)
    131. 

  131.                     </span><span class=special>;
    132. 

  132. 

  133.                 </span><span class=identifier>term </span><span class=special>=
    134. 

  134.                     </span><span class=identifier>factor
    135. 

  135.                         </span><span class=special>&gt;&gt; </span><span class=special>*(   </span><span class=special>(</span><span class=literal>'*' </span><span class=special>&gt;&gt; </span><span class=identifier>factor</span><span class=special>)[&</span><span class=identifier>do_mult</span><span class=special>]
    136. 

  136.                             </span><span class=special>|   </span><span class=special>(</span><span class=literal>'/' </span><span class=special>&gt;&gt; </span><span class=identifier>factor</span><span class=special>)[&</span><span class=identifier>do_div</span><span class=special>]
    137. 

  137.                             </span><span class=special>)
    138. 

  138.                         </span><span class=special>;
    139. 

  139. 

  140.                 </span><span class=identifier>factor
    141. 

  141.                     </span><span class=special>=   </span><span class=identifier>lexeme_d</span><span class=special>[(+</span><span class=identifier>digit_p</span><span class=special>)[&</span><span class=identifier>do_int</span><span class=special>]]
    142. 

  142.                     </span><span class=special>|   </span><span class=literal>'(' </span><span class=special>&gt;&gt; </span><span class=identifier>expression </span><span class=special>&gt;&gt; </span><span class=literal>')'
    143. 

  143.                     </span><span class=special>|   </span><span class=special>(</span><span class=literal>'-' </span><span class=special>&gt;&gt; </span><span class=identifier>factor</span><span class=special>)[&</span><span class=identifier>do_neg</span><span class=special>]
    144. 

  144.                     </span><span class=special>|   </span><span class=special>(</span><span class=literal>'+' </span><span class=special>&gt;&gt; </span><span class=identifier>factor</span><span class=special>)
    145. 

  145.                     </span><span class=special>;
    146. 

  146.             </span><span class=special>}
    147. 

  147. 

  148.             </span><span class=identifier>rule</span><span class=special>&lt;</span><span class=identifier>ScannerT</span><span class=special>&gt; </span><span class=identifier>expression</span><span class=special>, </span><span class=identifier>term</span><span class=special>, </span><span class=identifier>factor</span><span class=special>;
    149. 

  149. 

  150.             </span><span class=identifier>rule</span><span class=special>&lt;</span><span class=identifier>ScannerT</span><span class=special>&gt; </span><span class=keyword>const</span><span class=special>&
    151. 

  151.             </span><span class=identifier>start</span><span class=special>() </span><span class=keyword>const </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>expression</span><span class=special>; </span><span class=special>}
    152. 

  152.         </span><span class=special>};
    153. 

  153.     </span><span class=special>};</span></font></code></pre>
    154. 

  154. <p>Feeding in the expression <tt>(-1 + 2) * (3 + -4)</tt>, for example, to the
    155. 

  155.   rule <tt>expression</tt> will produce the expected output:</p>
    156. 

  156. <pre><code><span class=special>-</span><span class=number>1
    157. 

  157. </span><span class=number>2
    158. 

  158. </span><span class=identifier>ADD
    159. 

  159. </span><span class=number>3
    160. 

  160. </span><span class=special>-</span><span class=number>4
    161. 

  161. </span><span class=identifier>ADD
    162. 

  162. </span><span class=identifier>MULT</span></code></pre>
    163. 

  163. <p>which, by the way, is the Reverse Polish Notation (RPN) of the given expression, 
    164. 

  164.   reminiscent of some primitive calculators and the language Forth.</p>
    165. 

  165. <p><img src="theme/lens.gif" width="15" height="16"> <a href="../example/fundamental/calc_plain.cpp">View 
    166. 

  166.   the complete source code here</a>. This is part of the Spirit distribution. 
    167. 

  167. </p>
    168. 

  168. <h2><a name="specialized_actions"></a>Specialized Actions</h2>
    169. 

  169. <p>In general, semantic actions accept the first-last iterator pair. There are 
    170. 

  170.   situations though where we might want to pass data in its processed form. A 
    171. 

  171.   concrete example is the numeric parser. It is unwise to pass unprocessed data 
    172. 

  172.   to a semantic action attached to a numeric parser and just throw away what has 
    173. 

  173.   been parsed by the parser. We want to pass the actual parsed number.</p>
    174. 

  174. <p>The function and functor signature of a semantic action varies depending on 
    175. 

  175.   the parser where it is attached to. The following table lists the parsers that 
    176. 

  176.   accept unique signatures.</p>
    177. 

  177. <table width="80%" border="0" align="center">
    178. 

  178.   <tr> 
    179. 

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

  180.       explicitly stated in the documentation of a specific parser type, parsers 
    181. 

  181.       not included in the list by default expect the generic signature as explained 
    182. 

  182.       above.</td>
    183. 

  183.   </tr>
    184. 

  184. </table>
    185. 

  185. <h3>Numeric Actions</h3>
    186. 

  186. <p><b>Applies to:</b></p>
    187. 

  187. <blockquote>
    188. 

  188.   <p><img src="theme/bullet.gif" width="13" height="13"> uint_p<br>
    189. 

  189.     <img src="theme/bullet.gif" width="13" height="13"> int_p<br>
    190. 

  190.     <img src="theme/bullet.gif" width="13" height="13"> ureal_p<br>
    191. 

  191.     <img src="theme/bullet.gif" width="13" height="13"> real_p</p>
    192. 

  192. </blockquote>
    193. 

  193. <p><b>Signature for functions:</b></p>
    194. 

  194. <pre><code><font color="#000000"><span class=identifier>    </span><span class=keyword>void </span><span class=identifier>func</span><span class=special>(</span><span class=identifier>NumT </span><span class=identifier>val</span><span class=special>);</span></font></code></pre>
    195. 

  195. <p><b>Signature for functors:</b> </p>
    196. 

  196. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>ftor
    197. 

  197.     </span><span class=special>{
    198. 

  198.         </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()(</span><span class=identifier>NumT </span><span class=identifier>val</span><span class=special>) </span><span class=keyword>const</span><span class=special>;
    199. 

  199.     </span><span class=special>};</span></font></code></pre>
    200. 

  200. <p>Where <tt>NumT</tt> is any primitive numeric type such as <tt>int</tt>, <tt>long</tt>,
    201. 

  201.   <tt>float</tt>, <tt>double</tt>, etc., or a user defined numeric type such as
    202. 

  202.   big_int. <tt>NumT</tt> is the same type used as template parameter to <tt>uint_p</tt>,
    203. 

  203.   <tt>int_p</tt>, <tt>ureal_p</tt> or <tt>real_p</tt>. The parsed number is passed
    204. 

  204.   into the function/functor.</p>
    205. 

  205. <h3>Character Actions</h3>
    206. 

  206. <p><b>Applies to:</b></p>
    207. 

  207. <blockquote>
    208. 

  208.   <p><img src="theme/bullet.gif" width="13" height="13"> chlit, ch_p<br>
    209. 

  209.     <img src="theme/bullet.gif" width="13" height="13"> range, range_p<br>
    210. 

  210.     <img src="theme/bullet.gif" width="13" height="13"> anychar<br>
    211. 

  211.     <img src="theme/bullet.gif" width="13" height="13"> alnum, alpha<br>
    212. 

  212.     <img src="theme/bullet.gif" width="13" height="13"> cntrl, digit<br>
    213. 

  213.     <img src="theme/bullet.gif" width="13" height="13"> graph, lower<br>
    214. 

  214.     <img src="theme/bullet.gif" width="13" height="13"> print, punct<br>
    215. 

  215.     <img src="theme/bullet.gif" width="13" height="13"> space, upper<br>
    216. 

  216.     <img src="theme/bullet.gif" width="13" height="13"> xdigit</p>
    217. 

  217. </blockquote>
    218. 

  218. <p><b>Signature for functions:</b></p>
    219. 

  219. <pre><code><font color="#000000"><span class=identifier>    </span><span class=keyword>void </span><span class=identifier>func</span><span class=special>(</span><span class=identifier>CharT </span><span class=identifier>ch</span><span class=special>);</span></font></code></pre>
    220. 

  220. <p><b>Signature for functors:</b></p>
    221. 

  221. <pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>ftor
    222. 

  222.     </span><span class=special>{
    223. 

  223.         </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()(</span><span class=identifier>CharT </span><span class=identifier>ch</span><span class=special>) </span><span class=keyword>const</span><span class=special>;
    224. 

  224.     </span><span class=special>};</span></font></code></pre>
    225. 

  225. <p>Where <tt>CharT</tt> is the value_type of the iterator used in parsing. A <tt>char
    226. 

  226.   const*</tt> iterator for example has a <tt>value_type</tt> of <tt>char</tt>.
    227. 

  227.   The matching character is passed into the function/functor.</p>
    228. 

  228. <h2>Cascading Actions</h2>
    229. 

  229. <p>Actions can be cascaded. Cascaded actions also inherit the function/functor
    230. 

  230.   interface of the original. For example:</p>
    231. 

  231. <pre><code><font color="#000000"><span class=special>    </span><span class=identifier>uint_p</span><span class=special>[</span><span class=identifier>fa</span><span class=special>][</span><span class=identifier>fb</span><span class=special>][</span><span class=identifier>fc</span><span class=special>]</span></font></code></pre>
    232. 

  232. <p>Here, the functors <tt>fa</tt>, <tt>fb</tt> and <tt>fc</tt> all expect the
    233. 

  233.   signature <tt>void operator()(unsigned n) const</tt>.</p>
    234. 

  234. <h2>Directives and Actions</h2>
    235. 

  235. <p>Directives inherit the function/functor interface of the subject it is
    236. 

  236.   enclosing. Example:</p>
    237. 

  237. <pre><code><font color="#000000"><span class=special>    </span><span class=identifier>as_lower_d</span><span class=special>[</span><span class=identifier>ch_p</span><span class=special>(</span><span class=literal>'x'</span><span class=special>)][</span><span class=identifier>f</span><span class=special>]</span></font></code></pre>
    238. 

  238. <p>Here, the functor <tt>f</tt> expects the signature <tt>void operator()(char 
    239. 

  239.   ch) const</tt>, assuming that the iterator used is a <tt>char const*</tt>.</p>
    240. 

  240. <table border="0">
    241. 

  241.   <tr>
    242. 

  242.     <td width="10"></td>
    243. 

  243.     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
    244. 

  244.     <td width="30"><a href="subrules.html"><img src="theme/l_arr.gif" border="0"></a></td>
    245. 

  245.     <td width="30"><a href="indepth_the_parser.html"><img src="theme/r_arr.gif" border="0"></a></td>
    246. 

  246.   </tr>
    247. 

  247. </table>
    248. 

  248. <br>
    249. 

  249. <hr size="1">
    250. 

  250. <p class="copyright">Copyright &copy; 1998-2003 Joel de Guzman<br>
    251. 

  251.   <br>
    252. 

  252.   <font size="2">Use, modification and distribution is subject to the Boost Software
    253. 

  253.     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    254. 

  254.     http://www.boost.org/LICENSE_1_0.txt)</font></p>
    255. 

  255. <p>&nbsp;</p>
    256. 

  256. <p>&nbsp;</p>
    257. 

  257. </body>
    258. 

  258. </html>
    259.