-- File generated by the BNF Converter.
-- Parser definition for use with Happy.
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}

module ParJava
  ( happyError
  , myLexer
  , pProgramFile
  , pImport
  , pListImport
  , pTypeDeclaration
  , pListTypeDeclaration
  , pClassHeader
  , pFieldDeclaration
  , pListFieldDeclaration
  , pMethodBody
  , pLVarStatement
  , pListLVarStatement
  , pBody
  , pStm
  , pDeclaratorName
  , pVarDecl
  , pListVarDecl
  , pVariableInits
  , pArrayInits
  , pMethodDecl
  , pParameter
  , pListParameter
  , pSelectionStm
  , pElseIfStm
  , pListElseIfStm
  , pJumpStm
  , pGuardStm
  , pCatch
  , pListCatch
  , pIterStm
  , pForInit
  , pModifier
  , pListModifier
  , pBasicType
  , pTypeSpec
  , pTypeName
  , pListTypeName
  , pBracketsOpt
  , pListBracketsOpt
  , pListIdent
  , pExp
  , pExp2
  , pExp3
  , pExp4
  , pExp5
  , pExp6
  , pExp7
  , pExp8
  , pExp9
  , pExp10
  , pExp11
  , pExp12
  , pExp13
  , pExp14
  , pExp15
  , pExp16
  , pExp17
  , pExp18
  , pSpecName
  , pNewAlloc
  , pArrAcc
  , pSpecExp
  , pSpecExpNP
  , pMthCall
  , pFieldAcc
  , pArgs
  , pDimExpr
  , pListDimExpr
  , pListExp
  , pExp1
  , pConstant
  , pUnary_operator
  , pAssignment_op
  , pSemi
  , pListSemi
  ) where

import Prelude

import qualified AbsJava
import LexJava

}

%name pProgramFile ProgramFile
%name pImport Import
%name pListImport ListImport
%name pTypeDeclaration TypeDeclaration
%name pListTypeDeclaration ListTypeDeclaration
%name pClassHeader ClassHeader
%name pFieldDeclaration FieldDeclaration
%name pListFieldDeclaration ListFieldDeclaration
%name pMethodBody MethodBody
%name pLVarStatement LVarStatement
%name pListLVarStatement ListLVarStatement
%name pBody Body
%name pStm Stm
%name pDeclaratorName DeclaratorName
%name pVarDecl VarDecl
%name pListVarDecl ListVarDecl
%name pVariableInits VariableInits
%name pArrayInits ArrayInits
%name pMethodDecl MethodDecl
%name pParameter Parameter
%name pListParameter ListParameter
%name pSelectionStm SelectionStm
%name pElseIfStm ElseIfStm
%name pListElseIfStm ListElseIfStm
%name pJumpStm JumpStm
%name pGuardStm GuardStm
%name pCatch Catch
%name pListCatch ListCatch
%name pIterStm IterStm
%name pForInit ForInit
%name pModifier Modifier
%name pListModifier ListModifier
%name pBasicType BasicType
%name pTypeSpec TypeSpec
%name pTypeName TypeName
%name pListTypeName ListTypeName
%name pBracketsOpt BracketsOpt
%name pListBracketsOpt ListBracketsOpt
%name pListIdent ListIdent
%name pExp Exp
%name pExp2 Exp2
%name pExp3 Exp3
%name pExp4 Exp4
%name pExp5 Exp5
%name pExp6 Exp6
%name pExp7 Exp7
%name pExp8 Exp8
%name pExp9 Exp9
%name pExp10 Exp10
%name pExp11 Exp11
%name pExp12 Exp12
%name pExp13 Exp13
%name pExp14 Exp14
%name pExp15 Exp15
%name pExp16 Exp16
%name pExp17 Exp17
%name pExp18 Exp18
%name pSpecName SpecName
%name pNewAlloc NewAlloc
%name pArrAcc ArrAcc
%name pSpecExp SpecExp
%name pSpecExpNP SpecExpNP
%name pMthCall MthCall
%name pFieldAcc FieldAcc
%name pArgs Args
%name pDimExpr DimExpr
%name pListDimExpr ListDimExpr
%name pListExp ListExp
%name pExp1 Exp1
%name pConstant Constant
%name pUnary_operator Unary_operator
%name pAssignment_op Assignment_op
%name pSemi Semi
%name pListSemi ListSemi
%monad { Err } { (>>=) } { return }
%tokentype {Token}

