manpagez: man pages & more
man eyapp(1)
Home | html | info | man
=              User Contributed Perl Documentation             EYAPP(1)


       eyapp - A Perl front-end to the Parse::Eyapp module


           eyapp [options] grammar[.eyp]
           eyapp -V
           eyapp -h

               grammar     The grammar file. If no suffix is given, and the file
                           does not exists, .eyp is added


       The eyapp compiler is a front-end to the Parse::Eyapp module, which
       lets you compile Parse::Eyapp grammar input files into Perl LALR(1)
       Object Oriented parser modules.


       -v  Creates a file grammar.output describing your parser. It will show
           you a summary of conflicts, rules, the DFA (Deterministic Finite
           Automaton) states and overall usage of the parser.

           Implies option "-N". To produce a more detailed description of the
           states, the LALR tables aren't compacted.  Use the combination
           "-vN" to produce an  ".output" file corresponding to the compacted

       -s  Create a standalone module in which the parsing driver is included.
           The modules including the LALR driver (Parse::Eyapp::Driver), those
           for AST manipulations (Parse::Eyapp::Node and Parse::Eyapp::YATW))
           and Parse::Eyapp::Base are included - almost verbatim - inside the
           generated module.

           Note that if you have more than one parser module called from a
           program, to have it standalone, you need this option only for one
           of your grammars;

       -n  Disable source file line numbering embedded in your parser module.
           I don't know why one should need it, but it's there.

       -m module
           Gives your parser module the package name (or name space or module
           name or class name or whatever-you-call-it) of module.  It defaults
           to grammar

       -o outfile
           The compiled output file will be named outfile for your parser
           module.  It defaults to or, if you specified the option
           -m A::Module::Name (see below), to

       -c grammar[.eyp]
           Produces as output (STDOUT) the grammar without the actions. Only
           the syntactic parts are displayed. Comments will be also stripped
           if the "-v" option is added.

       -t filename
           The -t filename option allows you to specify a file which should be
           used as template for generating the parser output.  The default is
           to use the internal template defined in
           For how to write your own template and which substitutions are
           available, have a look to the module : it
           should be obvious.

       -b shebang
           If you work on systems that understand so called shebangs, and your
           generated parser is directly an executable script, you can specify
           one with the -b option, ie:

               eyapp -b '/usr/local/bin/perl -w' -o myscript.yp

           This will output a file called whose very first line

               #!/usr/local/bin/perl -w

           The argument is mandatory, but if you specify an empty string, the
           value of $Config{perlpath} will be used instead.

       -B prompt
           Adds a modulino call '__PACKAGE->main(<prompt>) unless caller();'
           as the very last line of the output file. The argument is

       -C grammar.eyp
           An abbreviation for the combined use of -b '' and  -B ''

       -T grammar.eyp
           Equivalent to %tree.

       -N grammar.eyp
           Equivalent to the directive %nocompact. Do not compact LALR action

       -l  Do not provide a default lexical analyzer. By default "eyapp"
           builds a lexical analyzer from your "%token = /regexp/" definitions

           The input grammar file. If no suffix is given, and the file does
           not exists, an attempt to open the file with a suffix of  .eyp is
           tried before exiting.

       -V  Display current version of Parse::Eyapp and gracefully exits.

       -h  Display the usage screen.


       The following "eyapp" program translates an infix expression like
       "2+3*4" to postfix: "2 3 4 * +"

           %token NUM = /([0-9]+(?:\.[0-9]+)?)/
           %token VAR = /([A-Za-z][A-Za-z0-9_]*)/

           %right  '='
           %left   '-' '+'
           %left   '*' '/'
           %left   NEG

           %defaultaction { "$left $right $op"; }

           line: $exp  { print "$exp\n" }

           exp:        $NUM  { $NUM }
                   |   $VAR  { $VAR }
                   |   VAR.left '='.op exp.right
                   |   exp.left '+'.op exp.right
                   |   exp.left '-'.op exp.right
                   |   exp.left '*'.op exp.right
                   |   exp.left '/'.op exp.right
                   |   '-' $exp %prec NEG { "$exp NEG" }
                   |   '(' $exp ')' { $exp }


       Notice that there is no need to write lexer and error report
       subroutines.  First, we compile the grammar:

           pl@nereida:~/LEyapp/examples/eyappintro$ eyapp -o -C Postfix.eyp

       If we use the "-C" option and no "main()" was written one default
       "main" sub is provided.  We can now execute the resulting program:

           pl@nereida:~/LEyapp/examples/eyappintro$ ./ -c 'a = 2*3 +b'
           a 2 3 * b + =

       When a non conformant input is given, it produces an accurate error

           pl@nereida:~/LEyapp/examples/eyappintro$ ./ -c 'a = 2**3 +b'

           Syntax error near '*'.
           Expected one of these terminals: '-' 'NUM' 'VAR' '('
           There were 1 errors during parsing


       Casiano Rodriguez-Leon


       (c) Copyright 2006 Casiano Rodriguez-Leon

       This library is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself, either Perl version 5.8.8 or, at
       your option, any later version of Perl 5 you may have available.


       o   Parse::Eyapp,

       o   perldoc vgg,

       o   The tutorial Parsing Strings and Trees with "Parse::Eyapp" (An
           Introduction to Compiler Construction in seven pages)> in

       o   The pdf file in

       o   <>

       o   eyapp,

       o   treereg,

       o   Parse::yapp,

       o   yacc(1),

       o   bison(1),

       o   the classic book "Compilers: Principles, Techniques, and Tools" by
           Alfred V. Aho, Ravi Sethi and

       o   Jeffrey D. Ullman (Addison-Wesley 1986)

       o   Parse::RecDescent.

perl v5.12.4                      2011-01-30                          EYAPP(1)

Mac OS X 10.8 - Generated Tue Aug 21 09:10:28 CDT 2012
© 2000-2021
Individual documents may contain additional copyright information.