parse::recdescent.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

propagate\fR out of unsuccessful productions, but \fIdo\fR survive
successful productions. Hence it is possible to dynamically alter the
text being parsed \- for example, to provide a \f(CW\*(C`#include\*(C'\fR\-like facility:
.Sp
.Vb 2
\&        hash_include: \*(Aq#include\*(Aq filename
\&                                { $text = ::loadfile($item[2]) . $text }
\&
\&        filename: \*(Aq<\*(Aq /[a\-z0\-9._\-]+/i \*(Aq>\*(Aq  { $return = $item[2] }
\&                | \*(Aq"\*(Aq /[a\-z0\-9._\-]+/i \*(Aq"\*(Aq  { $return = $item[2] }
.Ve
.ie n .IP "$thisline\fR and \f(CW$prevline" 4
.el .IP "\f(CW$thisline\fR and \f(CW$prevline\fR" 4
.IX Item "$thisline and $prevline"
\&\f(CW$thisline\fR stores the current line number within the current parse
(starting from 1). \f(CW$prevline\fR stores the line number for the last 
character which was already successfully parsed (this will be different from
\&\f(CW$thisline\fR at the end of each line).
.Sp
For efficiency, \f(CW$thisline\fR and \f(CW$prevline\fR are actually tied
hashes, and only recompute the required line number when the variable's
value is used.
.Sp
Assignment to \f(CW$thisline\fR adjusts the line number calculator, so that
it believes that the current line number is the value being assigned. Note
that this adjustment will be reflected in all subsequent line numbers
calculations.
.Sp
Modifying the value of the variable \f(CW$text\fR (as in the previous
\&\f(CW\*(C`hash_include\*(C'\fR example, for instance) will confuse the line
counting mechanism. To prevent this, you should call
\&\f(CW\*(C`Parse::RecDescent::LineCounter::resync($thisline)\*(C'\fR \fIimmediately\fR
after any assignment to the variable \f(CW$text\fR (or, at least, before the
next attempt to use \f(CW$thisline\fR).
.Sp
Note that if a production fails after assigning to or
resync'ing \f(CW$thisline\fR, the parser's line counter mechanism will
usually be corrupted.
.Sp
Also see the entry for \f(CW@itempos\fR.
.Sp
The line number can be set to values other than 1, by calling the start
rule with a second argument. For example:
.Sp
.Vb 1
\&        $parser = new Parse::RecDescent ($grammar);
\&
\&        $parser\->input($text, 10);      # START LINE NUMBERS AT 10
.Ve
.ie n .IP "$thiscolumn\fR and \f(CW$prevcolumn" 4
.el .IP "\f(CW$thiscolumn\fR and \f(CW$prevcolumn\fR" 4
.IX Item "$thiscolumn and $prevcolumn"
\&\f(CW$thiscolumn\fR stores the current column number within the current line
being parsed (starting from 1). \f(CW$prevcolumn\fR stores the column number
of the last character which was actually successfully parsed. Usually 
\&\f(CW\*(C`$prevcolumn == $thiscolumn\-1\*(C'\fR, but not at the end of lines.
.Sp
For efficiency, \f(CW$thiscolumn\fR and \f(CW$prevcolumn\fR are
actually tied hashes, and only recompute the required column number
when the variable's value is used.
.Sp
Assignment to \f(CW$thiscolumn\fR or \f(CW$prevcolumn\fR is a fatal error.
.Sp
Modifying the value of the variable \f(CW$text\fR (as in the previous
\&\f(CW\*(C`hash_include\*(C'\fR example, for instance) may confuse the column
counting mechanism.
.Sp
Note that \f(CW$thiscolumn\fR reports the column number \fIbefore\fR any
whitespace that might be skipped before reading a token. Hence
if you wish to know where a token started (and ended) use something like this:
.Sp
.Vb 2
\&        rule: token1 token2 startcol token3 endcol token4
\&                        { print "token3: columns $item[3] to $item[5]"; }
\&
\&        startcol: \*(Aq\*(Aq { $thiscolumn }    # NEED THE \*(Aq\*(Aq TO STEP PAST TOKEN SEP
\&        endcol:      { $prevcolumn }
.Ve
.Sp
Also see the entry for \f(CW@itempos\fR.
.ie n .IP "$thisoffset\fR and \f(CW$prevoffset" 4
.el .IP "\f(CW$thisoffset\fR and \f(CW$prevoffset\fR" 4
.IX Item "$thisoffset and $prevoffset"
\&\f(CW$thisoffset\fR stores the offset of the current parsing position
within the complete text
being parsed (starting from 0). \f(CW$prevoffset\fR stores the offset
of the last character which was actually successfully parsed. In all
cases \f(CW\*(C`$prevoffset == $thisoffset\-1\*(C'\fR.
.Sp
For efficiency, \f(CW$thisoffset\fR and \f(CW$prevoffset\fR are
actually tied hashes, and only recompute the required offset
when the variable's value is used.
.Sp
Assignment to \f(CW$thisoffset\fR or <$prevoffset> is a fatal error.
.Sp
Modifying the value of the variable \f(CW$text\fR will \fInot\fR affect the
offset counting mechanism.
.Sp
Also see the entry for \f(CW@itempos\fR.
.ie n .IP "@itempos" 4
.el .IP "\f(CW@itempos\fR" 4
.IX Item "@itempos"
The array \f(CW@itempos\fR stores a hash reference corresponding to
each element of \f(CW@item\fR. The elements of the hash provide the
following:
.Sp
.Vb 6
\&        $itempos[$n]{offset}{from}      # VALUE OF $thisoffset BEFORE $item[$n]
\&        $itempos[$n]{offset}{to}        # VALUE OF $prevoffset AFTER $item[$n]
\&        $itempos[$n]{line}{from}        # VALUE OF $thisline BEFORE $item[$n]
\&        $itempos[$n]{line}{to}          # VALUE OF $prevline AFTER $item[$n]
\&        $itempos[$n]{column}{from}      # VALUE OF $thiscolumn BEFORE $item[$n]
\&        $itempos[$n]{column}{to}        # VALUE OF $prevcolumn AFTER $item[$n]
.Ve
.Sp
Note that the various \f(CW\*(C`$itempos[$n]...{from}\*(C'\fR values record the
appropriate value \fIafter\fR any token prefix has been skipped.
.Sp
Hence, instead of the somewhat tedious and error-prone:
.Sp
.Vb 9
\&        rule: startcol token1 endcol
\&              startcol token2 endcol
\&              startcol token3 endcol
\&                        { print "token1: columns $item[1]
\&                                              to $item[3]
\&                                 token2: columns $item[4]
\&                                              to $item[6]
\&                                 token3: columns $item[7]
\&                                              to $item[9]" }
\&
\&        startcol: \*(Aq\*(Aq { $thiscolumn }    # NEED THE \*(Aq\*(Aq TO STEP PAST TOKEN SEP
\&        endcol:      { $prevcolumn }
.Ve
.Sp
it is possible to write:
.Sp
.Vb 7
\&        rule: token1 token2 token3
\&                        { print "token1: columns $itempos[1]{column}{from}
\&                                              to $itempos[1]{column}{to}
\&                                 token2: columns $itempos[2]{column}{from}
\&                                              to $itempos[2]{column}{to}
\&                                 token3: columns $itempos[3]{column}{from}
\&                                              to $itempos[3]{column}{to}" }
.Ve
.Sp
Note however that (in the current implementation) the use of \f(CW@itempos\fR
anywhere in a grammar implies that item positioning information is 
collected \fIeverywhere\fR during the parse. Depending on the grammar
and the size of the text to be parsed, this may be prohibitively
expensive and the explicit use of \f(CW$thisline\fR, \f(CW$thiscolumn\fR, etc. may
be a better choice.
.ie n .IP "$thisparser" 4
.el .IP "\f(CW$thisparser\fR" 4
.IX Item "$thisparser"
A reference to the \f(CW\*(C`Parse::RecDescent\*(C'\fR object through which
parsing was initiated.
.Sp
The value of \f(CW$thisparser\fR propagates down the subrules of a parse
but not back up. Hence, you can invoke subrules from another parser
for the scope of the current rule as follows:
.Sp
.Vb 4
\&        rule: subrule1 subrule2
\&            | { $thisparser = $::otherparser } <reject>
\&            | subrule3 subrule4
\&            | subrule5
.Ve
.Sp
The result is that the production calls \*(L"subrule1\*(R" and \*(L"subrule2\*(R" of
the current parser, and the remaining productions call the named subrules
from \f(CW$::otherparser\fR. Note, however that \*(L"Bad Things\*(R" will happen if
\&\f(CW\*(C`::otherparser\*(C'\fR isn't a blessed reference and/or doesn't have methods
with the same names as the required subrules!
.ie n .IP "$thisrule" 4
.el .IP "\f(CW$thisrule\fR" 4
.IX Item "$thisrule"
A reference to the \f(CW\*(C`Parse::RecDescent::Rule\*(C'\fR object corresponding to the 
rule currently being matched.
.ie n .IP "$thisprod" 4
.el .IP "\f(CW$thisprod\fR" 4
.IX Item "$thisprod"
A reference to the \f(CW\*(C`Parse::RecDescent::Production\*(C'\fR object
corresponding to the production currently being matched.
.ie n .IP "$score\fR and \f(CW$score_return" 4
.el .IP "\f(CW$score\fR and \f(CW$score_return\fR" 4
.IX Item "$score and $score_return"
\&\f(CW$score\fR stores the best production score to date, as specified by
an earlier \f(CW\*(C`<score:...>\*(C'\fR directive. \f(CW$score_return\fR stores
the corresponding return value for the successful production.
.Sp
See \*(L"Scored productions\*(R".
.PP
\&\fBWarning:\fR the parser relies on the information in the various \f(CW\*(C`this...\*(C'\fR
objects in some non-obvious ways. Tinkering with the other members of
these objects will probably cause Bad Things to happen, unless you
\&\fIreally\fR know what you're doing. The only exception to this advice is
that the use of \f(CW\*(C`$this...\->{local}\*(C'\fR is always safe.
.Sh "Start-up Actions"
.IX Subsection "Start-up Actions"
Any actions which appear \fIbefore\fR the first rule definition in a
grammar are treated as \*(L"start-up\*(R" actions. Each such action is
stripped of its outermost brackets and then evaluated (in the parser's
special namespace) just before the rules of the grammar are first
compiled.
.PP
The main use of start-up actions is to declare local variables within the
parser's special namespace:
.PP
.Vb 1
\&        { my $lastitem = \*(Aq???\*(Aq; }
\&
\&        list: item(s)   { $return = $lastitem }
\&
\&        item: book      { $lastitem = \*(Aqbook\*(Aq; }
\&              bell      { $lastitem = \*(Aqbell\*(Aq; }
\&              candle    { $lastitem = \*(Aqcandle\*(Aq; }
.Ve
.PP
but start-up actions can be used to execute \fIany\fR valid Perl code
within a parser's special namespace.
.PP
Start-up actions can appear within a grammar extension or replacement
(that is, a partial grammar installed via \f(CW\*(C`Parse::RecDescent::Extend()\*(C'\fR or 
\&\f(CW\*(C`Parse::RecDescent::Replace()\*(C'\fR \- see \*(L"Incremental Parsing\*(R"), and will be
executed before the new grammar is installed. Note, however, that a 
particular start-up action is only ever executed once.
.Sh "Autoactions"
.IX Subsection "Autoactions"
It is sometimes desirable to be able to specify a default action to be
taken at the end of every production (for example, in order to easily
build a parse tree). If the variable \f(CW$::RD_AUTOACTION\fR is defined
when \f(CW\*(C`Parse::RecDescent::new()\*(C'\fR is called, the contents of that
variable are treated as a specification of an action which is to appended
to each production in the corresponding grammar. So, for example, to construct
a simple parse tree:
.PP
.Vb 1
\&    $::RD_AUTOACTION = q { [@item] };
\&
\&    parser = new Parse::RecDescent (q{
\&        expression: and_expr \*(Aq||\*(Aq expression | and_expr
\&        and_expr:   not_expr \*(Aq&&\*(Aq and_expr   | not_expr
\&        not_expr:   \*(Aq!\*(Aq brack_expr           | brack_expr
\&        brack_expr: \*(Aq(\*(Aq expression \*(Aq)\*(Aq       | identifier
\&        identifier: /[a\-z]+/i
\&        });
.Ve
.PP
which is equivalent to:
.PP
.Vb 5
\&    parser = new Parse::RecDescent (q{
\&        expression: and_expr \*(Aq||\*(Aq expression
\&                        { [@item] }
\&                  | and_expr
\&                        { [@item] }
\&
\&        and_expr:   not_expr \*(Aq&&\*(Aq and_expr  
\&                        { [@item] }
\&                |   not_expr
\&                        { [@item] }
\&
\&        not_expr:   \*(Aq!\*(Aq brack_expr          
\&                        { [@item] }
\&                |   brack_expr
\&                        { [@item] }
\&
\&        brack_expr: \*(Aq(\*(Aq expression \*(Aq)\*(Aq      
\&                        { [@item] }
\&                  | identifier
\&                        { [@item] }
\&
\&        identifier: /[a\-z]+/i
\&                        { [@item] }
\&        });
.Ve
.PP
Alternatively, we could take an object-oriented approach, use different
classes for each node (and also eliminating redundant intermediate nodes):
.PP
.Vb 2
\&    $::RD_AUTOACTION = q
\&      { $#item==1 ? $item[1] : new ${"$item[0]_node"} (@item[1..$#item]) };
\&
\&    parser = new Parse::RecDescent (q{
\&        expression: and_expr \*(Aq||\*(Aq expression | and_expr
\&        and_expr:   not_expr \*(Aq&&\*(Aq and_expr   | not_expr
\&        not_expr:   \*(Aq!\*(Aq brack_expr           | brack_expr
\&        brack_expr: \*(Aq(\*(Aq expression \*(Aq)\*(Aq       | identifier
\&        identifier: /[a\-z]+/i
\&        });
.Ve
.PP
which is equivalent to:
.PP
.Vb 4
\&    parser = new Parse::RecDescent (q{
\&        expression: and_expr \*(Aq||\*(Aq expression
\&                        { new expression_node (@item[1..3]) }
\&                  | and_expr
\&
\&        and_expr:   not_expr \*(Aq&&\*(Aq and_expr  
\&                        { new and_expr_node (@item[1..3]) }
\&                |   not_expr
\&
\&        not_expr:   \*(Aq!\*(Aq brack_expr          
\&                        { new not_expr_node (@item[1..2]) }
\&                |   brack_expr
\&
\&        brack_expr: \*(Aq(\*(Aq expression \*(Aq)\*(Aq      
\&                        { new brack_expr_node (@item[1..3]) }
\&                  | identifier
\&
\&        identifier: /[a\-z]+/i
\&                        { new identifer_node (@item[1]) }
\&        });
.Ve
.PP
Note that, if a production already ends in an action, no autoaction is appended
to it. For example, in this version:
.PP
.Vb 2
\&    $::RD_AUTOACTION = q
\&      { $#item==1 ? $item[1] : new ${"$item[0]_node"} (@item[1..$#item]) };
\&