%token
  '!' { PT _ (TS _ 1) }
  '!=' { PT _ (TS _ 2) }
  '%' { PT _ (TS _ 3) }
  '%=' { PT _ (TS _ 4) }
  '&' { PT _ (TS _ 5) }
  '&&' { PT _ (TS _ 6) }
  '&=' { PT _ (TS _ 7) }
  '(' { PT _ (TS _ 8) }
  ')' { PT _ (TS _ 9) }
  '*' { PT _ (TS _ 10) }
  '*=' { PT _ (TS _ 11) }
  '+' { PT _ (TS _ 12) }
  '++' { PT _ (TS _ 13) }
  '+=' { PT _ (TS _ 14) }
  ',' { PT _ (TS _ 15) }
  '-' { PT _ (TS _ 16) }
  '--' { PT _ (TS _ 17) }
  '-=' { PT _ (TS _ 18) }
  '.' { PT _ (TS _ 19) }
  '.*' { PT _ (TS _ 20) }
  '.class' { PT _ (TS _ 21) }
  '.this' { PT _ (TS _ 22) }
  '/' { PT _ (TS _ 23) }
  '/=' { PT _ (TS _ 24) }
  ':' { PT _ (TS _ 25) }
  ';' { PT _ (TS _ 26) }
  '<' { PT _ (TS _ 27) }
  '<<' { PT _ (TS _ 28) }
  '<<=' { PT _ (TS _ 29) }
  '<=' { PT _ (TS _ 30) }
  '=' { PT _ (TS _ 31) }
  '==' { PT _ (TS _ 32) }
  '>' { PT _ (TS _ 33) }
  '>=' { PT _ (TS _ 34) }
  '>>' { PT _ (TS _ 35) }
  '>>=' { PT _ (TS _ 36) }
  '>>>' { PT _ (TS _ 37) }
  '>>>=' { PT _ (TS _ 38) }
  '?' { PT _ (TS _ 39) }
  '[' { PT _ (TS _ 40) }
  '[]' { PT _ (TS _ 41) }
  ']' { PT _ (TS _ 42) }
  '^' { PT _ (TS _ 43) }
  '^=' { PT _ (TS _ 44) }
  'abstract' { PT _ (TS _ 45) }
  'boolean' { PT _ (TS _ 46) }
  'break' { PT _ (TS _ 47) }
  'byte' { PT _ (TS _ 48) }
  'case' { PT _ (TS _ 49) }
  'catch' { PT _ (TS _ 50) }
  'char' { PT _ (TS _ 51) }
  'class' { PT _ (TS _ 52) }
  'continue' { PT _ (TS _ 53) }
  'default' { PT _ (TS _ 54) }
  'do' { PT _ (TS _ 55) }
  'double' { PT _ (TS _ 56) }
  'else' { PT _ (TS _ 57) }
  'else if' { PT _ (TS _ 58) }
  'extends' { PT _ (TS _ 59) }
  'false' { PT _ (TS _ 60) }
  'final' { PT _ (TS _ 61) }
  'finally' { PT _ (TS _ 62) }
  'float' { PT _ (TS _ 63) }
  'for' { PT _ (TS _ 64) }
  'if' { PT _ (TS _ 65) }
  'implements' { PT _ (TS _ 66) }
  'import' { PT _ (TS _ 67) }
  'instanceof' { PT _ (TS _ 68) }
  'int' { PT _ (TS _ 69) }
  'interface' { PT _ (TS _ 70) }
  'long' { PT _ (TS _ 71) }
  'native' { PT _ (TS _ 72) }
  'new' { PT _ (TS _ 73) }
  'null' { PT _ (TS _ 74) }
  'package' { PT _ (TS _ 75) }
  'private' { PT _ (TS _ 76) }
  'protected' { PT _ (TS _ 77) }
  'public' { PT _ (TS _ 78) }
  'return' { PT _ (TS _ 79) }
  'short' { PT _ (TS _ 80) }
  'static' { PT _ (TS _ 81) }
  'super' { PT _ (TS _ 82) }
  'switch' { PT _ (TS _ 83) }
  'synchronized' { PT _ (TS _ 84) }
  'this' { PT _ (TS _ 85) }
  'throw' { PT _ (TS _ 86) }
  'throws' { PT _ (TS _ 87) }
  'transient' { PT _ (TS _ 88) }
  'true' { PT _ (TS _ 89) }
  'try' { PT _ (TS _ 90) }
  'volatile' { PT _ (TS _ 91) }
  'while' { PT _ (TS _ 92) }
  '{' { PT _ (TS _ 93) }
  '|' { PT _ (TS _ 94) }
  '|=' { PT _ (TS _ 95) }
  '||' { PT _ (TS _ 96) }
  '}' { PT _ (TS _ 97) }
  '~' { PT _ (TS _ 98) }
  L_Ident { PT _ (TV $$) }
  L_doubl { PT _ (TD $$) }
  L_integ { PT _ (TI $$) }
  L_quoted { PT _ (TL $$) }
  L_Unsigned { PT _ (T_Unsigned $$) }
  L_Long { PT _ (T_Long $$) }
  L_UnsignedLong { PT _ (T_UnsignedLong $$) }
  L_Hexadecimal { PT _ (T_Hexadecimal $$) }
  L_HexUnsigned { PT _ (T_HexUnsigned $$) }
  L_HexLong { PT _ (T_HexLong $$) }
  L_HexUnsLong { PT _ (T_HexUnsLong $$) }
  L_Octal { PT _ (T_Octal $$) }
  L_OctalUnsigned { PT _ (T_OctalUnsigned $$) }
  L_OctalLong { PT _ (T_OctalLong $$) }
  L_OctalUnsLong { PT _ (T_OctalUnsLong $$) }
  L_JDouble { PT _ (T_JDouble $$) }
  L_JFloat { PT _ (T_JFloat $$) }
  L_JLongDouble { PT _ (T_JLongDouble $$) }
  L_UnicodeChar { PT _ (T_UnicodeChar $$) }
  L_JChar { PT _ (T_JChar $$) }

