Safe Haskell	None
Language	Haskell2010

Agda.Syntax.Parser.Alex

Contents

Alex requirements
Lex actions
Monad operations

Description

This module defines the things required by Alex and some other Alex related things.

Synopsis

data AlexInput = AlexInput {
- lexSrcFile :: !SrcFile
- lexPos :: !PositionWithoutFile
- lexInput :: String
- lexPrevChar :: !Char
}
lensLexInput :: Lens' String AlexInput
alexInputPrevChar :: AlexInput -> Char
alexGetChar :: AlexInput -> Maybe (Char, AlexInput)
alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)
newtype LexAction r = LexAction {
- runLexAction :: PreviousInput -> CurrentInput -> TokenLength -> Parser r
}
type LexPredicate = ([LexState], ParseFlags) -> PreviousInput -> TokenLength -> CurrentInput -> Bool
(.&&.) :: LexPredicate -> LexPredicate -> LexPredicate
(.||.) :: LexPredicate -> LexPredicate -> LexPredicate
not' :: LexPredicate -> LexPredicate
type PreviousInput = AlexInput
type CurrentInput = AlexInput
type TokenLength = Int
getLexInput :: Parser AlexInput
setLexInput :: AlexInput -> Parser ()

Alex requirements

data AlexInput Source #

This is what the lexer manipulates.

Constructors

AlexInput
Fields lexSrcFile :: !SrcFile File. lexPos :: !PositionWithoutFile Current position. lexInput :: String Current input. lexPrevChar :: !Char Previously read character.

lensLexInput :: Lens' String AlexInput Source #

A lens for lexInput.

alexInputPrevChar :: AlexInput -> Char Source #

Get the previously lexed character. Same as lexPrevChar. Alex needs this to be defined to handle "patterns with a left-context".

alexGetChar :: AlexInput -> Maybe (Char, AlexInput) Source #

Returns the next character, and updates the AlexInput value.

This function is not suitable for use by Alex 2, because it can return non-ASCII characters.

alexGetByte :: AlexInput -> Maybe (Word8, AlexInput) Source #

Returns the next byte, and updates the AlexInput value.

A trick is used to handle the fact that there are more than 256 Unicode code points. The function translates characters to bytes in the following way:

Whitespace characters other than '\t' and '\n' are translated to ' '.
Non-ASCII alphabetical characters are translated to 'z'.
Other non-ASCII printable characters are translated to '+'.
Everything else is translated to '\1'.

Note that it is important that there are no keywords containing 'z', '+', ' ' or '\1'.

This function is used by Alex (version 3).

Lex actions

newtype LexAction r Source #

In the lexer, regular expressions are associated with lex actions who's task it is to construct the tokens.

Constructors

LexAction
Fields runLexAction :: PreviousInput -> CurrentInput -> TokenLength -> Parser r

Instances

Instances details

Monad LexAction Source #
Instance details Defined in Agda.Syntax.Parser.Alex Methods (>>=) :: LexAction a -> (a -> LexAction b) -> LexAction b # (>>) :: LexAction a -> LexAction b -> LexAction b # return :: a -> LexAction a #
Functor LexAction Source #
Instance details Defined in Agda.Syntax.Parser.Alex Methods fmap :: (a -> b) -> LexAction a -> LexAction b # (<$) :: a -> LexAction b -> LexAction a #
Applicative LexAction Source #
Instance details Defined in Agda.Syntax.Parser.Alex Methods pure :: a -> LexAction a # (<>) :: LexAction (a -> b) -> LexAction a -> LexAction b # liftA2 :: (a -> b -> c) -> LexAction a -> LexAction b -> LexAction c # (>) :: LexAction a -> LexAction b -> LexAction b # (<*) :: LexAction a -> LexAction b -> LexAction a #
MonadState ParseState LexAction Source #
Instance details Defined in Agda.Syntax.Parser.Alex Methods get :: LexAction ParseState # put :: ParseState -> LexAction () # state :: (ParseState -> (a, ParseState)) -> LexAction a #

type LexPredicate = ([LexState], ParseFlags) -> PreviousInput -> TokenLength -> CurrentInput -> Bool Source #

Sometimes regular expressions aren't enough. Alex provides a way to do arbitrary computations to see if the input matches. This is done with a lex predicate.

(.&&.) :: LexPredicate -> LexPredicate -> LexPredicate Source #

Conjunction of LexPredicates.

(.||.) :: LexPredicate -> LexPredicate -> LexPredicate Source #

Disjunction of LexPredicates.

not' :: LexPredicate -> LexPredicate Source #

Negation of LexPredicates.

type PreviousInput = AlexInput Source #

type CurrentInput = AlexInput Source #

type TokenLength = Int Source #

Monad operations

getLexInput :: Parser AlexInput Source #

setLexInput :: AlexInput -> Parser () Source #