]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/spirit/classic/doc/numerics.html
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bump version to 12.2.2-pve1
[ceph.git] / ceph / src / boost / libs / spirit / classic / doc / numerics.html
CommitLineData
7c673cae
FG		 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>
Ceph