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