{-# LANGUAGE CPP #-}
module Language.Java.Parser (
parser,
compilationUnit, packageDecl, importDecl, typeDecl,
classDecl, interfaceDecl,
memberDecl, fieldDecl, methodDecl, constrDecl,
interfaceMemberDecl, absMethodDecl,
formalParams, formalParam,
modifier,
varDecls, varDecl,
block, blockStmt, stmt,
stmtExp, exp, primary, literal,
ttype, primType, refType, classType, resultType,
lambdaExp, methodRef,
typeParams, typeParam,
name, ident,
empty, list, list1, seplist, seplist1, opt, bopt, lopt,
comma, semiColon, period, colon
) where
import Language.Java.Lexer ( L(..), Token(..), lexer)
import Language.Java.Syntax
import Language.Java.Pretty (pretty)
import Text.Parsec hiding ( Empty )
import Text.Parsec.Pos
import Prelude hiding ( exp, catch, (>>), (>>=) )
import qualified Prelude as P ( (>>), (>>=) )
import Data.Maybe ( isJust, catMaybes )
import Control.Monad ( ap )
#if __GLASGOW_HASKELL__ < 707
import Control.Applicative ( (<$>), (<$), (<*) )
(<*>) :: Monad m => m (a -> b) -> m a -> m b
(<*>) = ap
infixl 4 <*>
#else
import Control.Applicative ( (<$>), (<$), (<*), (<*>) )
#endif
type P = Parsec [L Token] ()
>> :: ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
(>>) = forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(P.>>)
>>= :: ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
(>>=) = forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(P.>>=)
infixr 2 >>, >>=
parseCompilationUnit :: String -> Either ParseError CompilationUnit
parseCompilationUnit :: String -> Either ParseError CompilationUnit
parseCompilationUnit String
inp =
forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser P CompilationUnit
compilationUnit () String
"" (String -> [L Token]
lexer String
inp)
parser :: Parsec [L Token] () a -> String -> Either ParseError a
parser Parsec [L Token] () a
p = forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser Parsec [L Token] () a
p () String
"" forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [L Token]
lexer
compilationUnit :: P CompilationUnit
compilationUnit :: P CompilationUnit
compilationUnit = do
Maybe PackageDecl
mpd <- forall a. P a -> P (Maybe a)
opt P PackageDecl
packageDecl
[ImportDecl]
ids <- forall a. P a -> P [a]
list P ImportDecl
importDecl
[Maybe TypeDecl]
tds <- forall a. P a -> P [a]
list P (Maybe TypeDecl)
typeDecl
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe PackageDecl -> [ImportDecl] -> [TypeDecl] -> CompilationUnit
CompilationUnit Maybe PackageDecl
mpd [ImportDecl]
ids (forall a. [Maybe a] -> [a]
catMaybes [Maybe TypeDecl]
tds)
packageDecl :: P PackageDecl
packageDecl :: P PackageDecl
packageDecl = do
Token -> P ()
tok Token
KW_Package
Name
n <- P Name
name
P ()
semiColon
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> PackageDecl
PackageDecl Name
n
importDecl :: P ImportDecl
importDecl :: P ImportDecl
importDecl = do
Token -> P ()
tok Token
KW_Import
Bool
st <- forall a. P a -> P Bool
bopt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
KW_Static
Name
n <- P Name
name
Bool
ds <- forall a. P a -> P Bool
bopt forall a b. (a -> b) -> a -> b
$ P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
Op_Star
P ()
semiColon
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Name -> Bool -> ImportDecl
ImportDecl Bool
st Name
n Bool
ds
typeDecl :: P (Maybe TypeDecl)
typeDecl :: P (Maybe TypeDecl)
typeDecl = forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P TypeDecl
classOrInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall a b. a -> b -> a
const forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon
classOrInterfaceDecl :: P TypeDecl
classOrInterfaceDecl :: P TypeDecl
classOrInterfaceDecl = do
[Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
[Modifier] -> TypeDecl
de <- (do Mod ClassDecl
cd <- P (Mod ClassDecl)
classDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> TypeDecl
ClassTypeDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Mod InterfaceDecl
id <- ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> TypeDecl
InterfaceTypeDecl (Mod InterfaceDecl
id [Modifier]
ms))
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> TypeDecl
de [Modifier]
ms
classDecl :: P (Mod ClassDecl)
classDecl :: P (Mod ClassDecl)
classDecl = P (Mod ClassDecl)
normalClassDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P (Mod ClassDecl)
enumClassDecl
normalClassDecl :: P (Mod ClassDecl)
normalClassDecl :: P (Mod ClassDecl)
normalClassDecl = do
Token -> P ()
tok Token
KW_Class
Ident
i <- P Ident
ident
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
Maybe [RefType]
mex <- forall a. P a -> P (Maybe a)
opt P [RefType]
extends
[RefType]
imp <- forall a. P [a] -> P [a]
lopt P [RefType]
implements
ClassBody
bod <- P ClassBody
classBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> Ident
-> [TypeParam]
-> Maybe RefType
-> [RefType]
-> ClassBody
-> ClassDecl
ClassDecl [Modifier]
ms Ident
i [TypeParam]
tps ((forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> a
head) Maybe [RefType]
mex) [RefType]
imp ClassBody
bod
extends :: P [RefType]
extends :: P [RefType]
extends = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList
implements :: P [RefType]
implements :: P [RefType]
implements = Token -> P ()
tok Token
KW_Implements forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList
enumClassDecl :: P (Mod ClassDecl)
enumClassDecl :: P (Mod ClassDecl)
enumClassDecl = do
Token -> P ()
tok Token
KW_Enum
Ident
i <- P Ident
ident
[RefType]
imp <- forall a. P [a] -> P [a]
lopt P [RefType]
implements
EnumBody
bod <- P EnumBody
enumBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier] -> Ident -> [RefType] -> EnumBody -> ClassDecl
EnumDecl [Modifier]
ms Ident
i [RefType]
imp EnumBody
bod
classBody :: P ClassBody
classBody :: P ClassBody
classBody = [Decl] -> ClassBody
ClassBody forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
braces P [Decl]
classBodyStatements
enumBody :: P EnumBody
enumBody :: P EnumBody
enumBody = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
[EnumConstant]
ecs <- forall a sep. P a -> P sep -> P [a]
seplist P EnumConstant
enumConst P ()
comma
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional P ()
comma
[Decl]
eds <- forall a. P [a] -> P [a]
lopt P [Decl]
enumBodyDecls
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [EnumConstant] -> [Decl] -> EnumBody
EnumBody [EnumConstant]
ecs [Decl]
eds
enumConst :: P EnumConstant
enumConst :: P EnumConstant
enumConst = do
Ident
id <- P Ident
ident
[Argument]
as <- forall a. P [a] -> P [a]
lopt P [Argument]
args
Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> [Argument] -> Maybe ClassBody -> EnumConstant
EnumConstant Ident
id [Argument]
as Maybe ClassBody
mcb
enumBodyDecls :: P [Decl]
enumBodyDecls :: P [Decl]
enumBodyDecls = P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [Decl]
classBodyStatements
classBodyStatements :: P [Decl]
classBodyStatements :: P [Decl]
classBodyStatements = forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P [a]
list P (Maybe Decl)
classBodyStatement
annInterfaceDecl :: P (Mod InterfaceDecl)
annInterfaceDecl :: ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl = do
Token -> P ()
tok Token
KW_AnnInterface
Ident
id <- P Ident
ident
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
[RefType]
exs <- forall a. P [a] -> P [a]
lopt P [RefType]
extends
InterfaceBody
bod <- P InterfaceBody
interfaceBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceKind
-> [Modifier]
-> Ident
-> [TypeParam]
-> [RefType]
-> InterfaceBody
-> InterfaceDecl
InterfaceDecl InterfaceKind
InterfaceAnnotation [Modifier]
ms Ident
id [TypeParam]
tps [RefType]
exs InterfaceBody
bod
interfaceDecl :: P (Mod InterfaceDecl)
interfaceDecl :: ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl = do
Token -> P ()
tok Token
KW_Interface
Ident
id <- P Ident
ident
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
[RefType]
exs <- forall a. P [a] -> P [a]
lopt P [RefType]
extends
InterfaceBody
bod <- P InterfaceBody
interfaceBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceKind
-> [Modifier]
-> Ident
-> [TypeParam]
-> [RefType]
-> InterfaceBody
-> InterfaceDecl
InterfaceDecl InterfaceKind
InterfaceNormal [Modifier]
ms Ident
id [TypeParam]
tps [RefType]
exs InterfaceBody
bod
interfaceBody :: P InterfaceBody
interfaceBody :: P InterfaceBody
interfaceBody = [MemberDecl] -> InterfaceBody
InterfaceBody forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
forall a. P a -> P a
braces (forall a. P a -> P [a]
list P (Maybe MemberDecl)
interfaceBodyDecl)
classBodyStatement :: P (Maybe Decl)
classBodyStatement :: P (Maybe Decl)
classBodyStatement =
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
forall a. P a -> P [a]
list1 P ()
semiColon
forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Bool
mst <- forall a. P a -> P Bool
bopt (Token -> P ()
tok Token
KW_Static)
Block
blk <- P Block
block
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Bool -> Block -> Decl
InitDecl Bool
mst Block
blk) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Mod MemberDecl
dec <- P (Mod MemberDecl)
memberDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ MemberDecl -> Decl
MemberDecl (Mod MemberDecl
dec [Modifier]
ms))
memberDecl :: P (Mod MemberDecl)
memberDecl :: P (Mod MemberDecl)
memberDecl =
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Mod ClassDecl
cd <- P (Mod ClassDecl)
classDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> MemberDecl
MemberClassDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Mod InterfaceDecl
id <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> MemberDecl
MemberInterfaceDecl (Mod InterfaceDecl
id [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
fieldDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
methodDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
P (Mod MemberDecl)
constrDecl
fieldDecl :: P (Mod MemberDecl)
fieldDecl :: P (Mod MemberDecl)
fieldDecl = forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Type
typ <- P Type
ttype
[VarDecl]
vds <- P [VarDecl]
varDecls
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier] -> Type -> [VarDecl] -> MemberDecl
FieldDecl [Modifier]
ms Type
typ [VarDecl]
vds
methodDecl :: P (Mod MemberDecl)
methodDecl :: P (Mod MemberDecl)
methodDecl = do
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
Maybe Type
rt <- P (Maybe Type)
resultType
Ident
id <- P Ident
ident
[FormalParam]
fps <- P [FormalParam]
formalParams
[RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
MethodBody
bod <- P MethodBody
methodBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Maybe Type
-> Ident
-> [FormalParam]
-> [RefType]
-> Maybe Argument
-> MethodBody
-> MemberDecl
MethodDecl [Modifier]
ms [TypeParam]
tps Maybe Type
rt Ident
id [FormalParam]
fps [RefType]
thr forall a. Maybe a
Nothing MethodBody
bod
methodBody :: P MethodBody
methodBody :: P MethodBody
methodBody = Maybe Block -> MethodBody
MethodBody forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
(forall a b. a -> b -> a
const forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Block
block)
constrDecl :: P (Mod MemberDecl)
constrDecl :: P (Mod MemberDecl)
constrDecl = do
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
Ident
id <- P Ident
ident
[FormalParam]
fps <- P [FormalParam]
formalParams
[RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
ConstructorBody
bod <- P ConstructorBody
constrBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Ident
-> [FormalParam]
-> [RefType]
-> ConstructorBody
-> MemberDecl
ConstructorDecl [Modifier]
ms [TypeParam]
tps Ident
id [FormalParam]
fps [RefType]
thr ConstructorBody
bod
constrBody :: P ConstructorBody
constrBody :: P ConstructorBody
constrBody = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
Maybe ExplConstrInv
mec <- forall a. P a -> P (Maybe a)
opt (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P ExplConstrInv
explConstrInv)
[BlockStmt]
bss <- forall a. P a -> P [a]
list P BlockStmt
blockStmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ExplConstrInv -> [BlockStmt] -> ConstructorBody
ConstructorBody Maybe ExplConstrInv
mec [BlockStmt]
bss
explConstrInv :: P ExplConstrInv
explConstrInv :: P ExplConstrInv
explConstrInv = forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
[RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Token -> P ()
tok Token
KW_This
[Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> [Argument] -> ExplConstrInv
ThisInvoke [RefType]
tas [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
[RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Token -> P ()
tok Token
KW_Super
[Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> [Argument] -> ExplConstrInv
SuperInvoke [RefType]
tas [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Argument
pri <- P Argument
primary
P ()
period
[RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Token -> P ()
tok Token
KW_Super
[Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [RefType] -> [Argument] -> ExplConstrInv
PrimarySuperInvoke Argument
pri [RefType]
tas [Argument]
as)
interfaceBodyDecl :: P (Maybe MemberDecl)
interfaceBodyDecl :: P (Maybe MemberDecl)
interfaceBodyDecl = P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
do [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Mod MemberDecl
imd <- P (Mod MemberDecl)
interfaceMemberDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (Mod MemberDecl
imd [Modifier]
ms)
interfaceMemberDecl :: P (Mod MemberDecl)
interfaceMemberDecl :: P (Mod MemberDecl)
interfaceMemberDecl =
(do Mod ClassDecl
cd <- P (Mod ClassDecl)
classDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> MemberDecl
MemberClassDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Mod InterfaceDecl
id <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> MemberDecl
MemberInterfaceDecl (Mod InterfaceDecl
id [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
fieldDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
P (Mod MemberDecl)
absMethodDecl
absMethodDecl :: P (Mod MemberDecl)
absMethodDecl :: P (Mod MemberDecl)
absMethodDecl = do
[TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
Maybe Type
rt <- P (Maybe Type)
resultType
Ident
id <- P Ident
ident
[FormalParam]
fps <- P [FormalParam]
formalParams
[RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
Maybe Argument
def <- forall a. P a -> P (Maybe a)
opt P Argument
defaultValue
P ()
semiColon
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Maybe Type
-> Ident
-> [FormalParam]
-> [RefType]
-> Maybe Argument
-> MethodBody
-> MemberDecl
MethodDecl [Modifier]
ms [TypeParam]
tps Maybe Type
rt Ident
id [FormalParam]
fps [RefType]
thr Maybe Argument
def (Maybe Block -> MethodBody
MethodBody forall a. Maybe a
Nothing)
defaultValue :: P Exp
defaultValue :: P Argument
defaultValue = Token -> P ()
tok Token
KW_Default forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Argument
exp
throws :: P [RefType]
throws :: P [RefType]
throws = Token -> P ()
tok Token
KW_Throws forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList
formalParams :: P [FormalParam]
formalParams :: P [FormalParam]
formalParams = forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ do
[FormalParam]
fps <- forall a sep. P a -> P sep -> P [a]
seplist P FormalParam
formalParam P ()
comma
if [FormalParam] -> Bool
validateFPs [FormalParam]
fps
then forall (m :: * -> *) a. Monad m => a -> m a
return [FormalParam]
fps
else forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Only the last formal parameter may be of variable arity"
where validateFPs :: [FormalParam] -> Bool
validateFPs :: [FormalParam] -> Bool
validateFPs [] = Bool
True
validateFPs [FormalParam
_] = Bool
True
validateFPs (FormalParam [Modifier]
_ Type
_ Bool
b VarDeclId
_ :[FormalParam]
xs) = Bool -> Bool
not Bool
b
formalParam :: P FormalParam
formalParam :: P FormalParam
formalParam = do
[Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Type
typ <- P Type
ttype
Bool
var <- forall a. P a -> P Bool
bopt P ()
ellipsis
VarDeclId
vid <- P VarDeclId
varDeclId
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Bool -> VarDeclId -> FormalParam
FormalParam [Modifier]
ms Type
typ Bool
var VarDeclId
vid
ellipsis :: P ()
ellipsis :: P ()
ellipsis = P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
modifier :: P Modifier
modifier :: P Modifier
modifier =
Token -> P ()
tok Token
KW_Public forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Public
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Protected forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Protected
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Private forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Private
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Abstract forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Abstract
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Static forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Static
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Strictfp forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
StrictFP
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Final forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Final
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Native forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Native
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Transient forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Transient
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Volatile forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Volatile
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Synchronized forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Synchronized_
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Annotation -> Modifier
Annotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Annotation
annotation
annotation :: P Annotation
annotation :: P Annotation
annotation = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
($) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Token -> P ()
tok Token
Op_AtSign forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P Name
name forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a b c. (a -> b -> c) -> b -> a -> c
flip Name -> [(Ident, ElementValue)] -> Annotation
NormalAnnotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
parens P [(Ident, ElementValue)]
evlist)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a b c. (a -> b -> c) -> b -> a -> c
flip Name -> ElementValue -> Annotation
SingleElementAnnotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
parens P ElementValue
elementValue)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Name -> Annotation
MarkerAnnotation forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *) a. Monad m => a -> m a
return ())
)
evlist :: P [(Ident, ElementValue)]
evlist :: P [(Ident, ElementValue)]
evlist = forall a sep. P a -> P sep -> P [a]
seplist1 P (Ident, ElementValue)
elementValuePair P ()
comma
elementValuePair :: P (Ident, ElementValue)
elementValuePair :: P (Ident, ElementValue)
elementValuePair = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Ident
ident forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> P ()
tok Token
Op_Equal forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P ElementValue
elementValue
elementValue :: P ElementValue
elementValue :: P ElementValue
elementValue =
VarInit -> ElementValue
EVVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( ArrayInit -> VarInit
InitArray forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ArrayInit
arrayInit
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Argument -> VarInit
InitExp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
condExp )
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Annotation -> ElementValue
EVAnn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Annotation
annotation
varDecls :: P [VarDecl]
varDecls :: P [VarDecl]
varDecls = forall a sep. P a -> P sep -> P [a]
seplist1 P VarDecl
varDecl P ()
comma
varDecl :: P VarDecl
varDecl :: P VarDecl
varDecl = do
VarDeclId
vid <- P VarDeclId
varDeclId
Maybe VarInit
mvi <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
Op_Equal forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> ParsecT [L Token] () Identity VarInit
varInit
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ VarDeclId -> Maybe VarInit -> VarDecl
VarDecl VarDeclId
vid Maybe VarInit
mvi
varDeclId :: P VarDeclId
varDeclId :: P VarDeclId
varDeclId = do
Ident
id <- P Ident
ident
[()]
abs <- forall a. P a -> P [a]
list P ()
arrBrackets
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Ident -> VarDeclId
f ()
_ -> VarDeclId -> VarDeclId
VarDeclArray forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> VarDeclId
f) Ident -> VarDeclId
VarId [()]
abs Ident
id
arrBrackets :: P ()
arrBrackets :: P ()
arrBrackets = forall a. P a -> P a
brackets forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
localVarDecl :: P ([Modifier], Type, [VarDecl])
localVarDecl :: P ([Modifier], Type, [VarDecl])
localVarDecl = do
[Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Type
typ <- P Type
ttype
[VarDecl]
vds <- P [VarDecl]
varDecls
forall (m :: * -> *) a. Monad m => a -> m a
return ([Modifier]
ms, Type
typ, [VarDecl]
vds)
varInit :: P VarInit
varInit :: ParsecT [L Token] () Identity VarInit
varInit =
ArrayInit -> VarInit
InitArray forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ArrayInit
arrayInit forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Argument -> VarInit
InitExp forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
exp
arrayInit :: P ArrayInit
arrayInit :: P ArrayInit
arrayInit = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
[VarInit]
vis <- forall a sep. P a -> P sep -> P [a]
seplist ParsecT [L Token] () Identity VarInit
varInit P ()
comma
forall a. P a -> P (Maybe a)
opt P ()
comma
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [VarInit] -> ArrayInit
ArrayInit [VarInit]
vis
block :: P Block
block :: P Block
block = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ [BlockStmt] -> Block
Block forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P [a]
list P BlockStmt
blockStmt
blockStmt :: P BlockStmt
blockStmt :: P BlockStmt
blockStmt =
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
[Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Mod ClassDecl
cd <- P (Mod ClassDecl)
classDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassDecl -> BlockStmt
LocalClass (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
([Modifier]
m,Type
t,[VarDecl]
vds) <- forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ P ([Modifier], Type, [VarDecl])
localVarDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> [VarDecl] -> BlockStmt
LocalVars [Modifier]
m Type
t [VarDecl]
vds) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Stmt -> BlockStmt
BlockStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Stmt
stmt
stmt :: P Stmt
stmt :: P Stmt
stmt = P Stmt
ifStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
whileStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
forStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
labeledStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
stmtNoTrail
where
ifStmt :: P Stmt
ifStmt = do
Token -> P ()
tok Token
KW_If
Argument
e <- forall a. P a -> P a
parens P Argument
exp
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
do Stmt
th <- P Stmt
stmtNSI
Token -> P ()
tok Token
KW_Else
Stmt
el <- P Stmt
stmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt -> Stmt
IfThenElse Argument
e Stmt
th Stmt
el) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Stmt
th <- P Stmt
stmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
IfThen Argument
e Stmt
th)
whileStmt :: P Stmt
whileStmt = do
Token -> P ()
tok Token
KW_While
Argument
e <- forall a. P a -> P a
parens P Argument
exp
Stmt
s <- P Stmt
stmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
While Argument
e Stmt
s
forStmt :: P Stmt
forStmt = do
Token -> P ()
tok Token
KW_For
Stmt -> Stmt
f <- forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Maybe ForInit
fi <- forall a. P a -> P (Maybe a)
opt P ForInit
forInit
P ()
semiColon
Maybe Argument
e <- forall a. P a -> P (Maybe a)
opt P Argument
exp
P ()
semiColon
Maybe [Argument]
fu <- forall a. P a -> P (Maybe a)
opt P [Argument]
forUp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ForInit -> Maybe Argument -> Maybe [Argument] -> Stmt -> Stmt
BasicFor Maybe ForInit
fi Maybe Argument
e Maybe [Argument]
fu) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Type
t <- P Type
ttype
Ident
i <- P Ident
ident
P ()
colon
Argument
e <- P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Ident -> Argument -> Stmt -> Stmt
EnhancedFor [Modifier]
ms Type
t Ident
i Argument
e)
Stmt
s <- P Stmt
stmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Stmt
f Stmt
s
labeledStmt :: P Stmt
labeledStmt = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Ident
lbl <- P Ident
ident
P ()
colon
Stmt
s <- P Stmt
stmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Stmt -> Stmt
Labeled Ident
lbl Stmt
s
stmtNSI :: P Stmt
stmtNSI :: P Stmt
stmtNSI = P Stmt
ifStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
whileStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
forStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
labeledStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
stmtNoTrail
where
ifStmt :: P Stmt
ifStmt = do
Token -> P ()
tok Token
KW_If
Argument
e <- forall a. P a -> P a
parens P Argument
exp
Stmt
th <- P Stmt
stmtNSI
Token -> P ()
tok Token
KW_Else
Stmt
el <- P Stmt
stmtNSI
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt -> Stmt
IfThenElse Argument
e Stmt
th Stmt
el
whileStmt :: P Stmt
whileStmt = do
Token -> P ()
tok Token
KW_While
Argument
e <- forall a. P a -> P a
parens P Argument
exp
Stmt
s <- P Stmt
stmtNSI
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
While Argument
e Stmt
s
forStmt :: P Stmt
forStmt = do
Token -> P ()
tok Token
KW_For
Stmt -> Stmt
f <- forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Maybe ForInit
fi <- forall a. P a -> P (Maybe a)
opt P ForInit
forInit
P ()
semiColon
Maybe Argument
e <- forall a. P a -> P (Maybe a)
opt P Argument
exp
P ()
semiColon
Maybe [Argument]
fu <- forall a. P a -> P (Maybe a)
opt P [Argument]
forUp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ForInit -> Maybe Argument -> Maybe [Argument] -> Stmt -> Stmt
BasicFor Maybe ForInit
fi Maybe Argument
e Maybe [Argument]
fu)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (do
[Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
Type
t <- P Type
ttype
Ident
i <- P Ident
ident
P ()
colon
Argument
e <- P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Ident -> Argument -> Stmt -> Stmt
EnhancedFor [Modifier]
ms Type
t Ident
i Argument
e)
Stmt
s <- P Stmt
stmtNSI
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Stmt
f Stmt
s
labeledStmt :: P Stmt
labeledStmt = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Ident
i <- P Ident
ident
P ()
colon
Stmt
s <- P Stmt
stmtNSI
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Stmt -> Stmt
Labeled Ident
i Stmt
s
stmtNoTrail :: P Stmt
stmtNoTrail :: P Stmt
stmtNoTrail =
forall a b. a -> b -> a
const Stmt
Empty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Block -> Stmt
StmtBlock forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Block
block forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Assert
Argument
e <- P Argument
exp
Maybe Argument
me2 <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ P ()
colon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Maybe Argument -> Stmt
Assert Argument
e Maybe Argument
me2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Token -> P ()
tok Token
KW_Switch
Argument
e <- forall a. P a -> P a
parens P Argument
exp
[SwitchBlock]
sb <- P [SwitchBlock]
switchBlock
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [SwitchBlock] -> Stmt
Switch Argument
e [SwitchBlock]
sb) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Do
Stmt
s <- P Stmt
stmt
Token -> P ()
tok Token
KW_While
Argument
e <- forall a. P a -> P a
parens P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Argument -> Stmt
Do Stmt
s Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Break
Maybe Ident
mi <- forall a. P a -> P (Maybe a)
opt P Ident
ident
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Ident -> Stmt
Break Maybe Ident
mi) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Continue
Maybe Ident
mi <- forall a. P a -> P (Maybe a)
opt P Ident
ident
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Ident -> Stmt
Continue Maybe Ident
mi) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Return
Maybe Argument
me <- forall a. P a -> P (Maybe a)
opt P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Argument -> Stmt
Return Maybe Argument
me) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Token -> P ()
tok Token
KW_Synchronized
Argument
e <- forall a. P a -> P a
parens P Argument
exp
Block
b <- P Block
block
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Block -> Stmt
Synchronized Argument
e Block
b) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
KW_Throw
Argument
e <- P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt
Throw Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Token -> P ()
tok Token
KW_Try
Block
b <- P Block
block
[Catch]
c <- forall a. P a -> P [a]
list P Catch
catch
Maybe Block
mf <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
KW_Finally forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Block
block
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Block -> [Catch] -> Maybe Block -> Stmt
Try Block
b [Catch]
c Maybe Block
mf) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Argument -> Stmt
ExpStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
endSemi P Argument
stmtExp
forInit :: P ForInit
forInit :: P ForInit
forInit = (do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do ([Modifier]
m,Type
t,[VarDecl]
vds) <- P ([Modifier], Type, [VarDecl])
localVarDecl
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> [VarDecl] -> ForInit
ForLocalVars [Modifier]
m Type
t [VarDecl]
vds)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall a sep. P a -> P sep -> P [a]
seplist1 P Argument
stmtExp P ()
comma forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Argument] -> ForInit
ForInitExps)
forUp :: P [Exp]
forUp :: P [Argument]
forUp = forall a sep. P a -> P sep -> P [a]
seplist1 P Argument
stmtExp P ()
comma
switchBlock :: P [SwitchBlock]
switchBlock :: P [SwitchBlock]
switchBlock = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ forall a. P a -> P [a]
list P SwitchBlock
switchStmt
switchStmt :: P SwitchBlock
switchStmt :: P SwitchBlock
switchStmt = do
SwitchLabel
lbl <- P SwitchLabel
switchLabel
[BlockStmt]
bss <- forall a. P a -> P [a]
list P BlockStmt
blockStmt
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SwitchLabel -> [BlockStmt] -> SwitchBlock
SwitchBlock SwitchLabel
lbl [BlockStmt]
bss
switchLabel :: P SwitchLabel
switchLabel :: P SwitchLabel
switchLabel = (Token -> P ()
tok Token
KW_Default forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
colon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SwitchLabel
Default) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Token -> P ()
tok Token
KW_Case
Argument
e <- P Argument
exp
P ()
colon
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> SwitchLabel
SwitchCase Argument
e)
catch :: P Catch
catch :: P Catch
catch = do
Token -> P ()
tok Token
KW_Catch
FormalParam
fp <- forall a. P a -> P a
parens P FormalParam
formalParam
Block
b <- P Block
block
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ FormalParam -> Block -> Catch
Catch FormalParam
fp Block
b
stmtExp :: P Exp
stmtExp :: P Argument
stmtExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
preIncDec
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
postIncDec
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
assignment
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodInvocationExp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
lambdaExp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodRef
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
instanceCreation
preIncDec :: P Exp
preIncDec :: P Argument
preIncDec = do
Argument -> Argument
op <- P (Argument -> Argument)
preIncDecOp
Argument
e <- P Argument
unaryExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Argument
op Argument
e
postIncDec :: P Exp
postIncDec :: P Argument
postIncDec = do
Argument
e <- P Argument
postfixExpNES
[Argument -> Argument]
ops <- forall a. P a -> P [a]
list1 P (Argument -> Argument)
postfixOp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
e [Argument -> Argument]
ops
assignment :: P Exp
assignment :: P Argument
assignment = do
Lhs
lh <- P Lhs
lhs
AssignOp
op <- P AssignOp
assignOp
Argument
e <- P Argument
assignExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Lhs -> AssignOp -> Argument -> Argument
Assign Lhs
lh AssignOp
op Argument
e
lhs :: P Lhs
lhs :: P Lhs
lhs = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (FieldAccess -> Lhs
FieldLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P FieldAccess
fieldAccess)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ArrayIndex -> Lhs
ArrayLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [L Token] () Identity ArrayIndex
arrayAccess)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Name -> Lhs
NameLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Name
name
exp :: P Exp
exp :: P Argument
exp = P Argument
assignExp
assignExp :: P Exp
assignExp :: P Argument
assignExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodRef forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
lambdaExp forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
assignment forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
condExp
condExp :: P Exp
condExp :: P Argument
condExp = do
Argument
ie <- P Argument
infixExp
[Argument -> Argument]
ces <- forall a. P a -> P [a]
list P (Argument -> Argument)
condExpSuffix
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
ie [Argument -> Argument]
ces
condExpSuffix :: P (Exp -> Exp)
condExpSuffix :: P (Argument -> Argument)
condExpSuffix = do
Token -> P ()
tok Token
Op_Query
Argument
th <- P Argument
exp
P ()
colon
Argument
el <- P Argument
condExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ce -> Argument -> Argument -> Argument -> Argument
Cond Argument
ce Argument
th Argument
el
infixExp :: P Exp
infixExp :: P Argument
infixExp = do
Argument
ue <- P Argument
unaryExp
[Argument -> Argument]
ies <- forall a. P a -> P [a]
list P (Argument -> Argument)
infixExpSuffix
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
ue [Argument -> Argument]
ies
infixExpSuffix :: P (Exp -> Exp)
infixExpSuffix :: P (Argument -> Argument)
infixExpSuffix =
(do
Op
op <- P Op
infixCombineOp
Argument
ie2 <- P Argument
infixExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ie1 -> Argument -> Op -> Argument -> Argument
BinOp Argument
ie1 Op
op Argument
ie2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Op
op <- P Op
infixOp
Argument
e2 <- P Argument
unaryExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
e1 -> Argument -> Op -> Argument -> Argument
BinOp Argument
e1 Op
op Argument
e2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Token -> P ()
tok Token
KW_Instanceof
RefType
t <- P RefType
refType
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
e1 -> Argument -> RefType -> Argument
InstanceOf Argument
e1 RefType
t)
unaryExp :: P Exp
unaryExp :: P Argument
unaryExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
preIncDec forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
Argument -> Argument
op <- P (Argument -> Argument)
prefixOp
Argument
ue <- P Argument
unaryExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Argument
op Argument
ue) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
Type
t <- forall a. P a -> P a
parens P Type
ttype
Argument
e <- P Argument
unaryExp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Type -> Argument -> Argument
Cast Type
t Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
P Argument
postfixExp
postfixExpNES :: P Exp
postfixExpNES :: P Argument
postfixExpNES =
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
primary forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Name -> Argument
ExpName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Name
name
postfixExp :: P Exp
postfixExp :: P Argument
postfixExp = do
Argument
pe <- P Argument
postfixExpNES
[Argument -> Argument]
ops <- forall a. P a -> P [a]
list P (Argument -> Argument)
postfixOp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
pe [Argument -> Argument]
ops
primary :: P Exp
primary :: P Argument
primary = P Argument
primaryNPS forall a. P a -> P (a -> a) -> P a
|>> P (Argument -> Argument)
primarySuffix
primaryNPS :: P Exp
primaryNPS :: P Argument
primaryNPS = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
arrayCreation forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
primaryNoNewArrayNPS
primaryNoNewArray :: P Argument
primaryNoNewArray = forall a. P a -> P (a -> a) -> P a
startSuff P Argument
primaryNoNewArrayNPS P (Argument -> Argument)
primarySuffix
primaryNoNewArrayNPS :: P Exp
primaryNoNewArrayNPS :: P Argument
primaryNoNewArrayNPS =
Literal -> Argument
Lit forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Literal
literal forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall a b. a -> b -> a
const Argument
This forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> P ()
tok Token
KW_This forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall a. P a -> P a
parens P Argument
exp forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Maybe Type
rt <- P (Maybe Type)
resultType
P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_Class
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Type -> Argument
ClassLit Maybe Type
rt) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Name
n <- P Name
name
P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_This
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> Argument
ThisClass Name
n) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
instanceCreationNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (MethodInvocation -> Argument
MethodInv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P MethodInvocation
methodInvocationNPS) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (FieldAccess -> Argument
FieldAccess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P FieldAccess
fieldAccessNPS) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
ArrayIndex -> Argument
ArrayAccess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS
primarySuffix :: P (Exp -> Exp)
primarySuffix :: P (Argument -> Argument)
primarySuffix = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Argument -> Argument)
instanceCreationSuffix forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((ArrayIndex -> Argument
ArrayAccess forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> ArrayIndex)
arrayAccessSuffix) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((MethodInvocation -> Argument
MethodInv forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> MethodInvocation)
methodInvocationSuffix) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(FieldAccess -> Argument
FieldAccess forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> FieldAccess)
fieldAccessSuffix
instanceCreationNPS :: P Exp
instanceCreationNPS :: P Argument
instanceCreationNPS =
do Token -> P ()
tok Token
KW_New
[TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
TypeDeclSpecifier
tds <- P TypeDeclSpecifier
typeDeclSpecifier
[Argument]
as <- P [Argument]
args
Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [TypeArgument]
-> TypeDeclSpecifier -> [Argument] -> Maybe ClassBody -> Argument
InstanceCreation [TypeArgument]
tas TypeDeclSpecifier
tds [Argument]
as Maybe ClassBody
mcb
typeDeclSpecifier :: P TypeDeclSpecifier
typeDeclSpecifier :: P TypeDeclSpecifier
typeDeclSpecifier =
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do ClassType
ct <- P ClassType
classType
P ()
period
Ident
i <- P Ident
ident
Token -> P ()
tok Token
Op_LThan
Token -> P ()
tok Token
Op_GThan
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassType -> Ident -> Diamond -> TypeDeclSpecifier
TypeDeclSpecifierWithDiamond ClassType
ct Ident
i Diamond
Diamond
) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do Ident
i <- P Ident
ident
Token -> P ()
tok Token
Op_LThan
Token -> P ()
tok Token
Op_GThan
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Diamond -> TypeDeclSpecifier
TypeDeclSpecifierUnqualifiedWithDiamond Ident
i Diamond
Diamond
) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do ClassType
ct <- P ClassType
classType
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassType -> TypeDeclSpecifier
TypeDeclSpecifier ClassType
ct
)
instanceCreationSuffix :: P (Exp -> Exp)
instanceCreationSuffix :: P (Argument -> Argument)
instanceCreationSuffix =
do P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_New
[TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
Ident
i <- P Ident
ident
[Argument]
as <- P [Argument]
args
Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument
-> [TypeArgument]
-> Ident
-> [Argument]
-> Maybe ClassBody
-> Argument
QualInstanceCreation Argument
p [TypeArgument]
tas Ident
i [Argument]
as Maybe ClassBody
mcb
instanceCreation :: P Exp
instanceCreation :: P Argument
instanceCreation = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
instanceCreationNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
Argument
p <- P Argument
primaryNPS
[Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
let icp :: Argument
icp = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
case Argument
icp of
QualInstanceCreation {} -> forall (m :: * -> *) a. Monad m => a -> m a
return Argument
icp
Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""
lambdaParams :: P LambdaParams
lambdaParams :: P LambdaParams
lambdaParams = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Ident -> LambdaParams
LambdaSingleParam forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Ident
ident)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ [FormalParam] -> LambdaParams
LambdaFormalParams forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a sep. P a -> P sep -> P [a]
seplist P FormalParam
formalParam P ()
comma))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ [Ident] -> LambdaParams
LambdaInferredParams forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a sep. P a -> P sep -> P [a]
seplist P Ident
ident P ()
comma))
lambdaExp :: P Exp
lambdaExp :: P Argument
lambdaExp = LambdaParams -> LambdaExpression -> Argument
Lambda
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (P LambdaParams
lambdaParams forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Token -> P ()
tok Token
LambdaArrow))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Block -> LambdaExpression
LambdaBlock forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Block
block))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Argument -> LambdaExpression
LambdaExpression forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
exp))
methodRef :: P Exp
methodRef :: P Argument
methodRef = Name -> Ident -> Argument
MethodRef
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (P Name
name forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Token -> P ()
tok Token
MethodRefSep))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P Ident
ident
fieldAccessNPS :: P FieldAccess
fieldAccessNPS :: P FieldAccess
fieldAccessNPS =
(do Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
Ident
i <- P Ident
ident
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> FieldAccess
SuperFieldAccess Ident
i) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Name
n <- P Name
name
P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
Ident
i <- P Ident
ident
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> Ident -> FieldAccess
ClassFieldAccess Name
n Ident
i)
fieldAccessSuffix :: P (Exp -> FieldAccess)
fieldAccessSuffix :: P (Argument -> FieldAccess)
fieldAccessSuffix = do
P ()
period
Ident
i <- P Ident
ident
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument -> Ident -> FieldAccess
PrimaryFieldAccess Argument
p Ident
i
fieldAccess :: P FieldAccess
fieldAccess :: P FieldAccess
fieldAccess = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P FieldAccess
fieldAccessNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
Argument
p <- P Argument
primaryNPS
[Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
let fap :: Argument
fap = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
case Argument
fap of
FieldAccess FieldAccess
fa -> forall (m :: * -> *) a. Monad m => a -> m a
return FieldAccess
fa
Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""
methodInvocationNPS :: P MethodInvocation
methodInvocationNPS :: P MethodInvocation
methodInvocationNPS =
(do Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
[RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Ident
i <- P Ident
ident
[Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> Ident -> [Argument] -> MethodInvocation
SuperMethodCall [RefType]
rts Ident
i [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do Name
n <- P Name
name
Name -> MethodInvocation
f <- (do [Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Name
n -> Name -> [Argument] -> MethodInvocation
MethodCall Name
n [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> do
Maybe ()
msp <- forall a. P a -> P (Maybe a)
opt (Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period)
[RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Ident
i <- P Ident
ident
[Argument]
as <- P [Argument]
args
let mc :: Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
mc = forall b a. b -> (a -> b) -> Maybe a -> b
maybe Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
TypeMethodCall (forall a b. a -> b -> a
const Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
ClassMethodCall) Maybe ()
msp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Name
n -> Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
mc Name
n [RefType]
rts Ident
i [Argument]
as)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> MethodInvocation
f Name
n)
methodInvocationSuffix :: P (Exp -> MethodInvocation)
methodInvocationSuffix :: P (Argument -> MethodInvocation)
methodInvocationSuffix = do
P ()
period
[RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
Ident
i <- P Ident
ident
[Argument]
as <- P [Argument]
args
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument -> [RefType] -> Ident -> [Argument] -> MethodInvocation
PrimaryMethodCall Argument
p [] Ident
i [Argument]
as
methodInvocationExp :: P Exp
methodInvocationExp :: P Argument
methodInvocationExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
Argument
p <- P Argument
primaryNPS
[Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
let mip :: Argument
mip = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
case Argument
mip of
MethodInv MethodInvocation
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Argument
mip
Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"") forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(MethodInvocation -> Argument
MethodInv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P MethodInvocation
methodInvocationNPS)
args :: P [Argument]
args :: P [Argument]
args = forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist P Argument
exp P ()
comma
arrayAccessNPS :: P ArrayIndex
arrayAccessNPS :: ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS = do
Name
n <- P Name
name
[Argument]
e <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [Argument] -> ArrayIndex
ArrayIndex (Name -> Argument
ExpName Name
n) [Argument]
e
arrayAccessSuffix :: P (Exp -> ArrayIndex)
arrayAccessSuffix :: P (Argument -> ArrayIndex)
arrayAccessSuffix = do
[Argument]
e <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ref -> Argument -> [Argument] -> ArrayIndex
ArrayIndex Argument
ref [Argument]
e
arrayAccess :: ParsecT [L Token] () Identity ArrayIndex
arrayAccess = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
Argument
p <- P Argument
primaryNoNewArrayNPS
[Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
let aap :: Argument
aap = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
case Argument
aap of
ArrayAccess ArrayIndex
ain -> forall (m :: * -> *) a. Monad m => a -> m a
return ArrayIndex
ain
Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""
arrayCreation :: P Exp
arrayCreation :: P Argument
arrayCreation = do
Token -> P ()
tok Token
KW_New
Type
t <- P Type
nonArrayType
Type -> Argument
f <- (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
[()]
ds <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P ()
empty
ArrayInit
ai <- P ArrayInit
arrayInit
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Type
t -> Type -> Int -> ArrayInit -> Argument
ArrayCreateInit Type
t (forall (t :: * -> *) a. Foldable t => t a -> Int
length [()]
ds) ArrayInit
ai) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do [Argument]
des <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
[()]
ds <- forall a. P a -> P [a]
list forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P ()
empty
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Type
t -> Type -> [Argument] -> Int -> Argument
ArrayCreate Type
t [Argument]
des (forall (t :: * -> *) a. Foldable t => t a -> Int
length [()]
ds))
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Type -> Argument
f Type
t
literal :: P Literal
literal :: P Literal
literal =
forall a. (Token -> Maybe a) -> P a
javaToken forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
IntTok Integer
i -> forall a. a -> Maybe a
Just (Integer -> Literal
Int Integer
i)
LongTok Integer
l -> forall a. a -> Maybe a
Just (Integer -> Literal
Word Integer
l)
DoubleTok Double
d -> forall a. a -> Maybe a
Just (Double -> Literal
Double Double
d)
FloatTok Double
f -> forall a. a -> Maybe a
Just (Double -> Literal
Float Double
f)
CharTok Char
c -> forall a. a -> Maybe a
Just (Char -> Literal
Char Char
c)
StringTok String
s -> forall a. a -> Maybe a
Just (String -> Literal
String String
s)
BoolTok Bool
b -> forall a. a -> Maybe a
Just (Bool -> Literal
Boolean Bool
b)
Token
NullTok -> forall a. a -> Maybe a
Just Literal
Null
Token
_ -> forall a. Maybe a
Nothing
preIncDecOp, prefixOp, postfixOp :: P (Exp -> Exp)
preIncDecOp :: P (Argument -> Argument)
preIncDecOp =
(Token -> P ()
tok Token
Op_PPlus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreIncrement) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_MMinus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreDecrement)
prefixOp :: P (Argument -> Argument)
prefixOp =
(Token -> P ()
tok Token
Op_Bang forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreNot ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Tilde forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreBitCompl ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Plus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PrePlus ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Minus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreMinus )
postfixOp :: P (Argument -> Argument)
postfixOp =
(Token -> P ()
tok Token
Op_PPlus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PostIncrement) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_MMinus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PostDecrement)
assignOp :: P AssignOp
assignOp :: P AssignOp
assignOp =
(Token -> P ()
tok Token
Op_Equal forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
EqualA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_StarE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
MultA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_SlashE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
DivA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_PercentE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RemA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_PlusE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
AddA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_MinusE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
SubA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_LShiftE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
LShiftA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_RShiftE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RShiftA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_RRShiftE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RRShiftA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_AndE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
AndA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_CaretE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
XorA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_OrE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
OrA )
infixCombineOp :: P Op
infixCombineOp :: P Op
infixCombineOp =
(Token -> P ()
tok Token
Op_And forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
And ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Caret forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Xor ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Or forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Or ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_AAnd forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
CAnd ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_OOr forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
COr )
infixOp :: P Op
infixOp :: P Op
infixOp =
(Token -> P ()
tok Token
Op_Star forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Mult ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Slash forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Div ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Percent forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Rem ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Plus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Add ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Minus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Sub ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_LShift forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LShift ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_LThan forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LThan ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
Op_GThan
Token -> P ()
tok Token
Op_GThan
Token -> P ()
tok Token
Op_GThan
forall (m :: * -> *) a. Monad m => a -> m a
return Op
RRShift ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
Token -> P ()
tok Token
Op_GThan
Token -> P ()
tok Token
Op_GThan
forall (m :: * -> *) a. Monad m => a -> m a
return Op
RShift ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_GThan forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
GThan ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_LThanE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LThanE ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_GThanE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
GThanE ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_Equals forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Equal ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(Token -> P ()
tok Token
Op_BangE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
NotEq )
ttype :: P Type
ttype :: P Type
ttype = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (RefType -> Type
RefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> PrimType -> Type
PrimType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P PrimType
primType
primType :: P PrimType
primType :: P PrimType
primType =
Token -> P ()
tok Token
KW_Boolean forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
BooleanT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Byte forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
ByteT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Short forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
ShortT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Int forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
IntT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Long forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
LongT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Char forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
CharT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Float forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
FloatT forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
Token -> P ()
tok Token
KW_Double forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
DoubleT
refType :: P RefType
refType :: P RefType
refType =
(do PrimType
pt <- P PrimType
primType
(()
_:[()]
bs) <- forall a. P a -> P [a]
list1 P ()
arrBrackets
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\PrimType -> RefType
f ()
_ -> Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. RefType -> Type
RefType forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimType -> RefType
f)
(Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimType -> Type
PrimType) [()]
bs PrimType
pt) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
(do ClassType
ct <- P ClassType
classType
[()]
bs <- forall a. P a -> P [a]
list P ()
arrBrackets
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\ClassType -> RefType
f ()
_ -> Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. RefType -> Type
RefType forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClassType -> RefType
f)
ClassType -> RefType
ClassRefType [()]
bs ClassType
ct) forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"refType"
nonArrayType :: P Type
nonArrayType :: P Type
nonArrayType = PrimType -> Type
PrimType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P PrimType
primType forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
RefType -> Type
RefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ClassType -> RefType
ClassRefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ClassType
classType
classType :: P ClassType
classType :: P ClassType
classType = [(Ident, [TypeArgument])] -> ClassType
ClassType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a sep. P a -> P sep -> P [a]
seplist1 P (Ident, [TypeArgument])
classTypeSpec P ()
period
classTypeSpec :: P (Ident, [TypeArgument])
classTypeSpec :: P (Ident, [TypeArgument])
classTypeSpec = do
Ident
i <- P Ident
ident
[TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident
i, [TypeArgument]
tas)
resultType :: P (Maybe Type)
resultType :: P (Maybe Type)
resultType = Token -> P ()
tok Token
KW_Void forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Type
ttype forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"resultType"
refTypeList :: P [RefType]
refTypeList :: P [RefType]
refTypeList = forall a sep. P a -> P sep -> P [a]
seplist1 P RefType
refType P ()
comma
typeParams :: P [TypeParam]
typeParams :: P [TypeParam]
typeParams = forall a. P a -> P a
angles forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P TypeParam
typeParam P ()
comma
typeParam :: P TypeParam
typeParam :: P TypeParam
typeParam = do
Ident
i <- P Ident
ident
[RefType]
bs <- forall a. P [a] -> P [a]
lopt P [RefType]
bounds
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> [RefType] -> TypeParam
TypeParam Ident
i [RefType]
bs
bounds :: P [RefType]
bounds :: P [RefType]
bounds = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall a sep. P a -> P sep -> P [a]
seplist1 P RefType
refType (Token -> P ()
tok Token
Op_And)
typeArgs :: P [TypeArgument]
typeArgs :: P [TypeArgument]
typeArgs = forall a. P a -> P a
angles forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P TypeArgument
typeArg P ()
comma
typeArg :: P TypeArgument
typeArg :: P TypeArgument
typeArg = Token -> P ()
tok Token
Op_Query forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Maybe WildcardBound -> TypeArgument
Wildcard forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P (Maybe a)
opt P WildcardBound
wildcardBound
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> RefType -> TypeArgument
ActualType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType
wildcardBound :: P WildcardBound
wildcardBound :: P WildcardBound
wildcardBound = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> RefType -> WildcardBound
ExtendsBound forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> RefType -> WildcardBound
SuperBound forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType
refTypeArgs :: P [RefType]
refTypeArgs :: P [RefType]
refTypeArgs = forall a. P a -> P a
angles P [RefType]
refTypeList
name :: P Name
name :: P Name
name = [Ident] -> Name
Name forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a sep. P a -> P sep -> P [a]
seplist1 P Ident
ident P ()
period
ident :: P Ident
ident :: P Ident
ident = forall a. (Token -> Maybe a) -> P a
javaToken forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
IdentTok String
s -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ String -> Ident
Ident String
s
Token
_ -> forall a. Maybe a
Nothing
empty :: P ()
empty :: P ()
empty = forall (m :: * -> *) a. Monad m => a -> m a
return ()
opt :: P a -> P (Maybe a)
opt :: forall a. P a -> P (Maybe a)
opt = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe
bopt :: P a -> P Bool
bopt :: forall a. P a -> P Bool
bopt P a
p = forall a. P a -> P (Maybe a)
opt P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \Maybe a
ma -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Maybe a -> Bool
isJust Maybe a
ma
lopt :: P [a] -> P [a]
lopt :: forall a. P [a] -> P [a]
lopt P [a]
p = do Maybe [a]
mas <- forall a. P a -> P (Maybe a)
opt P [a]
p
case Maybe [a]
mas of
Maybe [a]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return []
Just [a]
as -> forall (m :: * -> *) a. Monad m => a -> m a
return [a]
as
list :: P a -> P [a]
list :: forall a. P a -> P [a]
list = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. P a -> P [a]
list1
list1 :: P a -> P [a]
list1 :: forall a. P a -> P [a]
list1 = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1
seplist :: P a -> P sep -> P [a]
seplist :: forall a sep. P a -> P sep -> P [a]
seplist P a
p P sep
sep = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep
seplist1 :: P a -> P sep -> P [a]
seplist1 :: forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep =
P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \a
a ->
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do P sep
sep
[a]
as <- forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep
forall (m :: * -> *) a. Monad m => a -> m a
return (a
aforall a. a -> [a] -> [a]
:[a]
as))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return [a
a]
startSuff, (|>>) :: P a -> P (a -> a) -> P a
startSuff :: forall a. P a -> P (a -> a) -> P a
startSuff P a
start P (a -> a)
suffix = do
a
x <- P a
start
[a -> a]
ss <- forall a. P a -> P [a]
list P (a -> a)
suffix
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\a
a a -> a
s -> a -> a
s a
a) a
x [a -> a]
ss
|>> :: forall a. P a -> P (a -> a) -> P a
(|>>) = forall a. P a -> P (a -> a) -> P a
startSuff
javaToken :: (Token -> Maybe a) -> P a
javaToken :: forall a. (Token -> Maybe a) -> P a
javaToken Token -> Maybe a
test = forall s t a u.
Stream s Identity t =>
(t -> String) -> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
token forall {a}. Show a => L a -> String
showT forall {a}. L a -> SourcePos
posT L Token -> Maybe a
testT
where showT :: L a -> String
showT (L Pos
_ a
t) = forall a. Show a => a -> String
show a
t
posT :: L a -> SourcePos
posT (L Pos
p a
_) = Pos -> SourcePos
pos2sourcePos Pos
p
testT :: L Token -> Maybe a
testT (L Pos
_ Token
t) = Token -> Maybe a
test Token
t
tok, matchToken :: Token -> P ()
tok :: Token -> P ()
tok = Token -> P ()
matchToken
matchToken :: Token -> P ()
matchToken Token
t = forall a. (Token -> Maybe a) -> P a
javaToken (\Token
r -> if Token
r forall a. Eq a => a -> a -> Bool
== Token
t then forall a. a -> Maybe a
Just () else forall a. Maybe a
Nothing)
pos2sourcePos :: (Int, Int) -> SourcePos
pos2sourcePos :: Pos -> SourcePos
pos2sourcePos (Int
l,Int
c) = String -> Int -> Int -> SourcePos
newPos String
"" Int
l Int
c
type Mod a = [Modifier] -> a
parens, braces, brackets, angles :: P a -> P a
parens :: forall a. P a -> P a
parens = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenParen) (Token -> P ()
tok Token
CloseParen)
braces :: forall a. P a -> P a
braces = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenCurly) (Token -> P ()
tok Token
CloseCurly)
brackets :: forall a. P a -> P a
brackets = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenSquare) (Token -> P ()
tok Token
CloseSquare)
angles :: forall a. P a -> P a
angles = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
Op_LThan) (Token -> P ()
tok Token
Op_GThan)
endSemi :: P a -> P a
endSemi :: forall a. P a -> P a
endSemi P a
p = P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \a
a -> P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return a
a
comma, colon, semiColon, period :: P ()
comma :: P ()
comma = Token -> P ()
tok Token
Comma
colon :: P ()
colon = Token -> P ()
tok Token
Op_Colon
semiColon :: P ()
semiColon = Token -> P ()
tok Token
SemiColon
period :: P ()
period = Token -> P ()
tok Token
Period
test :: String
test = String
"public class Foo { }"
testFile :: String -> IO ()
testFile String
file = do
String
i <- String -> IO String
readFile String
file
let r :: Either ParseError CompilationUnit
r = String -> Either ParseError CompilationUnit
parseCompilationUnit String
i
String -> IO ()
putStrLnforall a b. (a -> b) -> a -> b
$ forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ((String
"Parsing error:\n"forall a. [a] -> [a] -> [a]
++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show) (forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty a => a -> Doc
pretty) Either ParseError CompilationUnit
r