Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_34_1/libs/spirit/doc/numerics.html @ 33

Last change on this file since 33 was 29, checked in by landauf, 16 years ago

updated boost from 1_33_1 to 1_34_1
File size: 43.0 KB
RevLine 
[29]1<html>
2<head>
3<title>Numerics</title>
4<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
5<link rel="stylesheet" href="theme/style.css" type="text/css">
6</head>
7
8<body>
9<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
10  <tr>
11    <td width="10">
12    </td>
13    <td width="85%">
14      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Numerics</b></font>
15    </td>
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  </tr>
18</table>
19<br>
20<table border="0">
21  <tr>
22    <td width="10"></td>
23    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
24    <td width="30"><a href="operators.html"><img src="theme/l_arr.gif" border="0"></a></td>
25    <td width="30"><a href="rule.html"><img src="theme/r_arr.gif" border="0"></a></td>
26  </tr>
27</table>
28<p>Similar to <tt>chlit</tt>, <tt>strlit</tt> etc. numeric parsers are also primitives.
29  Numeric parsers are placed on
30
31
32 a section of their own
33
34 to give this important building
35  block better focus. The framework includes a couple of predefined objects for
36  parsing signed and unsigned integers and real numbers. These parsers are fully
37  parametric. Most of the important aspects of numeric parsing can be finely adjusted
38  to suit. This includes the radix base, the minimum and maximum number of allowable
39  digits, the exponent, the fraction etc. Policies control the real number parsers'
40  behavior. There are some predefined policies covering the most common real number
41  formats but the user can supply her own when needed. </p>
42<h2>uint_parser</h2>
43<p>This class is the simplest among the members of the numerics package. The <tt>uint_parser</tt>
44  can parse unsigned integers of arbitrary length and size. The <tt>uint_parser</tt>
45  parser can be used to parse ordinary primitive C/C++ integers or even user defined
46  scalars such as bigints (unlimited precision integers). Like most of the classes
47  in Spirit, the <tt>uint_parser</tt> is a template class. Template parameters
48  fine tune its behavior. The uint_parser is so flexible that the other numeric
49  parsers are implemented using it as the backbone.</p>
50<pre><code><font color="#000000"><span class=identifier>    </span><span class=keyword>template </span><span class=special>&lt;
51        </span><span class=keyword>typename </span><span class=identifier>T </span><span class=special>= </span><span class="keyword">unsigned</span><span class=special>,
52        </span><span class=keyword>int </span><span class=identifier>Radix </span><span class=special>= </span><span class=number>10</span><span class=special>,
53        </span><span class=keyword>unsigned </span><span class=identifier>MinDigits </span><span class=special>= </span><span class=number>1</span><span class=special>,
54        </span><span class=keyword>int </span><span class=identifier>MaxDigits </span><span class=special>= -</span><span class=number>1</span><span class=special>&gt;
55    </span><span class=keyword>struct </span><span class=identifier>uint_parser </span><span class=special>{ </span><span class=comment>/*...*/ </span><span class=special>};</span></font></code></pre>
56<table width="90%" border="0" align="center">
57  <tr>
58    <td colspan="2" class="table_title">uint_parser template parameters</td>
59  </tr>
60  <tr>
61    <td class="table_cells" width="21%"><b>T</b></td>
62    <td class="table_cells" width="79%">The numeric base type of the numeric parser.
63      Defaults to <tt>unsigned</tt></td>
64  </tr>
65  <tr>
66    <td class="table_cells" width="21%"><b>Radix</b></td>
67    <td class="table_cells" width="79%">The radix base. This can be either 2:
68      binary, 8: octal, 10: decimal and 16: hexadecimal. Defaults to 10; decimal</td>
69  </tr>
70  <tr>
71    <td class="table_cells" width="21%"><b>MinDigits</b></td>
72    <td class="table_cells" width="79%">The minimum number of digits allowable</td>
73  </tr>
74  <tr>
75    <td class="table_cells" width="21%"><b>MaxDigits</b></td>
76    <td class="table_cells" width="79%">The maximum number of digits allowable.
77      If this is -1, then the maximum limit becomes unbounded</td>
78  </tr>
79</table>
80<br>
81<table width="90%" border="0" align="center">
82  <tr>
83    <td colspan="2" class="table_title">Predefined uint_parsers</td>
84  </tr>
85  <tr>
86    <td class="table_cells" width="21%"><b>bin_p</b></td>
87    <td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>,
88      </span><span class=number>2</span><span class=special>, </span><span class=number>1</span><span class=special>,
89      -</span><span class=number>1</span><span class=special>&gt; </span><span class=keyword>const</span></code></td>
90  </tr>
91  <tr>
92    <td class="table_cells" width="21%"><b>oct_p</b></td>
93    <td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>,
94      </span><span class=number>8</span><span class=special>, </span><span class=number>1</span><span class=special>,
95      -</span><span class=number>1</span><span class=special>&gt; </span><span class=keyword>const</span></code></td>
96  </tr>
97  <tr>
98    <td class="table_cells" width="21%"><b>uint_p</b></td>
99    <td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>,
100      </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>,
101      -</span><span class=number>1</span><span class=special>&gt; </span><span class=keyword>const</span></code></td>
102  </tr>
103  <tr>
104    <td class="table_cells" width="21%"><b>hex_p</b></td>
105    <td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>,
106      </span><span class=number>16</span><span class=special>, </span><span class=number>1</span><span class=special>,
107      -</span><span class=number>1</span><span class=special>&gt; </span><span class=keyword>const</span></code></td>
108  </tr>
109</table>
110<p>The following example shows how the uint_parser can be used to parse thousand
111  separated numbers. The example can correctly parse numbers such as 1,234,567,890.</p>
112<pre><span class=keyword>    </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, </span><span class=number>3</span><span class=special>&gt; </span><span class=identifier>uint3_p</span><span class=special>;        </span><span class=comment>//  1..3 digits
113    </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>3</span><span class=special>, </span><span class=number>3</span><span class=special>&gt; </span><span class=identifier>uint3_3_p</span><span class=special>;      </span><span class=comment>//  exactly 3 digits
114    </span><span class=identifier>ts_num_p </span><span class=special>= </span><span class=special>(</span><span class=identifier>uint3_p </span><span class=special>&gt;&gt; </span><span class=special>*(</span><span class=literal>',' </span><span class=special>&gt;&gt; </span><span class=identifier>uint3_3_p</span><span class=special>));    </span><span class=comment>//  our thousand separated number parser</span></pre>
115<p><tt>bin_p</tt>, <tt>oct_p</tt>, <tt>uint_p</tt> and <tt>hex_p</tt> are parser
116  generator objects designed to be used within expressions. Here's an example
117  of a rule that parses comma delimited list of numbers (We've seen this <a href="quick_start.html#list_of_numbers">before</a>):</p>
118<pre><code><span class=identifier>    </span><span class=identifier>list_of_numbers </span><span class=special>=</span> <span class=identifier>real_p </span><span class=special>&gt;&gt; *(</span><span class=literal>','</span> <span class=special>&gt;&gt; </span><span class=identifier>real_p</span><span class=special>)</span></code>;
119</pre>
120<p></p>
121<p>Later, we shall see how we can extract the actual numbers parsed by the numeric
122  parsers. We shall deal with this when we get to the section on <a href="semantic_actions.html#specialized_actions">specialized
123  actions</a>.</p>
124<h2>int_parser</h2>
125<p>The <tt>int_parser</tt> can parse signed integers of arbitrary length and size.
126  This is almost the same as the <tt>uint_parser</tt>. The only difference is
127  the additional task of parsing the <tt><span class="quotes">'+'</span></tt>
128  or <tt class="quotes">'-'</tt> sign preceding the number. The class interface
129  is the same as that of the uint_parser.<br>
130</p>
131<table width="90%" border="0" align="center">
132  <tr>
133    <td colspan="2" class="table_title">A predefined int_parser</td>
134  </tr>
135  <tr>
136    <td class="table_cells" width="21%"><b>int_p</b></td>
137    <td class="table_cells" width="79%"><span class=identifier><code>int_parser</code></span><code><span class=special>&lt;</span><span class=keyword>int</span><span class=special>,
138      </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>,
139      -</span><span class=number>1</span><span class=special>&gt; </span><span class=keyword>const</span></code></td>
140  </tr>
141</table>
142<h2>real_parser</h2>
143<p>The <tt>real_parser</tt> can parse real numbers of arbitrary length and size
144  limited by its parametric type <tt>T</tt>. The <tt>real_parser</tt> is a template
145  class with 2 template parameters. Here's the <tt>real_parser</tt> template interface:</p>
146<pre><span class=keyword>    template</span><span class=special>&lt;
147        </span><span class=keyword>typename </span><span class=identifier>T </span><span class=special>= </span><span class=keyword>double</span><span class=special>,
148        </span><span class=keyword>typename </span><span class=identifier>RealPoliciesT </span><span class=special>= </span><span class=identifier>ureal_parser_policies</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt; </span><span class=special>&gt;
149</span><span class=keyword>    struct </span><span class=identifier>real_parser</span><span class=special>;</span></pre>
150<p>The first template parameter is its numeric base type <tt>T</tt>. This defaults
151  to <tt>double</tt>. </p>
152<table width="80%" border="0" align="center">
153  <tr>
154    <td class="note_box"><img src="theme/bulb.gif" width="13" height="18"><b>
155      Parsing special numeric types</b><br>
156      <br>
157      Notice that the numeric base type <tt>T</tt> can be specified by the user.
158      This means that we can use the numeric parsers to parse user defined numeric
159      types such as <tt>fixed_point</tt> (fixed point reals) and <tt>bigint</tt>
160      (unlimited precision integers).</td>
161  </tr>
162</table>
163<p>The second template parameter is a class that groups all the policies and defaults
164  to <tt>ureal_parser_policies&lt;T&gt;</tt>. Policies control the real number
165  parsers' behavior. The default policies provided are designed to parse C/C++
166  style real numbers of the form <b>nnn.fff.Eeee</b> where <b>nnn</b> is the whole
167  number part, <b>fff</b> is the fractional part, <b>E</b> is <tt class="quotes">'e'</tt>
168  or <tt class="quotes">'E'</tt> and <b>eee</b> is the exponent optionally preceded
169  by <tt class="quotes">'-'</tt> or <tt><span class="quotes">'+'</span></tt>.
170  This corresponds to the following grammar, with the exception that plain integers
171  without the decimal point are also accepted by default.</p>
172<pre><code><font color="#000000"><span class=keyword>    </span><span class=identifier>floatingliteral
173        </span><span class=special>=   </span><span class=identifier>fractionalconstant </span><span class=special>&gt;&gt; </span><span class=special>!</span><span class=identifier>exponentpart
174        </span><span class=special>|  </span><span class=special>+</span><span class=identifier>digit_p </span><span class=special>&gt;&gt; </span><span class=identifier>exponentpart
175        </span><span class=special>;
176
177    </span><span class=identifier>fractionalconstant
178        </span><span class=special>=  </span><span class=special>*</span><span class=identifier>digit_p </span><span class=special>&gt;&gt; </span><span class=literal>'.' </span><span class=special>&gt;&gt; </span><span class=special>+</span><span class=identifier>digit_p
179        </span><span class=special>|  </span><span class=special>+</span><span class=identifier>digit_p </span><span class=special>&gt;&gt; </span><span class=literal>'.'
180        </span><span class=special>;
181
182    </span><span class=identifier>exponentpart
183        </span><span class=special>=   </span><span class=special>(</span><span class=literal>'e' </span><span class=special>| </span><span class=literal>'E'</span><span class=special>) </span><span class=special>&gt;&gt; </span><span class=special>!(</span><span class=literal>'+' </span><span class=special>| </span><span class=literal>'-'</span><span class=special>) </span><span class=special>&gt;&gt; </span><span class=special>+</span><span class=identifier>digit_p
184        </span><span class=special>;</span></font></code></pre>
185<p>The default policies are provided to take care of the most common case (there
186  are many ways to represent, and hence parse, real numbers). In most cases, the
187  default setting of the <tt>real_parser</tt> is sufficient and can be used straight
188  out of the box. Actually, there are four <tt>real_parser</tt>s pre-defined for
189  immediate use:</p>
190<table width="90%" border="0" align="center">
191  <tr>
192    <td colspan="2" class="table_title">Predefined real_parsers</td>
193  </tr>
194  <tr>
195    <td class="table_cells" width="21%"><b>ureal_p</b></td>
196    <td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special>&lt;</span><span class=keyword>double</span><span class=special>,
197      </span><span class=identifier>ureal_parser_policies</span><span class=special>&lt;</span><span class=keyword>double</span><span class=special>&gt;
198      &gt; </span><span class=keyword>const</span></code></td>
199  </tr>
200  <tr>
201    <td class="table_cells" width="21%"><b>real_p</b></td>
202    <td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special>&lt;</span><span class=keyword>double</span><span class=special>,
203      </span><span class=identifier>real_parser_policies</span><span class=special>&lt;</span><span class=keyword>double</span><span class=special>&gt;
204      &gt; </span><span class=keyword>const</span></code></td>
205  </tr>
206  <tr>
207    <td class="table_cells" width="21%"><b>strict_ureal_p</b></td>
208    <td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special>&lt;</span><span class=keyword>double</span><span class=special>,
209      </span><span class=identifier>strict_ureal_parser_policies</span><span class=special>&lt;</span><span class=keyword>double</span><span class=special>&gt;
210      &gt; </span><span class=keyword>const</span></code></td>
211  </tr>
212  <tr>
213    <td class="table_cells" width="21%"><b>strict_real_p</b></td>
214    <td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special>&lt;</span><span class=keyword>double</span><span class=special>,
215      </span><span class=identifier>strict_real_parser_policies</span><span class=special>&lt;</span><span class=keyword>double</span><span class=special>&gt;
216      &gt; </span><span class=keyword>const</span></code></td>
217  </tr>
218</table>
219<p>We've seen <tt>real_p</tt> before. <tt>ureal_p</tt> is its unsigned variant.</p>
220<h3><a name="strict_reals"></a>Strict Reals </h3>
221<p>Integer numbers are considered a subset of real numbers, so <tt>real_p</tt>
222  and <tt>ureal_p</tt> recognize integer numbers (without a dot) as real numbers.
223  <tt>strict_real_p</tt> and <tt>strict_ureal_p</tt> are the equivalent parsers
224  that <strong>require</strong> a dot to be present for a number to be considered
225  a successful match.</p>
226<h2>Advanced: real_parser policies</h2>
227<p>The parser policies break down real number parsing into 6 steps:</p>
228<table width="90%" border="0" align="center">
229  <tr>
230    <td class="table_cells">1</td>
231    <td class="table_cells"><b>parse_sign</b></td>
232    <td class="table_cells">Parse the prefix sign</td>
233  </tr>
234  <tr>
235    <td class="table_cells">2</td>
236    <td class="table_cells"><b>parse_n</b></td>
237    <td class="table_cells">Parse the integer at the left of the decimal point</td>
238  </tr>
239  <tr>
240    <td class="table_cells">3</td>
241    <td class="table_cells"><b>parse_dot</b></td>
242    <td class="table_cells">Parse the decimal point</td>
243  </tr>
244  <tr>
245    <td class="table_cells">4</td>
246    <td class="table_cells"><b>parse_frac_n</b></td>
247    <td class="table_cells">Parse the fraction after the decimal point</td>
248  </tr>
249  <tr>
250    <td class="table_cells">5</td>
251    <td class="table_cells"><b>parse_exp</b></td>
252    <td class="table_cells">Parse the exponent prefix (e.g. 'e')</td>
253  </tr>
254  <tr>
255    <td class="table_cells">6</td>
256    <td class="table_cells"><b>parse_exp_n</b></td>
257    <td class="table_cells">Parse the actual exponent</td>
258  </tr>
259</table>
260<p>And the interaction of these sub-parsing tasks is further controlled by these
261  3 policies:</p>
262<table width="90%" border="0" align="center">
263  <tr>
264    <td class="table_cells">1</td>
265    <td class="table_cells"><b>allow_leading_dot</b></td>
266    <td class="table_cells">Allow a leading dot to be present (&quot;.1&quot; becomes
267      equivalent to &quot;0.1&quot;)</td>
268  </tr>
269  <tr>
270    <td class="table_cells">2</td>
271    <td class="table_cells"><b>allow_trailing_dot</b></td>
272    <td class="table_cells">Allow a trailing dot to be present (&quot;1.&quot; becomes
273    equivalent to &quot;1.0&quot;)</td>
274  </tr>
275  <tr>
276    <td class="table_cells">3</td>
277    <td class="table_cells"><b>expect_dot</b></td>
278    <td class="table_cells">Require a dot to be present (disallows &quot;1&quot; to
279    be equivalent to &quot;1.0&quot;)</td>
280  </tr>
281</table>
282<p>[ <img src="theme/lens.gif" width="15" height="16"> From here on, required
283  reading: <a href="scanner.html">The Scanner</a>, <a href="indepth_the_parser.html">In-depth
284  The Parser</a> and <a href="indepth_the_scanner.html">In-depth The Scanner</a>
285  ]</p>
286<h2>sign_parser and sign_p</h2>
287<p>Before we move on, a small utility parser is included here to ease the parsing
288  of the <span class="quotes">'-'</span> or <span class="quotes">'+'</span> sign.
289  While it is easy to write one:</p>
290<pre>    <span class=identifier>sign_p </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=literal>'-'</span><span class="special">)</span><span class=literal>;</span></pre>
291<p>it is not possible to extract the actual sign (positive or negative) without
292  resorting to semantic actions. The sign_p parser has a bool attribute returned
293  to the caller through the match object which, after parsing, is set to <strong>true</strong>
294  if the parsed sign is negative. This attribute detects if the negative sign
295  has been parsed. Examples:</p>
296<pre><span class=special>    </span><span class=keyword>bool </span><span class=identifier>is_negative</span><span class=special>;
297    </span><span class=identifier>r </span><span class=special>= </span><span class=identifier>sign_p</span><span class=special>[</span><span class=identifier>assign_a</span><span class=special>(</span><span class=identifier>is_negative</span><span class=special>)]</span><span class=special>;</span></pre>
298<p><span class=special></span>or simply...</p>
299<pre>    <span class=comment>// directly extract the result from the match result's value</span>
300    <span class=keyword>bool </span><span class=identifier>is_negative </span><span class=special>= </span><span class=identifier>sign_p</span><span class=special>.</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>).</span><span class=identifier>value</span><span class=special>();</span><span class=comment> </span></pre>
301<p>The sign_p parser expects attached semantic actions to have a signature (see
302  <a href="semantic_actions.html#specialized_actions">Specialized Actions</a>
303  for further detail) compatible with: </p>
304<p><b>Signature for functions:</b></p>
305<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="keyword">bool</span><span class=identifier> is_negative</span><span class=special>);</span></font></code></pre>
306<p><b>Signature for functors:</b> </p>
307<pre><code><font color="#000000"><span class=special>    </span><span class=keyword>struct </span><span class=identifier>ftor
308    </span><span class=special>{
309        </span><span class=keyword>void </span><span class=keyword>operator</span><span class=special>()(</span><span class="keyword">bool</span><span class=identifier> is_negative</span><span class=special>) </span><span class=keyword>const</span><span class=special>;
310    </span><span class=special>};</span></font></code></pre>
311<h2><span class=identifier>ureal_parser_policies</span></h2>
312<pre><span class=comment>    </span><span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>&gt;
313    </span><span class=keyword>struct </span><span class=identifier>ureal_parser_policies
314    </span><span class=special>{
315        </span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, -</span><span class=number>1</span><span class=special>&gt;   </span><span class=identifier>uint_parser_t</span><span class=special>;
316        </span><span class=keyword>typedef </span><span class=identifier>int_parser</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, -</span><span class=number>1</span><span class=special>&gt;    </span><span class=identifier>int_parser_t</span><span class=special>;
317
318        </span><span class=keyword>static const bool</span> <span class=identifier>allow_leading_dot</span> <span class=special> =</span> <span class=literal>true</span><span class=special>;</span><span class=special>
319        </span><span class=keyword>static const bool</span> <span class=identifier>allow_trailing_dot </span><span class=special>=</span> <span class=literal>true</span><span class=special>;</span><span class=special></span>
320<span class=special>        </span><span class=keyword>static const bool</span> <span class=identifier>expect_dot</span> <span class=special>        =</span> <span class=literal>false</span><span class=special>;</span><span class=special></span><span class=special><br>
321        </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;
322        </span><span class=keyword>static typename </span><span class=identifier>match_result</span><span class=special>&lt;</span><span class=identifier>ScannerT</span><span class=special>, </span><span class="identifier">nil_t</span><span class=special>&gt;::</span><span class=identifier>type
323        parse_sign</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
324        { </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
325
326        </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;
327        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
328        parse_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
329        { </span><span class=keyword>return </span><span class=identifier>uint_parser_t</span><span class=special>().</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
330
331        </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;
332        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>chlit</span><span class=special>&lt;&gt;, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
333        parse_dot</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
334        { </span><span class=keyword>return </span><span class=identifier>ch_p</span><span class=special>(</span><span class=literal>'.'</span><span class=special>).</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
335
336        </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;
337        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
338        parse_frac_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
339        { </span><span class=keyword>return </span><span class=identifier>uint_parser_t</span><span class=special>().</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
340
341        </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;
342        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>chlit</span><span class=special>&lt;&gt;, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
343        parse_exp</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
344        { </span><span class=keyword>return </span><span class=identifier>as_lower_d</span><span class=special>[</span><span class=literal>'e'</span><span class=special>].</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
345
346        </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;
347        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=keyword>int</span><span class=identifier>_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
348        parse_exp_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
349        { </span><span class=keyword>return int</span><span class=identifier>_parser_t</span><span class=special>().</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
350    };
351</span></pre>
352<p><span class=special></span><span class=identifier>The default ureal_parser_policies
353  uses the lower level integer numeric parsers to do its job. </span></p>
354<h2><span class=identifier>real_parser_policies</span></h2>
355<pre>    <span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>&gt;
356    </span><span class=keyword>struct </span><span class=identifier>real_parser_policies </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>ureal_parser_policies</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;
357    </span><span class=special>{
358        </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;
359        </span><span class=keyword>static </span><span class=keyword>typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>sign_parser</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
360        </span><span class=identifier>parse_sign</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
361        </span><span class=special>{ </span><span class=keyword>return </span><span class=identifier>sign_p</span><span class=special>.</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); </span><span class=special>}
362    </span><span class=special>};</span></pre>
363<p>Notice how the real_parser_policies replaced <b><tt>parse_sign</tt></b> of
364  the <b>u</b>real_parser_policies from which it is subclassed. The default real_parser_policies
365  simply uses a <tt>sign_p</tt> instead of <tt>scan.no_match()</tt> in the <tt>parse_sign
366  </tt> step. </p>
367<h2><span class=identifier>strict_ureal_parser_policies and strict_real_parser_policies</span></h2>
368<pre>    <span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>&gt;
369    </span><span class=keyword>struct </span><span class=identifier>strict_ureal_parser_policies </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>ureal_parser_policies</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;
370    </span><span class=special>{</span>
371<span class=special>        </span><span class=keyword>static const bool</span> <span class=identifier>expect_dot</span><span class=special> =</span> <span class=literal>true</span><span class=special>;</span><span class=special></span><span class=special></span>
372    <span class=special>};</span>
373
374    <span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>&gt;
375    </span><span class=keyword>struct </span><span class=identifier>strict_real_parser_policies </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>real_parser_policies</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;
376    </span><span class=special>{</span>
377<span class=special>        </span><span class=keyword>static const bool</span> <span class=identifier>expect_dot</span><span class=special> =</span> <span class=literal>true</span><span class=special>;</span><span class=special></span><span class=special></span>
378    <span class=special>};</span></pre>
379<p>Again, these policies replaced just the policies they wanted different from
380  their superclasses.</p>
381<p><i>Specialized</i> real parser policies can reuse some of the defaults while
382  replacing a few. For example, the following is a real number parser policy that
383  parses thousands separated numbers with at most two decimal places and no exponent.
384</p>
385<p><img src="theme/lens.gif" width="15" height="16">The full source code can be
386  viewed <a href="../example/fundamental/thousand_separated.cpp">here</a>. </p>
387<pre>
388<span class=identifier>    </span><span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>&gt;
389    </span><span class=keyword>struct </span><span class=identifier>ts_real_parser_policies </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>ureal_parser_policies</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;
390    {
391        </span><span class=comment>//  These policies can be used to parse thousand separated
392        //  numbers with at most 2 decimal digits after the decimal
393        //  point. e.g. 123,456,789.01
394
395        </span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, </span><span class=number>2</span><span class=special>&gt;  </span><span class=identifier>uint2_t</span><span class=special>;
396        </span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, -</span><span class=number>1</span><span class=special>&gt;   </span><span class=identifier>uint_parser_t</span><span class=special>;
397        </span><span class=keyword>typedef </span><span class=identifier>int_parser</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, -</span><span class=number>1</span><span class=special>&gt;  </span><span class=identifier>int_parser_t</span><span class=special>;
398
399        </span><span class=comment>//////////////////////////////////  2 decimal places Max
400        </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;
401        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>uint2_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
402        parse_frac_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
403        { </span><span class=keyword>return </span><span class=identifier>uint2_t</span><span class=special>().</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>); }
404
405</span><span class=special>        </span><span class=comment>//////////////////////////////////  No exponent<br></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;
406        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>chlit</span><span class=special>&lt;&gt;, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
407        parse_exp</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
408        { </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
409
410</span><span class=special>        </span><span class=comment>//////////////////////////////////  No exponent<br></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;
411        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>int_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
412        parse_exp_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
413        { </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
414
415        </span><span class=comment>//////////////////////////////////  Thousands separated numbers
416        </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;
417        </span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type
418        <a name="scanner_save"></a>parse_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>&amp; </span><span class=identifier>scan</span><span class=special>)
419        {
420            </span><span class=keyword>typedef typename </span><span class=identifier>parser_result</span><span class=special>&lt;</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>&gt;::</span><span class=identifier>type RT</span><span class=special>;
421            </span><span class="keyword">static </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>1</span><span class=special>, </span><span class=number>3</span><span class=special>&gt; </span><span class=identifier>uint3_p</span><span class=special>;
422            </span><span class="keyword">static </span><span class=identifier>uint_parser</span><span class=special>&lt;</span><span class=keyword>unsigned</span><span class=special>, </span><span class=number>10</span><span class=special>, </span><span class=number>3</span><span class=special>, </span><span class=number>3</span><span class=special>&gt; </span><span class=identifier>uint3_3_p</span><span class=special>;
423
424            </span><span class=keyword>if </span><span class=special>(</span><span class=identifier>RT hit </span><span class=special>= </span><span class=identifier>uint3_p</span><span class=special>.</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>))
425            {
426                </span><span class=identifier>T n</span><span class=special>;
427                </span><span class="keyword">typedef typename </span>ScannerT<span class="special">::</span>iterator_t iterator_t;<span class=special>
428                </span>iterator_t save<span class="special"> = </span>scan.first<span class="special">;
429                </span><span class=keyword>while </span><span class=special>(</span><span class=identifier>match</span><span class=special>&lt;&gt; </span><span class=identifier>next </span><span class=special>= (</span><span class=literal>',' </span><span class=special>&gt;&gt; </span><span class=identifier>uint3_3_p</span><span class=special>[</span><span class=identifier>assign_a</span><span class=special>(</span><span class=identifier>n</span><span class=special>)]).</span><span class=identifier>parse</span><span class=special>(</span><span class=identifier>scan</span><span class=special>))
430                {
431                    </span><span class=identifier>hit</span><span class=special>.</span><span class=identifier>value</span><span class=special>() *= </span><span class=number>1000</span><span class=special>;
432                    </span><span class=identifier>hit</span><span class=special>.</span><span class=identifier>value</span><span class=special>() += </span><span class=identifier>n</span><span class=special>;
433                    </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>concat_match</span><span class=special>(</span><span class=identifier>hit</span><span class=special>, </span><span class=identifier>next</span><span class=special>);
434                    </span><span class="identifier">save </span><span class=special><span class="special">= </span></span><span class="identifier">scan</span><span class="special">.</span><span class="identifier">first</span><span class=special><span class="special">;</span>
435                }
436                </span>scan<span class="special">.</span>first<span class="special"> = </span>save<span class="special">;
437                </span><span class=keyword>return </span><span class=identifier>hit</span><span class=special>;
438
439</span><span class=special>                // Note: On erroneous input such as &quot;123,45&quot;, the result should<br>                // be a partial match &quot;123&quot;. 'save' is used to makes sure that<br>                // the scanner position is placed at the last *valid* parse<br>                // position.<br>            }
440            </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>();
441        }
442    };</span></pre>
443<table border="0">
444  <tr>
445    <td width="10"></td>
446    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
447    <td width="30"><a href="operators.html"><img src="theme/l_arr.gif" border="0"></a></td>
448    <td width="30"><a href="rule.html"><img src="theme/r_arr.gif" border="0"></a></td>
449  </tr>
450</table>
451<br>
452<hr size="1">
453<p class="copyright">Copyright &copy; 1998-2002 Joel de Guzman<br>
454  <br>
455  <font size="2">Use, modification and distribution is subject to the Boost Software
456    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
457    http://www.boost.org/LICENSE_1_0.txt) </font> </p>
458<p>&nbsp;</p>
459</body>
460</html>
Note: See TracBrowser for help on using the repository browser.