%%

Ident :: { AbsJava.Ident }
Ident  : L_Ident { AbsJava.Ident $1 }

Double :: { Double }
Double  : L_doubl  { (read $1 ) :: Double }

Integer :: { Integer }
Integer  : L_integ  { (read $1 ) :: Integer }

String :: { String }
String  : L_quoted { $1 }

Unsigned :: { AbsJava.Unsigned }
Unsigned : L_Unsigned { AbsJava.Unsigned $1 }

Long :: { AbsJava.Long }
Long : L_Long { AbsJava.Long $1 }

UnsignedLong :: { AbsJava.UnsignedLong }
UnsignedLong : L_UnsignedLong { AbsJava.UnsignedLong $1 }

Hexadecimal :: { AbsJava.Hexadecimal }
Hexadecimal : L_Hexadecimal { AbsJava.Hexadecimal $1 }

HexUnsigned :: { AbsJava.HexUnsigned }
HexUnsigned : L_HexUnsigned { AbsJava.HexUnsigned $1 }

HexLong :: { AbsJava.HexLong }
HexLong : L_HexLong { AbsJava.HexLong $1 }

HexUnsLong :: { AbsJava.HexUnsLong }
HexUnsLong : L_HexUnsLong { AbsJava.HexUnsLong $1 }

Octal :: { AbsJava.Octal }
Octal : L_Octal { AbsJava.Octal $1 }

OctalUnsigned :: { AbsJava.OctalUnsigned }
OctalUnsigned : L_OctalUnsigned { AbsJava.OctalUnsigned $1 }

OctalLong :: { AbsJava.OctalLong }
OctalLong : L_OctalLong { AbsJava.OctalLong $1 }

OctalUnsLong :: { AbsJava.OctalUnsLong }
OctalUnsLong : L_OctalUnsLong { AbsJava.OctalUnsLong $1 }

JDouble :: { AbsJava.JDouble }
JDouble : L_JDouble { AbsJava.JDouble $1 }

JFloat :: { AbsJava.JFloat }
JFloat : L_JFloat { AbsJava.JFloat $1 }

JLongDouble :: { AbsJava.JLongDouble }
JLongDouble : L_JLongDouble { AbsJava.JLongDouble $1 }

UnicodeChar :: { AbsJava.UnicodeChar }
UnicodeChar : L_UnicodeChar { AbsJava.UnicodeChar $1 }

JChar :: { AbsJava.JChar }
JChar : L_JChar { AbsJava.JChar $1 }

ProgramFile :: { AbsJava.ProgramFile }
ProgramFile
  : 'package' ListIdent ListSemi ListImport ListTypeDeclaration { AbsJava.Prpkg $2 $3 $4 $5 }
  | ListImport ListTypeDeclaration { AbsJava.ProgF $1 $2 }

