Language.C.Monad

A monad for C code generation

Documentation

data Flags

Code generation flags

Constructors

Flags

data CEnv

Code generator state.

Constructors

CEnv

Fields

_flags :: Flags

_unique :: !Integer

_modules :: Map String [Definition]

_includes :: Set String

_typedefs :: [Definition]

_prototypes :: [Definition]

_globals :: [Definition]

_aliases :: Map Integer String

_params :: [Param]

_args :: [Exp]

_locals :: [InitGroup]

_stms :: [Stm]

_finalStms :: [Stm]

_usedVars :: Set Id

_funUsedVars :: Map String (Set Id)

Instances

Monad t => MonadState CEnv (CGenT t)

usedVars :: Lens' CEnv (Set Id)

unique :: Lens' CEnv Integer

typedefs :: Lens' CEnv [Definition]

stms :: Lens' CEnv [Stm]

prototypes :: Lens' CEnv [Definition]

params :: Lens' CEnv [Param]

modules :: Lens' CEnv (Map String [Definition])

locals :: Lens' CEnv [InitGroup]

includes :: Lens' CEnv (Set String)

globals :: Lens' CEnv [Definition]

funUsedVars :: Lens' CEnv (Map String (Set Id))

flags :: Lens' CEnv Flags

finalStms :: Lens' CEnv [Stm]

args :: Lens' CEnv [Exp]

aliases :: Lens' CEnv (Map Integer String)

(<<%=) :: MonadState s m => (forall f. Functor f => LensLike' f s a) -> (a -> a) -> m a

Reimplementation of <<%= from the lens package

(<<.=) :: MonadState s m => (forall f. Functor f => LensLike' f s a) -> a -> m a

Reimplementation of <<.= from the lens package

defaultCEnv :: Flags -> CEnv

Default code generator state

type MonadC m = (Functor m, Applicative m, Monad m, MonadState CEnv m, MonadException m, MonadFix m)

Code generation type constraints

newtype CGenT t a

The C code generation monad transformer

Constructors

CGenT

Fields

unCGenT :: StateT CEnv (ExceptionT t) a

Instances

Monad t => MonadState CEnv (CGenT t)

Monad t => Monad (CGenT t)

Functor t => Functor (CGenT t)

MonadFix t => MonadFix (CGenT t)

Monad t => Applicative (CGenT t)

Monad t => MonadException (CGenT t)

MonadIO t => MonadIO (CGenT t)

type CGen = CGenT Identity

runCGenT :: Monad m => CGenT m a -> CEnv -> m (a, CEnv)

Run the C code generation monad

runCGen :: CGen a -> CEnv -> (a, CEnv)

Run the C code generation monad

cenvToCUnit :: CEnv -> [Definition]

Extract a compilation unit from the CEnv state

prettyCGenT :: Monad m => CGenT m a -> m [(String, Doc)]

Generate C documents for each module

prettyCGen :: CGen a -> [(String, Doc)]

freshId :: MonadC m => m Integer

Retrieve a fresh identifier

gensym :: MonadC m => String -> m String

Generate a fresh symbol by appending a fresh id to a base name

touchVar :: (MonadC m, ToIdent v) => v -> m ()

Mark an identifier as used in this context.

setUsedVars :: MonadC m => String -> Set Id -> m ()

Set the Set of identifers used in the body of the given function.

addInclude :: MonadC m => String -> m ()

Add an include pre-processor directive. Specify <> or '""' around the file name.

addLocalInclude :: MonadC m => String -> m ()

Add a local include directive. The argument will be surrounded by '""'

addSystemInclude :: MonadC m => String -> m ()

Add a system include directive. The argument will be surrounded by <>

addTypedef :: MonadC m => Definition -> m ()

Add a type definition

addPrototype :: MonadC m => Definition -> m ()

Add a function prototype

addGlobal :: MonadC m => Definition -> m ()

Add a global definition

addGlobals :: MonadC m => [Definition] -> m ()

Add multiple global definitions

withAlias :: MonadC m => Integer -> String -> m a -> m a

Let a variable be known by another name

addParam :: MonadC m => Param -> m ()

Add a function parameter when building a function definition

addParams :: MonadC m => [Param] -> m ()

addArg :: MonadC m => Exp -> m ()

Add a function argument when building a function call

addLocal :: MonadC m => InitGroup -> m ()

Add a local declaration (including initializations)

addLocals :: MonadC m => [InitGroup] -> m ()

Add multiple local declarations

addStm :: MonadC m => Stm -> m ()

Add a statement to the current block

addStms :: MonadC m => [Stm] -> m ()

Add a sequence of statements to the current block

addFinalStm :: MonadC m => Stm -> m ()

Add a statement to the end of the current block

inBlock :: MonadC m => m a -> m a

Run an action in a new block

inNewBlock :: MonadC m => m a -> m (a, [BlockItem])

Run an action as a block and capture the items. Does not place the items in an actual C block.

inNewBlock_ :: MonadC m => m a -> m [BlockItem]

Run an action as a block and capture the items. Does not place the items in an actual C block.

inNewFunction :: MonadC m => m a -> m (a, Set Id, [Param], [BlockItem])

Run an action as a function declaration. Does not create a new function.

inFunction :: MonadC m => String -> m a -> m a

Declare a function

inFunctionTy :: MonadC m => Type -> String -> m a -> m a

Declare a function with the given return type.

collectDefinitions :: MonadC m => m a -> m (a, [Definition])

Collect all global definitions in the current state

collectArgs :: MonadC m => m [Exp]

Collect all function arguments in the current state

inModule :: MonadC m => String -> m a -> m a

Declare a C translation unit

wrapMain :: MonadC m => m a -> m ()

Wrap a program in a main function

liftSharedLocals :: MonadC m => m a -> m ()

Lift the declarations of all variables that are shared between functions to the top level. This relies on variable IDs being unique across programs, not just across the functions in which they are declared.

Only affects locally declared vars, not function arguments.

extractDecls :: (Id -> Bool) -> Definition -> (Definition, Set InitGroup)

Remove all declarations matching a predicate from the given function and return them in a separate list.