+++ /dev/null
-<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="30"><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 their own
-
- to give this important building
- block better focus. 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 includes 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=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 numeric base type of the numeric parser.
- Defaults to <tt>unsigned</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>.</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 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 numeric base 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 the numeric base type <tt>T</tt> can be specified by the user.
- This means 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 is a class that groups all the policies and defaults
- to <tt>ureal_parser_policies<T></tt>. Policies control the real number
- parsers' behavior. 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, with the exception that plain integers
- without the decimal point are also accepted by default.</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>
-<p>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 four <tt>real_parser</tt>s pre-defined for
- immediate use:</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>
- <tr>
- <td class="table_cells" width="21%"><b>strict_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>strict_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>strict_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>strict_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>
-<h3><a name="strict_reals"></a>Strict Reals </h3>
-<p>Integer numbers are considered a subset of real numbers, so <tt>real_p</tt>
- and <tt>ureal_p</tt> recognize integer numbers (without a dot) as real numbers.
- <tt>strict_real_p</tt> and <tt>strict_ureal_p</tt> are the equivalent parsers
- that <strong>require</strong> a dot to be present for a number to be considered
- a successful match.</p>
-<h2>Advanced: real_parser policies</h2>
-<p>The parser policies break down real number parsing into 6 steps:</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>And the interaction of these sub-parsing tasks is further controlled by these
- 3 policies:</p>
-<table width="90%" border="0" align="center">
- <tr>
- <td class="table_cells">1</td>
- <td class="table_cells"><b>allow_leading_dot</b></td>
- <td class="table_cells">Allow a leading dot to be present (".1" becomes
- equivalent to "0.1")</td>
- </tr>
- <tr>
- <td class="table_cells">2</td>
- <td class="table_cells"><b>allow_trailing_dot</b></td>
- <td class="table_cells">Allow a trailing dot to be present ("1." becomes
- equivalent to "1.0")</td>
- </tr>
- <tr>
- <td class="table_cells">3</td>
- <td class="table_cells"><b>expect_dot</b></td>
- <td class="table_cells">Require a dot to be present (disallows "1" to
- be equivalent to "1.0")</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 and 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
- to the caller through the match object which, after parsing, is set to <strong>true</strong>
- if the parsed sign is negative. This attribute detects 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_a</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...</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> </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 </span><span class=identifier>int_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>int_parser_t</span><span class=special>;
-
- </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>
- </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>
-<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>
- </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>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>); }
-
- </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 replaced <b><tt>parse_sign</tt></b> of
- the <b>u</b>real_parser_policies from which it is subclassed. 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>
-<h2><span class=identifier>strict_ureal_parser_policies and strict_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>strict_ureal_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=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>
- <span class=special>};</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>strict_real_parser_policies </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>real_parser_policies</span><span class=special><</span><span class=identifier>T</span><span class=special>>
- </span><span class=special>{</span>
-<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>
- <span class=special>};</span></pre>
-<p>Again, these policies replaced just the policies they wanted different from
- their superclasses.</p>
-<p><i>Specialized</i> real parser policies can reuse some of the defaults while
- replacing a few. For example, the following is a real number parser policy that
- parses thousands separated numbers with at most two decimal places and no exponent.
-</p>
-<p><img src="theme/lens.gif" width="15" height="16">The full source code can be
- viewed <a href="../example/fundamental/thousand_separated.cpp">here</a>. </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=special> </span><span class=comment>////////////////////////////////// No exponent<br></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=special> </span><span class=comment>////////////////////////////////// No exponent<br></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
- <a name="scanner_save"></a>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="keyword">static </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="keyword">static </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">typedef typename </span>ScannerT<span class="special">::</span>iterator_t iterator_t;<span class=special>
- </span>iterator_t save<span class="special"> = </span>scan.first<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_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>))
- {
- </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="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>
- }
- </span>scan<span class="special">.</span>first<span class="special"> = </span>save<span class="special">;
- </span><span class=keyword>return </span><span class=identifier>hit</span><span class=special>;
-
-</span><span class=special> // Note: On erroneous input such as "123,45", the result should<br> // be a partial match "123". 'save' is used to makes sure that<br> // the scanner position is placed at the last *valid* parse<br> // position.<br> }
- </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></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="30"><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">Use, modification and distribution is subject to the Boost Software
- License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt) </font> </p>
-<p> </p>
-</body>
-</html>
projects / ceph.git / blobdiff