Import :: { AbsJava.Import }
Import
  : 'import' ListIdent '.*' ListSemi { AbsJava.ImportA $2 $4 }
  | 'import' ListIdent ListSemi { AbsJava.ImportN $2 $3 }

ListImport :: { [AbsJava.Import] }
ListImport
  : {- empty -} { [] }
  | Import ListImport { (:) $1 $2 }

TypeDeclaration :: { AbsJava.TypeDeclaration }
TypeDeclaration
  : ClassHeader '{' ListFieldDeclaration '}' { AbsJava.TypeDecl $1 $3 }

ListTypeDeclaration :: { [AbsJava.TypeDeclaration] }
ListTypeDeclaration
  : {- empty -} { [] }
  | TypeDeclaration ListTypeDeclaration { (:) $1 $2 }

ClassHeader :: { AbsJava.ClassHeader }
ClassHeader
  : ListModifier 'class' Ident { AbsJava.ClassDec $1 $3 }
  | ListModifier 'class' Ident 'extends' ListTypeName { AbsJava.ClassDecE $1 $3 $5 }
  | ListModifier 'class' Ident 'extends' ListTypeName 'implements' ListTypeName { AbsJava.ClassDecEI $1 $3 $5 $7 }
  | ListModifier 'class' Ident 'implements' ListTypeName { AbsJava.ClassDecI $1 $3 $5 }
  | ListModifier 'interface' Ident { AbsJava.InterDec $1 $3 }
  | ListModifier 'interface' Ident 'extends' ListTypeName { AbsJava.InterDecE $1 $3 $5 }
  | ListModifier 'interface' Ident 'extends' ListTypeName 'implements' ListTypeName { AbsJava.InterDecEI $1 $3 $5 $7 }
  | ListModifier 'interface' Ident 'implements' ListTypeName { AbsJava.InterDecI $1 $3 $5 }

FieldDeclaration :: { AbsJava.FieldDeclaration }
FieldDeclaration
  : Body { AbsJava.Dblk $1 }
  | TypeDeclaration { AbsJava.Dinnerclass $1 }
  | ListModifier Ident '(' ListParameter ')' 'throws' ListTypeName Body { AbsJava.Dconstt $1 $2 $4 $7 $8 }
  | ListModifier Ident '(' ListParameter ')' Body { AbsJava.Dconst $1 $2 $4 $6 }
  | ListModifier TypeSpec MethodDecl 'throws' ListTypeName MethodBody { AbsJava.Dmthth $1 $2 $3 $5 $6 }
  | ListModifier TypeSpec MethodDecl MethodBody { AbsJava.Dmth $1 $2 $3 $4 }
  | ListModifier TypeSpec ListVarDecl ';' { AbsJava.Dvar $1 $2 $3 }

ListFieldDeclaration :: { [AbsJava.FieldDeclaration] }
ListFieldDeclaration
  : {- empty -} { [] }
  | FieldDeclaration ListFieldDeclaration { (:) $1 $2 }

MethodBody :: { AbsJava.MethodBody }
MethodBody
  : ';' { AbsJava.IBody }
  | Body { AbsJava.MBody $1 }

LVarStatement :: { AbsJava.LVarStatement }
LVarStatement
  : 'final' TypeSpec ListVarDecl ';' { AbsJava.LVarf $2 $3 }
  | Stm { AbsJava.Statem $1 }
  | TypeSpec ListVarDecl ';' { AbsJava.LVar $1 $2 }

ListLVarStatement :: { [AbsJava.LVarStatement] }
ListLVarStatement
  : {- empty -} { [] }
  | LVarStatement ListLVarStatement { (:) $1 $2 }

Body :: { AbsJava.Body }
Body
  : '{' ListLVarStatement '}' { AbsJava.BodyImpl $2 }

Stm :: { AbsJava.Stm }
Stm
  : ';' { AbsJava.Sem }
  | 'case' Exp ':' { AbsJava.Case $2 }
  | 'default' ':' { AbsJava.Dflt }
  | '{' ListLVarStatement '}' { AbsJava.LV $2 }
  | Ident ':' { AbsJava.Lbl $1 }
  | Exp ';' { AbsJava.Exps $1 }
  | GuardStm { AbsJava.Grd $1 }
  | IterStm { AbsJava.Iter $1 }
  | JumpStm { AbsJava.Jmp $1 }
  | SelectionStm { AbsJava.Sel $1 }

