<html>
<head>
<title>Numerics</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" href="theme/style.css" type="text/css">
</head>
<body>
<table width="100%" border="0" background="theme/bkd2.gif" cellspacing="2">
<tr>
<td width="10">
</td>
<td width="85%">
<font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Numerics</b></font>
</td>
<td width="112"><a href="http://spirit.sf.net"><img src="theme/spirit.gif" width="112" height="48" align="right" border="0"></a></td>
</tr>
</table>
<br>
<table border="0">
<tr>
<td width="10"></td>
<td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
<td width="30"><a href="operators.html"><img src="theme/l_arr.gif" border="0"></a></td>
<td width="20"><a href="rule.html"><img src="theme/r_arr.gif" border="0"></a></td>
</tr>
</table>
<p>Similar to <tt>chlit</tt>, <tt>strlit</tt> etc. numeric parsers are also primitives.
Numeric parsers are placed on a section of its own so as to provide a better
focus on this important building block. The framework includes a couple of predefined
objects for parsing signed and unsigned integers and real numbers. These parsers
are fully parametric. Most of the important aspects of numeric parsing can be
finely adjusted to suit. This include the radix base, the minimum and maximum
number of allowable digits, the exponent, the fraction etc. Policies control
the real number parsers' behavior. There are some predefined policies covering
the most common real number formats but the user can supply her own when needed.
</p>
<h2>uint_parser</h2>
<p>This class is the simplest among the members of the numerics package. The <tt>uint_parser</tt>
can parse unsigned integers of arbitrary length and size. The <tt>uint_parser</tt>
parser can be used to parse ordinary primitive C/C++ integers or even user defined
scalars such as bigints (unlimited precision integers). Like most of the classes
in Spirit, the <tt>uint_parser</tt> is a template class. Template parameters
fine tune its behavior. The uint_parser is so flexible that the other numeric
parsers are implemented using it as the backbone.</p>
<pre><code><font color="#000000"><span class=identifier> </span><span class=keyword>template </span><span class=special>
<
</span><span class=keyword>typename </span><span class=identifier>T </span><span class=special>= </span><span class=keyword>unsigned</span><span class=special>,
</span><span class=keyword>int </span><span class=identifier>Radix </span><span class=special>= </span><span class=number>10</span><span class=special>,
</span><span class=keyword>unsigned </span><span class=identifier>MinDigits </span><span class=special>= </span><span class=number>1</span><span class=special>,
</span><span class=keyword>int </span><span class=identifier>MaxDigits </span><span class=special>= </span><span class=special>-</span><span class=number>1
</span><span class=special>>
</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>
<table width="90%" border="0" align="center">
<tr>
<td colspan="2" class="table_title">uint_parser template parameters</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>T</b></td>
<td class="table_cells" width="79%">The underlying type of the numeric parser.
Defaults to <tt>unsigned int</tt></td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>Radix</b></td>
<td class="table_cells" width="79%">The radix base. This can be either 2:
binary, 8: octal, 10: decimal and 16: hexadecimal. Defaults to 10; decimal</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>MinDigits</b></td>
<td class="table_cells" width="79%">The minimum number of digits allowable</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>MaxDigits</b></td>
<td class="table_cells" width="79%">The maximum number of digits allowable.
If this is -1, then the maximum limit becomes unbounded</td>
</tr>
</table>
<br>
<table width="90%" border="0" align="center">
<tr>
<td colspan="2" class="table_title">Predefined uint_parsers</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>bin_p</b></td>
<td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special><</span><span class=keyword>unsigned</span><span class=special>,
</span><span class=number>2</span><span class=special>, </span><span class=number>1</span><span class=special>,
-</span><span class=number>1</span><span class=special>> </span><span class=keyword>const</span></code></td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>oct_p</b></td>
<td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special><</span><span class=keyword>unsigned</span><span class=special>,
</span><span class=number>8</span><span class=special>, </span><span class=number>1</span><span class=special>,
-</span><span class=number>1</span><span class=special>> </span><span class=keyword>const</span></code></td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>uint_p</b></td>
<td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special><</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>1</span><span class=special>> </span><span class=keyword>const</span></code></td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>hex_p</b></td>
<td class="table_cells" width="79%"><code><span class=identifier>uint_parser</span><span class=special><</span><span class=keyword>unsigned</span><span class=special>,
</span><span class=number>16</span><span class=special>, </span><span class=number>1</span><span class=special>,
-</span><span class=number>1</span><span class=special>> </span><span class=keyword>const</span></code></td>
</tr>
</table>
<p>The following example shows how the uint_parser can be used to parse thousand
separated numbers. The example can correctly parse numbers such as 1,234,567,890.</p>
<pre><span class=keyword> </span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint3_p</span><span class=special>; </span><span class=comment>// 1..3 digits
</span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint3_3_p</span><span class=special>; </span><span class=comment>// exactly 3 digits
</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>>> </span><span class=special>*(</span><span class=literal>',' </span><span class=special>>> </span><span class=identifier>uint3_3_p</span><span class=special>)); </span><span class=comment>// our thousand separated number parser</span></pre>
<p><tt>bin_p</tt>, <tt>oct_p</tt>, <tt>uint_p</tt> and <tt>hex_p</tt> are parser
generator objects designed to be used within expressions. Here's an example
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>
<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>>> *(</span><span class=literal>','</span> <span class=special>>> </span><span class=identifier>real_p</span><span class=special>)</span></code>;
</pre>
<p></p>
<p>Later, we shall see how we can extract the actual numbers parsed by the numeric
parsers. We shall deal with this when we get to the section on <a href="semantic_actions.html#specialized_actions">specialized
actions</a>.<br>
</p>
<h2>int_parser</h2>
<p>The <tt>int_parser</tt> can parse signed integers of arbitrary length and size.
This is almost the same as the <tt>uint_parser</tt>. The only difference is
the additional task of parsing the <tt><span class="quotes">'+'</span></tt>
or <tt class="quotes">'-'</tt> sign preceding the number. The class interface
is the same as that of the uint_parser.<br>
</p>
<table width="90%" border="0" align="center">
<tr>
<td colspan="2" class="table_title">A predefined int_parser</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>int_p</b></td>
<td class="table_cells" width="79%"><span class=identifier><code>int_parser</code></span><code><span class=special><</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>> </span><span class=keyword>const</span></code></td>
</tr>
</table>
<h2>real_parser</h2>
<p>The <tt>real_parser</tt> can parse real numbers of arbitrary length and size
limited by its underlying parametric type <tt>T</tt>. The <tt>real_parser</tt>
is a template class with 2 template parameters. Here's the <tt>real_parser</tt>
template interface:</p>
<pre><span class=keyword> template
</span><span class=special> <
</span><span class=keyword>typename </span><span class=identifier>T </span><span class=special>= </span><span class=keyword>double</span><span class=special>,
</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><</span><span class=identifier>T</span><span class=special>>
</span><span class=special> >
</span><span class=keyword> struct </span><span class=identifier>real_parser</span><span class=special>;</span></pre>
<p>The first template parameter is its underlying type <tt>T</tt>. This defaults
to <tt>double</tt>. </p>
<table width="80%" border="0" align="center">
<tr>
<td class="note_box"><img src="theme/bulb.gif" width="13" height="18"><b>
Parsing special numeric types</b><br>
<br>
Notice that <tt>T</tt> can be specified by the user. This is the underlying
data type of the parser. This implies that we can use the numeric parsers
to parse user defined numeric types such as <tt>fixed_point</tt> (fixed
point reals) and <tt>bigint</tt> (unlimited precision integers).</td>
</tr>
</table>
<p>The second template parameter are the policies grouped in a class and defaults
to <tt>ureal_parser_policies<T></tt>. As already mentioned, policies control
the real number parsers' behavior. The default policies are provided to take
care of the most common case (there are many ways to represent, and hence parse,
real numbers). In most cases, the default setting of the <tt>real_parser</tt>
is sufficient and can be used straight out of the box. Actually, there are two
real_parsers pre-defined for immediate use:<br>
</p>
<table width="90%" border="0" align="center">
<tr>
<td colspan="2" class="table_title">Predefined real_parsers</td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>ureal_p</b></td>
<td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special><</span><span class=keyword>double</span><span class=special>,
</span><span class=identifier>ureal_parser_policies</span><span class=special><</span><span class=keyword>double</span><span class=special>>
> </span><span class=keyword>const</span></code></td>
</tr>
<tr>
<td class="table_cells" width="21%"><b>real_p</b></td>
<td class="table_cells" width="79%"><span class=identifier><code>real_parser</code></span><code><span class=special><</span><span class=keyword>double</span><span class=special>,
</span><span class=identifier>real_parser_policies</span><span class=special><</span><span class=keyword>double</span><span class=special>>
> </span><span class=keyword>const</span></code></td>
</tr>
</table>
<p>We've seen <tt>real_p</tt> before. <tt>ureal_p</tt> is its unsigned variant.</p>
<p>The default policies provided are designed to parse C/C++ style real numbers
of the form <b>nnn.fff.Eeee</b> where <b>nnn</b> is the whole number part, <b>fff</b>
is the fractional part, <b>E</b> is <tt class="quotes">'e'</tt> or <tt class="quotes">'E'</tt>and
<b>eee</b> is the exponent optionally preceded by <tt class="quotes">'-'</tt>
or <tt><span class="quotes">'+'</span></tt>. This corresponds to the following
grammar:</p>
<pre><code><font color="#000000"><span class=keyword> </span><span class=identifier>floatingliteral
</span><span class=special>= </span><span class=identifier>fractionalconstant </span><span class=special>>> </span><span class=special>!</span><span class=identifier>exponentpart
</span><span class=special>| </span><span class=special>+</span><span class=identifier>digit_p </span><span class=special>>> </span><span class=identifier>exponentpart
</span><span class=special>;
</span><span class=identifier>fractionalconstant
</span><span class=special>= </span><span class=special>*</span><span class=identifier>digit_p </span><span class=special>>> </span><span class=literal>'.' </span><span class=special>>> </span><span class=special>+</span><span class=identifier>digit_p
</span><span class=special>| </span><span class=special>+</span><span class=identifier>digit_p </span><span class=special>>> </span><span class=literal>'.'
</span><span class=special>;
</span><span class=identifier>exponentpart
</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>>> </span><span class=special>!(</span><span class=literal>'+' </span><span class=special>| </span><span class=literal>'-'</span><span class=special>) </span><span class=special>>> </span><span class=special>+</span><span class=identifier>digit_p
</span><span class=special>;</span></font></code></pre>
<h2>Advanced: real_parser policies</h2>
<p>The parser policies break down real number parsing into 6 steps:<span class=special></span></p>
<table width="90%" border="0" align="center">
<tr>
<td class="table_cells">1</td>
<td class="table_cells"><b>parse_sign</b></td>
<td class="table_cells">Parse the prefix sign</td>
</tr>
<tr>
<td class="table_cells">2</td>
<td class="table_cells"><b>parse_n</b></td>
<td class="table_cells">Parse the integer at the left of the decimal point</td>
</tr>
<tr>
<td class="table_cells">3</td>
<td class="table_cells"><b>parse_dot</b></td>
<td class="table_cells">Parse the decimal point</td>
</tr>
<tr>
<td class="table_cells">4</td>
<td class="table_cells"><b>parse_frac_n</b></td>
<td class="table_cells">Parse the fraction after the decimal point</td>
</tr>
<tr>
<td class="table_cells">5</td>
<td class="table_cells"><b>parse_exp</b></td>
<td class="table_cells">Parse the exponent prefix (e.g. 'e')</td>
</tr>
<tr>
<td class="table_cells">6</td>
<td class="table_cells"><b>parse_exp_n</b></td>
<td class="table_cells">Parse the actual exponent</td>
</tr>
</table>
<p>[ <img src="theme/lens.gif" width="15" height="16"> From here on, required
reading: <a href="scanner.html">The Scanner</a>, <a href="indepth_the_parser.html">In-depth
The Parser</a> and <a href="indepth_the_scanner.html">In-depth The Scanner</a>
]</p>
<h2>sign_parser [ sign_p ]</h2>
<p>Before we move on, a small utility parser is included here to ease the parsing
of the <span class="quotes">'-'</span> or <span class="quotes">'+'</span> sign.
While it is easy to write one:</p>
<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>
<p>it is not possible to extract the actual sign (positive or negative) without
resorting to semantic actions. The sign_p parser has a bool attribute returned
back to the caller through the match object which, after parsing, is set to
<tt>true</tt> if the parsed sign is negative. This attribute can be used to
detect if the negative sign has been parsed . Examples:</p>
<pre><span class=special> </span><span class=keyword>bool </span><span class=identifier>is_negative</span><span class=special>;
</span><span class=identifier>r </span><span class=special>= </span><span class=identifier>sign_p</span><span class=special>[</span><span class=identifier>assign</span><span class=special>(</span><span class=identifier>is_negative</span><span class=special>)]</span><span class=special>;</span></pre>
<p><span class=special></span>or simply...<span class=special><br>
</span></p>
<pre> <span class=comment>// directly extract the result from the match result's value</span>
<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>
<p>The sign_p parser expects attached semantic actions to have a signature (see
<a href="semantic_actions.html#specialized_actions">Specialized Actions</a>
for further detail) compatible with: </p>
<p><b>Signature for functions:</b></p>
<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>
<p><b>Signature for functors:</b><b><br>
</b> </p>
<pre><code><font color="#000000"><span class=special> </span><span class=keyword>struct </span><span class=identifier>ftor
</span><span class=special>{
</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>;
</span><span class=special>};</span></font></code></pre>
<h2><span class=identifier>ureal_parser_policies</span></h2>
<pre><span class=comment> </span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>>
</span><span class=keyword>struct </span><span class=identifier>ureal_parser_policies
</span><span class=special>{
</span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint_parser_t</span><span class=special>;
</span><span class=keyword>typedef int</span><span class=identifier>_parser</span><span class=special><</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>> </span><span class=keyword>int</span><span class=identifier>_parser_t</span><span class=special>;
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>match_result</span><span class=special><</span><span class=identifier>ScannerT</span><span class=special>, </span><span class="identifier">nil_t</span><span class=special>>::</span><span class=identifier>type
parse_sign</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </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>); }
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>chlit</span><span class=special><>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_dot</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </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>); }
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_frac_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </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>); }
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>chlit</span><span class=special><>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_exp</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </span><span class=keyword>return </span><span class=identifier>nocase_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>); }
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=keyword>int</span><span class=identifier>_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_exp_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </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>); }
};
</span></pre>
<p><span class=special></span><span class=identifier>The default ureal_parser_policies
uses the lower level integer numeric parsers to do its job. </span></p>
<h2><span class=identifier>real_parser_policies</span></h2>
<pre> <span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>>
</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><</span><span class=identifier>T</span><span class=special>>
</span><span class=special>{
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static </span><span class=keyword>typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>sign_parser</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
</span><span class=identifier>parse_sign</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
</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>}
</span><span class=special>};</span></pre>
<p>Notice how the real_parser_policies has replaced <b><tt>parse_sign</tt></b>
of the <b>u</b>real_parser_policies from which it is subclassed from. The default
real_parser_policies simply uses a <tt>sign_p</tt> instead of <tt>scan.no_match()</tt>
in the <tt>parse_sign </tt> step. </p>
<p>Other <i>"specialized"</i> real parser policies can reuse these defaults.
One or more of these policies may be replaced by the client. For example, here's
a real number parser that parses thousands separated numbers with at most two
decimal places and no exponent:</p>
<pre>
<span class=identifier> </span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>T</span><span class=special>>
</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><</span><span class=identifier>T</span><span class=special>>
{
</span><span class=comment>// These policies can be used to parse thousand separated
// numbers with at most 2 decimal digits after the decimal
// point. e.g. 123,456,789.01
</span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint2_t</span><span class=special>;
</span><span class=keyword>typedef </span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint_parser_t</span><span class=special>;
</span><span class=keyword>typedef </span><span class=identifier>int_parser</span><span class=special><</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>> </span><span class=identifier>int_parser_t</span><span class=special>;
</span><span class=comment>////////////////////////////////// 2 decimal places Max
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>uint2_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_frac_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </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>); }
</span><span class=comment>//////////////////////////////////
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>chlit</span><span class=special><>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_exp</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
</span><span class=comment>//////////////////////////////////
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>int_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_exp_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{ </span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>(); }
</span><span class=comment>////////////////////////////////// Thousands separated numbers
</span><span class=keyword>template </span><span class=special><</span><span class=keyword>typename </span><span class=identifier>ScannerT</span><span class=special>>
</span><span class=keyword>static typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type
parse_n</span><span class=special>(</span><span class=identifier>ScannerT</span><span class=special>& </span><span class=identifier>scan</span><span class=special>)
{
</span><span class=keyword>typedef typename </span><span class=identifier>parser_result</span><span class=special><</span><span class=identifier>uint_parser_t</span><span class=special>, </span><span class=identifier>ScannerT</span><span class=special>>::</span><span class=identifier>type RT</span><span class=special>;
</span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint3_p</span><span class=special>;
</span><span class=identifier>uint_parser</span><span class=special><</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>> </span><span class=identifier>uint3_3_p</span><span class=special>;
</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>))
{
</span><span class=identifier>T n</span><span class=special>;
</span><span class=keyword>while </span><span class=special>(</span><span class=identifier>match</span><span class=special><> </span><span class=identifier>next </span><span class=special>= (</span><span class=literal>',' </span><span class=special>>> </span><span class=identifier>uint3_3_p</span><span class=special>[</span><span class=identifier>assign</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>))
{
</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>;
</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>;
</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>);
}
</span><span class=keyword>return </span><span class=identifier>hit</span><span class=special>;
}
</span><span class=keyword>return </span><span class=identifier>scan</span><span class=special>.</span><span class=identifier>no_match</span><span class=special>();
}
};
</span><span class="comment">// ts_real_p, our thousand separated numeric parser</span><span class=special>
</span><span class=identifier>real_parser</span><span class=special><</span><span class=keyword>double</span><span class=special>, </span><span class=identifier>ts_real_parser_policies</span><span class=special><</span><span class=keyword>double</span><span class=special>> > </span><span class=keyword>const
</span><span class=identifier>ts_real_p </span><span class=special>= </span><span class=identifier>real_parser</span><span class=special><</span><span class=keyword>double</span><span class=special>, </span><span class=identifier>ts_real_parser_policies</span><span class=special><</span><span class=keyword>double</span><span class=special>> >();
</span></pre>
<table border="0">
<tr>
<td width="10"></td>
<td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
<td width="30"><a href="operators.html"><img src="theme/l_arr.gif" border="0"></a></td>
<td width="20"><a href="rule.html"><img src="theme/r_arr.gif" border="0"></a></td>
</tr>
</table>
<br>
<hr size="1">
<p class="copyright">Copyright © 1998-2002 Joel de Guzman<br>
<br>
<font size="2">Permission to copy, use, modify, sell and distribute this document
is granted provided this copyright notice appears in all copies. This document
is provided "as is" without express or implied warranty, and with
no claim as to its suitability for any purpose. </font> </p>
<p> </p>
</body>
</html>
