{-# 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 ( (<$>), (<$), (<*) )
-- Since I cba to find the instance Monad m => Applicative m declaration.
(<*>) :: Monad m => m (a -> b) -> m a -> m b
(<*>) = ap
infixl 4 <*>
#else
import Control.Applicative ( (<$>), (<$), (<*), (<*>) )
#endif

type P = Parsec [L Token] ()

-- A trick to allow >> and >>=, normally infixr 1, to be
-- used inside branches of <|>, which is declared as infixl 1.
-- There are no clashes with other operators of precedence 2.
>> :: ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
(>>) = forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(P.>>)
>>= :: ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
(>>=) = forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(P.>>=)
infixr 2 >>, >>=
-- Note also when reading that <$> is infixl 4 and thus has
-- lower precedence than all the others (>>, >>=, and <|>).

----------------------------------------------------------------------------
-- Top-level parsing

parseCompilationUnit :: String -> Either ParseError CompilationUnit
parseCompilationUnit :: String -> Either ParseError CompilationUnit
parseCompilationUnit String
inp =
    forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser P CompilationUnit
compilationUnit () String
"" (String -> [L Token]
lexer String
inp)

parser :: Parsec [L Token] () a -> String -> Either ParseError a
parser Parsec [L Token] () a
p = forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser Parsec [L Token] () a
p () String
"" forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [L Token]
lexer

--class Parse a where
--  parse :: String -> a

----------------------------------------------------------------------------
-- Packages and compilation units

compilationUnit :: P CompilationUnit
compilationUnit :: P CompilationUnit
compilationUnit = do
    Maybe PackageDecl
mpd <- forall a. P a -> P (Maybe a)
opt P PackageDecl
packageDecl
    [ImportDecl]
ids <- forall a. P a -> P [a]
list P ImportDecl
importDecl
    [Maybe TypeDecl]
tds <- forall a. P a -> P [a]
list P (Maybe TypeDecl)
typeDecl
    forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe PackageDecl -> [ImportDecl] -> [TypeDecl] -> CompilationUnit
CompilationUnit Maybe PackageDecl
mpd [ImportDecl]
ids (forall a. [Maybe a] -> [a]
catMaybes [Maybe TypeDecl]
tds)

packageDecl :: P PackageDecl
packageDecl :: P PackageDecl
packageDecl = do
    Token -> P ()
tok Token
KW_Package
    Name
n <- P Name
name
    P ()
semiColon
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> PackageDecl
PackageDecl Name
n

importDecl :: P ImportDecl
importDecl :: P ImportDecl
importDecl = do
    Token -> P ()
tok Token
KW_Import
    Bool
st <- forall a. P a -> P Bool
bopt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
KW_Static
    Name
n  <- P Name
name
    Bool
ds <- forall a. P a -> P Bool
bopt forall a b. (a -> b) -> a -> b
$ P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
Op_Star
    P ()
semiColon
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool -> Name -> Bool -> ImportDecl
ImportDecl Bool
st Name
n Bool
ds

typeDecl :: P (Maybe TypeDecl)
typeDecl :: P (Maybe TypeDecl)
typeDecl = forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P TypeDecl
classOrInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
            forall a b. a -> b -> a
const forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon

----------------------------------------------------------------------------
-- Declarations

-- Class declarations

classOrInterfaceDecl :: P TypeDecl
classOrInterfaceDecl :: P TypeDecl
classOrInterfaceDecl = do
    [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
    [Modifier] -> TypeDecl
de <- (do Mod ClassDecl
cd <- P (Mod ClassDecl)
classDecl
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> TypeDecl
ClassTypeDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
          (do Mod InterfaceDecl
id <- ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> TypeDecl
InterfaceTypeDecl (Mod InterfaceDecl
id [Modifier]
ms))
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> TypeDecl
de [Modifier]
ms

classDecl :: P (Mod ClassDecl)
classDecl :: P (Mod ClassDecl)
classDecl = P (Mod ClassDecl)
normalClassDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P (Mod ClassDecl)
enumClassDecl

normalClassDecl :: P (Mod ClassDecl)
normalClassDecl :: P (Mod ClassDecl)
normalClassDecl = do
    Token -> P ()
tok Token
KW_Class
    Ident
i   <- P Ident
ident
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    Maybe [RefType]
mex <- forall a. P a -> P (Maybe a)
opt P [RefType]
extends
    [RefType]
imp <- forall a. P [a] -> P [a]
lopt P [RefType]
implements
    ClassBody
bod <- P ClassBody
classBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> Ident
-> [TypeParam]
-> Maybe RefType
-> [RefType]
-> ClassBody
-> ClassDecl
ClassDecl [Modifier]
ms Ident
i [TypeParam]
tps ((forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> a
head) Maybe [RefType]
mex) [RefType]
imp ClassBody
bod

extends :: P [RefType]
extends :: P [RefType]
extends = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList

implements :: P [RefType]
implements :: P [RefType]
implements = Token -> P ()
tok Token
KW_Implements forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList

enumClassDecl :: P (Mod ClassDecl)
enumClassDecl :: P (Mod ClassDecl)
enumClassDecl = do
    Token -> P ()
tok Token
KW_Enum
    Ident
i   <- P Ident
ident
    [RefType]
imp <- forall a. P [a] -> P [a]
lopt P [RefType]
implements
    EnumBody
bod <- P EnumBody
enumBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier] -> Ident -> [RefType] -> EnumBody -> ClassDecl
EnumDecl [Modifier]
ms Ident
i [RefType]
imp EnumBody
bod

classBody :: P ClassBody
classBody :: P ClassBody
classBody = [Decl] -> ClassBody
ClassBody forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
braces P [Decl]
classBodyStatements

enumBody :: P EnumBody
enumBody :: P EnumBody
enumBody = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
    [EnumConstant]
ecs <- forall a sep. P a -> P sep -> P [a]
seplist P EnumConstant
enumConst P ()
comma
    forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional P ()
comma
    [Decl]
eds <- forall a. P [a] -> P [a]
lopt P [Decl]
enumBodyDecls
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [EnumConstant] -> [Decl] -> EnumBody
EnumBody [EnumConstant]
ecs [Decl]
eds

enumConst :: P EnumConstant
enumConst :: P EnumConstant
enumConst = do
    Ident
id  <- P Ident
ident
    [Argument]
as  <- forall a. P [a] -> P [a]
lopt P [Argument]
args
    Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> [Argument] -> Maybe ClassBody -> EnumConstant
EnumConstant Ident
id [Argument]
as Maybe ClassBody
mcb

enumBodyDecls :: P [Decl]
enumBodyDecls :: P [Decl]
enumBodyDecls = P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [Decl]
classBodyStatements

classBodyStatements :: P [Decl]
classBodyStatements :: P [Decl]
classBodyStatements = forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P [a]
list P (Maybe Decl)
classBodyStatement

-- Interface declarations

annInterfaceDecl :: P (Mod InterfaceDecl)
annInterfaceDecl :: ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl = do
    Token -> P ()
tok Token
KW_AnnInterface
    Ident
id  <- P Ident
ident
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    [RefType]
exs <- forall a. P [a] -> P [a]
lopt P [RefType]
extends
    InterfaceBody
bod <- P InterfaceBody
interfaceBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceKind
-> [Modifier]
-> Ident
-> [TypeParam]
-> [RefType]
-> InterfaceBody
-> InterfaceDecl
InterfaceDecl InterfaceKind
InterfaceAnnotation [Modifier]
ms Ident
id [TypeParam]
tps [RefType]
exs InterfaceBody
bod

interfaceDecl :: P (Mod InterfaceDecl)
interfaceDecl :: ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl = do
    Token -> P ()
tok Token
KW_Interface
    Ident
id  <- P Ident
ident
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    [RefType]
exs <- forall a. P [a] -> P [a]
lopt P [RefType]
extends
    InterfaceBody
bod <- P InterfaceBody
interfaceBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceKind
-> [Modifier]
-> Ident
-> [TypeParam]
-> [RefType]
-> InterfaceBody
-> InterfaceDecl
InterfaceDecl InterfaceKind
InterfaceNormal [Modifier]
ms Ident
id [TypeParam]
tps [RefType]
exs InterfaceBody
bod

interfaceBody :: P InterfaceBody
interfaceBody :: P InterfaceBody
interfaceBody = [MemberDecl] -> InterfaceBody
InterfaceBody forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall a. P a -> P a
braces (forall a. P a -> P [a]
list P (Maybe MemberDecl)
interfaceBodyDecl)

-- Declarations

classBodyStatement :: P (Maybe Decl)
classBodyStatement :: P (Maybe Decl)
classBodyStatement =
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
       forall a. P a -> P [a]
list1 P ()
semiColon
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
       Bool
mst <- forall a. P a -> P Bool
bopt (Token -> P ()
tok Token
KW_Static)
       Block
blk <- P Block
block
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Bool -> Block -> Decl
InitDecl Bool
mst Block
blk) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do [Modifier]
ms  <- forall a. P a -> P [a]
list P Modifier
modifier
        Mod MemberDecl
dec <- P (Mod MemberDecl)
memberDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ MemberDecl -> Decl
MemberDecl (Mod MemberDecl
dec [Modifier]
ms))

