module Hidden.ParseRegexStr (
RegexAction(..)
, parseRegexStr
) where
import Hidden.RegexPRTypes ( RegexAction(..),
RegexSrcParser, runRegexSrcParser,
getBR, modifyBR,
setMode, setModes, getModes,
isModeI, isModeM, isModeX )
import Text.ParserCombinators.MTLParse
( runParse, spot, token, tokens, mzero, mplus,
still, parseNot, endOfInput, MonadParse,
MonadPlus,
list, neList, greedyNeList, optional )
import Hidden.Tools ( isSymbol, ignoreCase, skipRet, (>..>), ifM,
applyIf, (&&&), headOrErr, modifyFst )
import Data.Char ( isAlphaNum, isDigit, isSpace )
import Data.Ix ( inRange )
import Hidden.SrcRegActList( selfTest, oneCharList, backSlashesList, plusesList,
parensesList, charClassList )
import Control.Applicative ((<$>))
parseRegexStr :: String -> [RegexAction]
parseRegexStr :: Modes -> [RegexAction]
parseRegexStr Modes
src =
([RegexAction], (Int, Modes)) -> [RegexAction]
forall a b. (a, b) -> a
fst (([RegexAction], (Int, Modes)) -> [RegexAction])
-> (Modes -> ([RegexAction], (Int, Modes)))
-> Modes
-> [RegexAction]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([RegexAction], (Int, Modes)), (Modes, Modes))
-> ([RegexAction], (Int, Modes))
forall a b. (a, b) -> a
fst ((([RegexAction], (Int, Modes)), (Modes, Modes))
-> ([RegexAction], (Int, Modes)))
-> (Modes -> (([RegexAction], (Int, Modes)), (Modes, Modes)))
-> Modes
-> ([RegexAction], (Int, Modes))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Modes
-> [(([RegexAction], (Int, Modes)), (Modes, Modes))]
-> (([RegexAction], (Int, Modes)), (Modes, Modes))
forall a. Modes -> [a] -> a
headOrErr (Modes
"parse error: regex " Modes -> Modes -> Modes
forall a. [a] -> [a] -> [a]
++ Modes -> Modes
forall a. Show a => a -> Modes
show Modes
src Modes -> Modes -> Modes
forall a. [a] -> [a] -> [a]
++ Modes
" is uncorrect") ([(([RegexAction], (Int, Modes)), (Modes, Modes))]
-> (([RegexAction], (Int, Modes)), (Modes, Modes)))
-> (Modes -> [(([RegexAction], (Int, Modes)), (Modes, Modes))])
-> Modes
-> (([RegexAction], (Int, Modes)), (Modes, Modes))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
Parse Char ([RegexAction], (Int, Modes))
-> (Modes, Modes)
-> [(([RegexAction], (Int, Modes)), (Modes, Modes))]
forall a b. Parse a b -> ([a], [a]) -> [(b, ([a], [a]))]
runParse ( RegexSrcParser [RegexAction]
-> Parse Char ([RegexAction], (Int, Modes))
forall a. RegexSrcParser a -> Parse Char (a, (Int, Modes))
runRegexSrcParser RegexSrcParser [RegexAction]
parseRegexStrParser) ((Modes, Modes)
-> [(([RegexAction], (Int, Modes)), (Modes, Modes))])
-> (Modes -> (Modes, Modes))
-> Modes
-> [(([RegexAction], (Int, Modes)), (Modes, Modes))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) [] (Modes -> [RegexAction]) -> Modes -> [RegexAction]
forall a b. (a -> b) -> a -> b
$ Modes
src
parseRegexStrParser, parseTokensOr, parseTokens :: RegexSrcParser [RegexAction]
parseRegexStrParser :: RegexSrcParser [RegexAction]
parseRegexStrParser = RegexSrcParser [RegexAction]
parseTokensOr RegexSrcParser [RegexAction]
-> ([RegexAction] -> RegexSrcParser [RegexAction])
-> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [RegexAction] -> RegexSrcParser [RegexAction]
forall (m :: * -> *) a b. (MonadPlus m, MonadParse a m) => b -> m b
endOfInput
parseTokensOr :: RegexSrcParser [RegexAction]
parseTokensOr = RegexSrcParser [RegexAction]
parseTokens
RegexSrcParser [RegexAction]
-> RegexSrcParser [RegexAction] -> RegexSrcParser [RegexAction]
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
do { [RegexAction]
ra1 <- RegexSrcParser [RegexAction]
parseTokens; Char
_ <- Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'|'; [RegexAction]
ra2 <- RegexSrcParser [RegexAction]
parseTokensOr;
[RegexAction] -> RegexSrcParser [RegexAction]
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return [ [RegexAction] -> [RegexAction] -> RegexAction
RegexOr [RegexAction]
ra1 [RegexAction]
ra2 ] }
parseTokens :: RegexSrcParser [RegexAction]
parseTokens = StateT (Int, Modes) (Parse Char) RegexAction
-> RegexSrcParser [RegexAction]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list StateT (Int, Modes) (Parse Char) RegexAction
parseTokenPlus
parseTokenPlus, parseToken :: RegexSrcParser RegexAction
parseTokenPlus :: StateT (Int, Modes) (Parse Char) RegexAction
parseTokenPlus = do RegexAction
ra <- StateT (Int, Modes) (Parse Char) RegexAction
parseToken
RegexAction -> RegexAction
plus <- [(Modes, RegexAction -> RegexAction)]
-> RegexSrcParser (RegexAction -> RegexAction)
parsePluses [(Modes, RegexAction -> RegexAction)]
plusesList RegexSrcParser (RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` RegexSrcParser (RegexAction -> RegexAction)
parseQuantifier
RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$ RegexAction -> RegexAction
plus RegexAction
ra
parseQuantifier :: RegexSrcParser (RegexAction -> RegexAction)
parseQuantifier :: RegexSrcParser (RegexAction -> RegexAction)
parseQuantifier
= do { Char
_ <- Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'{';
Modes
mn <- StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
neList (StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isDigit;
Maybe Modes
mx <- do { Modes
cma <- StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
optional (StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall a b. (a -> b) -> a -> b
$ Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
',';
case Modes
cma of
Modes
"" -> Maybe Modes -> StateT (Int, Modes) (Parse Char) (Maybe Modes)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Modes
forall a. Maybe a
Nothing
Modes
_ -> (Modes -> Maybe Modes)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) (Maybe Modes)
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Modes -> Maybe Modes
forall a. a -> Maybe a
Just (StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) (Maybe Modes))
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) (Maybe Modes)
forall a b. (a -> b) -> a -> b
$ StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isDigit) };
Char
_ <- Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'}';
Bool
nd <- (Modes -> Bool)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Bool
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Modes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Bool)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Bool
forall a b. (a -> b) -> a -> b
$ StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
optional (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'?');
(RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction))
-> (RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
forall a b. (a -> b) -> a -> b
$ (if Bool
nd then Int -> Maybe Int -> RegexAction -> RegexAction
Repeat else Int -> Maybe Int -> RegexAction -> RegexAction
RepeatNotGreedy) (Modes -> Int
forall a. Read a => Modes -> a
read Modes
mn) (Maybe Int -> RegexAction -> RegexAction)
-> Maybe Int -> RegexAction -> RegexAction
forall a b. (a -> b) -> a -> b
$
case Maybe Modes
mx of
Maybe Modes
Nothing -> Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Modes -> Int
forall a. Read a => Modes -> a
read Modes
mn
Just Modes
"" -> Maybe Int
forall a. Maybe a
Nothing
Just Modes
n -> Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Modes -> Int
forall a. Read a => Modes -> a
read Modes
n }
parseToken :: StateT (Int, Modes) (Parse Char) RegexAction
parseToken
= StateT (Int, Modes) (Parse Char) Bool
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM StateT (Int, Modes) (Parse Char) Bool
isModeX StateT (Int, Modes) (Parse Char) RegexAction
parseTokenX StateT (Int, Modes) (Parse Char) RegexAction
forall a. StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( StateT (Int, Modes) (Parse Char) Bool
isModeI StateT (Int, Modes) (Parse Char) Bool
-> (Bool -> StateT (Int, Modes) (Parse Char) RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
ic ->
(Char -> RegexAction)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> RegexAction
Select ((Char -> Bool) -> RegexAction)
-> (Char -> Char -> Bool) -> Char -> RegexAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool
-> ((Char -> Bool) -> Char -> Bool)
-> (Char -> Bool)
-> Char
-> Bool
forall a. Bool -> (a -> a) -> a -> a
applyIf Bool
ic (Char -> Bool) -> Char -> Bool
ignoreCase ((Char -> Bool) -> Char -> Bool)
-> (Char -> Char -> Bool) -> Char -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==)) ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
selfTest) )
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
StateT (Int, Modes) (Parse Char) RegexAction
parseOpenBrace
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
StateT (Int, Modes) (Parse Char) Bool
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM StateT (Int, Modes) (Parse Char) Bool
isModeM ( Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'.' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Char -> Bool) -> RegexAction
Select ((Char -> Bool) -> RegexAction) -> (Char -> Bool) -> RegexAction
forall a b. (a -> b) -> a -> b
$ Bool -> Char -> Bool
forall a b. a -> b -> a
const Bool
True) ) StateT (Int, Modes) (Parse Char) RegexAction
forall a. StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
(Char -> RegexAction)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> RegexAction
Select ((Char -> Bool) -> RegexAction)
-> (Char -> Char -> Bool) -> Char -> RegexAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==)) (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'\\' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isSymbol)
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
StateT (Int, Modes) (Parse Char) RegexAction
parseBackReference
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( (Modes -> Bool)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Bool
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool -> Bool
not (Bool -> Bool) -> (Modes -> Bool) -> Modes -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Modes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) ( Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'[' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Modes
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
optional (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'^') ) StateT (Int, Modes) (Parse Char) Bool
-> (Bool -> StateT (Int, Modes) (Parse Char) RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
isNot ->
((Char -> Bool) -> RegexAction)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> RegexAction
Select ((Char -> Bool) -> RegexAction)
-> ((Char -> Bool) -> Char -> Bool)
-> (Char -> Bool)
-> RegexAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool
-> ((Char -> Bool) -> Char -> Bool)
-> (Char -> Bool)
-> Char
-> Bool
forall a. Bool -> (a -> a) -> a -> a
applyIf Bool
isNot (Bool -> Bool
not(Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)) (
StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharList StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> ((Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
']')
) )
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( RegexSrcParser Int
getBR RegexSrcParser Int
-> (Int -> StateT (Int, Modes) (Parse Char) RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
i -> ([RegexAction] -> RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> [RegexAction] -> RegexAction
Note Int
i) (RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$ Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'(' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Int -> Int) -> StateT (Int, Modes) (Parse Char) ()
modifyBR (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) StateT (Int, Modes) (Parse Char) ()
-> RegexSrcParser [RegexAction] -> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexSrcParser [RegexAction]
parseTokensOr
RegexSrcParser [RegexAction]
-> ([RegexAction] -> RegexSrcParser [RegexAction])
-> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> [RegexAction] -> RegexSrcParser [RegexAction]
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
')') )
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens Modes
"(?" StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (Int, Modes) (Parse Char) (Char, Bool)
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list StateT (Int, Modes) (Parse Char) (Char, Bool)
parseMode StateT (Int, Modes) (Parse Char) [(Char, Bool)]
-> ([(Char, Bool)] -> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) ()
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((Char, Bool) -> StateT (Int, Modes) (Parse Char) ())
-> [(Char, Bool)] -> StateT (Int, Modes) (Parse Char) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((Char -> Bool -> StateT (Int, Modes) (Parse Char) ())
-> (Char, Bool) -> StateT (Int, Modes) (Parse Char) ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Char -> Bool -> StateT (Int, Modes) (Parse Char) ()
setMode) StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
')'
StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return RegexAction
NopRegex )
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( StateT (Int, Modes) (Parse Char) Modes
getModes StateT (Int, Modes) (Parse Char) Modes
-> (Modes -> StateT (Int, Modes) (Parse Char) RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Modes
preModes ->
([RegexAction] -> RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [RegexAction] -> RegexAction
Parens (RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$
Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens Modes
"(?" StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (Int, Modes) (Parse Char) (Char, Bool)
-> StateT (Int, Modes) (Parse Char) [(Char, Bool)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list StateT (Int, Modes) (Parse Char) (Char, Bool)
parseMode StateT (Int, Modes) (Parse Char) [(Char, Bool)]
-> ([(Char, Bool)] -> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) ()
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((Char, Bool) -> StateT (Int, Modes) (Parse Char) ())
-> [(Char, Bool)] -> StateT (Int, Modes) (Parse Char) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((Char -> Bool -> StateT (Int, Modes) (Parse Char) ())
-> (Char, Bool) -> StateT (Int, Modes) (Parse Char) ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Char -> Bool -> StateT (Int, Modes) (Parse Char) ()
setMode) StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
':' StateT (Int, Modes) (Parse Char) Char
-> RegexSrcParser [RegexAction] -> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
RegexSrcParser [RegexAction]
parseTokensOr RegexSrcParser [RegexAction]
-> ([RegexAction] -> RegexSrcParser [RegexAction])
-> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> [RegexAction] -> RegexSrcParser [RegexAction]
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Modes -> StateT (Int, Modes) (Parse Char) ()
setModes Modes
preModes StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
')')
)
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
[(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseOneChar [(Char, RegexAction)]
oneCharList
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
[(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseBackSlashes [(Char, RegexAction)]
backSlashesList
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
[(Modes, [RegexAction] -> RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseParenses [(Modes, [RegexAction] -> RegexAction)]
parensesList
StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
(Modes -> RegexAction)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Modes -> RegexAction
Comment
( Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens Modes
"(?#" StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Modes
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
')')) StateT (Int, Modes) (Parse Char) Modes
-> (Modes -> StateT (Int, Modes) (Parse Char) Modes)
-> StateT (Int, Modes) (Parse Char) Modes
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> Modes -> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
')') )
parseMode :: RegexSrcParser (Char, Bool)
parseMode :: StateT (Int, Modes) (Parse Char) (Char, Bool)
parseMode =
((Modes, Char) -> (Char, Bool))
-> StateT (Int, Modes) (Parse Char) (Modes, Char)
-> StateT (Int, Modes) (Parse Char) (Char, Bool)
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( (Bool -> Char -> (Char, Bool)) -> (Bool, Char) -> (Char, Bool)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((Char -> Bool -> (Char, Bool)) -> Bool -> Char -> (Char, Bool)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (,)) ((Bool, Char) -> (Char, Bool))
-> ((Modes, Char) -> (Bool, Char)) -> (Modes, Char) -> (Char, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Modes -> Bool) -> (Modes, Char) -> (Bool, Char)
forall a c b. (a -> c) -> (a, b) -> (c, b)
modifyFst Modes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ) (StateT (Int, Modes) (Parse Char) (Modes, Char)
-> StateT (Int, Modes) (Parse Char) (Char, Bool))
-> StateT (Int, Modes) (Parse Char) (Modes, Char)
-> StateT (Int, Modes) (Parse Char) (Char, Bool)
forall a b. (a -> b) -> a -> b
$
StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
optional (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'-') StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) (Modes, Char)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m (a, b)
>..> (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot (Char -> Modes -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` Modes
"imx")
parseTokenX :: RegexSrcParser RegexAction
parseTokenX :: StateT (Int, Modes) (Parse Char) RegexAction
parseTokenX
= ( (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isSpace StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return RegexAction
NopRegex ) StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
(Modes -> RegexAction)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Modes -> RegexAction
Comment
( Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'#' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Modes
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'\n')) StateT (Int, Modes) (Parse Char) Modes
-> (Modes -> StateT (Int, Modes) (Parse Char) Modes)
-> StateT (Int, Modes) (Parse Char) Modes
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
StateT (Int, Modes) (Parse Char) Char
-> Modes -> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'\n' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Char -> StateT (Int, Modes) (Parse Char) Char
forall (m :: * -> *) a b. (MonadPlus m, MonadParse a m) => b -> m b
endOfInput Char
'\n') )
parsePluses ::
[ (String, RegexAction -> RegexAction) ] ->
RegexSrcParser (RegexAction -> RegexAction)
parsePluses :: [(Modes, RegexAction -> RegexAction)]
-> RegexSrcParser (RegexAction -> RegexAction)
parsePluses = ((Modes, RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction))
-> [(Modes, RegexAction -> RegexAction)]
-> RegexSrcParser (RegexAction -> RegexAction)
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse (\(Modes
t, RegexAction -> RegexAction
act) -> Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens Modes
t StateT (Int, Modes) (Parse Char) Modes
-> RegexSrcParser (RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (RegexAction -> RegexAction)
-> RegexSrcParser (RegexAction -> RegexAction)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return RegexAction -> RegexAction
act)
parseOneChar :: [ (Char, RegexAction) ] -> RegexSrcParser RegexAction
parseOneChar :: [(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseOneChar
= ((Char, RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> [(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse (\(Char
t, RegexAction
act) -> Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
t StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return RegexAction
act)
parseBackSlashes :: [ (Char, RegexAction) ] -> RegexSrcParser RegexAction
parseBackSlashes :: [(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseBackSlashes
= ((Char, RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> [(Char, RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse (\(Char
t, RegexAction
act) -> Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens [Char
'\\', Char
t] StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return RegexAction
act)
parseParenses ::
[ (String, [RegexAction] -> RegexAction) ] -> RegexSrcParser RegexAction
parseParenses :: [(Modes, [RegexAction] -> RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
parseParenses
= ((Modes, [RegexAction] -> RegexAction)
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> [(Modes, [RegexAction] -> RegexAction)]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse ( \(Modes
t, [RegexAction] -> RegexAction
act) ->
(([RegexAction] -> RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [RegexAction] -> RegexAction
act (RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexSrcParser [RegexAction]
-> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$ Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens (Char
'('Char -> Modes -> Modes
forall a. a -> [a] -> [a]
:Modes
t) StateT (Int, Modes) (Parse Char) Modes
-> RegexSrcParser [RegexAction] -> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RegexSrcParser [RegexAction]
parseTokensOr RegexSrcParser [RegexAction]
-> ([RegexAction] -> RegexSrcParser [RegexAction])
-> RegexSrcParser [RegexAction]
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> [RegexAction] -> RegexSrcParser [RegexAction]
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
')') ))
parseCharList :: RegexSrcParser (Char -> Bool)
parseCharList :: StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharList = do
Bool
modei <- StateT (Int, Modes) (Parse Char) Bool
isModeI
Char -> Bool
cl1 <- StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseOne StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` (Char -> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> Modes -> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse ((StateT (Int, Modes) (Parse Char) Char
-> (Char -> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Char -> Bool) -> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> (Char -> Char -> Bool)
-> Char
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==)) (StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> (Char -> StateT (Int, Modes) (Parse Char) Char)
-> Char
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token) Modes
"-]"
[Char -> Bool]
cl2 <- StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) [Char -> Bool]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
list (StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) [Char -> Bool])
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) [Char -> Bool]
forall a b. (a -> b) -> a -> b
$ StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseOne StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` (Char -> Char -> Bool)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'^')
(Char -> Bool) -> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b. (a -> b) -> a -> b
$ Bool
-> ((Char -> Bool) -> Char -> Bool)
-> (Char -> Bool)
-> Char
-> Bool
forall a. Bool -> (a -> a) -> a -> a
applyIf Bool
modei (Char -> Bool) -> Char -> Bool
ignoreCase ((Char -> Bool) -> Char -> Bool) -> (Char -> Bool) -> Char -> Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or ([Bool] -> Bool) -> (Char -> [Bool]) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Char -> Bool) -> Char -> Bool)
-> [Char -> Bool] -> Modes -> [Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Char -> Bool) -> Char -> Bool
forall a b. (a -> b) -> a -> b
($) (Char -> Bool
cl1 (Char -> Bool) -> [Char -> Bool] -> [Char -> Bool]
forall a. a -> [a] -> [a]
: [Char -> Bool]
cl2) (Modes -> [Bool]) -> (Char -> Modes) -> Char -> [Bool]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Modes
forall a. a -> [a]
repeat
where parseOne :: StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseOne = (Char -> Char -> Bool)
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==) StateT (Int, Modes) (Parse Char) Char
parseChar StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharArea
StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharClass
parseChar :: StateT (Int, Modes) (Parse Char) Char
parseChar = (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isAlphaNum StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'\\' StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isSymbol ) StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
(Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot (Char -> Bool
selfTest (Char -> Bool) -> (Char -> Bool) -> Char -> Bool
forall a. (a -> Bool) -> (a -> Bool) -> a -> Bool
&&& (Char -> Modes -> Bool) -> Modes -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> Modes -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem Modes
"-]" ) StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
(Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot (Char -> Modes -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` Modes
".+$" ) StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
forall a.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
( Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'[' StateT (Int, Modes) (Parse Char) Char
-> (Char -> StateT (Int, Modes) (Parse Char) Char)
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) ()
-> Char -> StateT (Int, Modes) (Parse Char) Char
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall b.
StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall a (m :: * -> *) b. MonadParse a m => m b -> m b
still (StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall a b. (a -> b) -> a -> b
$ ()
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) ()
forall c b.
c
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) c
forall a (m :: * -> *) c b. MonadParse a m => c -> m b -> m c
parseNot ()
(StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) ()
forall a b. (a -> b) -> a -> b
$ Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
':') )
parseCharArea :: StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharArea = ((Char, Char) -> Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char, Char)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
(a -> b)
-> StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (StateT (Int, Modes) (Parse Char) (Char, Char)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> StateT (Int, Modes) (Parse Char) (Char, Char)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b. (a -> b) -> a -> b
$ (StateT (Int, Modes) (Parse Char) Char
parseChar StateT (Int, Modes) (Parse Char) Char
-> (Char -> StateT (Int, Modes) (Parse Char) Char)
-> StateT (Int, Modes) (Parse Char) Char
forall a b.
StateT (Int, Modes) (Parse Char) a
-> (a -> StateT (Int, Modes) (Parse Char) b)
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= StateT (Int, Modes) (Parse Char) Char
-> Char -> StateT (Int, Modes) (Parse Char) Char
forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'-')) StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) (Char, Char)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m (a, b)
>..> StateT (Int, Modes) (Parse Char) Char
parseChar
parseCharClass :: StateT (Int, Modes) (Parse Char) (Char -> Bool)
parseCharClass = ((Modes, Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool))
-> [(Modes, Char -> Bool)]
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse
(\(Modes
s, Char -> Bool
p) -> Modes -> StateT (Int, Modes) (Parse Char) Modes
forall a (m :: * -> *). (Eq a, MonadParse a m) => [a] -> m [a]
tokens (Modes
"[:"Modes -> Modes -> Modes
forall a. [a] -> [a] -> [a]
++Modes
sModes -> Modes -> Modes
forall a. [a] -> [a] -> [a]
++Modes
":]") StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
-> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a b.
StateT (Int, Modes) (Parse Char) a
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Char -> Bool) -> StateT (Int, Modes) (Parse Char) (Char -> Bool)
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return Char -> Bool
p)
[(Modes, Char -> Bool)]
charClassList
concatMapParse :: MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse :: forall (m :: * -> *) b a. MonadPlus m => (b -> m a) -> [b] -> m a
concatMapParse b -> m a
f = (b -> m a -> m a) -> m a -> [b] -> m a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (m a -> m a -> m a
forall a. m a -> m a -> m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus (m a -> m a -> m a) -> (b -> m a) -> b -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> m a
f) m a
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
parseOpenBrace :: RegexSrcParser RegexAction
parseOpenBrace :: StateT (Int, Modes) (Parse Char) RegexAction
parseOpenBrace = do StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall b.
StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall a (m :: * -> *) b. MonadParse a m => m b -> m b
still (StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall a b. (a -> b) -> a -> b
$ ()
-> RegexSrcParser (RegexAction -> RegexAction)
-> StateT (Int, Modes) (Parse Char) ()
forall c b.
c
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) c
forall a (m :: * -> *) c b. MonadParse a m => c -> m b -> m c
parseNot () RegexSrcParser (RegexAction -> RegexAction)
parseQuantifier
StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall b.
StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) b
forall a (m :: * -> *) b. MonadParse a m => m b -> m b
still (StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ())
-> StateT (Int, Modes) (Parse Char) ()
-> StateT (Int, Modes) (Parse Char) ()
forall a b. (a -> b) -> a -> b
$ ()
-> StateT (Int, Modes) (Parse Char) RegexAction
-> StateT (Int, Modes) (Parse Char) ()
forall c b.
c
-> StateT (Int, Modes) (Parse Char) b
-> StateT (Int, Modes) (Parse Char) c
forall a (m :: * -> *) c b. MonadParse a m => c -> m b -> m c
parseNot () StateT (Int, Modes) (Parse Char) RegexAction
parseBackReference
Char
ret <- Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'{'
RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> RegexAction
Select (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
ret)
parseBackReference :: RegexSrcParser RegexAction
parseBackReference :: StateT (Int, Modes) (Parse Char) RegexAction
parseBackReference = do
Bool
brace <- Modes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Modes -> Bool)
-> StateT (Int, Modes) (Parse Char) Modes
-> StateT (Int, Modes) (Parse Char) Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
optional (Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'{')
Char
_ <- Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'\\'
Modes
dgt <- StateT (Int, Modes) (Parse Char) Char
-> StateT (Int, Modes) (Parse Char) Modes
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
greedyNeList ((Char -> Bool) -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). MonadParse a m => (a -> Bool) -> m a
spot Char -> Bool
isDigit)
Char
_ <- if Bool
brace then Char -> StateT (Int, Modes) (Parse Char) Char
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
' ' else Char -> StateT (Int, Modes) (Parse Char) Char
forall a (m :: * -> *). (Eq a, MonadParse a m) => a -> m a
token Char
'}'
RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a. a -> StateT (Int, Modes) (Parse Char) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction)
-> RegexAction -> StateT (Int, Modes) (Parse Char) RegexAction
forall a b. (a -> b) -> a -> b
$ Int -> RegexAction
BackReference (Int -> RegexAction) -> Int -> RegexAction
forall a b. (a -> b) -> a -> b
$ Modes -> Int
forall a. Read a => Modes -> a
read Modes
dgt