diff --git a/README.markdown b/README.markdown --- a/README.markdown +++ b/README.markdown @@ -51,6 +51,8 @@     ☒  2017-03-05 v0.5.0.0 [Ready for review: API, tutorials and examples finalized](https://github.com/iconnect/regex/milestone/6) +    ☒  2017-13-05 v0.6.0.0 [Split out PCRE](https://github.com/iconnect/regex/milestone/7) +     ☐  2017-03-20 v1.0.0.0 [First stable release](https://github.com/iconnect/regex/milestone/3)     ☐  2017-08-31 v2.0.0.0 [Fast text replacement with benchmarks](https://github.com/iconnect/regex/milestone/4) diff --git a/Text/RE/Internal/NamedCaptures.lhs b/Text/RE/Internal/NamedCaptures.lhs --- a/Text/RE/Internal/NamedCaptures.lhs +++ b/Text/RE/Internal/NamedCaptures.lhs @@ -26,12 +26,13 @@ import Text.RE import Text.RE.Internal.PreludeMacros import Text.RE.Internal.QQ -import Text.Regex.PCRE +import Text.RE.TestBench +import Text.Regex.TDFA cp :: QuasiQuoter cp = - (qq0 "re_") + (qq0 "cp") { quoteExp = parse_capture } @@ -158,9 +159,9 @@ idFormatTokenOptions :: FormatTokenOptions idFormatTokenOptions = FormatTokenOptions - { _fto_regex_type = Nothing - , _fto_min_caps = False - , _fto_incl_caps = True + { _fto_regex_type = Nothing + , _fto_min_caps = False + , _fto_incl_caps = True } formatTokens' :: FormatTokenOptions -> [Token] -> String @@ -170,7 +171,7 @@ where t_s = case tk of ECap mb -> ecap mb - PGrp -> if _fto_regex_type == Just TDFA then "(" else "(?:" + PGrp -> if maybe False isTDFA _fto_regex_type then "(" else "(?:" PCap -> "(?" Bra -> bra _fto_min_caps BS c -> "\\" ++ [c] @@ -182,7 +183,7 @@ Just nm -> "${"++nm++"}(" False -> bra _fto_min_caps - bra mc = case mc && _fto_regex_type == Just PCRE of + bra mc = case mc && maybe False isPCRE _fto_regex_type of True -> "(?:" False -> "(" \end{code} diff --git a/Text/RE/Internal/PreludeMacros.hs b/Text/RE/Internal/PreludeMacros.hs --- a/Text/RE/Internal/PreludeMacros.hs +++ b/Text/RE/Internal/PreludeMacros.hs @@ -58,14 +58,7 @@ formatMacroSource rty ExclCaptures (preludeMacroEnv rty) . prelude_macro_id preludeMacroEnv :: RegexType -> MacroEnv -preludeMacroEnv TDFA = prelude_macro_env_tdfa -preludeMacroEnv PCRE = prelude_macro_env_pcre - -prelude_macro_env_pcre :: MacroEnv -prelude_macro_env_pcre = fix $ prelude_macro_env PCRE - -prelude_macro_env_tdfa :: MacroEnv -prelude_macro_env_tdfa = fix $ prelude_macro_env TDFA +preludeMacroEnv rty = fix $ prelude_macro_env rty prelude_macro_env :: RegexType -> MacroEnv -> MacroEnv prelude_macro_env rty env = HML.fromList $ catMaybes @@ -273,8 +266,8 @@ -> MacroEnv -> PreludeMacro -> Maybe MacroDescriptor -string_macro PCRE _ _ = Nothing -string_macro rty@TDFA env pm = +string_macro (PCRE _) _ _ = Nothing +string_macro rty@(TDFA _) env pm = Just $ run_tests rty (fmap T.unpack . parseString) samples env pm MacroDescriptor { _md_source = "\"(?:[^\"\\]+|\\\\[\\\"])*\"" @@ -796,8 +789,8 @@ ] re = case rty of - PCRE -> re_pcre - TDFA -> re_tdfa + PCRE _ -> re_pcre + TDFA _ -> re_tdfa re_tdfa = bracketedRegexSource $ intercalate "|" $ diff --git a/Text/RE/PCRE.hs b/Text/RE/PCRE.hs deleted file mode 100644 --- a/Text/RE/PCRE.hs +++ /dev/null @@ -1,96 +0,0 @@ -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif -{-# OPTIONS_GHC -fno-warn-dodgy-exports #-} - -module Text.RE.PCRE - ( - -- * Tutorial - -- $tutorial - - -- * The Overloaded Match Operators - (*=~) - , (?=~) - , (=~) - , (=~~) - -- * The Toolkit - -- $toolkit - , module Text.RE - -- * The 'RE' Type - -- $re - , module Text.RE.PCRE.RE - -- * The Operator Instances - -- $instances - , module Text.RE.PCRE.ByteString - , module Text.RE.PCRE.ByteString.Lazy - , module Text.RE.PCRE.Sequence - , module Text.RE.PCRE.String - - ) where - - -import qualified Text.Regex.Base as B -import Text.RE -import Text.RE.Internal.AddCaptureNames -import Text.RE.PCRE.RE -import qualified Text.Regex.PCRE as PCRE -import Text.RE.PCRE.ByteString() -import Text.RE.PCRE.ByteString.Lazy() -import Text.RE.PCRE.Sequence() -import Text.RE.PCRE.String() - - --- | find all matches in text -(*=~) :: IsRegex RE s - => s - -> RE - -> Matches s -(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ matchMany rex bs - --- | find first match in text -(?=~) :: IsRegex RE s - => s - -> RE - -> Match s -(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ matchOnce rex bs - --- | the regex-base polymorphic match operator -(=~) :: ( B.RegexContext PCRE.Regex s a - , B.RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption s - ) - => s - -> RE - -> a -(=~) bs rex = B.match (reRegex rex) bs - --- | the regex-base monadic, polymorphic match operator -(=~~) :: ( Monad m - , B.RegexContext PCRE.Regex s a - , B.RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption s - ) - => s - -> RE - -> m a -(=~~) bs rex = B.matchM (reRegex rex) bs - --- $tutorial --- We have a regex tutorial at . These API --- docs are mainly for reference. - --- $toolkit --- --- Beyond the above match operators and the regular expression type --- below, "Text.RE" contains the toolkit for replacing captures, --- specifying options, etc. - --- $re --- --- "Text.RE.TDFA.RE" contains the toolkit specific to the 'RE' type, --- the type generated by the gegex compiler. - --- $instances --- --- These modules merely provide the instances for the above regex --- match operators at the various text types. diff --git a/Text/RE/PCRE/ByteString.hs b/Text/RE/PCRE/ByteString.hs deleted file mode 100644 --- a/Text/RE/PCRE/ByteString.hs +++ /dev/null @@ -1,91 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif - -module Text.RE.PCRE.ByteString - ( - -- * Tutorial - -- $tutorial - - -- * The Match Operators - (*=~) - , (?=~) - , (=~) - , (=~~) - -- * The Toolkit - -- $toolkit - , module Text.RE - -- * The 'RE' Type - -- $re - , module Text.RE.PCRE.RE - ) where - -import Prelude.Compat -import qualified Data.ByteString as B -import Data.Typeable -import Text.Regex.Base -import Text.RE -import Text.RE.Internal.AddCaptureNames -import Text.RE.PCRE.RE -import qualified Text.Regex.PCRE as PCRE - - --- | find all matches in text -(*=~) :: B.ByteString - -> RE - -> Matches B.ByteString -(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ match (reRegex rex) bs - --- | find first match in text -(?=~) :: B.ByteString - -> RE - -> Match B.ByteString -(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base polymorphic match operator -(=~) :: ( Typeable a - , RegexContext PCRE.Regex B.ByteString a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => B.ByteString - -> RE - -> a -(=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base monadic, polymorphic match operator -(=~~) :: ( Monad m - , Functor m - , Typeable a - , RegexContext PCRE.Regex B.ByteString a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => B.ByteString - -> RE - -> m a -(=~~) bs rex = addCaptureNames (reCaptureNames rex) <$> matchM (reRegex rex) bs - -instance IsRegex RE B.ByteString where - matchOnce = flip (?=~) - matchMany = flip (*=~) - regexSource = reSource - --- $tutorial --- We have a regex tutorial at . These API --- docs are mainly for reference. - --- $toolkit --- --- Beyond the above match operators and the regular expression type --- below, "Text.RE" contains the toolkit for replacing captures, --- specifying options, etc. - --- $re --- --- "Text.RE.PCRE.RE" contains the toolkit specific to the 'RE' type, --- the type generated by the gegex compiler. diff --git a/Text/RE/PCRE/ByteString/Lazy.hs b/Text/RE/PCRE/ByteString/Lazy.hs deleted file mode 100644 --- a/Text/RE/PCRE/ByteString/Lazy.hs +++ /dev/null @@ -1,91 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif - -module Text.RE.PCRE.ByteString.Lazy - ( - -- * Tutorial - -- $tutorial - - -- * The Match Operators - (*=~) - , (?=~) - , (=~) - , (=~~) - -- * The Toolkit - -- $toolkit - , module Text.RE - -- * The 'RE' Type - -- $re - , module Text.RE.PCRE.RE - ) where - -import Prelude.Compat -import qualified Data.ByteString.Lazy as LBS -import Data.Typeable -import Text.Regex.Base -import Text.RE -import Text.RE.Internal.AddCaptureNames -import Text.RE.PCRE.RE -import qualified Text.Regex.PCRE as PCRE - - --- | find all matches in text -(*=~) :: LBS.ByteString - -> RE - -> Matches LBS.ByteString -(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ match (reRegex rex) bs - --- | find first match in text -(?=~) :: LBS.ByteString - -> RE - -> Match LBS.ByteString -(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base polymorphic match operator -(=~) :: ( Typeable a - , RegexContext PCRE.Regex LBS.ByteString a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => LBS.ByteString - -> RE - -> a -(=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base monadic, polymorphic match operator -(=~~) :: ( Monad m - , Functor m - , Typeable a - , RegexContext PCRE.Regex LBS.ByteString a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => LBS.ByteString - -> RE - -> m a -(=~~) bs rex = addCaptureNames (reCaptureNames rex) <$> matchM (reRegex rex) bs - -instance IsRegex RE LBS.ByteString where - matchOnce = flip (?=~) - matchMany = flip (*=~) - regexSource = reSource - --- $tutorial --- We have a regex tutorial at . These API --- docs are mainly for reference. - --- $toolkit --- --- Beyond the above match operators and the regular expression type --- below, "Text.RE" contains the toolkit for replacing captures, --- specifying options, etc. - --- $re --- --- "Text.RE.PCRE.RE" contains the toolkit specific to the 'RE' type, --- the type generated by the gegex compiler. diff --git a/Text/RE/PCRE/RE.hs b/Text/RE/PCRE/RE.hs deleted file mode 100644 --- a/Text/RE/PCRE/RE.hs +++ /dev/null @@ -1,251 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE QuasiQuotes #-} -{-# LANGUAGE TemplateHaskell #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE TypeSynonymInstances #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif -{-# OPTIONS_GHC -fno-warn-orphans #-} - -module Text.RE.PCRE.RE - ( re - , reMS - , reMI - , reBS - , reBI - , reMultilineSensitive - , reMultilineInsensitive - , reBlockSensitive - , reBlockInsensitive - , re_ - , cp - , regexType - , RE - , reOptions - , reSource - , reCaptureNames - , reRegex - , Options - , prelude - , preludeEnv - , preludeTestsFailing - , preludeTable - , preludeSummary - , preludeSources - , preludeSource - , noPreludeOptions - , defaultOptions - , unpackSimpleRegexOptions - , compileRegex - , escape - , escapeREString - ) where - -import Data.Bits -import Data.Functor.Identity -import Language.Haskell.TH -import Language.Haskell.TH.Quote -import Prelude.Compat -import Text.RE -import Text.RE.Internal.EscapeREString -import Text.RE.Internal.NamedCaptures -import Text.RE.Internal.PreludeMacros -import Text.RE.Internal.QQ -import Text.RE.TestBench -import Text.Regex.PCRE - - -re - , reMS - , reMI - , reBS - , reBI - , reMultilineSensitive - , reMultilineInsensitive - , reBlockSensitive - , reBlockInsensitive - , re_ :: QuasiQuoter - -re = re' $ Just minBound -reMS = reMultilineSensitive -reMI = reMultilineInsensitive -reBS = reBlockSensitive -reBI = reBlockInsensitive -reMultilineSensitive = re' $ Just MultilineSensitive -reMultilineInsensitive = re' $ Just MultilineInsensitive -reBlockSensitive = re' $ Just BlockSensitive -reBlockInsensitive = re' $ Just BlockInsensitive -re_ = re' Nothing - -regexType :: RegexType -regexType = PCRE - -data RE = - RE - { _re_options :: !Options - , _re_source :: !String - , _re_cnames :: !CaptureNames - , _re_regex :: !Regex - } - -reOptions :: RE -> Options -reOptions = _re_options - -reSource :: RE -> String -reSource = _re_source - -reCaptureNames :: RE -> CaptureNames -reCaptureNames = _re_cnames - -reRegex :: RE -> Regex -reRegex = _re_regex - -type Options = Options_ RE CompOption ExecOption - -instance IsOption SimpleRegexOptions RE CompOption ExecOption where - makeOptions = unpackSimpleRegexOptions - -instance IsOption (Macros RE) RE CompOption ExecOption where - makeOptions ms = Options ms def_comp_option def_exec_option - -instance IsOption CompOption RE CompOption ExecOption where - makeOptions co = Options prelude co def_exec_option - -instance IsOption ExecOption RE CompOption ExecOption where - makeOptions eo = Options prelude def_comp_option eo - -instance IsOption Options RE CompOption ExecOption where - makeOptions = id - -instance IsOption () RE CompOption ExecOption where - makeOptions _ = unpackSimpleRegexOptions minBound - -def_comp_option :: CompOption -def_comp_option = optionsComp defaultOptions - -def_exec_option :: ExecOption -def_exec_option = optionsExec defaultOptions - -noPreludeOptions :: Options -noPreludeOptions = defaultOptions { optionsMacs = emptyMacros } - -defaultOptions :: Options -defaultOptions = makeOptions (minBound::SimpleRegexOptions) - -unpackSimpleRegexOptions :: SimpleRegexOptions -> Options -unpackSimpleRegexOptions sro = - Options - { optionsMacs = prelude - , optionsComp = comp - , optionsExec = defaultExecOpt - } - where - comp = - wiggle ml compMultiline $ - wiggle ci compCaseless - defaultCompOpt - - wiggle True m v = v .|. m - wiggle False m v = v .&. complement m - - (ml,ci) = case sro of - MultilineSensitive -> (,) True False - MultilineInsensitive -> (,) True True - BlockSensitive -> (,) False False - BlockInsensitive -> (,) False True - -compileRegex :: ( IsOption o RE CompOption ExecOption - , Functor m - , Monad m - ) - => o - -> String - -> m RE -compileRegex = compileRegex_ . makeOptions - -compileRegex_ :: ( Functor m , Monad m ) - => Options - -> String - -> m RE -compileRegex_ os re_s = uncurry mk <$> compileRegex' os re_s - where - mk cnms rex = - RE - { _re_options = os - , _re_source = re_s - , _re_cnames = cnms - , _re_regex = rex - } - -re' :: Maybe SimpleRegexOptions -> QuasiQuoter -re' mb = case mb of - Nothing -> - (qq0 "re_") - { quoteExp = parse minBound (\rs->[|flip unsafeCompileRegex rs|]) - } - Just sro -> - (qq0 "re") - { quoteExp = parse sro (\rs->[|unsafeCompileRegexSimple sro rs|]) - } - where - parse :: SimpleRegexOptions -> (String->Q Exp) -> String -> Q Exp - parse sro mk rs = either error (\_->mk rs) $ compileRegex_ os rs - where - os = unpackSimpleRegexOptions sro - -unsafeCompileRegexSimple :: SimpleRegexOptions -> String -> RE -unsafeCompileRegexSimple sro re_s = unsafeCompileRegex os re_s - where - os = unpackSimpleRegexOptions sro - -unsafeCompileRegex :: IsOption o RE CompOption ExecOption - => o - -> String - -> RE -unsafeCompileRegex = unsafeCompileRegex_ . makeOptions - -unsafeCompileRegex_ :: Options -> String -> RE -unsafeCompileRegex_ os = either oops id . compileRegex os - where - oops = error . ("unsafeCompileRegex: " ++) - -compileRegex' :: (Functor m,Monad m) - => Options - -> String - -> m (CaptureNames,Regex) -compileRegex' Options{..} s0 = do - (cnms,s2) <- either fail return $ extractNamedCaptures s1 - (,) cnms <$> makeRegexOptsM optionsComp optionsExec s2 - where - s1 = expandMacros reSource optionsMacs s0 - -prelude :: Macros RE -prelude = runIdentity $ preludeMacros mk PCRE ExclCaptures - where - mk = Identity . unsafeCompileRegex_ noPreludeOptions - -preludeTestsFailing :: [MacroID] -preludeTestsFailing = badMacros preludeEnv - -preludeEnv :: MacroEnv -preludeEnv = preludeMacroEnv PCRE - -preludeTable :: String -preludeTable = preludeMacroTable PCRE - -preludeSummary :: PreludeMacro -> String -preludeSummary = preludeMacroSummary PCRE - -preludeSources :: String -preludeSources = preludeMacroSources PCRE - -preludeSource :: PreludeMacro -> String -preludeSource = preludeMacroSource PCRE - -escape :: (String->String) -> String -> RE -escape f = unsafeCompileRegex () . f . escapeREString diff --git a/Text/RE/PCRE/Sequence.hs b/Text/RE/PCRE/Sequence.hs deleted file mode 100644 --- a/Text/RE/PCRE/Sequence.hs +++ /dev/null @@ -1,91 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif - -module Text.RE.PCRE.Sequence - ( - -- * Tutorial - -- $tutorial - - -- * The Match Operators - (*=~) - , (?=~) - , (=~) - , (=~~) - -- * The Toolkit - -- $toolkit - , module Text.RE - -- * The 'RE' Type - -- $re - , module Text.RE.PCRE.RE - ) where - -import Prelude.Compat -import qualified Data.Sequence as S -import Data.Typeable -import Text.Regex.Base -import Text.RE -import Text.RE.Internal.AddCaptureNames -import Text.RE.PCRE.RE -import qualified Text.Regex.PCRE as PCRE - - --- | find all matches in text -(*=~) :: (S.Seq Char) - -> RE - -> Matches (S.Seq Char) -(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ match (reRegex rex) bs - --- | find first match in text -(?=~) :: (S.Seq Char) - -> RE - -> Match (S.Seq Char) -(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base polymorphic match operator -(=~) :: ( Typeable a - , RegexContext PCRE.Regex (S.Seq Char) a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => (S.Seq Char) - -> RE - -> a -(=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base monadic, polymorphic match operator -(=~~) :: ( Monad m - , Functor m - , Typeable a - , RegexContext PCRE.Regex (S.Seq Char) a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => (S.Seq Char) - -> RE - -> m a -(=~~) bs rex = addCaptureNames (reCaptureNames rex) <$> matchM (reRegex rex) bs - -instance IsRegex RE (S.Seq Char) where - matchOnce = flip (?=~) - matchMany = flip (*=~) - regexSource = reSource - --- $tutorial --- We have a regex tutorial at . These API --- docs are mainly for reference. - --- $toolkit --- --- Beyond the above match operators and the regular expression type --- below, "Text.RE" contains the toolkit for replacing captures, --- specifying options, etc. - --- $re --- --- "Text.RE.PCRE.RE" contains the toolkit specific to the 'RE' type, --- the type generated by the gegex compiler. diff --git a/Text/RE/PCRE/String.hs b/Text/RE/PCRE/String.hs deleted file mode 100644 --- a/Text/RE/PCRE/String.hs +++ /dev/null @@ -1,91 +0,0 @@ -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 800 -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -#endif - -module Text.RE.PCRE.String - ( - -- * Tutorial - -- $tutorial - - -- * The Match Operators - (*=~) - , (?=~) - , (=~) - , (=~~) - -- * The Toolkit - -- $toolkit - , module Text.RE - -- * The 'RE' Type - -- $re - , module Text.RE.PCRE.RE - ) where - -import Prelude.Compat - -import Data.Typeable -import Text.Regex.Base -import Text.RE -import Text.RE.Internal.AddCaptureNames -import Text.RE.PCRE.RE -import qualified Text.Regex.PCRE as PCRE - - --- | find all matches in text -(*=~) :: String - -> RE - -> Matches String -(*=~) bs rex = addCaptureNamesToMatches (reCaptureNames rex) $ match (reRegex rex) bs - --- | find first match in text -(?=~) :: String - -> RE - -> Match String -(?=~) bs rex = addCaptureNamesToMatch (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base polymorphic match operator -(=~) :: ( Typeable a - , RegexContext PCRE.Regex String a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => String - -> RE - -> a -(=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs - --- | the regex-base monadic, polymorphic match operator -(=~~) :: ( Monad m - , Functor m - , Typeable a - , RegexContext PCRE.Regex String a - , RegexMaker PCRE.Regex PCRE.CompOption PCRE.ExecOption String - ) - => String - -> RE - -> m a -(=~~) bs rex = addCaptureNames (reCaptureNames rex) <$> matchM (reRegex rex) bs - -instance IsRegex RE String where - matchOnce = flip (?=~) - matchMany = flip (*=~) - regexSource = reSource - --- $tutorial --- We have a regex tutorial at . These API --- docs are mainly for reference. - --- $toolkit --- --- Beyond the above match operators and the regular expression type --- below, "Text.RE" contains the toolkit for replacing captures, --- specifying options, etc. - --- $re --- --- "Text.RE.PCRE.RE" contains the toolkit specific to the 'RE' type, --- the type generated by the gegex compiler. diff --git a/Text/RE/TDFA/RE.hs b/Text/RE/TDFA/RE.hs --- a/Text/RE/TDFA/RE.hs +++ b/Text/RE/TDFA/RE.hs @@ -82,7 +82,8 @@ re_ = re' Nothing regexType :: RegexType -regexType = TDFA +regexType = + TDFA $ \txt env md -> txt =~ mdRegexSource regexType ExclCaptures env md data RE = RE @@ -221,27 +222,27 @@ s1 = expandMacros reSource optionsMacs s0 prelude :: Macros RE -prelude = runIdentity $ preludeMacros mk TDFA ExclCaptures +prelude = runIdentity $ preludeMacros mk regexType ExclCaptures where mk = Identity . unsafeCompileRegex_ noPreludeOptions preludeEnv :: MacroEnv -preludeEnv = preludeMacroEnv TDFA +preludeEnv = preludeMacroEnv regexType preludeTestsFailing :: [MacroID] -preludeTestsFailing = badMacros $ preludeMacroEnv TDFA +preludeTestsFailing = badMacros $ preludeMacroEnv regexType preludeTable :: String -preludeTable = preludeMacroTable TDFA +preludeTable = preludeMacroTable regexType preludeSummary :: PreludeMacro -> String -preludeSummary = preludeMacroSummary TDFA +preludeSummary = preludeMacroSummary regexType preludeSources :: String -preludeSources = preludeMacroSources TDFA +preludeSources = preludeMacroSources regexType preludeSource :: PreludeMacro -> String -preludeSource = preludeMacroSource TDFA +preludeSource = preludeMacroSource regexType escape :: (String->String) -> String -> RE escape f = unsafeCompileRegex () . f . escapeREString diff --git a/Text/RE/TestBench.lhs b/Text/RE/TestBench.lhs --- a/Text/RE/TestBench.lhs +++ b/Text/RE/TestBench.lhs @@ -11,6 +11,9 @@ module Text.RE.TestBench ( MacroID(..) , RegexType(..) + , isTDFA + , isPCRE + , presentRegexType , MacroEnv , WithCaptures(..) , MacroDescriptor(..) @@ -28,6 +31,7 @@ , formatMacroSources , formatMacroSource , testMacroDescriptors + , mdRegexSource ) where import Data.Array @@ -42,20 +46,39 @@ import Text.RE.Capture import Text.RE.Options import Text.RE.Replace -import qualified Text.Regex.PCRE as PCRE -import qualified Text.Regex.TDFA as TDFA \end{code} Types ----- \begin{code} --- | what kind of back end will be compiling the RE + +type TestBenchMatcher = + String -> MacroEnv -> MacroDescriptor -> Matches String + +-- | what kind of back end will be compiling the RE, and its match +-- function data RegexType - = TDFA -- the TDFA back end - | PCRE -- the PCRE back end - deriving (Bounded,Enum,Eq,Ord,Show) + = TDFA TestBenchMatcher + | PCRE TestBenchMatcher +-- | test RegexType for TDFA/PCREness +isTDFA, isPCRE :: RegexType -> Bool + +isTDFA (TDFA _) = True +isTDFA (PCRE _) = False + +isPCRE (TDFA _) = False +isPCRE (PCRE _) = True + +presentRegexType :: RegexType -> String +presentRegexType (TDFA _) = "TDFA" +presentRegexType (PCRE _) = "PCRE" + +instance Show RegexType where + show (TDFA _) = "TDFA " + show (PCRE _) = "PCRE " + -- | do we need the captures in the RE or whould they be stripped out -- where possible data WithCaptures @@ -149,7 +172,7 @@ putStrLn $ "========================================================" return False where - lab' = lab ++ " [" ++ show rty ++"]" + lab' = lab ++ " [" ++ presentRegexType rty ++"]" badMacros :: MacroEnv -> [MacroID] badMacros m_env = @@ -191,8 +214,8 @@ test_neg src = test_neg' mid rty parser $ match_ src env md match_ = case rty of - TDFA -> match_tdfa - PCRE -> match_pcre + TDFA tbmf -> tbmf + PCRE tbmf -> tbmf \end{code} @@ -208,7 +231,7 @@ fp_t = "docs/" ++ rty_s ++ "-" ++ lab ++ ".txt" fp_s = "docs/" ++ rty_s ++ "-" ++ lab ++ "-src.txt" - rty_s = map toLower $ show rty + rty_s = map toLower $ presentRegexType rty \end{code} \begin{code} @@ -394,7 +417,7 @@ min_captures rty rets = length [ () | REToken{..}<-rets - , _ret_fixed || (_ret_grouping && rty==TDFA) + , _ret_fixed || (_ret_grouping && isTDFA rty) ] \end{code} @@ -413,7 +436,7 @@ False -> case (,) _ret_grouping (_ret_capturing && wc==InclCaptures) of (False,False) -> "" - (True ,False) -> if rty==PCRE then "(?:" else "(" + (True ,False) -> if isPCRE rty then "(?:" else "(" (False,True ) -> "(" (True ,True ) -> "(" @@ -465,18 +488,6 @@ \end{code} -scan_re -------- - -\begin{code} -match_tdfa :: String -> MacroEnv -> MacroDescriptor -> Matches String -match_tdfa txt env md = txt TDFA.=~ mdRegexSource TDFA ExclCaptures env md - -match_pcre :: String -> MacroEnv -> MacroDescriptor -> Matches String -match_pcre txt env md = txt PCRE.=~ mdRegexSource PCRE ExclCaptures env md -\end{code} - - mdRegexSource ------------- @@ -560,5 +571,5 @@ where mid_s = getMacroID mid neg_s = if is_neg then "-ve" else "+ve" :: String - rty_s = show rty + rty_s = presentRegexType rty \end{code} diff --git a/changelog b/changelog --- a/changelog +++ b/changelog @@ -1,5 +1,8 @@ -*-change-log-*- +0.6.0.0 Chris Dornan 2017-03-13 + * Split out rexex-with-pcre package (#65) + 0.5.0.0 Chris Dornan 2017-03-05 * Fix inter-operation of =~ & =~~ and named captures (#55) * Add escaping functions (#37) diff --git a/regex.cabal b/regex.cabal --- a/regex.cabal +++ b/regex.cabal @@ -1,5 +1,5 @@ Name: regex -Version: 0.5.0.0 +Version: 0.6.0.0 Synopsis: Toolkit for regex-base Description: A Regular Expression Toolkit for regex-base with Compile-time checking of RE syntax, data types for @@ -31,10 +31,11 @@ Source-Repository this Type: git Location: https://github.com/iconnect/regex.git - Tag: 0.5.0.0 + Tag: 0.6.0.0 + Library Hs-Source-Dirs: . Exposed-Modules: @@ -51,12 +52,6 @@ Text.RE.LineNo Text.RE.Options Text.RE.Parsers - Text.RE.PCRE - Text.RE.PCRE.ByteString - Text.RE.PCRE.ByteString.Lazy - Text.RE.PCRE.RE - Text.RE.PCRE.Sequence - Text.RE.PCRE.String Text.RE.Replace Text.RE.TDFA Text.RE.TDFA.ByteString @@ -86,7 +81,6 @@ , hashable >= 1.2.3.3 , heredoc >= 0.2.0.0 , regex-base >= 0.93.2 - , regex-pcre-builtin >= 0.94.4.8.8.35 , regex-tdfa >= 1.2.0 , regex-tdfa-text >= 1.0.0.3 , template-haskell >= 2.7 @@ -97,5 +91,4 @@ , unordered-containers >= 0.2.5.1 - --- Generated from lib/cabal-masters/mega-regex with re-gen-cabals +-- Generated with re-gen-cabals