memberDecl :: P (Mod MemberDecl)
memberDecl :: P (Mod MemberDecl)
memberDecl =
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Mod ClassDecl
cd  <- P (Mod ClassDecl)
classDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> MemberDecl
MemberClassDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Mod InterfaceDecl
id  <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> MemberDecl
MemberInterfaceDecl (Mod InterfaceDecl
id [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>

    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
fieldDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
methodDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    P (Mod MemberDecl)
constrDecl

fieldDecl :: P (Mod MemberDecl)
fieldDecl :: P (Mod MemberDecl)
fieldDecl = forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
    Type
typ <- P Type
ttype
    [VarDecl]
vds <- P [VarDecl]
varDecls
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier] -> Type -> [VarDecl] -> MemberDecl
FieldDecl [Modifier]
ms Type
typ [VarDecl]
vds

methodDecl :: P (Mod MemberDecl)
methodDecl :: P (Mod MemberDecl)
methodDecl = do
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    Maybe Type
rt  <- P (Maybe Type)
resultType
    Ident
id  <- P Ident
ident
    [FormalParam]
fps <- P [FormalParam]
formalParams
    [RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
    MethodBody
bod <- P MethodBody
methodBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Maybe Type
-> Ident
-> [FormalParam]
-> [RefType]
-> Maybe Argument
-> MethodBody
-> MemberDecl
MethodDecl [Modifier]
ms [TypeParam]
tps Maybe Type
rt Ident
id [FormalParam]
fps [RefType]
thr forall a. Maybe a
Nothing MethodBody
bod

methodBody :: P MethodBody
methodBody :: P MethodBody
methodBody = Maybe Block -> MethodBody
MethodBody forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    (forall a b. a -> b -> a
const forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Block
block)


constrDecl :: P (Mod MemberDecl)
constrDecl :: P (Mod MemberDecl)
constrDecl = do
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    Ident
id  <- P Ident
ident
    [FormalParam]
fps <- P [FormalParam]
formalParams
    [RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
    ConstructorBody
bod <- P ConstructorBody
constrBody
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Ident
-> [FormalParam]
-> [RefType]
-> ConstructorBody
-> MemberDecl
ConstructorDecl [Modifier]
ms [TypeParam]
tps Ident
id [FormalParam]
fps [RefType]
thr ConstructorBody
bod

constrBody :: P ConstructorBody
constrBody :: P ConstructorBody
constrBody = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
    Maybe ExplConstrInv
mec <- forall a. P a -> P (Maybe a)
opt (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P ExplConstrInv
explConstrInv)
    [BlockStmt]
bss <- forall a. P a -> P [a]
list P BlockStmt
blockStmt
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ExplConstrInv -> [BlockStmt] -> ConstructorBody
ConstructorBody Maybe ExplConstrInv
mec [BlockStmt]
bss

explConstrInv :: P ExplConstrInv
explConstrInv :: P ExplConstrInv
explConstrInv = forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        [RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
        Token -> P ()
tok Token
KW_This
        [Argument]
as  <- P [Argument]
args
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> [Argument] -> ExplConstrInv
ThisInvoke [RefType]
tas [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        [RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
        Token -> P ()
tok Token
KW_Super
        [Argument]
as  <- P [Argument]
args
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> [Argument] -> ExplConstrInv
SuperInvoke [RefType]
tas [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Argument
pri <- P Argument
primary
        P ()
period
        [RefType]
tas <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
        Token -> P ()
tok Token
KW_Super
        [Argument]
as  <- P [Argument]
args
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [RefType] -> [Argument] -> ExplConstrInv
PrimarySuperInvoke Argument
pri [RefType]
tas [Argument]
as)

-- TODO: This should be parsed like class bodies, and post-checked.
--       That would give far better error messages.
interfaceBodyDecl :: P (Maybe MemberDecl)
interfaceBodyDecl :: P (Maybe MemberDecl)
interfaceBodyDecl = P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    do [Modifier]
ms  <- forall a. P a -> P [a]
list P Modifier
modifier
       Mod MemberDecl
imd <- P (Mod MemberDecl)
interfaceMemberDecl
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (Mod MemberDecl
imd [Modifier]
ms)

interfaceMemberDecl :: P (Mod MemberDecl)
interfaceMemberDecl :: P (Mod MemberDecl)
interfaceMemberDecl =
    (do Mod ClassDecl
cd  <- P (Mod ClassDecl)
classDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> ClassDecl -> MemberDecl
MemberClassDecl (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Mod InterfaceDecl
id  <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
annInterfaceDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity (Mod InterfaceDecl)
interfaceDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> InterfaceDecl -> MemberDecl
MemberInterfaceDecl (Mod InterfaceDecl
id [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Mod MemberDecl)
fieldDecl forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    P (Mod MemberDecl)
absMethodDecl

absMethodDecl :: P (Mod MemberDecl)
absMethodDecl :: P (Mod MemberDecl)
absMethodDecl = do
    [TypeParam]
tps <- forall a. P [a] -> P [a]
lopt P [TypeParam]
typeParams
    Maybe Type
rt  <- P (Maybe Type)
resultType
    Ident
id  <- P Ident
ident
    [FormalParam]
fps <- P [FormalParam]
formalParams
    [RefType]
thr <- forall a. P [a] -> P [a]
lopt P [RefType]
throws
    Maybe Argument
def <- forall a. P a -> P (Maybe a)
opt P Argument
defaultValue
    P ()
semiColon
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \[Modifier]
ms -> [Modifier]
-> [TypeParam]
-> Maybe Type
-> Ident
-> [FormalParam]
-> [RefType]
-> Maybe Argument
-> MethodBody
-> MemberDecl
MethodDecl [Modifier]
ms [TypeParam]
tps Maybe Type
rt Ident
id [FormalParam]
fps [RefType]
thr Maybe Argument
def (Maybe Block -> MethodBody
MethodBody forall a. Maybe a
Nothing)

defaultValue :: P Exp
defaultValue :: P Argument
defaultValue = Token -> P ()
tok Token
KW_Default forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Argument
exp

throws :: P [RefType]
throws :: P [RefType]
throws = Token -> P ()
tok Token
KW_Throws forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P [RefType]
refTypeList

-- Formal parameters

formalParams :: P [FormalParam]
formalParams :: P [FormalParam]
formalParams = forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ do
    [FormalParam]
fps <- forall a sep. P a -> P sep -> P [a]
seplist P FormalParam
formalParam P ()
comma
    if [FormalParam] -> Bool
validateFPs [FormalParam]
fps
     then forall (m :: * -> *) a. Monad m => a -> m a
return [FormalParam]
fps
     else forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Only the last formal parameter may be of variable arity"
  where validateFPs :: [FormalParam] -> Bool
        validateFPs :: [FormalParam] -> Bool
validateFPs [] = Bool
True
        validateFPs [FormalParam
_] = Bool
True
        validateFPs (FormalParam [Modifier]
_ Type
_ Bool
b VarDeclId
_ :[FormalParam]
xs) = Bool -> Bool
not Bool
b

formalParam :: P FormalParam
formalParam :: P FormalParam
formalParam = do
    [Modifier]
ms  <- forall a. P a -> P [a]
list P Modifier
modifier
    Type
typ <- P Type
ttype
    Bool
var <- forall a. P a -> P Bool
bopt P ()
ellipsis
    VarDeclId
vid <- P VarDeclId
varDeclId
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Bool -> VarDeclId -> FormalParam
FormalParam [Modifier]
ms Type
typ Bool
var VarDeclId
vid

ellipsis :: P ()
ellipsis :: P ()
ellipsis = P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period

-- Modifiers

modifier :: P Modifier
modifier :: P Modifier
modifier =
        Token -> P ()
tok Token
KW_Public      forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Public
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Protected   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Protected
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Private     forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Private
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Abstract    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Abstract
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Static      forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Static
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Strictfp    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
StrictFP
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Final       forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Final
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Native      forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Native
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Transient   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Transient
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Volatile    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Volatile
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Synchronized forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Modifier
Synchronized_
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Annotation -> Modifier
Annotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Annotation
annotation

annotation :: P Annotation
annotation :: P Annotation
annotation = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
($) forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Token -> P ()
tok Token
Op_AtSign forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P Name
name forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (
               forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a b c. (a -> b -> c) -> b -> a -> c
flip Name -> [(Ident, ElementValue)] -> Annotation
NormalAnnotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
parens P [(Ident, ElementValue)]
evlist)
           forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a b c. (a -> b -> c) -> b -> a -> c
flip Name -> ElementValue -> Annotation
SingleElementAnnotation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
parens P ElementValue
elementValue)
           forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Name -> Annotation
MarkerAnnotation forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *) a. Monad m => a -> m a
return ())
        )

evlist :: P [(Ident, ElementValue)]
evlist :: P [(Ident, ElementValue)]
evlist = forall a sep. P a -> P sep -> P [a]
seplist1 P (Ident, ElementValue)
elementValuePair P ()
comma

elementValuePair :: P (Ident, ElementValue)
elementValuePair :: P (Ident, ElementValue)
elementValuePair = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Ident
ident forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> P ()
tok Token
Op_Equal forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P ElementValue
elementValue

elementValue :: P ElementValue
elementValue :: P ElementValue
elementValue =
    VarInit -> ElementValue
EVVal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (    ArrayInit -> VarInit
InitArray forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ArrayInit
arrayInit
               forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Argument -> VarInit
InitExp   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
condExp )
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Annotation -> ElementValue
EVAnn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Annotation
annotation


----------------------------------------------------------------------------
-- Variable declarations

varDecls :: P [VarDecl]
varDecls :: P [VarDecl]
varDecls = forall a sep. P a -> P sep -> P [a]
seplist1 P VarDecl
varDecl P ()
comma

varDecl :: P VarDecl
varDecl :: P VarDecl
varDecl = do
    VarDeclId
vid <- P VarDeclId
varDeclId
    Maybe VarInit
mvi <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
Op_Equal forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> ParsecT [L Token] () Identity VarInit
varInit
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ VarDeclId -> Maybe VarInit -> VarDecl
VarDecl VarDeclId
vid Maybe VarInit
mvi

varDeclId :: P VarDeclId
varDeclId :: P VarDeclId
varDeclId = do
    Ident
id  <- P Ident
ident
    [()]
abs <- forall a. P a -> P [a]
list P ()
arrBrackets
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Ident -> VarDeclId
f ()
_ -> VarDeclId -> VarDeclId
VarDeclArray forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> VarDeclId
f) Ident -> VarDeclId
VarId [()]
abs Ident
id

arrBrackets :: P ()
arrBrackets :: P ()
arrBrackets = forall a. P a -> P a
brackets forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()

localVarDecl :: P ([Modifier], Type, [VarDecl])
localVarDecl :: P ([Modifier], Type, [VarDecl])
localVarDecl = do
    [Modifier]
ms  <- forall a. P a -> P [a]
list P Modifier
modifier
    Type
typ <- P Type
ttype
    [VarDecl]
vds <- P [VarDecl]
varDecls
    forall (m :: * -> *) a. Monad m => a -> m a
return ([Modifier]
ms, Type
typ, [VarDecl]
vds)

varInit :: P VarInit
varInit :: ParsecT [L Token] () Identity VarInit
varInit =
    ArrayInit -> VarInit
InitArray forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ArrayInit
arrayInit forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Argument -> VarInit
InitExp   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
exp

arrayInit :: P ArrayInit
arrayInit :: P ArrayInit
arrayInit = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ do
    [VarInit]
vis <- forall a sep. P a -> P sep -> P [a]
seplist ParsecT [L Token] () Identity VarInit
varInit P ()
comma
    forall a. P a -> P (Maybe a)
opt P ()
comma
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [VarInit] -> ArrayInit
ArrayInit [VarInit]
vis

----------------------------------------------------------------------------
-- Statements

block :: P Block
block :: P Block
block = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ [BlockStmt] -> Block
Block forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P [a]
list P BlockStmt
blockStmt

blockStmt :: P BlockStmt
blockStmt :: P BlockStmt
blockStmt =
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        [Modifier]
ms  <- forall a. P a -> P [a]
list P Modifier
modifier
        Mod ClassDecl
cd  <- P (Mod ClassDecl)
classDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassDecl -> BlockStmt
LocalClass (Mod ClassDecl
cd [Modifier]
ms)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        ([Modifier]
m,Type
t,[VarDecl]
vds) <- forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ P ([Modifier], Type, [VarDecl])
localVarDecl
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> [VarDecl] -> BlockStmt
LocalVars [Modifier]
m Type
t [VarDecl]
vds) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Stmt -> BlockStmt
BlockStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Stmt
stmt

stmt :: P Stmt
stmt :: P Stmt
stmt = P Stmt
ifStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
whileStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
forStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
labeledStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
stmtNoTrail
  where
    ifStmt :: P Stmt
ifStmt = do
        Token -> P ()
tok Token
KW_If
        Argument
e   <- forall a. P a -> P a
parens P Argument
exp
        (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
            do Stmt
th <- P Stmt
stmtNSI
               Token -> P ()
tok Token
KW_Else
               Stmt
el <- P Stmt
stmt
               forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt -> Stmt
IfThenElse Argument
e Stmt
th Stmt
el) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
           (do Stmt
th <- P Stmt
stmt
               forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
IfThen Argument
e Stmt
th)
    whileStmt :: P Stmt
whileStmt = do
        Token -> P ()
tok Token
KW_While
        Argument
e   <- forall a. P a -> P a
parens P Argument
exp
        Stmt
s   <- P Stmt
stmt
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
While Argument
e Stmt
s
    forStmt :: P Stmt
forStmt = do
        Token -> P ()
tok Token
KW_For
        Stmt -> Stmt
f <- forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$
            (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
                Maybe ForInit
fi <- forall a. P a -> P (Maybe a)
opt P ForInit
forInit
                P ()
semiColon
                Maybe Argument
e  <- forall a. P a -> P (Maybe a)
opt P Argument
exp
                P ()
semiColon
                Maybe [Argument]
fu <- forall a. P a -> P (Maybe a)
opt P [Argument]
forUp
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ForInit -> Maybe Argument -> Maybe [Argument] -> Stmt -> Stmt
BasicFor Maybe ForInit
fi Maybe Argument
e Maybe [Argument]
fu) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
            (do [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
                Type
t  <- P Type
ttype
                Ident
i  <- P Ident
ident
                P ()
colon
                Argument
e  <- P Argument
exp
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Ident -> Argument -> Stmt -> Stmt
EnhancedFor [Modifier]
ms Type
t Ident
i Argument
e)
        Stmt
s <- P Stmt
stmt
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Stmt
f Stmt
s
    labeledStmt :: P Stmt
labeledStmt = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Ident
lbl <- P Ident
ident
        P ()
colon
        Stmt
s   <- P Stmt
stmt
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Stmt -> Stmt
Labeled Ident
lbl Stmt
s

stmtNSI :: P Stmt
stmtNSI :: P Stmt
stmtNSI = P Stmt
ifStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
whileStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
forStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
labeledStmt forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Stmt
stmtNoTrail
  where
    ifStmt :: P Stmt
ifStmt = do
        Token -> P ()
tok Token
KW_If
        Argument
e  <- forall a. P a -> P a
parens P Argument
exp
        Stmt
th <- P Stmt
stmtNSI
        Token -> P ()
tok Token
KW_Else
        Stmt
el <- P Stmt
stmtNSI
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt -> Stmt
IfThenElse Argument
e Stmt
th Stmt
el
    whileStmt :: P Stmt
whileStmt = do
        Token -> P ()
tok Token
KW_While
        Argument
e <- forall a. P a -> P a
parens P Argument
exp
        Stmt
s <- P Stmt
stmtNSI
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt -> Stmt
While Argument
e Stmt
s
    forStmt :: P Stmt
forStmt = do
        Token -> P ()
tok Token
KW_For
        Stmt -> Stmt
f <- forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
            Maybe ForInit
fi <- forall a. P a -> P (Maybe a)
opt P ForInit
forInit
            P ()
semiColon
            Maybe Argument
e  <- forall a. P a -> P (Maybe a)
opt P Argument
exp
            P ()
semiColon
            Maybe [Argument]
fu <- forall a. P a -> P (Maybe a)
opt P [Argument]
forUp
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe ForInit -> Maybe Argument -> Maybe [Argument] -> Stmt -> Stmt
BasicFor Maybe ForInit
fi Maybe Argument
e Maybe [Argument]
fu)
            forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (do
            [Modifier]
ms <- forall a. P a -> P [a]
list P Modifier
modifier
            Type
t  <- P Type
ttype
            Ident
i  <- P Ident
ident
            P ()
colon
            Argument
e  <- P Argument
exp
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> Ident -> Argument -> Stmt -> Stmt
EnhancedFor [Modifier]
ms Type
t Ident
i Argument
e)
        Stmt
s <- P Stmt
stmtNSI
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Stmt
f Stmt
s
    labeledStmt :: P Stmt
labeledStmt = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Ident
i <- P Ident
ident
        P ()
colon
        Stmt
s <- P Stmt
stmtNSI
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Stmt -> Stmt
Labeled Ident
i Stmt
s

stmtNoTrail :: P Stmt
stmtNoTrail :: P Stmt
stmtNoTrail =
    -- empty statement
    forall a b. a -> b -> a
const Stmt
Empty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ()
semiColon forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- inner block
    Block -> Stmt
StmtBlock forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Block
block forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- assertions
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Assert
        Argument
e   <- P Argument
exp
        Maybe Argument
me2 <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ P ()
colon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Argument
exp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Maybe Argument -> Stmt
Assert Argument
e Maybe Argument
me2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- switch stmts
    (do Token -> P ()
tok Token
KW_Switch
        Argument
e  <- forall a. P a -> P a
parens P Argument
exp
        [SwitchBlock]
sb <- P [SwitchBlock]
switchBlock
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [SwitchBlock] -> Stmt
Switch Argument
e [SwitchBlock]
sb) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- do-while loops
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Do
        Stmt
s <- P Stmt
stmt
        Token -> P ()
tok Token
KW_While
        Argument
e <- forall a. P a -> P a
parens P Argument
exp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Stmt -> Argument -> Stmt
Do Stmt
s Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- break
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Break
        Maybe Ident
mi <- forall a. P a -> P (Maybe a)
opt P Ident
ident
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Ident -> Stmt
Break Maybe Ident
mi) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- continue
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Continue
        Maybe Ident
mi <- forall a. P a -> P (Maybe a)
opt P Ident
ident
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Ident -> Stmt
Continue Maybe Ident
mi) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- return
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Return
        Maybe Argument
me <- forall a. P a -> P (Maybe a)
opt P Argument
exp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Argument -> Stmt
Return Maybe Argument
me) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- synchronized
    (do Token -> P ()
tok Token
KW_Synchronized
        Argument
e <- forall a. P a -> P a
parens P Argument
exp
        Block
b <- P Block
block
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Block -> Stmt
Synchronized Argument
e Block
b) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- throw
    (forall a. P a -> P a
endSemi forall a b. (a -> b) -> a -> b
$ do
        Token -> P ()
tok Token
KW_Throw
        Argument
e <- P Argument
exp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Stmt
Throw Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- try-catch, both with and without a finally clause
    (do Token -> P ()
tok Token
KW_Try
        Block
b <- P Block
block
        [Catch]
c <- forall a. P a -> P [a]
list P Catch
catch
        Maybe Block
mf <- forall a. P a -> P (Maybe a)
opt forall a b. (a -> b) -> a -> b
$ Token -> P ()
tok Token
KW_Finally forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P Block
block
        -- TODO: here we should check that there exists at
        -- least one catch or finally clause
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Block -> [Catch] -> Maybe Block -> Stmt
Try Block
b [Catch]
c Maybe Block
mf) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- expressions as stmts
    Argument -> Stmt
ExpStmt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P a
endSemi P Argument
stmtExp

-- For loops

forInit :: P ForInit
forInit :: P ForInit
forInit = (do
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do ([Modifier]
m,Type
t,[VarDecl]
vds) <- P ([Modifier], Type, [VarDecl])
localVarDecl
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Modifier] -> Type -> [VarDecl] -> ForInit
ForLocalVars [Modifier]
m Type
t [VarDecl]
vds)) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall a sep. P a -> P sep -> P [a]
seplist1 P Argument
stmtExp P ()
comma forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Argument] -> ForInit
ForInitExps)

