Safe Haskell	None
Language	Haskell2010

Foreign.Hoppy.Generator.Language.Haskell

Contents

Code generators
Exports
Imports
Language extensions
Code generation

Description

Shared portion of the Haskell code generator. Usable by binding definitions.

Synopsis

Documentation

data Managed #

Indicates who is managing the lifetime of an object via an object pointer.

Constructors

Unmanaged	The object's lifetime is being managed manually.
Managed	The object's lifetime is being managed by the Haskell garbage collector.

Instances

Bounded Managed #
Methods minBound :: Managed # maxBound :: Managed #
Enum Managed #
Methods succ :: Managed -> Managed # pred :: Managed -> Managed # toEnum :: Int -> Managed # fromEnum :: Managed -> Int # enumFrom :: Managed -> [Managed] # enumFromThen :: Managed -> Managed -> [Managed] # enumFromTo :: Managed -> Managed -> [Managed] # enumFromThenTo :: Managed -> Managed -> Managed -> [Managed] #
Eq Managed #
Methods (==) :: Managed -> Managed -> Bool # (/=) :: Managed -> Managed -> Bool #
Ord Managed #
Methods compare :: Managed -> Managed -> Ordering # (<) :: Managed -> Managed -> Bool # (<=) :: Managed -> Managed -> Bool # (>) :: Managed -> Managed -> Bool # (>=) :: Managed -> Managed -> Bool # max :: Managed -> Managed -> Managed # min :: Managed -> Managed -> Managed #

getModuleName :: Interface -> Module -> String #

Returns the complete Haskell module name for a Module in an Interface, taking into account the interfaceHaskellModuleBase and the moduleHaskellName.

toModuleName :: String -> String #

Performs case conversions on the given string to ensure that it is a valid component of a Haskell module name.

Code generators

data Partial #

A partially-rendered Module. Contains all of the module's bindings, but may be subject to further processing.

Constructors

Partial
Fields partialModuleHsName :: String This is just the module name. partialOutput :: Output

Instances

Eq Partial #
Methods (==) :: Partial -> Partial -> Bool # (/=) :: Partial -> Partial -> Bool #
Ord Partial #
Methods compare :: Partial -> Partial -> Ordering # (<) :: Partial -> Partial -> Bool # (<=) :: Partial -> Partial -> Bool # (>) :: Partial -> Partial -> Bool # (>=) :: Partial -> Partial -> Bool # max :: Partial -> Partial -> Partial # min :: Partial -> Partial -> Partial #

data Output #

A chunk of generated Haskell code, including information about imports and exports.

Constructors

Output

Fields

outputExports :: [HsExport]
Haskell module exports. Each HsExport should include one item to go in the export list of the generated module. Should only contain objects imported or defined in the same Output.
outputImports :: HsImportSet
Haskell module imports. Should include all imports needed for the outputBody.
outputBody :: [String]
Lines of Haskell code (possibly empty). These lines may not contain the newline character in them. There is an implicit newline between each string, as given by intercalate "\n" . outputBody.
outputExtensions :: Set String
Language extensions to enable via the {--} pragma for the whole module.

Instances

Monoid Output #
Methods mempty :: Output # mappend :: Output -> Output -> Output # mconcat :: [Output] -> Output #

type Generator = ReaderT Env (WriterT Output (Except ErrorMsg)) #

A generator monad for Haskell code.

Errors thrown in this monad are of the form:

"$problem; $context; $moreContext; $evenMoreContext."

For example, "Class Foo is not convertible (use classModifyConversion); generating function bar; in module baz.".

The main error message given to throwError should be capitalized and should not end with punctuation. If there is a suggestion, include it in parentheses at the end of the message. withErrorContext and inFunction add context information, and should be given clauses, without punctuation.

runGenerator :: Interface -> Module -> Generator a -> Either ErrorMsg (Partial, a) #

Runs a generator action for the given interface and module name string. Returns an error message if an error occurred, otherwise the action's output together with its value.

evalGenerator :: Interface -> Module -> Generator a -> Either ErrorMsg a #

Runs a generator action and returns the its value.

execGenerator :: Interface -> Module -> Generator a -> Either ErrorMsg Partial #

Runs a generator action and returns its output.

renderPartial :: Partial -> String #

Converts a Partial into a complete Haskell module.

askInterface :: Generator Interface #

Returns the currently generating interface.

askModule :: Generator Module #

Returns the currently generating module.

askModuleName :: Generator String #

Returns the currently generating module's Haskell module name.

getModuleForExtName :: ExtName -> Generator Module #

Looks up the Module containing a given external name, throwing an error if it can't be found.

withErrorContext :: String -> Generator a -> Generator a #

Adds context information to the end of any error message thrown by the action. See Generator.

inFunction :: String -> Generator a -> Generator a #

Adds the given function name to any error message thrown by the action, for context.

Exports

type HsExport = String #

Indicates strings that represent an item in a Haskell module export list.

addExport :: HsExport -> Generator () #

Adds an export to the current module.

