Страницы справочника OS X

Эта страница руководства для  версии 10.9 Mac OS X

Читать страницы руководства

Parse::Eyapp::Driver(3)              User Contributed Perl Documentation             Parse::Eyapp::Driver(3)



NAME
       Parse::Eyapp::Driver - The LR parser

INTRODUCTION
       This class has the method "YYParse" implementing the LR generic parsing algorithm plus the methods
       that give support to the generated parser.

THE "YYParse" METHOD
       The "YYParse" methods implements the generic LR parsing algorithm.  It very much works
       "Parse::Yapp::YYParse" and as yacc/bison "yyparse".  It accepts almost the same arguments as
       "Class->new" (Being "Class" the name of the generated class).

       The parser uses two tables and a stack. The two tables are called the action table and the goto
       table.  The stack is used to keep track of the states visited.

       At each step the generated parser consults the "action" table and takes one decision: To shift to a
       new state consuming one token (and pushing the current state in the stack) or to reduce by some
       production rule. In the last case the parser pops from its stack as many states as symbols are on the
       right hand side of the production rule. Here is a Perl/C like pseudocode summarizing the activity of
       "YYParse":

            1   my $parser = shift; # The parser object
            2   push(@stack, $parser->{startstate});
            3   $b = $parser->YYLexer(); # Get the first token
            4   FOREVER: {
            5     $s = top(0);  # Get the state on top of the stack
            6     $a = $b;
            7     switch ($parser->action[$s->state][$a]) {
            8       case "shift t" :
            9         my $t;
           10         $t->{state} = t;
           11         $t->{attr}  = $a->{attr};
           12         push($t);
           13         $b = $parser->YYLexer(); # Call the lexical analyzer
           14         break;
           15       case "reduce A->alpha" :
           16         # Call the semantic action with the attributes of the rhs as args
           17         my $semantic  = $parser->Semantic{A ->alpha}; # The semantic action
           18         my $r;
           19         $r->{attr} = $semantic->($parser, top(|alpha|-1)->attr, ... , top(0)->attr);
           20
           21         # Pop as many states as symbols on the rhs of A->alpha
           22         pop(|alpha|);
           23
           24         # Goto next state
           25         $r->{state} = $parser->goto[top(0)][A];
           26         push($r);
           27         break;
           28       case "accept" : return (1);
           29       default : $parser->YYError("syntax error");
           30     }
           31     redo FOREVER;
           32   }

       Here "|alpha|" stands for the length of "alpha". Function top(k) returns the state in position "k"
       from the top of the stack, i.e. the state at depth "k".  Function pop(k) extracts "k" states from the
       stack. The call "$state->attr" returns the attribute associated with $state. The call
       "$parser->Semantic{A ->alpha}" returns the semantic action associated with production "A ->alpha".

       Let us see a trace for the small grammar in "examples/debuggingtut/aSb.yp":

         pl@nereida:~/LEyapp/examples$ /usr/local/bin/paste.pl aSb.yp aSb.output | head -5
         %%                                             | Rules:
         S:                 { print "S -> epsilon\n" }  | ------| -----|
             |   'a' S 'b'  { print "S -> a S b\n" }    | 0:    $start -> S $end
         ;                                              | 1:    S -> /* empty */
         %%                                             | 2:    S -> 'a' S 'b'

       The tables in file "aSb.output" describe the actions and transitions to take:

         pl@nereida:~/LEyapp/examples$ cat -n aSb.output
            .  .........................................
            7  States:
            8  -------9 ------9
            9  State 0:
           10
           11          $start -> . S $end      (Rule 0)
           12
           13          'a'     shift, and go to state 2
           14
           15          $default        reduce using rule 1 (S)
           16
           17          S       go to state 1
           18
           19  State 1:
           20
           21          $start -> S . $end      (Rule 0)
           22
           23          $end    shift, and go to state 3
           24
           25  State 2:
           26
           27          S -> 'a' . S 'b'        (Rule 2)
           28
           29          'a'     shift, and go to state 2
           30
           31          $default        reduce using rule 1 (S)
           32
           33          S       go to state 4
           34
           35  State 3:
           36
           37          $start -> S $end .      (Rule 0)
           38
           39          $default        accept
           40
           41  State 4:
           42
           43          S -> 'a' S . 'b'        (Rule 2)
           44
           45          'b'     shift, and go to state 5
           46
           47  State 5:
           48
           49          S -> 'a' S 'b' .        (Rule 2)
           50
           51          $default        reduce using rule 2 (S)
           52
           53
           54  Summary:
           55  --------56 -------56
           56  Number of rules         : 3
           57  Number of terminals     : 3
           58  Number of non-terminals : 2
           59  Number of states        : 6

       When executed with "yydebug" set and input "aabb"  we obtain the following output:

         pl@nereida:~/LEyapp/examples/debuggingtut$ eyapp -b '' -o use_aSb.pl aSb
         pl@nereida:~/LEyapp/examples/debuggingtut$ ./use_aSb.pl -d
         Provide a statement like "a a b b" and press <CR><CTRL-D>: aabb
         ----------------------------------------In ---------------------------------------In
         In state 0:
         Stack:[0]
         Need token. Got >a<
         Shift and go to state 2.
         ----------------------------------------
         In state 2:
         Stack:[0,2]
         Need token. Got >a<
         Shift and go to state 2.
         ----------------------------------------
         In state 2:
         Stack:[0,2,2]
         Need token. Got >b<
         Reduce using rule 1 (S --> /* empty */): S -> epsilon
         Back to state 2, then go to state 4.
         ----------------------------------------In ---------------------------------------In
         In state 4:
         Stack:[0,2,2,4]
         Shift and go to state 5.
         ----------------------------------------In ---------------------------------------In
         In state 5:
         Stack:[0,2,2,4,5]
         Don't need token.
         Reduce using rule 2 (S --> a S b): S -> a S b
         Back to state 2, then go to state 4.
         ----------------------------------------As ---------------------------------------As

       As a result of reducing by rule 2 the three last visited states are popped from the stack, and the
       stack becomes "[0,2]". But that means that we are now in state 2 seeing a "S".  If you look at the
       table above being in state 2 and seeing a "S" we go to state 4.

         In state 4:
         Stack:[0,2,4]
         Need token. Got >b<
         Shift and go to state 5.
         ----------------------------------------
         In state 5:
         Stack:[0,2,4,5]
         Don't need token.
         Reduce using rule 2 (S --> a S b): S -> a S b
         Back to state 0, then go to state 1.
         ----------------------------------------In ---------------------------------------In
         In state 1:
         Stack:[0,1]
         Need token. Got ><
         Shift and go to state 3.
         ----------------------------------------
         In state 3:
         Stack:[0,1,3]
         Don't need token.
         Accept.