forUp :: P [Exp]
forUp :: P [Argument]
forUp = forall a sep. P a -> P sep -> P [a]
seplist1 P Argument
stmtExp P ()
comma

-- Switches

switchBlock :: P [SwitchBlock]
switchBlock :: P [SwitchBlock]
switchBlock = forall a. P a -> P a
braces forall a b. (a -> b) -> a -> b
$ forall a. P a -> P [a]
list P SwitchBlock
switchStmt

switchStmt :: P SwitchBlock
switchStmt :: P SwitchBlock
switchStmt = do
    SwitchLabel
lbl <- P SwitchLabel
switchLabel
    [BlockStmt]
bss <- forall a. P a -> P [a]
list P BlockStmt
blockStmt
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SwitchLabel -> [BlockStmt] -> SwitchBlock
SwitchBlock SwitchLabel
lbl [BlockStmt]
bss

switchLabel :: P SwitchLabel
switchLabel :: P SwitchLabel
switchLabel = (Token -> P ()
tok Token
KW_Default forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
colon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SwitchLabel
Default) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Token -> P ()
tok Token
KW_Case
        Argument
e <- P Argument
exp
        P ()
colon
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> SwitchLabel
SwitchCase Argument
e)

-- Try-catch clauses

catch :: P Catch
catch :: P Catch
catch = do
    Token -> P ()