addExport' :: HsExport -> Generator () #

addExport' "x" adds an export of the form x (..) to the current module.

addExports :: [HsExport] -> Generator () #

Adds multiple exports to the current module.

Imports

addImports :: HsImportSet -> Generator () #

Adds imports to the current module.

Language extensions

addExtension :: String -> Generator () #

Adds a Haskell language extension to the current module.

Code generation

sayLn :: String -> Generator () #

Outputs a line of Haskell code. A newline will be added on the end of the input. Newline characters must not be given to this function.

saysLn :: [String] -> Generator () #

Outputs multiple words to form a line of Haskell code (effectively saysLn = sayLn . concat).

ln :: Generator () #

Outputs an empty line of Haskell code. This is reportedly valid Perl code as well.

indent :: Generator a -> Generator a #

Runs the given action, indenting all code output by the action one level.

indentSpaces :: Int -> Generator a -> Generator a #

Runs the given action, indenting all code output by the action N spaces.

sayLet :: [Generator ()] -> Maybe (Generator ()) -> Generator () #

Takes a list of binding actions and a body action, and outputs a let expression. By passing in Nothing for the body, it will be omitted, so let statements in do blocks can be created as well. Output is of the form:

let
  <binding1>
  ...
  <bindingN>
  in
    <body>

To stretch a binding over multiple lines, lines past the first should use indent manually.

toHsEnumTypeName :: CppEnum -> Generator String #

Returns the Haskell name for an enum.

toHsEnumTypeName' :: CppEnum -> String #

Pure version of toHsEnumTypeName that doesn't create a qualified name.

toHsEnumCtorName :: CppEnum -> [String] -> Generator String #

Constructs the data constructor name for a value in an enum. Like C++ and unlike say Java, Haskell enum values aren't in a separate enum-specific namespace, so we prepend the enum name to the value name to get the data constructor name. The value name is a list of words; see enumValueNames.

toHsEnumCtorName' :: CppEnum -> [String] -> String #

Pure version of toHsEnumCtorName that doesn't create a qualified name.

toHsBitspaceTypeName :: Bitspace -> Generator String #

Returns the Haskell name for a bitspace. See toHsEnumTypeName.

toHsBitspaceTypeName' :: Bitspace -> String #

Pure version of toHsBitspaceTypeName that doesn't create a qualified name.

toHsBitspaceValueName :: Bitspace -> [String] -> Generator String #

Constructs the data constructor name for a value in a bitspace. See toHsEnumCtorName.

toHsBitspaceValueName' :: Bitspace -> [String] -> String #

Pure version of toHsBitspaceValueName that doesn't create a qualified name.

toHsBitspaceToNumName :: Bitspace -> Generator String #

Returns the name of the function that will convert a bitspace value into a raw numeric value.

toHsBitspaceToNumName' :: Bitspace -> String #

Pure version of toHsBitspaceToNumName that doesn't create a qualified name.

toHsBitspaceClassName :: Bitspace -> Generator String #

The name of the Haskell typeclass that contains a method for converting to a bitspace value.

toHsBitspaceClassName' :: Bitspace -> String #

Pure version of toHsBitspaceClassName that doesn't create a qualified name.

toHsBitspaceFromValueName :: Bitspace -> Generator String #

The name of the method in the toHsBitspaceClassName typeclass that constructs bitspace values.

toHsBitspaceFromValueName' :: Bitspace -> String #

Pure version of toHsBitspaceFromValueName that doesn't create a qualified name.

toHsValueClassName :: Class -> Generator String #

The name for the typeclass of types that can be represented as values of the given C++ class.

toHsValueClassName' :: Class -> String #

Pure version of toHsValueClassName that doesn't create a qualified name.

toHsWithValuePtrName :: Class -> Generator String #

The name of the method within the toHsValueClassName typeclass for accessing an object of the type as a pointer.

toHsWithValuePtrName' :: Class -> String #

Pure version of toHsWithValuePtrName that doesn't create a qualified name.

toHsPtrClassName :: Constness -> Class -> Generator String #

The name for the typeclass of types that are (possibly const) pointers to objects of the given C++ class, or subclasses.

toHsPtrClassName' :: Constness -> Class -> String #

Pure version of toHsPtrClassName that doesn't create a qualified name.

toHsCastMethodName :: Constness -> Class -> Generator String #

The name of the function that upcasts pointers to the specific class type and constness.

toHsCastMethodName' :: Constness -> Class -> String #

Pure version of toHsCastMethodName that doesn't create a qualified name.

toHsDownCastClassName :: Constness -> Class -> Generator String #

The name of the typeclass that provides a method to downcast to a specific class type. See toHsDownCastMethodName.

toHsDownCastClassName' :: Constness -> Class -> String #

Pure version of toHsDownCastClassName that doesn't create a qualified name.

toHsDownCastMethodName :: Constness -> Class -> Generator String #

The name of the function that downcasts pointers to the specific class type and constness.

toHsDownCastMethodName' :: Constness -> Class -> String #

