[Zope-Checkins] CVS: Zope2 - ts_regex.py:1.7.158.1

Andreas Jung andreas@dhcp165.digicool.com
Tue, 17 Apr 2001 10:14:25 -0400


Update of /cvs-repository/Zope2/lib/python
In directory yetix:/work/sandboxes/ajung-2_4-ts_regex-exterminiation-branch/lib/python

Modified Files:
      Tag: ajung-2_4-ts_regex-exterminiation-branch
	ts_regex.py 
Log Message:
private copy



--- Updated File ts_regex.py in package Zope2 --
--- ts_regex.py	1999/08/18 20:06:52	1.7
+++ ts_regex.py	2001/04/17 14:14:24	1.7.158.1
@@ -82,67 +82,53 @@
 # attributions are listed in the accompanying credits file.
 # 
 ##############################################################################
-"""Provide a thread-safe interface to regex
 """
-import regex, regsub #, Sync
-from regex import *
-from regsub import split, sub, gsub, splitx, capwords
-
-try: 
-    import thread
-except:
-    class allocate_lock:
-        def acquire(*args): pass
-        def release(*args): pass
-
-else:
-    class SafeFunction:
-        _l=thread.allocate_lock()
-        _a=_l.acquire
-        _r=_l.release
-
-        def __init__(self, f):
-            self._f=f
-
-        def __call__(self, *args, **kw):
-            self._a()
-            try: return apply(self._f, args, kw)
-            finally: self._r()
-
-    split=SafeFunction(split)
-    sub=SafeFunction(sub)
-    gsub=SafeFunction(gsub)
-    splitx=SafeFunction(splitx)
-    capwords=SafeFunction(capwords)
+Replacement of the old ts_regex module using the standard re module
+"""
 
-    allocate_lock=thread.allocate_lock
+import re,reconvert
+_rcCV = reconvert.convert
 
-class compile:
+
+def sub(pat,repl,str):
+    return re.sub(_rcCV(pat) , repl , str, count=1)
+
+
+def gsub(pat,repl,str):
+    return re.sub(_rcCV(pat) , repl , str )
+
+
+
+def split(str,pat,maxsplit=0):
+    return re.split(_rcCV(pat) , str , maxsplit)
+
+
+def splitx(str,pat,maxsplit=0):
+    return re.split('(' + _rcCV(pat) + ')' , str , maxsplit)
 
-    _r=None
-    groupindex=None
 
+
+
+class compile:
+
     def __init__(self, *args):
-        self._r=r=apply(regex.compile,args)
-        self._init(r)
 
-    def _init(self, r):
-        lock=allocate_lock()
-        self.__a=lock.acquire
-        self.__r=lock.release
-        self.translate=r.translate
-        self.givenpat=r.givenpat
-        self.realpat=r.realpat
+        if len(args)==1:
+            self._re = re.compile(_rcCV(args[0]))
+        else: 
+            self._re = re.compile(_rcCV(args[0]), args[1:])
+        
 
     def match(self, string, pos=0):
-        self.__a()
-        try: return self._r.match(string, pos)
-        finally: self.__r()
+        mo = self._re.match(string, pos)
+        if mo==None: return -1
+        else:        return mo.end(0) 
 
+
     def search(self, string, pos=0):
-        self.__a()
-        try: return self._r.search(string, pos)
-        finally: self.__r()
+        mo = self._re.search(string, pos)
+        if mo==None: return -1
+        else:        return mo.start(0) 
         
     def search_group(self, str, group, pos=0):
         """Search a string for a pattern.
@@ -151,13 +137,10 @@
         otherwise, the location where the pattern was found,
         as well as any specified group are returned.
         """
-        self.__a()
-        try:
-            r=self._r
-            l=r.search(str, pos)
-            if l < 0: return None
-            return l, apply(r.group, group)
-        finally: self.__r()
+        mo = self._re.search(str, pos)
+        if mo==None : return None
+        print 'groups:',mo.groups()
+        return mo.start(0), apply(mo.group,group)
 
     def match_group(self, str, group, pos=0):
         """Match a pattern against a string
@@ -166,50 +149,73 @@
         returned, otherwise, the length of the match, as well
         as any specified group are returned.
         """
-        self.__a()
-        try:
-            r=self._r
-            l=r.match(str, pos)
-            if l < 0: return None
-            return l, apply(r.group, group)
-        finally: self.__r()
 
-    def search_regs(self, str, pos=0):
-        """Search a string for a pattern.
+        mo = self._re.search(str, pos)
+        if mo==None : return None
+        print 'groups:',mo.groups()
+        return 0
+#        return mo.end(0), apply(mo.group,group)
 
-        If the pattern was not found, then None is returned,
-        otherwise, the 'regs' attribute of the expression is
-        returned.
-        """
-        self.__a()
-        try:
-            r=self._r
-            r.search(str, pos)
-            return r.regs
-        finally: self.__r()
+      
 
-    def match_regs(self, str, pos=0):
-        """Match a pattern against a string
 
-        If the string does not match the pattern, then None is
-        returned, otherwise, the 'regs' attribute of the expression is
-        returned.
-        """
-        self.__a()
-        try:
-            r=self._r
-            r.match(str, pos)
-            return r.regs
-        finally: self.__r()
+if __name__=='__main__':
 
-class symcomp(compile):
+    import sys,ts_regex_old as TRO
 
-    def __init__(self, *args):
-        self._r=r=apply(regex.symcomp,args)
-        self._init(r)
-        self.groupindex=r.groupindex
+    s1 = 'The quick brown fox jumps of The lazy dog'
+    s2 = '892 The quick brown 123 fox jumps over  3454 21 The lazy dog'
 
+    r1 = ' [a-zA-Z][a-zA-Z] '
+    r2 = '[0-9][0-9]'
 
+    print 'new:',split(s1,' ')
+    print 'old:',TRO.split(s1,' ')
 
+    print 'new:',splitx(s2,' ')
+    print 'old:',TRO.splitx(s2,' ')
 
-        
+    print 'new:',split(s2,' ',2)
+    print 'old:',TRO.split(s2,' ',2)
+
+    print 'new:',splitx(s2,' ',2)
+    print 'old:',TRO.splitx(s2,' ',2)
+
+
+    print 'new:',sub('The','###',s1)
+    print 'old:',TRO.sub('The','###',s1)
+
+    print 'new:',gsub('The','###',s1)
+    print 'old:',TRO.gsub('The','###',s1)
+
+    sys.exit(1)
+
+
+    for s in [s1,s2]:
+
+        for r in [r1,r2]:
+
+            pat1 = compile(r)
+            pat2 = TRO.compile(r)
+          
+            print '-'*78
+            print s,r
+
+#            print 'search' 
+#            print 'new:',pat1.search(s)
+#            print 'old:',pat2.search(s)
+#
+#        
+#            print 'match' 
+#            print 'new:',pat1.match(s)
+#            print 'old:',pat2.match(s)
+ 
+
+            print 'match_group'
+            print 'new:',pat1.match_group(s,(0,))
+            print 'old:',pat2.match_group(s,(0,))
+
+
+            print 'search_group'
+            print 'new:',pat1.match_group(s,(0,1))
+            print 'old:',pat2.match_group(s,(0,1))