{-# OPTIONS_GHC -fno-warn-orphans #-}
module Text.Regex.Posix.String(
Regex,
MatchOffset,
MatchLength,
ReturnCode,
WrapError,
unusedOffset,
compile,
regexec,
execute,
CompOption(CompOption),
compBlank,
compExtended,
compIgnoreCase,
compNoSub,
compNewline,
ExecOption(ExecOption),
execBlank,
execNotBOL,
execNotEOL
) where
import Prelude hiding (fail)
import Control.Monad.Fail (MonadFail(fail))
import Data.Array(listArray, Array)
import Data.List(genericDrop, genericTake)
import Foreign.C.String(withCAString)
import System.IO.Unsafe(unsafePerformIO)
import Text.Regex.Base.RegexLike(RegexContext(..),RegexMaker(..),RegexLike(..),MatchOffset,MatchLength)
import Text.Regex.Posix.Wrap
import Text.Regex.Base.Impl(polymatch,polymatchM)
instance RegexContext Regex String String where
match :: Regex -> String -> String
match = forall a b. RegexLike a b => a -> b -> b
polymatch
matchM :: forall (m :: * -> *). MonadFail m => Regex -> String -> m String
matchM = forall a b (m :: * -> *).
(RegexLike a b, MonadFail m) =>
a -> b -> m b
polymatchM
unusedOffset :: Int
unusedOffset :: Int
unusedOffset = forall a b. (Integral a, Num b) => a -> b
fromIntegral RegOffset
unusedRegOffset
unwrap :: (Show e) => Either e v -> IO v
unwrap :: forall e v. Show e => Either e v -> IO v
unwrap Either e v
x = case Either e v
x of Left e
err -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Text.Regex.Posix.String died: "forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show e
err)
Right v
v -> forall (m :: * -> *) a. Monad m => a -> m a
return v
v
instance RegexMaker Regex CompOption ExecOption String where
makeRegexOpts :: CompOption -> ExecOption -> String -> Regex
makeRegexOpts CompOption
c ExecOption
e String
pattern = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
(CompOption -> ExecOption -> String -> IO (Either WrapError Regex)
compile CompOption
c ExecOption
e String
pattern forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall e v. Show e => Either e v -> IO v
unwrap)
makeRegexOptsM :: forall (m :: * -> *).
MonadFail m =>
CompOption -> ExecOption -> String -> m Regex
makeRegexOptsM CompOption
c ExecOption
e String
pattern = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (m :: * -> *) a. MonadFail m => String -> m a
failforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a. Show a => a -> String
show) forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
(CompOption -> ExecOption -> String -> IO (Either WrapError Regex)
compile CompOption
c ExecOption
e String
pattern)
instance RegexLike Regex String where
matchTest :: Regex -> String -> Bool
matchTest Regex
regex String
str = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
forall a. String -> (CString -> IO a) -> IO a
withCAString String
str (Regex -> CString -> IO (Either WrapError Bool)
wrapTest Regex
regex) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall e v. Show e => Either e v -> IO v
unwrap
matchOnce :: Regex -> String -> Maybe MatchArray
matchOnce Regex
regex String
str = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
Regex -> String -> IO (Either WrapError (Maybe MatchArray))
execute Regex
regex String
str forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall e v. Show e => Either e v -> IO v
unwrap
matchAll :: Regex -> String -> [MatchArray]
matchAll Regex
regex String
str = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
forall a. String -> (CString -> IO a) -> IO a
withCAString String
str (Regex -> CString -> IO (Either WrapError [MatchArray])
wrapMatchAll Regex
regex) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall e v. Show e => Either e v -> IO v
unwrap
matchCount :: Regex -> String -> Int
matchCount Regex
regex String
str = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
forall a. String -> (CString -> IO a) -> IO a
withCAString String
str (Regex -> CString -> IO (Either WrapError Int)
wrapCount Regex
regex) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall e v. Show e => Either e v -> IO v
unwrap
compile :: CompOption
-> ExecOption
-> String
-> IO (Either WrapError Regex)
compile :: CompOption -> ExecOption -> String -> IO (Either WrapError Regex)
compile CompOption
flags ExecOption
e String
pattern = forall a. String -> (CString -> IO a) -> IO a
withCAString String
pattern (CompOption -> ExecOption -> CString -> IO (Either WrapError Regex)
wrapCompile CompOption
flags ExecOption
e)
execute :: Regex
-> String
-> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))
execute :: Regex -> String -> IO (Either WrapError (Maybe MatchArray))
execute Regex
regex String
str = do
Either WrapError (Maybe [(RegOffset, RegOffset)])
maybeStartEnd <- forall a. String -> (CString -> IO a) -> IO a
withCAString String
str (Regex
-> CString
-> IO (Either WrapError (Maybe [(RegOffset, RegOffset)]))
wrapMatch Regex
regex)
case Either WrapError (Maybe [(RegOffset, RegOffset)])
maybeStartEnd of
Right Maybe [(RegOffset, RegOffset)]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right forall a. Maybe a
Nothing)
Right (Just [(RegOffset, RegOffset)]
parts) ->
forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,forall a. Enum a => a -> a
pred (forall (t :: * -> *) a. Foldable t => t a -> Int
length [(RegOffset, RegOffset)]
parts))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\(RegOffset
s,RegOffset
e)->(forall a b. (Integral a, Num b) => a -> b
fromIntegral RegOffset
s, forall a b. (Integral a, Num b) => a -> b
fromIntegral (RegOffset
eforall a. Num a => a -> a -> a
-RegOffset
s)))
forall a b. (a -> b) -> a -> b
$ [(RegOffset, RegOffset)]
parts
Left WrapError
err -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left WrapError
err)
regexec :: Regex
-> String
-> IO (Either WrapError (Maybe (String, String, String, [String])))
regexec :: Regex
-> String
-> IO (Either WrapError (Maybe (String, String, String, [String])))
regexec Regex
regex String
str = do
let getSub :: (RegOffset, RegOffset) -> String
getSub (RegOffset
start,RegOffset
stop) | RegOffset
start forall a. Eq a => a -> a -> Bool
== RegOffset
unusedRegOffset = String
""
| Bool
otherwise =
forall i a. Integral i => i -> [a] -> [a]
genericTake (RegOffset
stopforall a. Num a => a -> a -> a
-RegOffset
start) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i a. Integral i => i -> [a] -> [a]
genericDrop RegOffset
start forall a b. (a -> b) -> a -> b
$ String
str
matchedParts :: [(RegOffset, RegOffset)] -> (String, String, String, [String])
matchedParts [] = (String
str,String
"",String
"",[])
matchedParts (matchedStartStop :: (RegOffset, RegOffset)
matchedStartStop@(RegOffset
start,RegOffset
stop):[(RegOffset, RegOffset)]
subStartStop) =
(forall i a. Integral i => i -> [a] -> [a]
genericTake RegOffset
start String
str
,(RegOffset, RegOffset) -> String
getSub (RegOffset, RegOffset)
matchedStartStop
,forall i a. Integral i => i -> [a] -> [a]
genericDrop RegOffset
stop String
str
,forall a b. (a -> b) -> [a] -> [b]
map (RegOffset, RegOffset) -> String
getSub [(RegOffset, RegOffset)]
subStartStop)
Either WrapError (Maybe [(RegOffset, RegOffset)])
maybeStartEnd <- forall a. String -> (CString -> IO a) -> IO a
withCAString String
str (Regex
-> CString
-> IO (Either WrapError (Maybe [(RegOffset, RegOffset)]))
wrapMatch Regex
regex)
case Either WrapError (Maybe [(RegOffset, RegOffset)])
maybeStartEnd of
Right Maybe [(RegOffset, RegOffset)]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right forall a. Maybe a
Nothing)
Right (Just [(RegOffset, RegOffset)]
parts) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(RegOffset, RegOffset)] -> (String, String, String, [String])
matchedParts forall a b. (a -> b) -> a -> b
$ [(RegOffset, RegOffset)]
parts
Left WrapError
err -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left WrapError
err)