DeclaratorName :: { AbsJava.DeclaratorName }
DeclaratorName
  : Ident { AbsJava.DeclName $1 }
  | Ident ListBracketsOpt { AbsJava.DeclArray $1 $2 }

VarDecl :: { AbsJava.VarDecl }
VarDecl
  : Ident { AbsJava.VDecl $1 }
  | DeclaratorName '=' VariableInits { AbsJava.VDeclAssign $1 $3 }

ListVarDecl :: { [AbsJava.VarDecl] }
ListVarDecl
  : VarDecl { (:[]) $1 }
  | VarDecl ',' ListVarDecl { (:) $1 $3 }

VariableInits :: { AbsJava.VariableInits }
VariableInits
  : '{' '}' { AbsJava.IEmpt }
  | '{' ArrayInits '}' { AbsJava.IArri $2 }
  | Exp { AbsJava.IExp $1 }

ArrayInits :: { AbsJava.ArrayInits }
ArrayInits
  : ArrayInits ',' { AbsJava.Vais $1 }
  | ArrayInits ',' VariableInits { AbsJava.Vai $1 $3 }
  | VariableInits { AbsJava.Vainit $1 }

MethodDecl :: { AbsJava.MethodDecl }
MethodDecl
  : DeclaratorName '(' ListParameter ')' { AbsJava.Mth $1 $3 }
  | MethodDecl BracketsOpt { AbsJava.MthdArr $1 $2 }

Parameter :: { AbsJava.Parameter }
Parameter
  : 'final' TypeSpec DeclaratorName { AbsJava.Pfinal $2 $3 }
  | TypeSpec DeclaratorName { AbsJava.Param $1 $2 }

ListParameter :: { [AbsJava.Parameter] }
ListParameter
  : {- empty -} { [] }
  | Parameter { (:[]) $1 }
  | Parameter ',' ListParameter { (:) $1 $3 }

SelectionStm :: { AbsJava.SelectionStm }
SelectionStm
  : 'if' '(' Exp ')' Stm ListElseIfStm { AbsJava.Ifone $3 $5 $6 }
  | 'if' '(' Exp ')' Stm ListElseIfStm 'else' Stm { AbsJava.If $3 $5 $6 $8 }
  | 'switch' '(' Exp ')' Body { AbsJava.Switch $3 $5 }

ElseIfStm :: { AbsJava.ElseIfStm }
ElseIfStm
  : 'else if' '(' Exp ')' Stm { AbsJava.Elseif $3 $5 }

ListElseIfStm :: { [AbsJava.ElseIfStm] }
ListElseIfStm
  : {- empty -} { [] }
  | ElseIfStm ListElseIfStm { (:) $1 $2 }

JumpStm :: { AbsJava.JumpStm }
JumpStm
  : 'break' ';' { AbsJava.Break }
  | 'break' Ident ';' { AbsJava.Brlabel $2 }
  | 'continue' ';' { AbsJava.Continue }
  | 'continue' Ident ';' { AbsJava.Continuelabel $2 }
  | 'return' ';' { AbsJava.Return }
  | 'return' Exp ';' { AbsJava.ReturnExp $2 }
  | 'throw' Exp ';' { AbsJava.Throw $2 }

GuardStm :: { AbsJava.GuardStm }
GuardStm
  : 'synchronized' '(' Exp ')' Body { AbsJava.Synchronized $3 $5 }
  | 'try' Body ListCatch { AbsJava.Try $2 $3 }
  | 'try' Body ListCatch 'finally' Body { AbsJava.Tryfinally $2 $3 $5 }

Catch :: { AbsJava.Catch }
Catch
  : 'catch' '(' TypeSpec ')' Body { AbsJava.Catch2 $3 $5 }
  | 'catch' '(' TypeSpec Ident ')' Body { AbsJava.Catch1 $3 $4 $6 }

ListCatch :: { [AbsJava.Catch] }
ListCatch
  : {- empty -} { [] }
  | Catch ListCatch { (:) $1 $2 }

IterStm :: { AbsJava.IterStm }
IterStm
  : 'do' Stm 'while' '(' Exp ')' { AbsJava.Do $2 $5 }
  | 'for' '(' ForInit ListExp ';' ListExp ')' Stm { AbsJava.For $3 $4 $6 $8 }
  | 'while' '(' Exp ')' Stm { AbsJava.While $3 $5 }

