UU.Parsing.Machine

Documentation

pDynE :: ParsRec state result s p a -> AnaParser state result s p a

pDynL :: ParsRec state result s p a -> AnaParser state result s p a

newtype RealParser state s p a

Constructors

P (forall r' r''. (a -> r'' -> r') -> (state -> Steps r'' s p) -> state -> Steps r' s p)

newtype RealRecogn state s p

Constructors

R (forall r. (state -> Steps r s p) -> state -> Steps r s p)

newtype RealAccept state result s p a

Constructors

A (forall r. (state -> Steps r s p) -> state -> Steps (result a r) s p)

newtype ParsRec state result s p a

Constructors

PR (RealParser state s p a, RealRecogn state s p, RealAccept state result s p a)

mkPR :: OutputState result => (RealParser state s p a, RealRecogn state s p) -> ParsRec state result s p a

unP :: RealParser state s p a -> (a -> r'' -> r') -> (state -> Steps r'' s p) -> state -> Steps r' s p

unR :: RealRecogn state s p -> (state -> Steps r s p) -> state -> Steps r s p

parseRecbasic :: (inp -> Steps (out c d) sym pos) -> ParsRec inp out sym pos a -> inp -> Steps (out a (out c d)) sym pos

parsebasic :: (inp -> Steps (out c d) sym pos) -> AnaParser inp out sym pos a -> inp -> Steps (out a (out c d)) sym pos

libAccept :: (OutputState a, InputState b s p) => ParsRec b a s p s

libInsert :: (InputState state s3 p, InputState state s1 p, InputState state s2 p, OutputState result) => Int# -> s1 -> Expecting s1 -> ParsRec state result s1 p s1

libSucceed :: OutputState result => p1 -> ParsRec state result s p2 p1

libSeq :: (OutputState result2, OutputState result1) => ParsRec state result3 s p (a1 -> a2) -> ParsRec state result2 s p a1 -> ParsRec state result1 s p a2

libDollar :: OutputState result1 => (a1 -> a2) -> ParsRec state result2 s p a1 -> ParsRec state result1 s p a2

libDollarL :: OutputState result1 => p1 -> ParsRec state result2 s p2 a -> ParsRec state result1 s p2 p1

libDollarR :: OutputState result1 => p1 -> ParsRec state result2 s p2 a -> ParsRec state result1 s p2 a

libSeqL :: OutputState result1 => ParsRec state result2 s p a1 -> ParsRec state result3 s p a2 -> ParsRec state result1 s p a1

libSeqR :: OutputState result1 => ParsRec state result2 s p a1 -> ParsRec state result3 s p a2 -> ParsRec state result1 s p a2

libOr :: (Ord s, OutputState result1) => ParsRec state result2 s p a -> ParsRec state result3 s p a -> ParsRec state result1 s p a

libFail :: OutputState a => ParsRec b a c p d

starting :: Steps a s p -> Expecting s

hasSuccess :: Steps a s p -> Bool

getStart :: Message sym pos -> Expecting sym

addToMessage :: Ord sym => Message sym pos -> Expecting sym -> Message sym pos

addexpecting :: Ord s => Expecting s -> Steps val s p -> Steps val s p

eor :: Ord a => Expecting a -> Expecting a -> Expecting a

libBest :: Ord s => Steps b s p -> Steps b s p -> Steps b s p

libBest' :: Ord s => Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p

isTrue :: Int# -> Bool

lib_correct :: Ord s => (b -> c -> Steps d s p) -> (b -> c -> Steps d s p) -> b -> c -> Steps d s p

libCorrect :: Ord s => Steps a s p -> Steps c s p -> (a -> d) -> (c -> d) -> Steps d s p

data ToBeat a

Constructors

ToBeat Int# a

traverse :: ToBeat (Steps a s p) -> (Steps v s p -> Steps a s p, Steps v s p) -> Int# -> Int# -> ToBeat (Steps a s p)

data AnaParser state result s p a

Constructors

AnaParser

Fields

• pars :: ParsRec state result s p a
• leng :: Nat
• zerop :: Maybe (Bool, Either a (ParsRec state result s p a))
• onep :: OneDescr state result s p a

Instances

(InputState inp s p, OutputState out) => StateParser (AnaParser (inp, st) out s p) st

Methods

change :: (st -> st) -> AnaParser (inp, st) out s p st

set :: st -> AnaParser (inp, st) out s p st

get :: AnaParser (inp, st) out s p st

(Ord s, Symbol s, InputState state s p, OutputState result) => IsParser (AnaParser state result s p) s

The fast AnaParser instance of the IsParser class. Note that this requires a functioning Ord for the symbol type s, as tokens are often compared using the compare function in Ord rather than always using == rom Eq. The two do need to be consistent though, that is for any two x1, x2 such that x1 == x2 you must have compare x1 x2 == EQ.

Methods

pSucceed :: a -> AnaParser state result s p a

pLow :: a -> AnaParser state result s p a

pFail :: AnaParser state result s p a

pCostRange :: Int# -> s -> SymbolR s -> AnaParser state result s p s

pCostSym :: Int# -> s -> s -> AnaParser state result s p s

pSym :: s -> AnaParser state result s p s

pRange :: s -> SymbolR s -> AnaParser state result s p s

getfirsts :: AnaParser state result s p v -> Expecting s

setfirsts :: Expecting s -> AnaParser state result s p v -> AnaParser state result s p v

getzerop :: AnaParser state result s p v -> Maybe (AnaParser state result s p v)

getonep :: AnaParser state result s p v -> Maybe (AnaParser state result s p v)

data OneDescr state result s p a

Constructors

OneDescr

Fields

• firsts :: Expecting s
• table :: [(SymbolR s, TableEntry state result s p a)]

data TableEntry state result s p a

Constructors

TableEntry (ParsRec state result s p a) (Expecting s -> ParsRec state result s p a)

anaFail :: OutputState a => AnaParser b a c p d

noOneParser :: OneDescr state result s p a

pEmpty :: ParsRec state result s p a -> (Bool, Either a (ParsRec state result s p a)) -> AnaParser state result s p a

anaSucceed :: OutputState result => a -> AnaParser state result s p a

anaLow :: OutputState result => a -> AnaParser state result s p a

anaDynE :: ParsRec state result s p a -> AnaParser state result s p a

anaDynL :: ParsRec state result s p a -> AnaParser state result s p a

anaOr :: (Ord s, OutputState result, Symbol s, InputState state s p) => AnaParser state result s p a -> AnaParser state result s p a -> AnaParser state result s p a

anaSeq :: (OutputState result2, Ord s, OutputState result1, Symbol s, InputState state1 s p1) => (a1 -> ParsRec state2 result2 s p2 a2 -> ParsRec state1 result1 s p1 a3) -> (ParsRec state3 result3 s p3 a1 -> ParsRec state2 result2 s p2 a2 -> ParsRec state1 result1 s p1 a3) -> (a1 -> a2 -> a3) -> AnaParser state3 result3 s p3 a1 -> AnaParser state2 result2 s p2 a2 -> AnaParser state1 result1 s p1 a3

seqZeroZero :: OutputState result => Maybe (Bool, Either t1 t2) -> Maybe (Bool, Either p1 (ParsRec state result s p2 p1)) -> (t1 -> ParsRec state result s p2 p1 -> b) -> (t2 -> ParsRec state result s p2 p1 -> b) -> (t1 -> p1 -> a) -> Maybe (Bool, Either a b)

orOneOneDescr :: Ord s => OneDescr state result s p a -> OneDescr state result s p a -> Bool -> OneDescr state result s p a

anaCostRange :: (Ord s, Symbol s, OutputState a, InputState b s p) => Int# -> s -> SymbolR s -> AnaParser b a s p s

anaGetFirsts :: AnaParser state result s p a -> Expecting s

anaSetFirsts :: (OutputState result, Ord s, Symbol s, InputState state s p) => Expecting s -> AnaParser state result s p a -> AnaParser state result s p a

mapOnePars :: (ParsRec state1 result1 s p1 a1 -> ParsRec state2 result2 s p2 a2) -> OneDescr state1 result1 s p1 a1 -> OneDescr state2 result2 s p2 a2

mkParser :: (InputState state s p, Symbol s, Ord s, OutputState result) => Nat -> Maybe (Bool, Either a (ParsRec state result s p a)) -> OneDescr state result s p a -> AnaParser state result s p a

data Nat

Constructors

Zero

Succ Nat

Infinite

Instances

Eq Nat

Methods

(==) :: Nat -> Nat -> Bool

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

Show Nat

Methods

showsPrec :: Int -> Nat -> ShowS

show :: Nat -> String

showList :: [Nat] -> ShowS

nat_le :: Nat -> Nat -> Bool

nat_min :: Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)

nat_add :: Nat -> Nat -> Nat

mergeTables :: (OutputState result, Ord s, Symbol a1, Ord a1) => [(SymbolR a1, ParsRec state result s p a2)] -> [(SymbolR a1, ParsRec state result s p a2)] -> [(SymbolR a1, ParsRec state result s p a2)]

libMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps r s p -> (state, Steps r s p)) -> ParsRec state result s p a -> ParsRec state result s p b

pMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps r s p -> (state, Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b

libWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> ParsRec state result s p a -> ParsRec state result s p b

pWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b

lookupSym :: Ord a => BinSearchTree (SymbolR a, b) -> a -> Maybe b