tok Token
KW_Catch
    FormalParam
fp <- forall a. P a -> P a
parens P FormalParam
formalParam
    Block
b  <- P Block
block
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ FormalParam -> Block -> Catch
Catch FormalParam
fp Block
b

----------------------------------------------------------------------------
-- Expressions

stmtExp :: P Exp
stmtExp :: P Argument
stmtExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
preIncDec
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
postIncDec
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
assignment
    -- There are sharing gains to be made by unifying these two
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodInvocationExp
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
lambdaExp
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodRef
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
instanceCreation

preIncDec :: P Exp
preIncDec :: P Argument
preIncDec = do
    Argument -> Argument
op <- P (Argument -> Argument)
preIncDecOp
    Argument
e <- P Argument
unaryExp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Argument
op Argument
e

postIncDec :: P Exp
postIncDec :: P Argument
postIncDec = do
    Argument
e <- P Argument
postfixExpNES
    [Argument -> Argument]
ops <- forall a. P a -> P [a]
list1 P (Argument -> Argument)
postfixOp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
e [Argument -> Argument]
ops

assignment :: P Exp
assignment :: P Argument
assignment = do
    Lhs
lh <- P Lhs
lhs
    AssignOp
op <- P AssignOp
assignOp
    Argument
e  <- P Argument
assignExp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Lhs -> AssignOp -> Argument -> Argument
Assign Lhs
lh AssignOp
op Argument
e