Pure version of toHsDownCastMethodName that doesn't create a qualified name.

toHsCastPrimitiveName :: Class -> Class -> Class -> Generator String #

The import name for the foreign function that casts between two specific pointer types. Used for upcasting and downcasting.

We need to know which module the cast function resides in, and while we could look this up, the caller always knows, so we just have them pass it in.

toHsCastPrimitiveName' :: Class -> Class -> String #

Pure version of toHsCastPrimitiveName that doesn't create a qualified name.

toHsConstCastFnName :: Constness -> Class -> Generator String #

The name of one of the functions that addremove const tofrom a class's pointer type. Given Const, it will return the function that adds const, and given Nonconst, it will return the function that removes const.

toHsConstCastFnName' :: Constness -> Class -> String #

Pure version of toHsConstCastFnName that doesn't create a qualified name.

toHsDataTypeName :: Constness -> Class -> Generator String #

The name of the data type that represents a pointer to an object of the given class and constness.

toHsDataTypeName' :: Constness -> Class -> String #

Pure version of toHsDataTypeName that doesn't create a qualified name.

toHsDataCtorName :: Managed -> Constness -> Class -> Generator String #

The name of a data constructor for one of the object pointer types.

toHsDataCtorName' :: Managed -> Constness -> Class -> String #

Pure version of toHsDataCtorName that doesn't create a qualified name.

toHsClassDeleteFnName' :: Class -> String #

The name of the foreign function import wrapping delete for the given class type. This is in internal to the binding; normal users should use delete.

This is internal to a generated Haskell module, so it does not have a public (qualified) form.

toHsClassDeleteFnPtrName' :: Class -> String #

The name of the foreign import that imports the same function as toHsClassDeleteFnName, but as a FunPtr rather than an actual function.

This is internal to a generated Haskell module, so it does not have a public (qualified) form.

toHsCtorName :: Class -> Ctor -> Generator String #

Returns the name of the Haskell function that invokes the given constructor.

toHsCtorName' :: Class -> Ctor -> String #

Pure version of toHsCtorName that doesn't create a qualified name.

toHsMethodName :: Class -> Method -> Generator String #

Returns the name of the Haskell function that invokes the given method.

toHsMethodName' :: Class -> Method -> String #

Pure version of toHsMethodName that doesn't create a qualified name.

toHsClassEntityName :: IsFnName String name => Class -> name -> Generator String #

Returns the name of the Haskell function for an entity in a class.

toHsClassEntityName' :: IsFnName String name => Class -> name -> String #

Pure version of toHsClassEntityName that doesn't create a qualified name.

toHsCallbackCtorName :: Callback -> Generator String #

The name of the function that takes a Haskell function and wraps it in a callback object. This is internal to the binding; normal users can pass Haskell functions to be used as callbacks inplicitly.

toHsCallbackCtorName' :: Callback -> String #

Pure version of toHsCallbackCtorName that doesn't create a qualified name.

toHsCallbackNewFunPtrFnName :: Callback -> Generator String #

The name of the function that takes a Haskell function with Haskell-side types and wraps it in a FunPtr that does appropriate conversions to and from C-side types.

toHsCallbackNewFunPtrFnName' :: Callback -> String #

Pure version of toHsCallbackNewFunPtrFnName that doesn't create a qualified name.

toHsFnName :: ExtName -> Generator String #

Converts an external name into a name suitable for a Haskell function or variable.

toHsFnName' :: ExtName -> String #

Pure version of toHsFnName that doesn't create a qualified name.

toArgName :: Int -> String #

Returns a distinct argument variable name for each nonnegative number.

data HsTypeSide #

The Haskell side of bindings performs conversions between C FFI types and Haskell types. This denotes which side's type is being used.

Constructors

HsCSide	The C type sent from C++.
HsHsSide	The Haskell-native type.

Instances

Eq HsTypeSide #
Methods (==) :: HsTypeSide -> HsTypeSide -> Bool # (/=) :: HsTypeSide -> HsTypeSide -> Bool #
Show HsTypeSide #
Methods showsPrec :: Int -> HsTypeSide -> ShowS # show :: HsTypeSide -> String # showList :: [HsTypeSide] -> ShowS #

cppTypeToHsTypeAndUse :: HsTypeSide -> Type -> Generator HsType #

Returns the HsType corresponding to a Type, and also adds imports to the Generator as necessary for Haskell types that the Type references. On failure, an error is thrown.

getClassHaskellConversion :: Class -> ClassHaskellConversion #

Returns the ClassHaskellConversion of a class.

callbackToTFn :: HsTypeSide -> Callback -> Generator Type #

Constructs the function type for a callback. For Haskell, the type depends on the side; the C++ side has additional parameters.

Keep this in sync with the C++ generator's version.

prettyPrint :: Pretty a => a -> String #

Prints a value like prettyPrint, but removes newlines so that they don't cause problems with this module's textual generation. Should be mainly used for printing types; stripping newlines from definitions for example could go badly.