[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))