METHODS IN THE GENERATED CLASS: "Parse::Eyapp::Driver" METHODS
       The class containing the parser generated by "Parse::Eyapp" inherits from "Parse::Eyapp::Driver".
       Therefore all the methods in "Parse::Eyapp::Driver"  are available in the generated class.

       This section describes the methods and objects belonging to the class generated either using eyapp or
       "Parse::Eyapp->new_grammar". In the incoming paragraphs we will assume that "Class" was the value
       selected for the "classname" argument when "Parse::Eyapp->new_grammar" was called.  Objects belonging
       to  "Class" are the actual parsers for the input grammar.

   Class->new
       The method "Class->new" returns a new LALR parser object.  Here "Class" stands for the name of the
       class containing the parser.  See an example of call:

         my $parser = main->new(yyprefix => 'Parse::Eyapp::Node::',
                                yylex    => \&main::_Lexer,
                                yyerror  => \&main::_Error,
                                yydebug => 0x1F,
         );

       The meaning of the arguments used in the example are as follows:

       - yyprefix
           Used with %tree or %metatree.  When used, the type names of the nodes of the syntax tree will be
           build prefixing the value associated to "yyprefix" to the name of the production rule. The name
           of the production rule is either explicitly given through a %name directive or the concatenation
           of the left hand side of the rule with the ordinal of the right hand side of the production.  See
           section "Compiling with eyapp and treereg" in Parse::Eyapp for an example.

       - yylex
           Reference to the lexical analyzer subroutine

       - yyerror
           Reference to the error subroutine. The error subroutine receives as first argument the reference
           to the "Class" parser object.  This way it can take advantage of methods like "YYCurval" and
           YYExpect (see below):

             sub _Error {
               my($token)=$_[0]->YYCurval;
               my($what)= $token ? "input: '$token'" : "end of input";
               my @expected = $_[0]->YYExpect();

               local $" = ', ';
               die "Syntax error near $what. Expected one of these tokens: @expected\n";
             }

       - yydebug
           Controls the level of debugging. Must be a number.

       The package produced from the grammar has several methods.

       The parser object has the following methods that work at parsing time exactly as in Parse::Yapp.
       These methods can be found in the module Parse::Eyapp::Driver.  Assume you have in $parser the
       reference to your parser object:

   $parser->YYAction
       Receives the name of a production and a subroutine reference implementing the new semantic action.
       If no subroutine reference is set returns the reference to the current semantic action. See the
       tutorial Parse::Eyapp::defaultaction and the examples in the "examples/recycle/" directory

    $parser->YYAccept
       Works as yacc/bison "YYACCEPT".  The parser finishes returning the current semantic value to indicate
       success.

    $parser->YYAbort
       Works as yacc/bison "YYABORT".  The parser finishes returning "undef" to indicate failure.

   Parse::Eyapp::Driver::BeANode
       Is not a method.  Receives as input a "Class" name.  Introduces "Parse::Eyapp::Node" as an ancestor
       class of "Class". To work correctly, objects belonging to "Class" must be hashes with a "children"
       key whose value must be a reference to the array of children. The children must be also
       "Parse::Eyapp::Node" nodes.  Actually you can circumvent this call by directly introducing
       "Parse::Eyapp::Node" in the ancestors of "Class":

                push @{$class."::ISA"}, "Parse::Eyapp::Node"

   $parser->YYBuildAST
       Sometimes the best time to decorate a node with some attributes is just after being built. In such
       cases the programmer can take manual control building the node with "YYBuildAST" to immediately
       proceed to decorate it.

       The following example from the file "lib/Simple/Types.eyp" in the tarball in
       "examples/typechecking/Simple-Types-XXX.tar.gz" illustrates the idea:

        Variable:
            %name  VARARRAY
            $ID ('[' binary ']') <%name INDEXSPEC +>
              {
                my $self = shift;
                my $node =  $self->YYBuildAST(@_);
                $node->{line} = $ID->[1];
                return $node;
              }

       Actually, the %tree directive is semantically equivalent to:

         %default action { goto &Parse::Eyapp::Driver::YYBuildAST }

    $parser->YYBuildingTree
       Influences the semantic of list operators.  If true the action associated with "X+" will be to build
       a "Parse::Eyapp::Node" node with all the attributes of the elements in the list as children. This is
       the appropriate semantic when working under the %tree directive.  If set to false the semantic action
       will return an anonymous list with the attributes associated with the "X" in the plus list.  Same
       thing with the operators "*" and "?".

   $parser->YYBuildTS
       Similar to "$parser->YYBuildAST" but builds nodes for translation schemes.

   $parser->YYBypass
       Returns TRUE if running under the "%tree bypass" clause

   $parser->YYBypassrule
       Returns TRUE if the production being used for reduction was marked to be bypassed.

    $parser->YYCurtok
       Gives the current token

    $parser->YYCurval
       Gives the attribute associated with the current token

   $parser->YYDelegateaction
       Use it as "defaultaction" if you want to recycle your grammar.  It is equivalent to:

         sub YYDelegateaction {
           my $self = shift;

           my $action = $self->YYName;

           $self->$action(@_);
         }

       For a full example illustrating how to use it, see files "examples/recycle/NoacInh.eyp" and
       "examples/recycle/icalcu_and_ipost.pl" in the Parse::Eyapp distribution

    $parser->YYEndOfInput
       True if the "pos()" of the input being scanned in "${$parser->input}" is at the end

    $parser->YYErrok
       Works as yacc/bison "yyerrok".  Modifies the error status so that subsequent error messages will be
       emitted.

    $parser->YYError
       Works as yacc/bison "YYERROR".  Pretends that a syntax error has been detected.

    $parser->YYExpect
       Returns the list of tokens the parser expected when the failure occurred

        pl@nereida:~/src/perl/YappWithDefaultAction/examples$ \
                                   sed -ne '26,33p' Postfix.eyp
        sub _Error {
          my($token)=$_[0]->YYCurval;
          my($what)= $token ? "input: '$token'" : "end of input";
          my @expected = $_[0]->YYExpect();

          local $" = ', ';
          die "Syntax error near $what. Expected one of these tokens: @expected\n";
        }

       See the tutorial Parse::Eyapp::datagenerationtut and the section TOKENS DEPENDING ON THE SYNTACTIC
       CONTEXT in the tutorial Parse::Eyapp::debuggingtut for more detailed examples of use of "YYExpect".

   $parser->YYFirstline
       First line of the input string describing the grammar

   $parser->YYGrammar
       Return the list of grammar items.  Each item is an anonymous list containing

       • The name of the production

       • The LHS of the production

       • An anonymous list containing the symbols in the RHS

       If it receives an index as argument returns the corresponding item The following debugger session
       explain its use:

         pl@europa:~/LEyapp/examples/recycle$ perl -wd usepostfix.pl
         main::(usepostfix.pl:5):        my $parser = new Postfix();
           DB<1> n
         main::(usepostfix.pl:6):        $parser->Run;
           DB<1> x $parser->YYGrammar
         0  ARRAY(0xde5e20)
            0  '_SUPERSTART'
            1  '$start'
            2  ARRAY(0xc85e80)
               0  'line'
               1  '$end'
            3  0
         1  ARRAY(0xe2b6b0)
            0  'line_1'
            1  'line'
            2  ARRAY(0xe3abc0)
               0  'exp'
            3  0
         2  ARRAY(0xa05530)
            0  'exp_2'
            1  'exp'
            2  ARRAY(0x75bdc0)
               0  'NUM'
            3  0

            ...  etc, etc

       If an index is provided it returns the item for such number:

           DB<2> x $parser->YYGrammar(10)
         0  'exp_10'
         1  'exp'
         2  ARRAY(0xa05f80)
            0  '('
            1  'exp'
            2  ')'
         3  0

       You can also use a production name as argument:

           DB<3> x $parser->YYGrammar('exp_7')
         0  'exp_7'
         1  'exp'
         2  ARRAY(0xa05890)
            0  'exp'
            1  '*'
            2  'exp'
         3  0

   $parser->YYGetLRAction($state, $token)
       Returns the shift-reduce action for state $state and token $token. A positive number must be
       interpreted as a shift to the state with that number. A negative number "-m" indicates a reduction by
       production with index "m".  Returns "undef" if no action is defined for such combination "($state,
       $token)".

       See example "DynamicallyChangingTheParser.eyp" in the directory "examples/debuggintut" for an example
       of use.

   $parser->YYIssemantic
       Returns TRUE if the terminal is semantic. Semantics token can be declared using the directive
       "%semantic token". The opposite of a Semantic token is a Syntactic token. Syntactic tokens can be
       declared using the directive  "%syntactic token".

       When using the %tree directive all the nodes corresponding to syntactic tokens are pruned from the
       tree. Under this directive tokens in the text delimited by simple quotes (like '+') are, by default,
       considered syntactic tokens.

       When using the %metatree directive all the tokens are considered, by default, semantic tokens.  Thus,
       no nodes will be - by default- pruned when construction the code augmented tree. The exception are
       string tokens used as separators in the definition of lists,  like in "S <* ';'>". If you want the
       separating string token to appear include an explicit semantic declaration for it (example "%semantic
       token ';'").

   $parser->YYIndex
       Receives the name of production (right hand side).  Returns the index in the grammar of the
       production with such name.  When called in a list context and without a name return the hash
       containing the relation

                  production name => production index

       The following debugger session illustrates its use:

         pl@europa:~/LEyapp/examples/recycle$ perl -wd usepostfix.pl
         main::(usepostfix.pl:5):        my $parser = new Postfix();
         main::(usepostfix.pl:6):        $parser->Run;
         DB<1> x $parser->YYIndex
         0  'line_1'
         1  1
         2  'exp_3'
         3  3
         4  'exp_6'
         5  6
         6  'exp_4'
         7  4
         8  'exp_10'
         9  10
         10  'exp_8'
         11  8
         12  'exp_5'
         13  5
         14  'exp_7'
         15  7
         16  'exp_2'
         17  2
         18  '_SUPERSTART'
         19  0
         20  'exp_9'
         21  9

       We can specify a list of names:

         DB<2> x $parser->YYIndex(qw{exp_4 exp_7})
         0  4
         1  7
         DB<3> x $parser->YYIndex(qw{exp_4})
         0  4

   $parser->YYInput
       Alias "input". If an argument is provided, sets the input for the parser object.  The argument is a
       string or a reference to a string.  It returns a reference to the input string or "undef" if not set.

   $parser->YYIsterm
       Returns TRUE  if the symbol given as argument is a terminal. Example:

         DB<0> x $self->YYIsterm('exp')
        0  ''
         DB<1> x $self->YYIsterm('*')
        0  1

       An example of combined use of "YYRightside", "YYRuleindex", "YYLhs" and "YYIsterm" can be found
       "examples/Eyapp/Rule3.yp":

        nereida:~/src/perl/YappWithDefaultAction/examples> sed -n -e '4,22p' Rule3.yp | cat -n
         1  sub build_node {
         2    my $self = shift;
         3    my @children = @_;
         4    my @right = $self->YYRightside();
         5    my $var = $self->YYLhs;
         6    my $rule = $self->YYRuleindex();
         7
         8    for(my $i = 0; $i < @right; $i++) {
         9      $_ = $right[$i];
        10      if ($self->YYIsterm($_)) {
        11        $children[$i] = bless { token => $_, attr => $children[$i] },
        12                                            __PACKAGE__.'::TERMINAL';
        13      }
        14    }
        15    bless {
        16            children => \@children,
        17            info => "$var -> @right"
        18          }, __PACKAGE__."::${var}_$rule"
        19  }

       when executed an output similar to this is produced:

        nereida:~/src/perl/YappWithDefaultAction/examples> userule3.pl
        2*3
        $VAR1 = bless( {
          'info' => 'exp -> exp * exp',
          'children' => [
            bless( {
              'info' => 'exp -> NUM',
              'children' => [ bless( { 'attr' => '2', 'token' => 'NUM' }, 'Rule3::TERMINAL' ) ]
            }, 'Rule3::exp_6' ),
            bless( { 'attr' => '*', 'token' => '*' }, 'Rule3::TERMINAL' ),
            bless( {
              'info' => 'exp -> NUM',
              'children' => [ bless( { 'attr' => '3', 'token' => 'NUM' }, 'Rule3::TERMINAL' )
              ]
            }, 'Rule3::exp_6' )
          ]
        }, 'Rule3::exp_11' );

    $parser->YYLexer
       Returns a reference to the lexical analyzer

    $parser->YYLhs
       Returns the identifier of the left hand side of the current production (the one that is being used
       for reduction/reverse derivation. An example of use can be found in "examples/Eyapp/Lhs1.yp":

         %defaultaction { print $_[0]->YYLhs,"\n" }

   $parser->YYMain
       Alias is also "main".

       Other than the package, it has as optional arguments the "prompt" (shown each time it ask for input),
       the name of the input file (if it wasn't specified in the command line using "--file filename") and
       also the input string.

       This method provides a default "main" for testing the generated parser.  It parses the commandline
       searching for a number of options. See an example of use:

         pl@nereida:~/LEyapp/examples/eyapplanguageref$ cat use_list2.pl
         #!/usr/bin/env perl
         use warnings;
         use strict;
         use List2;

         unshift @ARGV, '--noslurp';
         List2->new->main("Try input 'aacbb': ");
         pl@nereida:~/LEyapp/examples/eyapplanguageref$ ./use_list2.pl --help
         Available options:
             --debug                    sets yydebug on
             --nodebug                  sets yydebug off
             --file filepath            read input from filepath
             --commandinput string      read input from string
             --tree                     prints $tree->str
             --notree                   does not print $tree->str
             --info                     When printing $tree->str shows the value of TERMINALs
             --help                     shows this help
             --slurp                    read until EOF reached
             --noslurp                  read until CR is reached
             --argfile                  main() will take the input string from its @_
             --noargfile                main() will not take the input string from its @_
             --yaml                     dumps YAML for $tree: YAML module must be installed
             --margin=i                 controls the indentation of $tree->str (i.e. $Parse::Eyapp::Node::INDENT)

   $parser->YYName
       Returns the name of the current rule (The production whose reduction gave place to the execution of
       the current semantic action).

         DB<12> x $self->YYName
        0  'exp_11'

   $parser->YYNames
       Return the list of production names. In a scalar context returns a reference to such list.

         pl@europa:~/LEyapp/examples/recycle$ eyapp Postfix
         pl@europa:~/LEyapp/examples/recycle$ perl -wd usepostfix.pl
         main::(usepostfix.pl:5):        my $parser = new Postfix();
         main::(usepostfix.pl:6):        $parser->Run;
         DB<1> x $parser->YYNames
         0  '_SUPERSTART'
         1  'line_1'
         2  'exp_2'
         3  'exp_3'
         4  'exp_4'
         5  'exp_5'
         6  'exp_6'
         7  'exp_7'
         8  'exp_8'
         9  'exp_9'
         10  'exp_10'

   $parser->YYNberr
       The current number of errors

   $parser->YYNextState();
       If called inside a semantic action, returns the state after the reduction by the current production.

       Provide a token if called from any other side:

         $parser->YYNextState($token);

       It will return the state given by the action table for the state in the top of the stack and the
       given token.

       For an example, see the program "DynamicallyChangingTheParser.eyp" in the directory
       "examples/debuggintut/".

   $parser->YYPrefix
       Return and/or sets the "yyprefix" attribute. This a string that will be concatenated as a prefix to
       any "Parse::Eyapp::Node" nodes in the syntax tree.

    $parser->YYParse()
       It very much works "Parse::Yapp::YYParse" and as yacc/bison "yyparse".  It accepts almost the same
       arguments as "Class->new" with the exception of "yyprefix" which can be used only with "new".

    $parser->YYRecovering
       Works as yacc/bison "YYRECOVERING".  Returns "TRUE" if the parser is recovering from a syntax error.

   $parser->YYRestoreLRAction('conflictname', $token)
       This method has been designed to solve shift-reduce and reduce-reduce conflicts at parsing-time using
       the postponed conflict strategy.  It has to be called inside the semantic action associated with the
       postponed conflict rule. The LALR table is changed so that the action in the presence of the token
       $token is restored the one before the last call to

         $parser->YYSetReduce($token, $productionname )

       See the examples in "examples/debuggingtut/" in files "DynamicallyChangingTheParser2.eyp" and
       "Cplusplus.eyp".

   $parser->YYRHSLength($productionindex)
       Also:

         $parser->YYRHSLength

       returns the length of the right hand side (the number of symbols) of $productionindex. The name of
       the production can be used instead of its index.  If no index or name is provided and the method is
       called inside a semantic action, the length of the current production is returned.

   $parser->YYRightside
       Also:

         $parser->YYRightside($index)

       Returns an array of strings describing the right hand side of the rule.  The name of the production
       can be given instead of $index. If no $index is provided and the method is called inside a semantic
       action the right hand side of the current production is returned.

   $parser->YYRuleindex
       To be called inside a semantic action.  Returns the index of the current production rule, counting
       the super rule as rule 0.

       To know the numbers have a look at  the ".output" file.  To get a ".output" file use the option "-v"
       of "eyapp" or the "outputfile" parameter when using method "new_grammar" (see the documentation for
       eyapp).

   $parser->YYRule
       Return the list of rules.  The following debugger session illustrates its use:

         pl@europa:~/LEyapp/examples/recycle$ perl -wd usepostfix.pl
         main::(usepostfix.pl:5):        my $parser = new Postfix();
         main::(usepostfix.pl:6):        $parser->Run;
         0  ARRAY(0xa068e0)
            0  '$start'
            1  2
            2  undef
         1  ARRAY(0xa06940)
            0  'line'
            1  1
            2  CODE(0xc22360)
               -> &Postfix::__ANON__[Postfix.eyp:10] in Postfix.eyp:227-10
         ... etc, etc.

       Each item has three components: the LHS of the production, the number of symbols in the RHS and the
       CODE reference to the semantic action.

       If an index is specified as argument it returns the corresponding item:

            DB<2> x $parser->YYRule(7)
         0  'exp'
         1  3
         2  CODE(0xc1fce0)
            -> &Postfix::__ANON__[Postfix.eyp:7] in Postfix.eyp:276-7

       To know to what production an item is associated we can use the "YYGrammar" method:

            DB<3> x $parser->YYGrammar('exp_7')
         0  'exp_7'
         1  'exp'
         2  ARRAY(0xa05290)
            0  'exp'
            1  '*'
            2  'exp'
         3  0

       We can also use the name of the rule to get the item:

          DB<4> x $parser->YYRule('exp_7')
         0  'exp'
         1  3
         2  CODE(0xc1fce0)
            -> &Postfix::__ANON__[Postfix.eyp:7] in Postfix.eyp:276-7

   $parser->YYSetaction
       Receives a hash with keys the names of the production rules (right hand sides) and values the new
       semantic actions. Used to reuse a grammar without overwriting all the semantic actions.  See section
       Reusing Grammars by Dynamic Substitution of Semantic Actions in Parse::Eyapp::defaultactionsintro.

   $parser->YYSetLRAction($conflictstate, $token, $shiftreduceaction )
       It also accepts the syntax:

         $parser->YYSetLRAction($conflictstate, [$token1, ... ], $shiftreduceaction )

       This method has been designed to solve shift-reduce and reduce-reduce conflicts at parsing-time (not
       at parser-generation time).

       The LR table is changed so that the action in state $conflictstate in the presence of the token
       $token will be given by $shiftreduceaction.  The current shift-reduce action isn't saved.

       See an example in "Cplusplus2.eyp" in the directory "examples/debuggintut".

   $parser->YYSetReduce($token, $productionname )
       This method has been designed to solve shift-reduce and reduce-reduce conflicts at parsing-time using
       the postponed conflict strategy. See the corresponding section in Parse::Eyapp::debuggintut. It has
       to be called inside the semantic action associated with the postponed conflict rule "conflictname".
       The LALR table is changed so that the action in the presence of the token $token will be to reduce by
       $productionname. The current shift-reduce action is saved to be restored using

         $parser->YYRestoreLRAction('conflictname', $token)

       See the examples in "examples/debuggingtut/" in files

       • "DynamicallyChangingTheParser2.eyp"

       • "confusingsolveddynamic.eyp"

       • "DebugDynamicResolution.eyp"

       • "DynamicallyChangingTheParser2.eyp"

       • "DynamicallyChangingTheParser3.eyp"

       • "DynamicallyChangingTheParser.eyp"

       • "DynamicvsTieIns.eyp"

       • "nolr_k_grammarsolveddynamic.eyp"

       • "pascalenumeratedvsrangesolvedviadyn.eyp"

       • "Cplusplus.eyp".

   $parser->YYSetShift($token)
       Also:

             $parser->YYSetShift([$token1, $token2, ... ])

       This method has been designed to solve shift-reduce at parsing-time using the postponed conflict
       strategy. See the corresponding section in Parse::Eyapp::debuggintut. It has to be called inside the
       semantic action associated with the postponed conflict rule "conflictname".  The LALR table is
       changed so that the action in the presence of the token $token will be to shift.

       See the examples in "examples/debuggingtut/" in files

       • "DebugDynamicResolution.eyp"

       • "DynamicallyChangingTheParser.eyp"

   $parser->YYSlurpFile
       alias:

        $parser->slurp_file($filename[,$prompt[,$mode]])

       Receives the name of the file, reads its contents and stores it in "$parser->input".

       If the file does not exists, it proceeds to read from "STDIN".  If a prompt was set with
       "$parser->YYPrompt", it will be shown.  The additional optional parameter $mode is used in such case
       to set $/. It can also be used as a class method.

   $parser->YYState
       "YYState" returns a reference to the list of states containing the LALR(1) tables: the action and
       GOTO tables.  Each state is an anonymous hash:

         DB<4> x $parser->YYState(2)
         0  HASH(0xfa7120)
            'ACTIONS' => HASH(0xfa70f0) # token => state
                  ':' => '-7'
            'DEFAULT' => '-6'

       A negative number means reduction using the corresponding production rule (opposite) number. The
       former example tells to reduce by rule 7 when in state 2 and seeing token ':'. By default, the action
       when in state 2 is to reduce by rule number 6.

       There are three keys: ACTIONS, GOTOS and  DEFAULT

         DB<7> x $parser->YYState(13)
        0  HASH(0xfa8b50)
           'ACTIONS' => HASH(0xfa7530)
              'VAR' => 17
           'GOTOS' => HASH(0xfa8b20)
              'type' => 19

       The GOTOS tables contains the DFA transition tables for the syntactic variables. The former example
       tells to move to state 19 when in state 13 after seeing the syntactic variable "type" (i.e. if after
       reducing by a rule of "type" we are in state 13).

   $parser->YYTopState($length)
       If $length is zero or not provided it returns the state on top of the stack.  Otherwise, returns the
       state $length units deep in the stack.

CONTRIBUTORS
       • Hal Finkel <http://www.halssoftware.com/>

       • G. Williams <http://kasei.us/>

       • Thomas L. Shinnick <http://search.cpan.org/~tshinnic/>

       • Frank Leray

AUTHOR
       Casiano Rodriguez-Leon (casiano@ull.es)

ACKNOWLEDGMENTS
       This work has been supported by CEE (FEDER) and the Spanish Ministry of Educacion y Ciencia through
       Plan Nacional I+D+I number TIN2005-08818-C04-04 (ULL::OPLINK project <http://www.oplink.ull.es/>).
       Support from Gobierno de Canarias was through GC02210601 (Grupos Consolidados).  The University of La
       Laguna has also supported my work in many ways and for many years.

       A large percentage of  code is verbatim taken from Parse::Yapp 1.05.  The author of Parse::Yapp is
       Francois Desarmenien.

       I wish to thank Francois Desarmenien for his Parse::Yapp module, to my students at La Laguna and to
       the Perl Community. Thanks to the people who have contributed to improve the module (see
       "CONTRIBUTORS" in Parse::Eyapp).  Thanks to Larry Wall for giving us Perl.  Special thanks to Juana.

LICENCE AND COPYRIGHT
       Copyright (c) 2006-2008 Casiano Rodriguez-Leon (casiano@ull.es). All rights reserved.

       Parse::Yapp copyright is of Francois Desarmenien, all rights reserved. 1998-2001

       These modules are free software; you can redistribute it and/or modify it under the same terms as
       Perl itself. See perlartistic.

       This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
       even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.



perl v5.12.5                                     2011-02-16                          Parse::Eyapp::Driver(3)