lhs :: P Lhs
lhs :: P Lhs
lhs = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (FieldAccess -> Lhs
FieldLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P FieldAccess
fieldAccess)
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ArrayIndex -> Lhs
ArrayLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [L Token] () Identity ArrayIndex
arrayAccess)
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Name -> Lhs
NameLhs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Name
name



exp :: P Exp
exp :: P Argument
exp = P Argument
assignExp

assignExp :: P Exp
assignExp :: P Argument
assignExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
methodRef forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
lambdaExp forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
assignment forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
condExp

condExp :: P Exp
condExp :: P Argument
condExp = do
    Argument
ie <- P Argument
infixExp
    [Argument -> Argument]
ces <- forall a. P a -> P [a]
list P (Argument -> Argument)
condExpSuffix
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
ie [Argument -> Argument]
ces

condExpSuffix :: P (Exp -> Exp)
condExpSuffix :: P (Argument -> Argument)
condExpSuffix = do
    Token -> P ()
tok Token
Op_Query
    Argument
th <- P Argument
exp
    P ()
colon
    Argument
el <- P Argument
condExp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ce -> Argument -> Argument -> Argument -> Argument
Cond Argument
ce Argument
th Argument
el

infixExp :: P Exp
infixExp :: P Argument
infixExp = do
    Argument
ue <- P Argument
unaryExp
    [Argument -> Argument]
ies <- forall a. P a -> P [a]
list P (Argument -> Argument)
infixExpSuffix
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
ue [Argument -> Argument]
ies

infixExpSuffix :: P (Exp -> Exp)
infixExpSuffix :: P (Argument -> Argument)
infixExpSuffix =
    (do
      Op
op <- P Op
infixCombineOp
      Argument
ie2 <- P Argument
infixExp
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ie1 -> Argument -> Op -> Argument -> Argument
BinOp Argument
ie1 Op
op Argument
ie2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Op
op <- P Op
infixOp
        Argument
e2 <- P Argument
unaryExp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
e1 -> Argument -> Op -> Argument -> Argument
BinOp Argument
e1 Op
op Argument
e2) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Token -> P ()
tok Token
KW_Instanceof
        RefType
t  <- P RefType
refType
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
e1 -> Argument -> RefType -> Argument
InstanceOf Argument
e1 RefType
t)

unaryExp :: P Exp
unaryExp :: P Argument
unaryExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
preIncDec forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
        Argument -> Argument
op <- P (Argument -> Argument)
prefixOp
        Argument
ue <- P Argument
unaryExp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> Argument
op Argument
ue) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
        Type
t <- forall a. P a -> P a
parens P Type
ttype
        Argument
e <- P Argument
unaryExp
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Type -> Argument -> Argument
Cast Type
t Argument
e) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    P Argument
postfixExp

postfixExpNES :: P Exp
postfixExpNES :: P Argument
postfixExpNES = -- try postIncDec <|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
primary forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Name -> Argument
ExpName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Name
name

postfixExp :: P Exp
postfixExp :: P Argument
postfixExp = do
    Argument
pe <- P Argument
postfixExpNES
    [Argument -> Argument]
ops <- forall a. P a -> P [a]
list P (Argument -> Argument)
postfixOp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
pe [Argument -> Argument]
ops


primary :: P Exp
primary :: P Argument
primary = P Argument
primaryNPS forall a. P a -> P (a -> a) -> P a
|>> P (Argument -> Argument)
primarySuffix

primaryNPS :: P Exp
primaryNPS :: P Argument
primaryNPS = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
arrayCreation forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P Argument
primaryNoNewArrayNPS

primaryNoNewArray :: P Argument
primaryNoNewArray = forall a. P a -> P (a -> a) -> P a
startSuff P Argument
primaryNoNewArrayNPS P (Argument -> Argument)
primarySuffix

primaryNoNewArrayNPS :: P Exp
primaryNoNewArrayNPS :: P Argument
primaryNoNewArrayNPS =
    Literal -> Argument
Lit forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Literal
literal forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall a b. a -> b -> a
const Argument
This forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> P ()
tok Token
KW_This forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall a. P a -> P a
parens P Argument
exp forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    -- TODO: These two following should probably be merged more
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Maybe Type
rt <- P (Maybe Type)
resultType
        P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_Class
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Type -> Argument
ClassLit Maybe Type
rt) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
        Name
n <- P Name
name
        P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_This
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> Argument
ThisClass Name
n) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
instanceCreationNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (MethodInvocation -> Argument
MethodInv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P MethodInvocation
methodInvocationNPS) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (FieldAccess -> Argument
FieldAccess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P FieldAccess
fieldAccessNPS) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    ArrayIndex -> Argument
ArrayAccess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS

primarySuffix :: P (Exp -> Exp)
primarySuffix :: P (Argument -> Argument)
primarySuffix = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P (Argument -> Argument)
instanceCreationSuffix forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((ArrayIndex -> Argument
ArrayAccess forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> ArrayIndex)
arrayAccessSuffix) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((MethodInvocation -> Argument
MethodInv forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> MethodInvocation)
methodInvocationSuffix) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (FieldAccess -> Argument
FieldAccess forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P (Argument -> FieldAccess)
fieldAccessSuffix


instanceCreationNPS :: P Exp
instanceCreationNPS :: P Argument
instanceCreationNPS =
    do Token -> P ()
tok Token
KW_New
       [TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
       TypeDeclSpecifier
tds <- P TypeDeclSpecifier
typeDeclSpecifier
       [Argument]
as  <- P [Argument]
args
       Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [TypeArgument]
-> TypeDeclSpecifier -> [Argument] -> Maybe ClassBody -> Argument
InstanceCreation [TypeArgument]
tas TypeDeclSpecifier
tds [Argument]
as Maybe ClassBody
mcb

typeDeclSpecifier :: P TypeDeclSpecifier
typeDeclSpecifier :: P TypeDeclSpecifier
typeDeclSpecifier =
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do ClassType
ct <- P ClassType
classType
              P ()
period
              Ident
i <- P Ident
ident
              Token -> P ()
tok Token
Op_LThan
              Token -> P ()
tok Token
Op_GThan
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassType -> Ident -> Diamond -> TypeDeclSpecifier
TypeDeclSpecifierWithDiamond ClassType
ct Ident
i Diamond
Diamond
    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do Ident
i <- P Ident
ident
              Token -> P ()
tok Token
Op_LThan
              Token -> P ()
tok Token
Op_GThan
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> Diamond -> TypeDeclSpecifier
TypeDeclSpecifierUnqualifiedWithDiamond Ident
i Diamond
Diamond
    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do ClassType
ct <- P ClassType
classType
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ClassType -> TypeDeclSpecifier
TypeDeclSpecifier ClassType
ct
    )

instanceCreationSuffix :: P (Exp -> Exp)
instanceCreationSuffix :: P (Argument -> Argument)
instanceCreationSuffix =
     do P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_New
        [TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
        Ident
i   <- P Ident
ident
        [Argument]
as  <- P [Argument]
args
        Maybe ClassBody
mcb <- forall a. P a -> P (Maybe a)
opt P ClassBody
classBody
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument
-> [TypeArgument]
-> Ident
-> [Argument]
-> Maybe ClassBody
-> Argument
QualInstanceCreation Argument
p [TypeArgument]
tas Ident
i [Argument]
as Maybe ClassBody
mcb

instanceCreation :: P Exp
instanceCreation :: P Argument
instanceCreation = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Argument
instanceCreationNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    Argument
p <- P Argument
primaryNPS
    [Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
    let icp :: Argument
icp = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
    case Argument
icp of
     QualInstanceCreation {} -> forall (m :: * -> *) a. Monad m => a -> m a
return Argument
icp
     Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""


lambdaParams :: P LambdaParams
lambdaParams :: P LambdaParams
lambdaParams = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Ident -> LambdaParams
LambdaSingleParam forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Ident
ident)
               forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ [FormalParam] -> LambdaParams
LambdaFormalParams forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a sep. P a -> P sep -> P [a]
seplist P FormalParam
formalParam P ()
comma))
               forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ [Ident] -> LambdaParams
