JVM.Builder.Monad

This module defines Generate[IO] monad, which helps generating JVM code and creating Java class constants pool.

Code generation could be done using one of two monads: Generate and GenerateIO. Generate monad is pure (simply State monad), while GenerateIO is IO-related. In GenerateIO additional actions are available, such as setting up ClassPath and loading classes (from .class files or JAR archives).

Documentation

data GState

Generator state

Constructors

GState

Fields

generated :: [Instruction]

Already generated code (in current method)

currentPool :: Pool Direct

Already generated constants pool

nextPoolIndex :: Word16

Next index to be used in constants pool

doneMethods :: [Method Direct]

Already generated class methods

currentMethod :: Maybe (Method Direct)

Current method

stackSize :: Word16

Maximum stack size for current method

locals :: Word16

Maximum number of local variables for current method

classPath :: [Tree CPEntry]

Instances

Eq GState

Show GState

MonadState GState (GenerateIO e)

MonadState GState (Generate e)

MonadIO (EMT e (StateT GState IO))

emptyGState :: GState

Empty generator state

class (Monad (g e), MonadState GState (g e)) => Generator e g where

Methods

throwG :: (Exception x, Throws x e) => x -> g e a

Instances

MonadState GState (EMT e (State GState)) => Generator e Generate

Generator e GenerateIO

data Generate e a

Generate monad

Instances

MonadState GState (EMT e (State GState)) => Generator e Generate

MonadState GState (Generate e)

Monad (Generate e)

data GenerateIO e a

IO version of Generate monad

Instances

Generator e GenerateIO

MonadState GState (GenerateIO e)

Monad (GenerateIO e)

MonadIO (GenerateIO e)

addToPool :: Generator e g => Constant Direct -> g e Word16

Add a constant into pool

i0 :: Generator e g => Instruction -> g e ()

Generate one (zero-arguments) instruction

i1 :: Generator e g => (Word16 -> Instruction) -> Constant Direct -> g e ()

Generate one one-argument instruction

i8 :: Generator e g => (Word8 -> Instruction) -> Constant Direct -> g e ()

Generate one one-argument instruction

newMethod

Arguments

:: (Generator e g, Throws UnexpectedEndMethod e)

=> [AccessFlag]

Access flags for method (public, static etc)

-> ByteString

Method name

-> [ArgumentSignature]

Signatures of method arguments

-> ReturnSignature

Method return signature

-> g e ()

Generator for method code

-> g e (NameType (Method Direct))

Generate new method

setStackSize :: Generator e g => Word16 -> g e ()

Set maximum stack size for current method

setMaxLocals :: Generator e g => Word16 -> g e ()

Set maximum number of local variables for current method

withClassPath :: ClassPath () -> GenerateIO e ()

Update ClassPath

getClassField :: (Throws ENotFound e, Throws ENotLoaded e) => String -> ByteString -> GenerateIO e (NameType (Field Direct))

Get class field signature from current ClassPath

getClassMethod :: (Throws ENotFound e, Throws ENotLoaded e) => String -> ByteString -> GenerateIO e (NameType (Method Direct))

Get class method signature from current ClassPath

generate :: [Tree CPEntry] -> ByteString -> Generate (Caught SomeException NoExceptions) () -> Class Direct

Generate a class

generateIO :: [Tree CPEntry] -> ByteString -> GenerateIO (Caught SomeException NoExceptions) () -> IO (Class Direct)

Generate a class

generateCodeLength :: Generate (Caught SomeException NoExceptions) a -> Word32