ParseGen grammar for quirk20.  [Revision -5]
This grammar is designed for action routines that take arguments.
The <pos> nonterminal returns the current position.

*terminals

eof
id
typeid
typeid2
charliteral
floatliteral
intliteral
Stringliteral
.
(
)
[
]
*
+
,
-
/
;
=
==
!
sharp
ne
lt
le
gt
ge
and
or
boolean
char
class
constant
double
else
false
for
from
function
if
int
new
null
proc
public
return
static
String
to
true
unless
void
when
while
{
}

*productions

<program>        ::=  <classdec> <program-rest> eof            #cons
<program-rest>   ::=                                           #emptyList
                 ::=  <program>                                #identity

<type>           ::=  <primtype> <type-rest>                   #mk_type
                 ::=  <typeid> <type-rest>                     #mk_type
                 ::=  <funtype> <type-rest>                    #mk_type

<type-rest>      ::=                                           #mk_complete
                 ::=  [ ] <type-rest>                          #mk_arraytype
<primtype>       ::=  boolean                                  #mkBooleanType
                 ::=  char                                     #mkCharType
                 ::=  String                                   #mkStringType
                 ::=  int                                      #mkIntType
                 ::=  double                                   #mkDoubleType
<funtype>        ::=  function ( from ( <types> ) to <rtype> ) #mkFunType
<rtype>          ::=  <type>                                   #identity
                 ::=  void                                     #mkVoidType

<classdec>       ::=  class <typeid> { <bodydecs> }            #mkClassDec

<bodydec>        ::=  <access> <bodydec-rest>                  #mkBodyDec
<bodydec-rest>   ::=  constant <primtype> <id> = <literal> ;   #mkConstDec
                 ::=  static <primtype> <id> = <literal> ;     #mkGlobalDec
                 ::=  <formal> ;                               #identity
                 ::=  <fundec>                                 #identity

<formal>         ::=  <type> <id>                              #mkFormal
<access>         ::=                                           #mkDefault
                 ::=  public                                   #mkPublic

<block>          ::=  { <localdecs> <stms> }                   #mkBlock

<localdec>       ::=  <vardec>                                 #identity
                 ::=  <fundec>                                 #identity
<vardec>         ::=  <type> <id> = <exp> ;                    #mkVarDec
<fundec>         ::=  proc <rtype> <id> ( <formals> ) <block>  #mkFunDec

<stm>            ::=  ;                                        #mkSkip
                 ::=  <exp> ;                                  #mkExpStm
                 ::=  if ( <exp> ) <stm> else <stm>            #mkIfStm
                 ::=  when ( <exp> ) <stm>                     #mkWhenStm
                 ::=  unless ( <exp> ) <stm>                   #mkUnlessStm
                 ::=  while ( <exp> ) <stm>                    #mkWhileStm
                 ::=  for ( <vardec> <exp> ; <exp> ) <stm>     #mkForStm
                 ::=  return <exp> ;                           #mkReturnStm
                 ::=  <block>                                  #identity

<exp>            ::=  <lhs> <exp-rest>                         #mk_right
<exp-rest>       ::=                                           #mk_complete
                 ::=  <assignop> <exp>                         #mk_partial
<lhs>            ::=  <disjunct> <lhs-rest>                    #mk_right
<lhs-rest>       ::=                                           #mk_complete
                 ::=  <orop> <lhs>                             #mk_partial
<disjunct>       ::=  <conjunct> <disjunct-rest>               #mk_right
<disjunct-rest>  ::=                                           #mk_complete
                 ::=  <andop> <disjunct>                       #mk_partial
<conjunct>       ::=  <simple> <conjunct-rest>                 #mk_noassoc
<conjunct-rest>  ::=                                           #mk_complete
                 ::=  <relop> <simple>                         #mk_partial
<simple>         ::=  <term> <simple-rest>                     #mk_left
<simple-rest>    ::=                                           #mk_complete
                 ::=  <addop> <term> #mk_partial <simple-rest> #mk_partial
<term>           ::=  <factor> <term-rest>                     #mk_left
<term-rest>      ::=                                           #mk_complete
                 ::=  <mulop> <factor> #mk_partial <term-rest> #mk_partial
<factor>         ::=  <unop> <factor>                          #mk_unary
                 ::=  <literal>                                #mkLiteral
                 ::=  new <new-rest>                           #identity
                 ::=  ( <exp> ) <factor-rest>                  #mk_factor
                 ::=  <id> <factor-rest>                       #mk_factor
                 ::=  <typeid2> . <id> <factor-rest>           #mk_qfactor
<factor-rest>    ::=                                           #mk_complete
                 ::=  ( <actuals> ) <factor-rest>              #mk_call
                 ::=  . <id> <factor-rest>                     #mk_qualified
                 ::=  [ <exp> ] <factor-rest>                  #mk_aref
<new-rest>       ::=  <typeid> <new-rest1>                     #mk_new1
                 ::=  <primtype> [ <new-rest2>                 #mk_new2
                 ::=  <funtype> [ <new-rest2>                  #mk_new2
<new-rest1>      ::=  ( )                                      #mk_new3
                 ::=  [ <new-rest2>                            #identity
<new-rest2>      ::=  <exp> ]                                  #mk_new4
                 ::=  ] [ <new-rest2>                          #mk_new5

<literal>        ::=  null                                     #mkNull
                 ::=  true                                     #mkTrue
                 ::=  false                                    #mkFalse
                 ::=  charliteral                              #mkCharLiteral
                 ::=  Stringliteral                          #mkStringLiteral
                 ::=  intliteral                               #mkIntLiteral
                 ::=  floatliteral                            #mkFloatLiteral

<types>          ::=                                           #emptyList
                 ::=  <type> <types-rest>                      #cons
<types-rest>     ::=                                           #emptyList
                 ::=  , <type> <types-rest>                    #cons
<bodydecs>       ::=                                           #emptyList
                 ::=  <bodydec> <bodydecs>                     #cons
<localdecs>      ::=                                           #emptyList
                 ::=  <localdec> <localdecs>                   #cons
<stms>           ::=                                           #emptyList
                 ::=  <stm> <stms>                             #cons
<formals>        ::=                                           #emptyList
                 ::=  <formal> <formals-rest>                  #cons
<formals-rest>   ::=                                           #emptyList
                 ::=  , <formal> <formals-rest>                #cons
<actuals>        ::=                                           #emptyList
                 ::=  <exp> <actuals-rest>                     #cons
<actuals-rest>   ::=                                           #emptyList
                 ::=  , <exp> <actuals-rest>                   #cons

<assignop>       ::=  =                                        #mkop_assign
<orop>           ::=  or                                       #mkop_or
<andop>          ::=  and                                      #mkop_and
<relop>          ::=  ==                                       #mkop_equal
                 ::=  ne                                       #mkop_ne
                 ::=  lt                                       #mkop_less
                 ::=  le                                       #mkop_le
                 ::=  gt                                       #mkop_greater
                 ::=  ge                                       #mkop_ge
<addop>          ::=  +                                        #mkop_plus
                 ::=  -                                        #mkop_minus
<mulop>          ::=  *                                        #mkop_times
                 ::=  /                                        #mkop_divide
<unop>           ::=  !                                        #mkop_not
                 ::=  -                                        #mkop_minus
                 ::=  sharp                                    #mkop_sharp

<id>             ::=  id                                       #mkId
<typeid>         ::=  typeid                                   #mkTypeId
<typeid2>        ::=  typeid2                                  #mkTypeId

*end