LambdaInferredParams forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a sep. P a -> P sep -> P [a]
seplist P Ident
ident P ()
comma))

lambdaExp :: P Exp
lambdaExp :: P Argument
lambdaExp = LambdaParams -> LambdaExpression -> Argument
Lambda 
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (P LambdaParams
lambdaParams forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Token -> P ()
tok Token
LambdaArrow))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Block -> LambdaExpression
LambdaBlock forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P Block
block))
                 forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Argument -> LambdaExpression
LambdaExpression forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Argument
exp))

methodRef :: P Exp
methodRef :: P Argument
methodRef = Name -> Ident -> Argument
MethodRef 
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (P Name
name forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  (Token -> P ()
tok Token
MethodRefSep))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> P Ident
ident

{-
instanceCreation =
    (do tok KW_New
        tas <- lopt typeArgs
        ct  <- classType
        as  <- args
        mcb <- opt classBody
        return $ InstanceCreation tas ct as mcb) <|>
    (do p   <- primary
        period >> tok KW_New
        tas <- lopt typeArgs
        i   <- ident
        as  <- args
        mcb <- opt classBody
        return $ QualInstanceCreation p tas i as mcb)
-}

fieldAccessNPS :: P FieldAccess
fieldAccessNPS :: P FieldAccess
fieldAccessNPS =
    (do Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
        Ident
i <- P Ident
ident
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> FieldAccess
SuperFieldAccess Ident
i) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Name
n <- P Name
name
        P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
        Ident
i <- P Ident
ident
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> Ident -> FieldAccess
ClassFieldAccess Name
n Ident
i)

fieldAccessSuffix :: P (Exp -> FieldAccess)
fieldAccessSuffix :: P (Argument -> FieldAccess)
fieldAccessSuffix = do
    P ()
period
    Ident
i <- P Ident
ident
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument -> Ident -> FieldAccess
PrimaryFieldAccess Argument
p Ident
i