ForInit :: { AbsJava.ForInit }
ForInit
  : 'final' TypeSpec ListVarDecl ';' { AbsJava.DeclVarFinal $2 $3 }
  | TypeSpec ListVarDecl ';' { AbsJava.DeclVar $1 $2 }
  | ListExp ';' { AbsJava.Exprs1 $1 }

Modifier :: { AbsJava.Modifier }
Modifier
  : 'abstract' { AbsJava.Mabstract }
  | 'final' { AbsJava.Mfinal }
  | 'native' { AbsJava.Mnative }
  | 'private' { AbsJava.Mprivate }
  | 'protected' { AbsJava.Mprotected }
  | 'public' { AbsJava.Mpublic }
  | 'static' { AbsJava.Mstatic }
  | 'synchronized' { AbsJava.Msync }
  | 'transient' { AbsJava.Mtransient }
  | 'volatile' { AbsJava.Mvolatile }

ListModifier :: { [AbsJava.Modifier] }
ListModifier
  : {- empty -} { [] }
  | Modifier ListModifier { (:) $1 $2 }

BasicType :: { AbsJava.BasicType }
BasicType
  : 'boolean' { AbsJava.Tboolean }
  | 'byte' { AbsJava.Tbyte }
  | 'char' { AbsJava.Tchar }
  | 'double' { AbsJava.Tdouble }
  | 'float' { AbsJava.Tfloat }
  | 'int' { AbsJava.Tint }
  | 'long' { AbsJava.Tlong }
  | 'short' { AbsJava.Tshort }

TypeSpec :: { AbsJava.TypeSpec }
TypeSpec
  : TypeName { AbsJava.NamedType $1 }
  | TypeName ListBracketsOpt { AbsJava.ArrayType $1 $2 }

TypeName :: { AbsJava.TypeName }
TypeName
  : BasicType { AbsJava.BuiltIn $1 }
  | ListIdent { AbsJava.ClassType $1 }

ListTypeName :: { [AbsJava.TypeName] }
ListTypeName
  : TypeName { (:[]) $1 }
  | TypeName ',' ListTypeName { (:) $1 $3 }

BracketsOpt :: { AbsJava.BracketsOpt }
BracketsOpt
  : '[]' { AbsJava.BracketsEmpty }

ListBracketsOpt :: { [AbsJava.BracketsOpt] }
ListBracketsOpt
  : BracketsOpt { (:[]) $1 }
  | BracketsOpt ListBracketsOpt { (:) $1 $2 }

ListIdent :: { [AbsJava.Ident] }
ListIdent
  : Ident { (:[]) $1 }
  | Ident '.' ListIdent { (:) $1 $3 }

Exp :: { AbsJava.Exp }
Exp
  : Exp1 { $1 }
  | Exp14 'instanceof' TypeName { AbsJava.Etype $1 $3 }
  | Exp14 Assignment_op Exp { AbsJava.Eassign $1 $2 $3 }

Exp2 :: { AbsJava.Exp }
Exp2
  : Exp3 { $1 }
  | Exp3 '?' Exp ':' Exp2 { AbsJava.Econdition $1 $3 $5 }

Exp3 :: { AbsJava.Exp }
Exp3
  : Exp3 '||' Exp4 { AbsJava.Elor $1 $3 }
  | Exp4 { $1 }

Exp4 :: { AbsJava.Exp }
Exp4
  : Exp4 '&&' Exp5 { AbsJava.Eland $1 $3 }
  | Exp5 { $1 }

Exp5 :: { AbsJava.Exp }
Exp5
  : Exp5 '|' Exp6 { AbsJava.Ebitor $1 $3 }
  | Exp6 { $1 }

Exp6 :: { AbsJava.Exp }
Exp6
  : Exp6 '^' Exp7 { AbsJava.Ebitexor $1 $3 }
  | Exp7 { $1 }

Exp7 :: { AbsJava.Exp }
Exp7
  : Exp7 '&' Exp8 { AbsJava.Ebitand $1 $3 }
  | Exp8 { $1 }

Exp8 :: { AbsJava.Exp }
Exp8
  : Exp8 '!=' Exp9 { AbsJava.Eneq $1 $3 }
  | Exp8 '==' Exp9 { AbsJava.Eeq $1 $3 }
  | Exp9 { $1 }

