module Sasha (
Sasha,
sasha,
ERE,
empty,
eps,
char,
charRange,
charSet,
utf8Char,
anyChar,
anyUtf8Char,
appends,
unions,
intersections,
star,
plus,
string,
utf8String,
complement,
satisfy,
digit,
) where
import Data.Word (Word8)
import qualified Data.ByteString as BS
import Sasha.Internal.ERE
type Sasha r = [(ERE, BS.ByteString -> BS.ByteString -> r)]
sasha
:: forall r. r
-> Sasha r
-> BS.ByteString
-> r
sasha :: forall r. r -> Sasha r -> ByteString -> r
sasha r
noMatch Sasha r
grammar ByteString
input0 = r -> Int -> ByteString -> Sasha r -> r
go r
noMatch Int
0 ByteString
input0 Sasha r
grammar
where
go :: r -> Int -> BS.ByteString -> Sasha r -> r
go :: r -> Int -> ByteString -> Sasha r -> r
go r
acc !Int
_ !ByteString
_ [] = r
acc
go r
acc !Int
i !ByteString
input Sasha r
ts = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
input of
Maybe (Word8, ByteString)
Nothing -> r
acc
Just (Word8
c, ByteString
input') -> r -> Int -> ByteString -> Sasha r -> r
go (forall {p}. [p] -> p -> p
next [r]
accs r
acc) (Int
i forall a. Num a => a -> a -> a
+ Int
1) ByteString
input' Sasha r
ts'
where
ts' :: Sasha r
ts' = forall r. Word8 -> Sasha r -> Sasha r
derivativeSasha Word8
c Sasha r
ts
accs :: [r]
accs = [ case Int -> ByteString -> (ByteString, ByteString)
BS.splitAt (Int
i forall a. Num a => a -> a -> a
+ Int
1) ByteString
input0 of (ByteString
pfx, ByteString
sfx) -> ByteString -> ByteString -> r
f ByteString
pfx ByteString
sfx | (ERE
ere, ByteString -> ByteString -> r
f) <- Sasha r
ts', ERE -> Bool
nullable ERE
ere]
next :: [p] -> p -> p
next [] p
x = p
x
next (p
x:[p]
_) p
_ = p
x
derivativeSasha :: Word8 -> Sasha r -> Sasha r
derivativeSasha :: forall r. Word8 -> Sasha r -> Sasha r
derivativeSasha Word8
c Sasha r
ts =
[ (ERE
ere', ByteString -> ByteString -> r
f)
| (ERE
ere, ByteString -> ByteString -> r
f) <- Sasha r
ts
, let ere' :: ERE
ere' = Word8 -> ERE -> ERE
derivative Word8
c ERE
ere
, Bool -> Bool
not (ERE -> Bool
isEmpty ERE
ere')
]