fieldAccess :: P FieldAccess
fieldAccess :: P FieldAccess
fieldAccess = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try P FieldAccess
fieldAccessNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    Argument
p <- P Argument
primaryNPS
    [Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
    let fap :: Argument
fap = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
    case Argument
fap of
     FieldAccess FieldAccess
fa -> forall (m :: * -> *) a. Monad m => a -> m a
return FieldAccess
fa
     Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""

{-
fieldAccess :: P FieldAccess
fieldAccess = try fieldAccessNPS <|> do
    p <- primary
    fs <- fieldAccessSuffix
    return (fs p)
-}

{-
fieldAccess :: P FieldAccess
fieldAccess =
    (do tok KW_Super >> period
        i <- ident
        return $ SuperFieldAccess i) <|>
    (try $ do
        n <- name
        period >> tok KW_Super >> period
        i <- ident
        return $ ClassFieldAccess n i) <|>
    (do p <- primary
        period
        i <- ident
        return $ PrimaryFieldAccess p i)
-}

methodInvocationNPS :: P MethodInvocation
methodInvocationNPS :: P MethodInvocation
methodInvocationNPS =
    (do Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period
        [RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
        Ident
i   <- P Ident
ident
        [Argument]
as  <- P [Argument]
args
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [RefType] -> Ident -> [Argument] -> MethodInvocation
SuperMethodCall [RefType]
rts Ident
i [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do Name
n <- P Name
name
        Name -> MethodInvocation
f <- (do [Argument]
as <- P [Argument]
args
                 forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Name
n -> Name -> [Argument] -> MethodInvocation
MethodCall Name
n [Argument]
as) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
             (P ()
period forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> do
                Maybe ()
msp <- forall a. P a -> P (Maybe a)
opt (Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> P ()
period)
                [RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
                Ident
i   <- P Ident
ident
                [Argument]
as  <- P [Argument]
args
                let mc :: Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
mc = forall b a. b -> (a -> b) -> Maybe a -> b
maybe Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
TypeMethodCall (forall a b. a -> b -> a
const Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
ClassMethodCall) Maybe ()
msp
                forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Name
n -> Name -> [RefType] -> Ident -> [Argument] -> MethodInvocation
mc Name
n [RefType]
rts Ident
i [Argument]
as)
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> MethodInvocation
f Name
n)

methodInvocationSuffix :: P (Exp -> MethodInvocation)
methodInvocationSuffix :: P (Argument -> MethodInvocation)
methodInvocationSuffix = do
        P ()
period
        [RefType]
rts <- forall a. P [a] -> P [a]
lopt P [RefType]
refTypeArgs
        Ident
i   <- P Ident
ident
        [Argument]
as  <- P [Argument]
args
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
p -> Argument -> [RefType] -> Ident -> [Argument] -> MethodInvocation
PrimaryMethodCall Argument
p [] Ident
i [Argument]
as

methodInvocationExp :: P Exp
methodInvocationExp :: P Argument
methodInvocationExp = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do
    Argument
p <- P Argument
primaryNPS
    [Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
    let mip :: Argument
mip = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
    case Argument
mip of
     MethodInv MethodInvocation
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Argument
mip
     Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"") forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
     (MethodInvocation -> Argument
MethodInv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P MethodInvocation
methodInvocationNPS)

{-
methodInvocation :: P MethodInvocation
methodInvocation =
    (do tok KW_Super >> period
        rts <- lopt refTypeArgs
        i   <- ident
        as  <- args
        return $ SuperMethodCall rts i as) <|>
    (do p <- primary
        period
        rts <- lopt refTypeArgs
        i   <- ident
        as  <- args
        return $ PrimaryMethodCall p rts i as) <|>
    (do n <- name
        f <- (do as <- args
                 return $ \n -> MethodCall n as) <|>
             (period >> do
                msp <- opt (tok KW_Super >> period)
                rts <- lopt refTypeArgs
                i   <- ident
                as  <- args
                let mc = maybe TypeMethodCall (const ClassMethodCall) msp
                return $ \n -> mc n rts i as)
        return $ f n)
-}

args :: P [Argument]
args :: P [Argument]
args = forall a. P a -> P a
parens forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist P Argument
exp P ()
comma

-- Arrays

arrayAccessNPS :: P ArrayIndex
arrayAccessNPS :: ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS = do
    Name
n <- P Name
name
    [Argument]
e <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Argument -> [Argument] -> ArrayIndex
ArrayIndex (Name -> Argument
ExpName Name
n) [Argument]
e

arrayAccessSuffix :: P (Exp -> ArrayIndex)
arrayAccessSuffix :: P (Argument -> ArrayIndex)
arrayAccessSuffix = do
    [Argument]
e <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Argument
ref -> Argument -> [Argument] -> ArrayIndex
ArrayIndex Argument
ref [Argument]
e

arrayAccess :: ParsecT [L Token] () Identity ArrayIndex
arrayAccess = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT [L Token] () Identity ArrayIndex
arrayAccessNPS forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    Argument
p <- P Argument
primaryNoNewArrayNPS
    [Argument -> Argument]
ss <- forall a. P a -> P [a]
list P (Argument -> Argument)
primarySuffix
    let aap :: Argument
aap = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Argument
a Argument -> Argument
s -> Argument -> Argument
s Argument
a) Argument
p [Argument -> Argument]
ss
    case Argument
aap of
     ArrayAccess ArrayIndex
ain -> forall (m :: * -> *) a. Monad m => a -> m a
return ArrayIndex
ain
     Argument
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""

{-
arrayAccess :: P (Exp, Exp)
arrayAccess = do
    ref <- arrayRef
    e   <- brackets exp
    return (ref, e)

arrayRef :: P Exp
arrayRef = ExpName <$> name <|> primaryNoNewArray
-}

arrayCreation :: P Exp
arrayCreation :: P Argument
arrayCreation = do
    Token -> P ()
tok Token
KW_New
    Type
t <- P Type
nonArrayType
    Type -> Argument
f <- (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
             [()]
ds <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P ()
empty
             ArrayInit
ai <- P ArrayInit
arrayInit
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Type
t -> Type -> Int -> ArrayInit -> Argument
ArrayCreateInit Type
t (forall (t :: * -> *) a. Foldable t => t a -> Int
length [()]
ds) ArrayInit
ai) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
         (do [Argument]
des <- forall a. P a -> P [a]
list1 forall a b. (a -> b) -> a -> b
$ forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P Argument
exp
             [()]
ds  <- forall a. P a -> P [a]
list  forall a b. (a -> b) -> a -> b
$ forall a. P a -> P a
brackets P ()
empty
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Type
t -> Type -> [Argument] -> Int -> Argument
ArrayCreate Type
t [Argument]
des (forall (t :: * -> *) a. Foldable t => t a -> Int
length [()]
ds))
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Type -> Argument
f Type
t

literal :: P Literal
literal :: P Literal
literal =
    forall a. (Token -> Maybe a) -> P a
javaToken forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        IntTok     Integer
i -> forall a. a -> Maybe a
Just (Integer -> Literal
Int Integer
i)
        LongTok    Integer
l -> forall a. a -> Maybe a
Just (Integer -> Literal
Word Integer
l)
        DoubleTok  Double
d -> forall a. a -> Maybe a
Just (Double -> Literal
Double Double
d)
        FloatTok   Double
f -> forall a. a -> Maybe a
Just (Double -> Literal
Float Double
f)
        CharTok    Char
c -> forall a. a -> Maybe a
Just (Char -> Literal
Char Char
c)
        StringTok  String
s -> forall a. a -> Maybe a
Just (String -> Literal
String String
s)
        BoolTok    Bool
b -> forall a. a -> Maybe a
Just (Bool -> Literal
Boolean Bool
b)
        Token
NullTok      -> forall a. a -> Maybe a
Just Literal
Null
        Token
_ -> forall a. Maybe a
Nothing

-- Operators

preIncDecOp, prefixOp, postfixOp :: P (Exp -> Exp)
preIncDecOp :: P (Argument -> Argument)
preIncDecOp =
    (Token -> P ()
tok Token
Op_PPlus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreIncrement) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_MMinus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreDecrement)
prefixOp :: P (Argument -> Argument)
prefixOp =
    (Token -> P ()
tok Token
Op_Bang  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreNot      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Tilde forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreBitCompl ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Plus  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PrePlus     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Minus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PreMinus    )
postfixOp :: P (Argument -> Argument)
postfixOp =
    (Token -> P ()
tok Token
Op_PPlus  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PostIncrement) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_MMinus forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Argument -> Argument
PostDecrement)

assignOp :: P AssignOp
assignOp :: P AssignOp
assignOp =
    (Token -> P ()
tok Token
Op_Equal    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
EqualA   ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_StarE    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
MultA    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_SlashE   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
DivA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_PercentE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RemA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_PlusE    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
AddA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_MinusE   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
SubA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_LShiftE  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
LShiftA  ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_RShiftE  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RShiftA  ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_RRShiftE forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
RRShiftA ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_AndE     forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
AndA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_CaretE   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
XorA     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_OrE      forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return AssignOp
OrA      )

infixCombineOp :: P Op
infixCombineOp :: P Op
infixCombineOp = 
    (Token -> P ()
tok Token
Op_And     forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
And       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Caret   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Xor       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Or      forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Or        ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_AAnd    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
CAnd      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_OOr     forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
COr       )


infixOp :: P Op
infixOp :: P Op
infixOp =
    (Token -> P ()
tok Token
Op_Star    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Mult      ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Slash   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Div       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Percent forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Rem       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Plus    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Add       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Minus   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Sub       ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_LShift  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LShift    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_LThan   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LThan     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
       Token -> P ()
tok Token
Op_GThan   
       Token -> P ()
tok Token
Op_GThan   
       Token -> P ()
tok Token
Op_GThan
       forall (m :: * -> *) a. Monad m => a -> m a
return Op
RRShift   ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
           
    (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
       Token -> P ()
tok Token
Op_GThan 
       Token -> P ()
tok Token
Op_GThan
       forall (m :: * -> *) a. Monad m => a -> m a
return Op
RShift    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
           
    (Token -> P ()
tok Token
Op_GThan   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
GThan     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>                                          
    (Token -> P ()
tok Token
Op_LThanE  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
LThanE    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_GThanE  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
GThanE    ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_Equals  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
Equal     ) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (Token -> P ()
tok Token
Op_BangE   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Op
NotEq     )


----------------------------------------------------------------------------
-- Types

ttype :: P Type
ttype :: P Type
ttype = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (RefType -> Type
RefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> PrimType -> Type
PrimType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P PrimType
primType

primType :: P PrimType
primType :: P PrimType
primType =
    Token -> P ()
tok Token
KW_Boolean forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
BooleanT  forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Byte    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
ByteT     forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Short   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
ShortT    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Int     forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
IntT      forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Long    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
LongT     forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Char    forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
CharT     forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Float   forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
FloatT    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    Token -> P ()
tok Token
KW_Double  forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return PrimType
DoubleT

refType :: P RefType
refType :: P RefType
refType =
    (do PrimType
pt <- P PrimType
primType
        (()
_:[()]
bs) <- forall a. P a -> P [a]
list1 P ()
arrBrackets
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\PrimType -> RefType
f ()
_ -> Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. RefType -> Type
RefType forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimType -> RefType
f)
                        (Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimType -> Type
PrimType) [()]
bs PrimType
pt) forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    (do ClassType
ct <- P ClassType
classType
        [()]
bs <- forall a. P a -> P [a]
list P ()
arrBrackets
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\ClassType -> RefType
f ()
_ -> Type -> RefType
ArrayType forall b c a. (b -> c) -> (a -> b) -> a -> c
. RefType -> Type
RefType forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClassType -> RefType
f)
                            ClassType -> RefType
ClassRefType [()]
bs ClassType
ct) forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"refType"

nonArrayType :: P Type
nonArrayType :: P Type
nonArrayType = PrimType -> Type
PrimType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P PrimType
primType forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
    RefType -> Type
RefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ClassType -> RefType
ClassRefType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P ClassType
classType

classType :: P ClassType
classType :: P ClassType
classType = [(Ident, [TypeArgument])] -> ClassType
ClassType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a sep. P a -> P sep -> P [a]
seplist1 P (Ident, [TypeArgument])
classTypeSpec P ()
period

classTypeSpec :: P (Ident, [TypeArgument])
classTypeSpec :: P (Ident, [TypeArgument])
classTypeSpec = do
    Ident
i   <- P Ident
ident
    [TypeArgument]
tas <- forall a. P [a] -> P [a]
lopt P [TypeArgument]
typeArgs
    forall (m :: * -> *) a. Monad m => a -> m a
return (Ident
i, [TypeArgument]
tas)

resultType :: P (Maybe Type)
resultType :: P (Maybe Type)
resultType = Token -> P ()
tok Token
KW_Void forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P Type
ttype forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"resultType"

refTypeList :: P [RefType]
refTypeList :: P [RefType]
refTypeList = forall a sep. P a -> P sep -> P [a]
seplist1 P RefType
refType P ()
comma

----------------------------------------------------------------------------
-- Type parameters and arguments

typeParams :: P [TypeParam]
typeParams :: P [TypeParam]
typeParams = forall a. P a -> P a
angles forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P TypeParam
typeParam P ()
comma

typeParam :: P TypeParam
typeParam :: P TypeParam
typeParam = do
    Ident
i  <- P Ident
ident
    [RefType]
bs <- forall a. P [a] -> P [a]
lopt P [RefType]
bounds
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Ident -> [RefType] -> TypeParam
TypeParam Ident
i [RefType]
bs

bounds :: P [RefType]
bounds :: P [RefType]
bounds = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall a sep. P a -> P sep -> P [a]
seplist1 P RefType
refType (Token -> P ()
tok Token
Op_And)

typeArgs :: P [TypeArgument]
typeArgs :: P [TypeArgument]
typeArgs = forall a. P a -> P a
angles forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P TypeArgument
typeArg P ()
comma

typeArg :: P TypeArgument
typeArg :: P TypeArgument
typeArg = Token -> P ()
tok Token
Op_Query forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> Maybe WildcardBound -> TypeArgument
Wildcard forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. P a -> P (Maybe a)
opt P WildcardBound
wildcardBound
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> RefType -> TypeArgument
ActualType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType

wildcardBound :: P WildcardBound
wildcardBound :: P WildcardBound
wildcardBound = Token -> P ()
tok Token
KW_Extends forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> RefType -> WildcardBound
ExtendsBound forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType
    forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> P ()
tok Token
KW_Super forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> RefType -> WildcardBound
SuperBound forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P RefType
refType

refTypeArgs :: P [RefType]
refTypeArgs :: P [RefType]
refTypeArgs = forall a. P a -> P a
angles P [RefType]
refTypeList

----------------------------------------------------------------------------
-- Names

name :: P Name
name :: P Name
name = [Ident] -> Name
Name forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a sep. P a -> P sep -> P [a]
seplist1 P Ident
ident P ()
period

ident :: P Ident
ident :: P Ident
ident = forall a. (Token -> Maybe a) -> P a
javaToken forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    IdentTok String
s -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ String -> Ident
Ident String
s
    Token
_ -> forall a. Maybe a
Nothing

------------------------------------------------------------

empty :: P ()
empty :: P ()
empty = forall (m :: * -> *) a. Monad m => a -> m a
return ()

opt :: P a -> P (Maybe a)
opt :: forall a. P a -> P (Maybe a)
opt = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe

bopt :: P a -> P Bool
bopt :: forall a. P a -> P Bool
bopt P a
p = forall a. P a -> P (Maybe a)
opt P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \Maybe a
ma -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Maybe a -> Bool
isJust Maybe a
ma

lopt :: P [a] -> P [a]
lopt :: forall a. P [a] -> P [a]
lopt P [a]
p = do Maybe [a]
mas <- forall a. P a -> P (Maybe a)
opt P [a]
p
            case Maybe [a]
mas of
             Maybe [a]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return []
             Just [a]
as -> forall (m :: * -> *) a. Monad m => a -> m a
return [a]
as

list :: P a -> P [a]
list :: forall a. P a -> P [a]
list = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. P a -> P [a]
list1

list1 :: P a -> P [a]
list1 :: forall a. P a -> P [a]
list1 = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1

seplist :: P a -> P sep -> P [a]
--seplist = sepBy
seplist :: forall a sep. P a -> P sep -> P [a]
seplist P a
p P sep
sep = forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep

seplist1 :: P a -> P sep -> P [a]
--seplist1 = sepBy1
seplist1 :: forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep =
    P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \a
a ->
        forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do P sep
sep
                [a]
as <- forall a sep. P a -> P sep -> P [a]
seplist1 P a
p P sep
sep
                forall (m :: * -> *) a. Monad m => a -> m a
return (a
aforall a. a -> [a] -> [a]
:[a]
as))
        forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return [a
a]

startSuff, (|>>) :: P a -> P (a -> a) -> P a
startSuff :: forall a. P a -> P (a -> a) -> P a
startSuff P a
start P (a -> a)
suffix = do
    a
x <- P a
start
    [a -> a]
ss <- forall a. P a -> P [a]
list P (a -> a)
suffix
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\a
a a -> a
s -> a -> a
s a
a) a
x [a -> a]
ss

|>> :: forall a. P a -> P (a -> a) -> P a
(|>>) = forall a. P a -> P (a -> a) -> P a
startSuff

------------------------------------------------------------

javaToken :: (Token -> Maybe a) -> P a
javaToken :: forall a. (Token -> Maybe a) -> P a
javaToken Token -> Maybe a
test = forall s t a u.
Stream s Identity t =>
(t -> String) -> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
token forall {a}. Show a => L a -> String
showT forall {a}. L a -> SourcePos
posT L Token -> Maybe a
testT
  where showT :: L a -> String
showT (L Pos
_ a
t) = forall a. Show a => a -> String
show a
t
        posT :: L a -> SourcePos
posT  (L Pos
p a
_) = Pos -> SourcePos
pos2sourcePos Pos
p
        testT :: L Token -> Maybe a
testT (L Pos
_ Token
t) = Token -> Maybe a
test Token
t

tok, matchToken :: Token -> P ()
tok :: Token -> P ()
tok = Token -> P ()
matchToken
matchToken :: Token -> P ()
matchToken Token
t = forall a. (Token -> Maybe a) -> P a
javaToken (\Token
r -> if Token
r forall a. Eq a => a -> a -> Bool
== Token
t then forall a. a -> Maybe a
Just () else forall a. Maybe a
Nothing)

pos2sourcePos :: (Int, Int) -> SourcePos
pos2sourcePos :: Pos -> SourcePos
pos2sourcePos (Int
l,Int
c) = String -> Int -> Int -> SourcePos
newPos String
"" Int
l Int
c

type Mod a = [Modifier] -> a

parens, braces, brackets, angles :: P a -> P a
parens :: forall a. P a -> P a
parens   = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenParen)  (Token -> P ()
tok Token
CloseParen)
braces :: forall a. P a -> P a
braces   = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenCurly)  (Token -> P ()
tok Token
CloseCurly)
brackets :: forall a. P a -> P a
brackets = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
OpenSquare) (Token -> P ()
tok Token
CloseSquare)
angles :: forall a. P a -> P a
angles   = forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Token -> P ()
tok Token
Op_LThan)   (Token -> P ()
tok Token
Op_GThan)