Exp9 :: { AbsJava.Exp }
Exp9
  : Exp9 '<' Exp10 { AbsJava.Elthen $1 $3 }
  | Exp9 '<=' Exp10 { AbsJava.Ele $1 $3 }
  | Exp9 '>' Exp10 { AbsJava.Egrthen $1 $3 }
  | Exp9 '>=' Exp10 { AbsJava.Ege $1 $3 }
  | Exp10 { $1 }

Exp10 :: { AbsJava.Exp }
Exp10
  : Exp10 '<<' Exp11 { AbsJava.Eleft $1 $3 }
  | Exp10 '>>' Exp11 { AbsJava.Eright $1 $3 }
  | Exp10 '>>>' Exp11 { AbsJava.Etrip $1 $3 }
  | Exp11 { $1 }

Exp11 :: { AbsJava.Exp }
Exp11
  : Exp11 '+' Exp12 { AbsJava.Eplus $1 $3 }
  | Exp11 '-' Exp12 { AbsJava.Eminus $1 $3 }
  | Exp12 { $1 }

Exp12 :: { AbsJava.Exp }
Exp12
  : Exp12 '%' Exp13 { AbsJava.Emod $1 $3 }
  | Exp12 '*' Exp13 { AbsJava.Etimes $1 $3 }
  | Exp12 '/' Exp13 { AbsJava.Ediv $1 $3 }
  | Exp13 { $1 }

Exp13 :: { AbsJava.Exp }
Exp13
  : '(' BasicType ')' Exp13 { AbsJava.Ebcoercion $2 $4 }
  | '(' Exp ')' Exp15 { AbsJava.Eexpcoercion $2 $4 }
  | '(' ListIdent ListBracketsOpt ')' Exp13 { AbsJava.Earrcoercion $2 $3 $5 }
  | Exp14 { $1 }

Exp14 :: { AbsJava.Exp }
Exp14
  : '++' Exp14 { AbsJava.Epreinc $2 }
  | '--' Exp14 { AbsJava.Epredec $2 }
  | Unary_operator Exp13 { AbsJava.Epreop $1 $2 }
  | Exp15 { $1 }

Exp15 :: { AbsJava.Exp }
Exp15
  : Exp15 '++' { AbsJava.Epostinc $1 }
  | Exp15 '--' { AbsJava.Epostdec $1 }
  | Exp16 { $1 }

Exp16 :: { AbsJava.Exp }
Exp16
  : String { AbsJava.Estring $1 }
  | ArrAcc { AbsJava.Earr $1 }
  | Constant { AbsJava.Econst $1 }
  | FieldAcc { AbsJava.Efld $1 }
  | MthCall { AbsJava.Emth $1 }
  | SpecName { AbsJava.Especname $1 }
  | Exp17 { $1 }

Exp17 :: { AbsJava.Exp }
Exp17
  : NewAlloc { AbsJava.Enewalloc $1 }
  | Exp18 { $1 }

Exp18 :: { AbsJava.Exp }
Exp18
  : '(' Exp ')' { $2 }
  | ListIdent { AbsJava.Evar $1 }

SpecName :: { AbsJava.SpecName }
SpecName
  : 'null' { AbsJava.SSnull }
  | 'super' { AbsJava.SSsuper }
  | 'this' { AbsJava.SSthis }

NewAlloc :: { AbsJava.NewAlloc }
NewAlloc
  : 'new' TypeName Args { AbsJava.Anewclass $2 $3 }
  | 'new' TypeName Args '{' ListFieldDeclaration '}' { AbsJava.Anewinnerclass $2 $3 $5 }
  | 'new' TypeName ListDimExpr { AbsJava.Anewarray $2 $3 }
  | 'new' TypeName ListDimExpr '{' '}' { AbsJava.Anewarriempty $2 $3 }
  | 'new' TypeName ListDimExpr '{' ArrayInits '}' { AbsJava.Anewarrinits $2 $3 $5 }

ArrAcc :: { AbsJava.ArrAcc }
ArrAcc
  : SpecExp '[' Exp ']' { AbsJava.Aarr1 $1 $3 }
  | ListIdent '[' Exp ']' { AbsJava.Aarr $1 $3 }

SpecExp :: { AbsJava.SpecExp }
SpecExp
  : '(' Exp ')' { AbsJava.Cep $2 }
  | SpecExpNP { AbsJava.Cnp $1 }
  | SpecName { AbsJava.Cthis $1 }

SpecExpNP :: { AbsJava.SpecExpNP }
SpecExpNP
  : ArrAcc { AbsJava.CNParr $1 }
  | Constant { AbsJava.CNLit $1 }
  | FieldAcc { AbsJava.CNPfld $1 }
  | MthCall { AbsJava.CNPmth $1 }

