diff options
Diffstat (limited to 'dev-haskell/regex-base/files/regex-base-0.71-0.72.patch')
| -rw-r--r-- | dev-haskell/regex-base/files/regex-base-0.71-0.72.patch | 422 |
1 files changed, 422 insertions, 0 deletions
diff --git a/dev-haskell/regex-base/files/regex-base-0.71-0.72.patch b/dev-haskell/regex-base/files/regex-base-0.71-0.72.patch new file mode 100644 index 000000000000..7d20ce4e10f1 --- /dev/null +++ b/dev-haskell/regex-base/files/regex-base-0.71-0.72.patch @@ -0,0 +1,422 @@ +diff -urwpN regex-base-0.71/doc/lazy.html ghc-6.6.1/libraries/regex-base/doc/lazy.html +--- regex-base-0.71/doc/lazy.html 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/doc/lazy.html 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,139 @@ ++<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> ++<HTML> ++ <head> ++ <title>Text.Regex.Lazy</title> ++ </head> ++<body> ++<h1><tt>Text.Regex.Lazy</tt></h1> ++<h2>Version 0.70 (2006-08-10)</h2> ++ ++<h3>By Chris Kuklewicz (TextRegexLazy (at) personal (dot) mightyreason (dot) com)</h3> ++ ++Changes from 0.66 to 0.70 ++<ul> ++ <li> regex-tre added for libtre backend (Text.Regex.TRE), see http://laurikari.net/tre/ ++ <li> regex-devel added for tests and benchmarks ++ <li> Text.Regex.*.Wrap APIs improved: the exported wrap* functions ++ never call fail or error under normal circumstances, and use Either ++ types to report errors. Allocation failures are reported with fail. ++ <li> Text.Regex.*.(ByteString|String) all should export ++ compile/execute/regexec functions which report errors using Either. ++</ul> ++ ++Changes from 0.55 to 0.66 ++<ul> ++ <li> I broke this into many packages, regex-base for the interface and regex-pcre, regex-posix, regex-parsec, regex-dfa for the four backends and regex-compat to replace Text.Regex(.New) ++ <li> The top level Makefile now can drive setup and installation of all the packages at once. ++</ul> ++ ++Changes from 0.44 to 0.55 ++<ul> ++ <li> <b>JRegex has been assimilated: PCRE and PosixRE are here</b>. ++ The JRegex-style API rocks, see below and Context.hs and Example.hs ++ <li> Haddock seems to run via ./setup haddock, but the documentation is very thin ++ <li> ./setup test runs TestTestRegexLazy binary if uncommented in cabal file ++ <li> default is now to compile with -Wall -Werror -O2 ++ <li> You may need to point the cabal file's "Extra-Lib-Dirs" to point to pcre. ++ <li> You may or may not need a "-lpcre" option to ghc when building ++ projects that depend on Text.Regex.Lazy now. ++</ul> ++ ++Changes from 0.33 to 0.44 ++<ul> ++ <li> Cabal ++ <li> Compile with -Wall -Werror ++ <li> Change DFAEngineFPS from Data.FastPackedString to Data.ByteString ++</ul> ++See the LICENSE file for details on copyright. See README for building instructions. ++<br/> ++The new API is very close to JRegex and supports 4 backends: ++<ul> ++ <li> Posix, the standard c regex library ++ <li> PCRE, the <a href="http://www.pcre.org/">Perl Compatible Regular Expressions</a> c library ++ <li> Full, the lazy Parsec based library (see old api below) ++ <li> DFA, the fast lazy matching library (see old api below) ++</ul> ++And for all backends, there are two types that can be used as a source ++of regular expressions or to match a regular expression against: ++String, and ByteString. The ByteString library will be in the next ++GHC and can be gotten ++from <a ++href="http://www.cse.unsw.edu.au/~dons/fps.html">http://www.cse.unsw.edu.au/~dons/fps.html</a>. ++<p> ++For simplest use of the new API: import Text.Regex.Lazy and one of ++<pre> ++import Text.Regex.PCRE((=~),(=~~)) ++import Text.Regex.Parsec((=~),(=~~)) ++import Text.Regex.DFA((=~),(=~~)) ++import Text.Regex.PosixRE((=~),(=~~)) ++import Text.Regex.TRE((=~),(=~~)) ++</pre> ++The things you can demand of (=~) and (=~~) are all ++instance defined in Text.Regex.Impl.Context and they are used ++in <tt>Example.hs</tt> as well. ++<p> ++<p> ++You can redefine (=~) and (=~~) to use different options by using makeRegexOpts: ++<pre> ++(=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target) => source1 -> source -> target ++(=~) x r = let q :: Regex ++ q = makeRegexOpts (some compoption) (some execoption) r ++ in match q x ++ ++(=~~) ::(RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,Monad m) => source1 -> source -> m target ++(=~~) x r = let q :: Regex ++ q = makeRegexOpts (some compoption) (some execoption) r ++ in matchM q x ++</pre> ++There is a medium level API with functions compile/execute/regexec in ++all the Text.Regex.*.(String|ByteString) modules. These allow for ++errors to be reported as Either types when compiling or running. ++<p> ++The low level APIs are in the Text.Regex.*.Wrap modules. For the ++c-library backends these expose most of the c-api in wrap* functions ++that make the type more Haskell-like: CString and CStingLen and ++newtypes to specify compile and execute options. The actual foreign ++calls are not exported; it does not export the raw c api. ++<p> ++Also, Text.Regex.PCRE.Wrap will let you query if it was compiled with ++UTF8 suppor: <tt>configUTF8 :: Bool</tt>. But I do not provide a way ++to marshall to or from UTF8. (If you have a UTF8 ByteString then you ++would probably be able to make it work, assuming the indices PCRE uses ++are in bytes, otherwise look at the wrap* functions which are a thin ++layer over the pcreapi). ++<p> ++ ++<p> ++The old Text.Regex API is can be replaced. If you need to be drop in ++compatible with <tt>Text.Regex</tt> then you can ++import <tt>Text.Regex.New</tt> and report any infidelities as bugs. ++ ++Some advantages of <tt>Text.Regex.Parsec</tt> over <tt>Text.Regex</tt>: ++<ul> ++ <li> It does not marshal to and from c-code arrays, so it is much ++ faster on large input strings. ++ <li> It consumes the input <tt>String</tt> in a mostly lazy manner. ++ This makes streaming from input to output possible. ++ <li> It performs sanity checks so that <tt>subRegex</tt> ++ and <tt>splitRegex</tt> don't loop or go crazy if the pattern ++ matches an empty string -- it will just return the input. ++ <li> If the <tt>String</tt> regex does not parse then you get a nicer error ++ message. ++</ul> ++<p> ++Internally it uses <tt>Parsec</tt> to turn the string regex into ++a <tt>Pattern</tt> data type, simplify the <tt>Pattern</tt>, then ++transform the <tt>Pattern</tt> into a <tt>Parsec</tt> parser that ++accepts matching strings and stores the sub-strings of parenthesized ++groups. ++<p> ++All of this was motivated by the inability to use <tt>Text.Regex</tt> ++to complete ++the <a ++href="http://shootout.alioth.debian.org/gp4/benchmark.php?test=regexdna&lang=all">regex-dna ++benchmark</a> on <a href="http://shootout.alioth.debian.org/">The ++Computer Language Shootout</a>. The current entry there, by Don ++Stewart and Alson Kemp and Chris Kuklewicz, does not use this Parsec ++solution, but rather a custom DFA lexer from the CTK library. ++</body> ++</HTML> +diff -urwpN regex-base-0.71/doc/README ghc-6.6.1/libraries/regex-base/doc/README +--- regex-base-0.71/doc/README 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/doc/README 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,39 @@ ++README for TestRegexLazy-0.66 ++ ++By Chris Kuklewicz (TextRegexLazy (at) personal (dot) mightyreason (dot) com) ++ ++For more detail on Text.Regex.Lazy look at the very very outdated ++lazy.html file or the LICENSE file. ++ ++To build and install: ++ get Data.ByteString from http://www.cse.unsw.edu.au/~dons/fps.html ++ (You probably want to configure ByteString's cabal with -p for profiling) ++ edit list of BACKENDS in Makefile if you want to exclude regex-tre or regex-pcre ++ edit regex-pcre/regex-pcre.cabal to point to your PCRE installation ++ edit CONF and USER variables in Makefile to point to your setup ++ (The CONF includes -p for profiling) ++ run "make all" which will create and install all the packages in $(SUBDIRS) ++ ++The packages: ++ regex-base : This hold the type class definitions and (most) RegexContext,Extract instances ++ regex-compat : Builds Text.Regex.New (soon to replace Text.Regex) on top of regex-parsec ++ regex-pcre : Build the PCRE backend, http://www.pcre.org/ ++ regex-posix : Builds the Posix backend ++ regex-parsec : Builds my lazy parsec based pure haskell backend ++ regex-dfa : Build the simple backend based on CTKLight (this is LGPL) ++ ++There is an additional "regex-devel" package where I am setting up ++testing and bechmarking. Use "make regex-devel" at the top level to ++compile (not install), or use its cabal Setup.hs. ++regex-devel/bench/runbench.sh is my simple toy benchmark. ++ ++To use =~ and =~~ new API: ++ ++> import Text.Regex.(Parsec|DFA|PCRE|PosixRE|TRE) ++and perhaps ++> import Text.Regex.Base ++ ++Look at Example*.hs and instances in Text.Regex.Base.Context.hs for what it can do. ++ ++For old "Text.Regex" API drop in compatibility, import Text.Regex.New (uses PosixRE backend) ++ +diff -urwpN regex-base-0.71/doc/Redesign.txt ghc-6.6.1/libraries/regex-base/doc/Redesign.txt +--- regex-base-0.71/doc/Redesign.txt 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/doc/Redesign.txt 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,14 @@ ++The regular expression stuff needs some of a rethink. ++ ++Things that could be made more efficient, as I think of them: ++ ++(1) Making Arrays in Wrap* may be a bit inefficient ++counter: Usage may be like "look up element 3" so random access is good ++ ++(2) String DFA: the findRegex computes the prefix string itself, which is sometimes wasted / sometimes wanted / always discarded. Also, the input string at the start of the match is discarded ++ ++(3) Lazy computes MatchedStrings array then discards it. Wasteful. ++ ++(4) Mighty extend RegexLike with ability to return "strings", i.e. Extract instance. The default conversion could be left in for some things. Then RegexContext could pull from that instead of matchOnce/matchAll. ++ ++(5) make RegexLike default matchAll/matchOnce in terms of matchOnceText and matchAllText +diff -urwpN regex-base-0.71/examples/Example2.hs ghc-6.6.1/libraries/regex-base/examples/Example2.hs +--- regex-base-0.71/examples/Example2.hs 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/examples/Example2.hs 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,44 @@ ++{-# OPTIONS_GHC -fglasgow-exts #-} ++import Text.Regex.Base ++import Text.Regex.Posix(Regex,(=~),(=~~)) -- or DFA or PCRE or PosixRE ++import qualified Data.ByteString.Char8 as B(ByteString,pack) ++ ++-- Show mixing of ByteString and String as well as polymorphism: ++ ++main = let x :: (RegexContext Regex String target) => target ++ x = ("abaca" =~ B.pack "(.)a") ++ x' :: (RegexContext Regex String target,Monad m) => m target ++ x' = ("abaca" =~~ "(.)a") ++ y :: (RegexContext Regex B.ByteString target) => target ++ y = (B.pack "abaca" =~ "(.)a") ++ y' :: (RegexContext Regex B.ByteString target,Monad m) => m target ++ y' = (B.pack "abaca" =~~ B.pack "(.)a") ++ in do print (x :: Bool) ++ print (x :: Int) ++ print (x :: [MatchArray]) ++ print (x' :: Maybe (String,String,String,[String])) ++ print (y :: Bool) ++ print (y :: Int) ++ print (y :: [MatchArray]) ++ print (y' :: Maybe (B.ByteString,B.ByteString,B.ByteString,[B.ByteString])) ++ ++{- Output is, except for replacing Full with DFA (which has no capture) ++True ++2 ++[array (0,1) [(0,(1,2)),(1,(1,1))],array (0,1) [(0,(3,2)),(1,(3,1))]] ++Just ("a","ba","ca",["b"]) ++True ++2 ++[array (0,1) [(0,(1,2)),(1,(1,1))],array (0,1) [(0,(3,2)),(1,(3,1))]] ++Just ("a","ba","ca",["b"]) ++-} ++{- The output for DFA is ++True ++2 ++[array (0,0) [(0,(1,2))],array (0,0) [(0,(3,2))]] ++Just ("a","ba","ca",[]) ++True ++2 ++[array (0,0) [(0,(1,2))],array (0,0) [(0,(3,2))]] ++Just ("a","ba","ca",[]) ++-} +diff -urwpN regex-base-0.71/examples/Example3.lhs ghc-6.6.1/libraries/regex-base/examples/Example3.lhs +--- regex-base-0.71/examples/Example3.lhs 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/examples/Example3.lhs 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,21 @@ ++> {-# OPTIONS_GHC -fglasgow-exts #-} ++ ++> import Text.Regex.Base ++ ++> import qualified Text.Regex.PCRE as R ++> import qualified Text.Regex.PosixRE as S ++> import qualified Text.Regex.Parsec as F ++ ++Choose which library to use depending on presence of PCRE library. ++ ++> (=~) :: (RegexMaker R.Regex R.CompOption R.ExecOption a,RegexContext R.Regex b t ++> ,RegexMaker F.Regex F.CompOption F.ExecOption a,RegexContext F.Regex b t ++> ,RegexMaker S.Regex S.CompOption S.ExecOption a,RegexContext S.Regex b t) ++> => b -> a -> t ++> (=~) = case R.getVersion of ++> Just _ -> (R.=~) ++> Nothing -> case S.getVersion of ++> Just _ -> (S.=~) ++> Nothing -> (F.=~) ++ ++> main = print ("abc" =~ "(.)c" :: Bool) +\ No newline at end of file +diff -urwpN regex-base-0.71/examples/Example.hs ghc-6.6.1/libraries/regex-base/examples/Example.hs +--- regex-base-0.71/examples/Example.hs 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/examples/Example.hs 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,14 @@ ++{-# OPTIONS_GHC -fglasgow-exts #-} ++import Text.Regex.Base ++import Text.Regex.Posix((=~),(=~~)) -- or DFA or PCRE or PosixRE ++import qualified Data.ByteString.Char8 as B(ByteString,pack) ++ ++main = let b :: Bool ++ b = ("abaca" =~ "(.)a") ++ c :: [MatchArray] ++ c = ("abaca" =~ "(.)a") ++ d :: Maybe (String,String,String,[String]) ++ d = ("abaca" =~~ "(.)a") ++ in do print b ++ print c ++ print d +diff -urwpN regex-base-0.71/Makefile ghc-6.6.1/libraries/regex-base/Makefile +--- regex-base-0.71/Makefile 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/Makefile 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,20 @@ ++TOP=.. ++include $(TOP)/mk/boilerplate.mk ++ ++SUBDIRS = ++ ++ALL_DIRS = \ ++ Text/Regex \ ++ Text/Regex/Base ++ ++PACKAGE = regex-base ++VERSION = 0.72 ++PACKAGE_DEPS = base ++ ++EXCLUDED_SRCS = Setup.hs ++ ++SRC_HC_OPTS += -cpp ++ ++SRC_HADDOCK_OPTS += -t "Haskell Hierarchical Libraries ($(PACKAGE) package)" ++ ++include $(TOP)/mk/target.mk +diff -urwpN regex-base-0.71/package.conf.in ghc-6.6.1/libraries/regex-base/package.conf.in +--- regex-base-0.71/package.conf.in 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/package.conf.in 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1,27 @@ ++name: PACKAGE ++version: VERSION ++license: BSD3 ++maintainer: TextRegexLazy@personal.mightyreason.com ++exposed: True ++ ++exposed-modules: Text.Regex.Base ++ Text.Regex.Base.RegexLike ++ Text.Regex.Base.Context ++ Text.Regex.Base.Impl ++ ++hidden-modules: ++ ++import-dirs: IMPORT_DIR ++library-dirs: LIB_DIR ++hs-libraries: "HSregex-base" ++extra-libraries: ++include-dirs: ++includes: ++depends: base ++hugs-options: ++cc-options: ++ld-options: ++framework-dirs: ++frameworks: ++haddock-interfaces: HADDOCK_IFACE ++haddock-html: HTML_DIR +diff -urwpN regex-base-0.71/prologue.txt ghc-6.6.1/libraries/regex-base/prologue.txt +--- regex-base-0.71/prologue.txt 1970-01-01 01:00:00.000000000 +0100 ++++ ghc-6.6.1/libraries/regex-base/prologue.txt 2007-04-25 18:24:10.000000000 +0100 +@@ -0,0 +1 @@ ++Interfaces for regular expressions +diff -urwpN regex-base-0.71/regex-base.cabal ghc-6.6.1/libraries/regex-base/regex-base.cabal +--- regex-base-0.71/regex-base.cabal 2006-12-05 18:29:02.000000000 +0000 ++++ ghc-6.6.1/libraries/regex-base/regex-base.cabal 2007-04-25 18:24:10.000000000 +0100 +@@ -2,7 +2,7 @@ + -- To fix for cabal < 1.1.4 comment out the Extra-Source-Files line + -- **************************************************************** + Name: regex-base +-Version: 0.71 ++Version: 0.72 + -- Cabal-Version: >=1.1.4 + License: BSD3 + License-File: LICENSE +@@ -28,7 +28,7 @@ Buildable: True + -- Other-Modules: + -- ********* Be backward compatible until 6.4.2 is futher deployed + -- HS-Source-Dirs: "." +-Extensions: MultiParamTypeClasses, FunctionalDependencies ++Extensions: MultiParamTypeClasses, FunctionalDependencies, CPP + -- GHC-Options: -Wall -Werror + GHC-Options: -Wall -Werror -O2 + -- GHC-Options: -Wall -ddump-minimal-imports +diff -urwpN regex-base-0.71/Text/Regex/Base/Context.hs ghc-6.6.1/libraries/regex-base/Text/Regex/Base/Context.hs +--- regex-base-0.71/Text/Regex/Base/Context.hs 2006-12-05 18:29:02.000000000 +0000 ++++ ghc-6.6.1/libraries/regex-base/Text/Regex/Base/Context.hs 2007-04-25 18:24:10.000000000 +0100 +@@ -185,9 +185,12 @@ instance (RegexLike a b) => RegexContext + match r s = maybe (-1,0) (!0) (matchOnce r s) + matchM r s = maybe regexFailed (return.(!0)) (matchOnce r s) + ++#if __GLASGOW_HASKELL__ ++-- overlaps with instance (RegexLike a b) => RegexContext a b (Array Int b) + instance (RegexLike a b) => RegexContext a b MatchArray where + match r s = maybe nullArray id (matchOnce r s) + matchM r s = maybe regexFailed return (matchOnce r s) ++#endif + + instance (RegexLike a b) => RegexContext a b (b,MatchText b,b) where + match r s = maybe (s,nullArray,empty) id (matchOnceText r s) +@@ -216,21 +219,27 @@ instance (RegexLike a b) => RegexContext + , mrMatch = whole + , mrAfter = post + , mrSubs = fmap fst ma +- , mrSubList = tail (map fst subs) }) ++ , mrSubList = map fst subs }) + + -- ** Instances based on matchAll,matchAllText + ++#if __GLASGOW_HASKELL__ ++-- overlaps with instance (RegexLike a b) => RegexContext a b [Array Int b] + instance (RegexLike a b) => RegexContext a b [MatchArray] where + match = matchAll + matchM = nullFail ++#endif + + instance (RegexLike a b) => RegexContext a b [MatchText b] where + match = matchAllText + matchM = nullFail + ++#if __GLASGOW_HASKELL__ ++-- overlaps with instance (RegexLike a b) => RegexContext a b [b] + instance (RegexLike a b) => RegexContext a b [(MatchOffset,MatchLength)] where + match r s = [ ma!0 | ma <- matchAll r s ] + matchM = nullFail ++#endif + + instance (RegexLike a b) => RegexContext a b [b] where + match r s = [ fst (ma!0) | ma <- matchAllText r s ] |