endSemi :: P a -> P a
endSemi :: forall a. P a -> P a
endSemi P a
p = P a
p forall {a} {b}.
ParsecT [L Token] () Identity a
-> (a -> ParsecT [L Token] () Identity b)
-> ParsecT [L Token] () Identity b
>>= \a
a -> P ()
semiColon forall {a} {b}.
ParsecT [L Token] () Identity a
-> ParsecT [L Token] () Identity b
-> ParsecT [L Token] () Identity b
>> forall (m :: * -> *) a. Monad m => a -> m a
return a
a

comma, colon, semiColon, period :: P ()
comma :: P ()
comma     = Token -> P ()
tok Token
Comma
colon :: P ()
colon     = Token -> P ()
tok Token
Op_Colon
semiColon :: P ()
semiColon = Token -> P ()
tok Token
SemiColon
period :: P ()
period    = Token -> P ()
tok Token
Period

------------------------------------------------------------

test :: String
test = String
"public class Foo { }"
testFile :: String -> IO ()
testFile String
file = do
  String
i <- String -> IO String
readFile String
file
  let r :: Either ParseError CompilationUnit
r = String -> Either ParseError CompilationUnit
parseCompilationUnit String
i
  String -> IO ()
putStrLnforall a b. (a -> b) -> a -> b
$ forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ((String
"Parsing error:\n"forall a. [a] -> [a] -> [a]
++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show) (forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty a => a -> Doc
pretty) Either ParseError CompilationUnit
r