Language.Pads.Padsc

This module re-exports all the modules necessary to make use of the Pads quasiquoter and compilation infrastructure.

Documentation

data Span

A span in the source input, covering a contiguous range of the Source input. AFAIK there's no distinction between the states where begin == end and where end == Nothing.

Constructors

Span

Fields

• begin :: Loc

  Start location of the Span

• end :: Maybe Loc

  End location of the Span, inclusive

Instances

Eq Span

Defined in Language.Pads.Source

Methods

(==) :: Span -> Span -> Bool

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

Data Span

Defined in Language.Pads.Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Span -> c Span

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Span

toConstr :: Span -> Constr

dataTypeOf :: Span -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Span)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Span)

gmapT :: (forall b. Data b => b -> b) -> Span -> Span

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Span -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Span -> r

gmapQ :: (forall d. Data d => d -> u) -> Span -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Span -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Span -> m Span

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Span -> m Span

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Span -> m Span

Ord Span

Defined in Language.Pads.Source

Methods

compare :: Span -> Span -> Ordering

(<) :: Span -> Span -> Bool

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

(>) :: Span -> Span -> Bool

(>=) :: Span -> Span -> Bool

max :: Span -> Span -> Span

min :: Span -> Span -> Span

Show Span

Defined in Language.Pads.Source

Methods

showsPrec :: Int -> Span -> ShowS

show :: Span -> String

showList :: [Span] -> ShowS

Pretty Span

Defined in Language.Pads.Source

Methods

ppr :: Span -> Doc

pprPrec :: Int -> Span -> Doc

pprList :: [Span] -> Doc

data Loc

Source location information.

Constructors

Loc

Fields

• recordNumber :: Int64

  Number of records parsed so far (i.e. record index)

• byteOffset :: Int64

  Total number of bytes parsed into the source input so far

Instances

Eq Loc

Defined in Language.Pads.Source

Methods

(==) :: Loc -> Loc -> Bool

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

Data Loc

Defined in Language.Pads.Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc

toConstr :: Loc -> Constr

dataTypeOf :: Loc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)

gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

Ord Loc

Defined in Language.Pads.Source

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

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

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Show Loc

Defined in Language.Pads.Source

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Pretty Loc

Defined in Language.Pads.Source

Methods

ppr :: Loc -> Doc

pprPrec :: Int -> Loc -> Doc

pprList :: [Loc] -> Doc

data RecordDiscipline

A record discipline specifies the manner by which pads should partition the input into records. Note that the record character gets consumed internally by the parsing monad.

Constructors

Single Word8

Split input based on a single 8-bit unsigned integer (character)

Multi ByteString

Split input based on more than one character

Bytes Int

Split the input into records every Int characters

NoPartition

No partitioning of the input - all input data is in the current field

NoDiscipline

No discipline is currently installed; all input data is in rest field

data Source

Input source abstraction

Constructors

Source

Fields

• current :: ByteString

  The current input before EOR

• rest :: ByteString

  The rest of the input after the next EOR

• loc :: Loc

  The current location Loc in the input

• bit :: Int

  Bit offset into the current input being parsed

• disc :: RecordDiscipline

  The record discipline of this input source

• eorAtEOF :: Bool

  Relevant for seperator-based record disciplines: Single, Multi Set when current record is last record and separtor appeared at end.

Instances

Pretty Source

Defined in Language.Pads.Source

Methods

ppr :: Source -> Doc

pprPrec :: Int -> Source -> Doc

pprList :: [Source] -> Doc

newline :: RecordDiscipline

Record discipline for Unix newlines

windows :: RecordDiscipline

Record discipline for Windows CRLF newlines

bytes :: Int -> RecordDiscipline

Record discipline for every n characters

none :: RecordDiscipline

No record discipline

zeroLoc :: Loc

Initial instance of a Loc

zeroSpan :: Span

A span starting at the beginning of the file and containing nothing.

zeroBit :: Int

Parse the most significant bit in a byte first

incRecordNumber :: Loc -> Loc

Increment how many records have been seen in the given Loc

decLineNumber :: Loc -> Loc

Decrement how many records have been seen in the given Loc

incOffset :: Loc -> Loc

Increment the offset of the Loc by one

incOffsetBy :: Loc -> Int -> Loc

Increment the offset of the given Loc by some number

decOffset :: Loc -> Loc

Decrement the offset of the given Loc by one

emptySource :: Source

An empty Source with reasonable defaults for everything.

padsSourceFromString :: String -> Source

Stuff the given String into a Source with a newline discipline by default (see padsSourceFromByteString)

padsSourceFromStringWithDisc :: RecordDiscipline -> String -> Source

Stuff the given String into a Source with the given record discipline

padsSourceFromFile :: FilePath -> IO Source

Read a Source from disk

padsSourceFromFileWithDisc :: RecordDiscipline -> FilePath -> IO Source

Read a Source from disk using the given record discipline

padsSourceFromByteString :: ByteString -> Source

Construct a Source from the given ByteString, preparing the first record immediately.

padsSourceFromByteStringWithDisc :: RecordDiscipline -> ByteString -> Source

Same as padsSourceFromByteString but with a record discipline

isEOF :: Source -> Bool

Whether or not the Source has consumed all available input

isEOR :: Source -> Bool

Whether or not the Source has consumed all input in the current record

takeHeadStr :: String -> Source -> (Bool, Source)

If the front of the current source input matches the given string then remove it and return the modified source. Otherwise return the original source and a boolean flag indicating that we failed to take the given string off the front of the source input.

scanStr :: String -> Source -> (Maybe String, Source)

Scan the current source input until we find the given string: - If we don't find the string return Nothing and leave source unmodified - If we return (Maybe []), then we found the string at the beginning of the source and removed it. - If we return (Maybe junk), then we found the string somewhere after the first character in the source and we consumed / removed (junk:str).