MthCall :: { AbsJava.MthCall }
MthCall
  : SpecExpNP Args { AbsJava.Mmth1 $1 $2 }
  | SpecName Args { AbsJava.Mmthspec $1 $2 }
  | ListIdent Args { AbsJava.Mmth $1 $2 }

FieldAcc :: { AbsJava.FieldAcc }
FieldAcc
  : BasicType '.class' { AbsJava.Ffclass2 $1 }
  | NewAlloc '.' Ident { AbsJava.Ffvar1 $1 $3 }
  | SpecExp '.' Ident { AbsJava.Ffvar $1 $3 }
  | ListIdent '.class' { AbsJava.Fclass $1 }
  | ListIdent '.this' { AbsJava.Ffthis $1 }

Args :: { AbsJava.Args }
Args
  : '(' ListExp ')' { AbsJava.ArgList $2 }

DimExpr :: { AbsJava.DimExpr }
DimExpr
  : '[' Exp ']' { AbsJava.Dim $2 }

ListDimExpr :: { [AbsJava.DimExpr] }
ListDimExpr
  : DimExpr { (:[]) $1 }
  | DimExpr ListDimExpr { (:) $1 $2 }

ListExp :: { [AbsJava.Exp] }
ListExp
  : {- empty -} { [] }
  | Exp { (:[]) $1 }
  | Exp ',' ListExp { (:) $1 $3 }

Exp1 :: { AbsJava.Exp }
Exp1
  : Exp2 { $1 }

Constant :: { AbsJava.Constant }
Constant
  : 'false' { AbsJava.Efalse }
  | 'true' { AbsJava.Etrue }
  | Double { AbsJava.Efloat $1 }
  | Integer { AbsJava.Eint $1 }
  | HexLong { AbsJava.Ehexalong $1 }
  | HexUnsLong { AbsJava.Ehexaunslong $1 }
  | HexUnsigned { AbsJava.Ehexaunsign $1 }
  | Hexadecimal { AbsJava.Ehexadec $1 }
  | JChar { AbsJava.Echar $1 }
  | JDouble { AbsJava.Ecdouble $1 }
  | JFloat { AbsJava.Ecfloat $1 }
  | JLongDouble { AbsJava.Eclongdouble $1 }
  | Long { AbsJava.Elong $1 }
  | Octal { AbsJava.Eoctal $1 }
  | OctalLong { AbsJava.Eoctallong $1 }
  | OctalUnsLong { AbsJava.Eoctalunslong $1 }
  | OctalUnsigned { AbsJava.Eoctalunsign $1 }
  | UnicodeChar { AbsJava.Eunicode $1 }
  | Unsigned { AbsJava.Eunsigned $1 }
  | UnsignedLong { AbsJava.Eunsignlong $1 }

Unary_operator :: { AbsJava.Unary_operator }
Unary_operator
  : '!' { AbsJava.Logicalneg }
  | '+' { AbsJava.Plus }
  | '-' { AbsJava.Negative }
  | '~' { AbsJava.Complement }

Assignment_op :: { AbsJava.Assignment_op }
Assignment_op
  : '%=' { AbsJava.AssignMod }
  | '&=' { AbsJava.AssignAnd }
  | '*=' { AbsJava.AssignMul }
  | '+=' { AbsJava.AssignAdd }
  | '-=' { AbsJava.AssignSub }
  | '/=' { AbsJava.AssignDiv }
  | '<<=' { AbsJava.AssignLeft }
  | '=' { AbsJava.Assign }
  | '>>=' { AbsJava.AssignRight }
  | '>>>=' { AbsJava.AssignTrip }
  | '^=' { AbsJava.AssignXor }
  | '|=' { AbsJava.AssignOr }

Semi :: { AbsJava.Semi }
Semi
  : ';' { AbsJava.Sem1 }

ListSemi :: { [AbsJava.Semi] }
ListSemi
  : {- empty -} { [] }
  | Semi ListSemi { (:) $1 $2 }

{

type Err = Either String

happyError :: [Token] -> Err a
happyError ts = Left $
  "syntax error at " ++ tokenPos ts ++ 
  case ts of
    []      -> []
    [Err _] -> " due to lexer error"
    t:_     -> " before `" ++ (prToken t) ++ "'"

myLexer :: String -> [Token]
myLexer = tokens

}