Hpp.Types

The core types involved used by the pre-processor.

Documentation

type LineNum = Int

Line numbers are represented as Ints

type Env = [(String, Macro)]

A macro binding environment.

Errors

data Error

Error conditions we may encounter.

Constructors

UnterminatedBranch

BadMacroDefinition LineNum

BadIfPredicate

BadLineArgument LineNum String

IncludeDoesNotExist LineNum FilePath

FailedInclude LineNum FilePath

UserError LineNum String

UnknownCommand LineNum String

TooFewArgumentsToMacro LineNum String

BadMacroArguments LineNum String

NoInputFile

BadCommandLine String

RanOutOfInput

Instances

Eq Error

Ord Error

Show Error

Monad m => HasError (ExceptT Error m)

class HasError m where

Hpp can raise various parsing errors.

Methods

throwError :: Error -> m a

Instances

Monad m => HasError (ExceptT Error m)

Applicative m => HasError (HppT t m)

(Monad m, HasError m) => HasError (Parser m i)

(Monad m, HasError m) => HasError (Streamer m i o)

Resource cleanup

newtype Cleanup

A cleanup action that is run at most once. To be used as an abstract type with only runCleanup and mkCleanup as interface.

Constructors

Cleanup (IORef (IO ()))

runCleanup :: Cleanup -> IO ()

Runs an action and replaces it with a nop

mkCleanup :: IO () -> IO (Cleanup, IO ())

mkCleanup cleanup returns two things: a Cleanup value, and an action to neutralize that Cleanup. In this way, the Cleanup value can be registered with a resource manager so that, in the event of an error, the cleanup action is run, while the neutralizer may be used to ensure that the registered Cleanup action has no effect if it is run. Typically one would neutralize a registered cleanup action before performing a manual cleanup that subsumes the registered cleanup.

Free Monad Transformers

data FreeF f a r

Base functor for a free monad transformer

Constructors

PureF a

FreeF (f r)

Instances

Functor f => Functor (FreeF f a)

Pre-processor Actions

data HppState

Dynamic state of the preprocessor engine.

Constructors

HppState

Fields

hppConfig :: Config

hppLineNum :: LineNum

hppCleanups :: [Cleanup]

hppEnv :: Env

data HppF t r

A free monad construction to strictly delimit what capabilities we need to perform pre-processing.

Constructors

ReadFile Int FilePath (t -> r)

ReadNext Int FilePath (t -> r)

GetState (HppState -> r)

SetState HppState r

ThrowError Error

Instances

Functor (HppF t)

Hpp Monad Transformer

newtype HppT t m a

A free monad transformer specialized to HppF as the base functor.

Constructors

HppT

Fields

runHppT :: m (FreeF (HppF t) a (HppT t m a))

Instances

MonadTrans (HppT t)

Monad m => Monad (HppT t m)

Functor m => Functor (HppT t m)

Monad m => Applicative (HppT t m)

MonadIO m => MonadIO (HppT t m)

Monad m => HasEnv (HppT t m)

Monad m => HasHppState (HppT t m)

Applicative m => HasError (HppT t m)

class HasHppState m where

An interpreter capability to modify dynamic state.

Methods

getState :: m HppState

setState :: HppState -> m ()

Instances

(Monad m, HasHppState m) => HasHppState (ExceptT e m)

Monad m => HasHppState (HppT t m)

(Monad m, HasHppState m) => HasHppState (Parser m i)

(Monad m, HasHppState m) => HasHppState (Streamer m i o)

class HasEnv m where

An interpreter capability of threading a binding environment.

Methods

getEnv :: m Env

setEnv :: Env -> m ()

Instances

(HasEnv m, Monad m) => HasEnv (ExceptT e m)

Monad m => HasEnv (HppT t m)

(Monad m, HasEnv m) => HasEnv (Streamer m i o)

Expansion

data Scan

Macro expansion involves treating tokens differently if they appear in the original source for or as the result of a previous macro expansion. This distinction is used to prevent divergence by masking out definitions that could be used recursively.

Things are made somewhat more complicated than one might expect due to the fact that the scope of this masking is not structurally recursive. A object-like macro can expand into a fragment of a macro function application, one of whose arguments is a token matching the original object-like macro. That argument should not be expanded.

Constructors

Unmask String

Mask String

Scan Token

Rescan Token

Instances

Eq Scan

Show Scan

Macros

data Macro

There are object-like macros and function-like macros.

Constructors

Object [Token]

An object-like macro is replaced with its definition

Function Int ([([Scan], String)] -> [Scan])

A function-like macro of some arity taks macro-expanded and raw versions of its arguments, then substitutes them into a body producing a new set of tokens.

Instances

Show Macro