Language.CSPM.Frontend

Frontend contains some reexports from other modules

Documentation

testFrontend :: FilePath -> IO (LModule, LModule)

parseFile :: FilePath -> IO LModule

Lex and parse a file and return a LModule, throw an exception in case of an error

data Token

Instances

Eq Token

Data Token

Ord Token

Show Token

Typeable Token

MonadState PState (GenParser Token PState)

NodeIdSupply (GenParser Token PState)

lexInclude :: String -> IO (Either LexError [Token])

lexPlain :: String -> Either LexError [Token]

filterIgnoredToken :: [Token] -> [Token]

data LexError

Constructors

LexError

Fields

lexEPos :: !AlexPosn

lexEMsg :: !String

Instances

Show LexError

Typeable LexError

Exception LexError

parse :: SourceName -> [Token] -> Either ParseError LModule

The parse function parses a List of Token. It returns a ParseError or a Labled Module. The SourceName argument is currently not used.

data ParseError

Constructors

ParseError

Fields

parseErrorMsg :: String

parseErrorToken :: Token

parseErrorPos :: AlexPosn

Instances

Show ParseError

Typeable ParseError

Exception ParseError

data Module

Instances

Eq Module

Data Module

Ord Module

Show Module

Typeable Module

PP Module

type LModule = Labeled Module

data Labeled t

Constructors

Labeled

Fields

nodeId :: NodeId

srcLoc :: SrcLoc

unLabel :: t

Instances

Functor Labeled

Typeable1 Labeled

Eq (Labeled t)

Data t => Data (Labeled t)

Ord (Labeled t)

Show t => Show (Labeled t)

PP x => PP (Labeled x)

type Bindings = Map String UniqueIdent

data SrcLoc

Constructors

TokIdPos TokenId

TokIdSpan TokenId TokenId

TokSpan Token Token

TokPos Token

NoLocation

FixedLoc

Fields

fixedStartLine :: !Int

fixedStartCol :: !Int

fixedStartOffset :: !Int

fixedLen :: !Int

fixedEndLine :: !Int

fixedEndCol :: !Int

fixedEndOffset :: !Int

Instances

Eq SrcLoc

Data SrcLoc

Ord SrcLoc

Show SrcLoc

Typeable SrcLoc

getRenaming :: LModule -> Either RenameError (Bindings, AstAnnotation UniqueIdent, AstAnnotation UniqueIdent)

getRenaming computes two AstAnnotations. The first one contains all the defining occurences of identifier The second one contains all the using occurences of identitier. getRename returns an RenameError if the Module contains unbound identifiers or illegal redefinitions.

applyRenaming :: (Bindings, AstAnnotation UniqueIdent, AstAnnotation UniqueIdent) -> LModule -> LModule

applyRenaming uses SYB to replace turn every Ident in the Module into to the UIdent version, i.e. set the UniqueIdent. At the same time, we also replace VarPat x with ConstrPat x if x an toplevel constant It is an error if the Module contains occurences of Ident that are not covered by the AstAnnotations.

removeSourceLocations :: LModule -> LModule

removeSourceLocations sets all locationsInfos to NoLocation

removeParens :: LModule -> LModule

removeParens removes all occurences of of Parens,i.e. explicit parentheses from the AST

removeModuleTokens :: LModule -> LModule

set the tokenlist in the module datatype to Nothing

unUniqueIdent :: LModule -> LModule

unUniqueIdent replaces the all UIdent with the Ident of the the new name, thus forgetting | additional information like the bindingside, etc. | Usefull to get a smaller AST.

showAst :: Data a => Labeled a -> String

'a show function that omits the node labeles. | TODO : fix this is very buggy. | this does not work for Compiles pattern / Arrays

relabelAst :: NodeId -> LModule -> LModule

relabelAst compute an AST with new NodeIds starting with the given NodeId

computeFreeNames :: Data a => a -> FreeNames

Compute the FreeNames of an Expression. | This function does only work after renaming has been done. | This implementation is inefficient.

data RenameError

Constructors

RenameError

Fields

renameErrorMsg :: String

renameErrorLoc :: SrcLoc

Instances

Show RenameError

Typeable RenameError

Exception RenameError

Error RenameError

eitherToExc :: Exception a => Either a b -> IO b

eitherToExe returns the Right part of Either or throws the Left part as an dynamic exception.

handleLexError :: (LexError -> IO a) -> IO a -> IO a

Handle a dymanic exception of type LexError.

handleParseError :: (ParseError -> IO a) -> IO a -> IO a

Handle a dymanic exception of type ParseError.

handleRenameError :: (RenameError -> IO a) -> IO a -> IO a

Handle a dymanic exception of type RenameError.

compilePattern :: LModule -> LModule

replace all pattern in the module with list of linear Selectors

version :: IO String

version returns a String with some info about the, on which the libray was built.

pp :: PP x => x -> Doc