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

Methods

(==) :: Error -> Error -> Bool

(/=) :: Error -> Error -> Bool

Ord Error

Methods

compare :: Error -> Error -> Ordering

(<) :: Error -> Error -> Bool

(<=) :: Error -> Error -> Bool

(>) :: Error -> Error -> Bool

(>=) :: Error -> Error -> Bool

max :: Error -> Error -> Error

min :: Error -> Error -> Error

Show Error

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

Monad m => HasError (ExceptT Error m)

Methods

throwError :: Error -> ExceptT Error m a

class HasError m where

Hpp can raise various parsing errors.

Minimal complete definition

throwError

Methods

throwError :: Error -> m a

Instances

Monad m => HasError (ExceptT Error m)

Methods

throwError :: Error -> ExceptT Error m a

Applicative m => HasError (HppT t m)

Methods

throwError :: Error -> HppT t m a

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

Methods

throwError :: Error -> Parser m i a

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

Methods

throwError :: Error -> Streamer m i o a

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)

Methods

fmap :: (a -> b) -> FreeF f a a -> FreeF f a b

(<$) :: a -> FreeF f a b -> FreeF f a 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)

Methods

fmap :: (a -> b) -> HppF t a -> HppF t b

(<$) :: a -> HppF t b -> HppF t a

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)

Methods

lift :: Monad m => m a -> HppT t m a

Monad m => Monad (HppT t m)

Methods

(>>=) :: HppT t m a -> (a -> HppT t m b) -> HppT t m b

(>>) :: HppT t m a -> HppT t m b -> HppT t m b

return :: a -> HppT t m a

fail :: String -> HppT t m a

Functor m => Functor (HppT t m)

Methods

fmap :: (a -> b) -> HppT t m a -> HppT t m b

(<$) :: a -> HppT t m b -> HppT t m a

Monad m => Applicative (HppT t m)

Methods

pure :: a -> HppT t m a

(<*>) :: HppT t m (a -> b) -> HppT t m a -> HppT t m b

(*>) :: HppT t m a -> HppT t m b -> HppT t m b

(<*) :: HppT t m a -> HppT t m b -> HppT t m a

MonadIO m => MonadIO (HppT t m)

Methods

liftIO :: IO a -> HppT t m a

Monad m => HasEnv (HppT t m)

Methods

getEnv :: HppT t m Env

setEnv :: Env -> HppT t m ()

Monad m => HasHppState (HppT t m)

Methods

getState :: HppT t m HppState

setState :: HppState -> HppT t m ()

Applicative m => HasError (HppT t m)

Methods

throwError :: Error -> HppT t m a

class HasHppState m where

An interpreter capability to modify dynamic state.

Minimal complete definition

getState, setState

Methods

getState :: m HppState

setState :: HppState -> m ()

Instances

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

Methods

getState :: ExceptT e m HppState

setState :: HppState -> ExceptT e m ()

Monad m => HasHppState (HppT t m)

Methods

getState :: HppT t m HppState

setState :: HppState -> HppT t m ()

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

Methods

getState :: Parser m i HppState

setState :: HppState -> Parser m i ()

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

Methods

getState :: Streamer m i o HppState

setState :: HppState -> Streamer m i o ()

class HasEnv m where

An interpreter capability of threading a binding environment.

Minimal complete definition

getEnv, setEnv

Methods

getEnv :: m Env

setEnv :: Env -> m ()

Instances

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

Methods

getEnv :: ExceptT e m Env

setEnv :: Env -> ExceptT e m ()

Monad m => HasEnv (HppT t m)

Methods

getEnv :: HppT t m Env

setEnv :: Env -> HppT t m ()

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

Methods

getEnv :: Streamer m i o Env

setEnv :: Env -> 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

Methods

(==) :: Scan -> Scan -> Bool

(/=) :: Scan -> Scan -> Bool

Show Scan

Methods

showsPrec :: Int -> Scan -> ShowS

show :: Scan -> String

showList :: [Scan] -> ShowS

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

Methods

showsPrec :: Int -> Macro -> ShowS

show :: Macro -> String

showList :: [Macro] -> ShowS