module Text.Regex.TDFA.Sequence(
Regex
,CompOption
,ExecOption
,compile
,execute
,regexec
) where
import Data.Array((!),elems)
import Data.Sequence as S
import Text.Regex.Base(MatchArray,RegexContext(..),RegexMaker(..),RegexLike(..))
import Text.Regex.Base.Impl(polymatch,polymatchM)
import Text.Regex.TDFA.String()
import Text.Regex.TDFA.TDFA(patternToDFA)
import Text.Regex.TDFA.MutRunSeq(findMatch,findMatchAll,countMatchAll)
import Text.Regex.TDFA.Wrap(Regex(..),CompOption,ExecOption)
import Text.Regex.TDFA.ReadRegex(parseRegex)
instance RegexContext Regex (S.Seq Char) (S.Seq Char) where
match = polymatch
matchM = polymatchM
instance RegexMaker Regex CompOption ExecOption (S.Seq Char) where
makeRegexOptsM c e source = either fail return $ compile c e source
instance RegexLike Regex (S.Seq Char) where
matchOnce = findMatch
matchAll = findMatchAll
matchCount = countMatchAll
toList :: S.Seq Char -> [Char]
toList s = expand (S.viewl s) where
expand EmptyL = []
expand (c :< cs) = c : expand (S.viewl cs)
compile :: CompOption
-> ExecOption
-> (S.Seq Char)
-> Either String Regex
compile compOpt execOpt bs =
case parseRegex (toList bs) of
Left err -> Left ("parseRegex for Text.Regex.TDFA.ByteString failed:"++show err)
Right pattern ->
let (dfa,i,tags,groups) = patternToDFA compOpt pattern
in Right (Regex dfa i tags groups compOpt execOpt)
execute :: Regex
-> (S.Seq Char)
-> Either String (Maybe MatchArray)
execute r bs = Right (matchOnce r bs)
regexec :: Regex
-> (S.Seq Char)
-> Either String (Maybe ((S.Seq Char), (S.Seq Char), (S.Seq Char), [(S.Seq Char)]))
regexec r bs =
case matchOnceText r bs of
Nothing -> Right (Nothing)
Just (pre,mt,post) ->
let main = fst (mt!0)
rest = map fst (tail (elems mt))
in Right (Just (pre,main,post,rest))