regexMatch :: RE -> Source -> (Maybe String, Source)

Match the beginning of the source input with a regex, returning a tuple of the matched string and the modified source with that string removed.

regexStop :: RE -> Source -> (Maybe String, Source)

Find the first match of a regex in the source input, returning the contents of the source input *before* the match. * If there's no match return Nothing and leave the source unmodified. * If there's a match, return the string before the match and remove *just* the string before from the source input.

whileS :: (Char -> Bool) -> Source -> Maybe (String, Source)

Same as span but for predicates over type Char.

scanTo :: Char -> Source -> (Bool, Source, Span)

Scan the input source until we find the given character. If we don't find the character indicate as such with the boolean (False) and remove all source input from the current record. If we do find the character, return True and consume input up to and including the matched character. The Span in the returned tuple indicates the region in the input that got scanned and removed by this function (whether or not we failed to find the character).

module Language.Pads.RegExp

data ErrInfo

Error information relating back to the source input

Constructors

ErrInfo ErrMsg (Maybe Span)

Instances

Eq ErrInfo

Defined in Language.Pads.Errors

Methods

(==) :: ErrInfo -> ErrInfo -> Bool

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

Data ErrInfo

Defined in Language.Pads.Errors

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ErrInfo -> c ErrInfo

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ErrInfo

toConstr :: ErrInfo -> Constr

dataTypeOf :: ErrInfo -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ErrInfo)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ErrInfo)

gmapT :: (forall b. Data b => b -> b) -> ErrInfo -> ErrInfo

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ErrInfo -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ErrInfo -> r

gmapQ :: (forall d. Data d => d -> u) -> ErrInfo -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ErrInfo -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ErrInfo -> m ErrInfo

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ErrInfo -> m ErrInfo

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ErrInfo -> m ErrInfo

Ord ErrInfo

Defined in Language.Pads.Errors

Methods

compare :: ErrInfo -> ErrInfo -> Ordering

(<) :: ErrInfo -> ErrInfo -> Bool

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

(>) :: ErrInfo -> ErrInfo -> Bool

(>=) :: ErrInfo -> ErrInfo -> Bool

max :: ErrInfo -> ErrInfo -> ErrInfo

min :: ErrInfo -> ErrInfo -> ErrInfo

Show ErrInfo

Defined in Language.Pads.Errors

Methods

showsPrec :: Int -> ErrInfo -> ShowS

show :: ErrInfo -> String

showList :: [ErrInfo] -> ShowS

Pretty ErrInfo

Pretty printer for reporting where in the source text a parse error occured.

Defined in Language.Pads.Errors

Methods

ppr :: ErrInfo -> Doc

pprPrec :: Int -> ErrInfo -> Doc

pprList :: [ErrInfo] -> Doc

data ErrMsg

Errors which can be encountered at runtime when parsing a Pads type

Constructors

FoundWhenExpecting String String

MissingLiteral String

ExtraBeforeLiteral String

LineError String

Insufficient Int Int

RegexMatchFail String

TransformToDstFail String String String

TransformToSrcFail String String String

UnderlyingTypedefFail

PredicateFailure

ExtraStuffBeforeTy String String

FileError String String

BitWidthError Int Int

Instances

Eq ErrMsg

Defined in Language.Pads.Errors

Methods

(==) :: ErrMsg -> ErrMsg -> Bool

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

Data ErrMsg

Defined in Language.Pads.Errors

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ErrMsg -> c ErrMsg

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ErrMsg

toConstr :: ErrMsg -> Constr

dataTypeOf :: ErrMsg -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ErrMsg)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ErrMsg)

gmapT :: (forall b. Data b => b -> b) -> ErrMsg -> ErrMsg

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ErrMsg -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ErrMsg -> r

gmapQ :: (forall d. Data d => d -> u) -> ErrMsg -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ErrMsg -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ErrMsg -> m ErrMsg

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ErrMsg -> m ErrMsg

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ErrMsg -> m ErrMsg

Ord ErrMsg

Defined in Language.Pads.Errors

Methods

compare :: ErrMsg -> ErrMsg -> Ordering

(<) :: ErrMsg -> ErrMsg -> Bool

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

(>) :: ErrMsg -> ErrMsg -> Bool

(>=) :: ErrMsg -> ErrMsg -> Bool

max :: ErrMsg -> ErrMsg -> ErrMsg

min :: ErrMsg -> ErrMsg -> ErrMsg

Show ErrMsg

Defined in Language.Pads.Errors

Methods

showsPrec :: Int -> ErrMsg -> ShowS

show :: ErrMsg -> String

showList :: [ErrMsg] -> ShowS

Pretty ErrMsg

Pretty printer for Pads runtime error messages.

Defined in Language.Pads.Errors

Methods

ppr :: ErrMsg -> Doc

pprPrec :: Int -> ErrMsg -> Doc

pprList :: [ErrMsg] -> Doc

mergeErrInfo :: ErrInfo -> ErrInfo -> ErrInfo

Always just pick the first error message

maybeMergeErrInfo :: Maybe ErrInfo -> Maybe ErrInfo -> Maybe ErrInfo

Merge errors in the Maybe monad

module Language.Pads.PadsParser

module Language.Pads.MetaData

module Language.Pads.Generic

module Language.Pads.CoreBaseTypes

module Language.Pads.Quote

module Language.Pads.Syntax

module Language.Pads.BaseTypes

module Language.Pads.Pretty

module Language.Pads.PadsPrinter

module Language.Pads.Generation

module Data.Data

module Data.List

pretty :: Int -> Doc -> String

Render and convert a document to a Doc.