Fredrik Lundh: here's the 96.6% version of SRE
diff --git a/Lib/sre.py b/Lib/sre.py
index 79878b3..455cd27 100644
--- a/Lib/sre.py
+++ b/Lib/sre.py
@@ -1,4 +1,3 @@
-# -*- Mode: Python; tab-width: 4 -*-
#
# Secret Labs' Regular Expression Engine
# $Id$
@@ -7,39 +6,127 @@
#
# Copyright (c) 1998-2000 by Secret Labs AB. All rights reserved.
#
-# This code can only be used for 1.6 alpha testing. All other use
-# require explicit permission from Secret Labs AB.
-#
# Portions of this engine have been developed in cooperation with
# CNRI. Hewlett-Packard provided funding for 1.6 integration and
# other compatibility work.
#
-"""
-this is a long string
-"""
-
import sre_compile
+# flags
+I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE
+L = LOCALE = sre_compile.SRE_FLAG_LOCALE
+M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE
+S = DOTALL = sre_compile.SRE_FLAG_DOTALL
+X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE
+
# --------------------------------------------------------------------
# public interface
-def compile(pattern, flags=0):
- return sre_compile.compile(pattern, _fixflags(flags))
+# FIXME: add docstrings
def match(pattern, string, flags=0):
- return compile(pattern, _fixflags(flags)).match(string)
+ return _compile(pattern, flags).match(string)
def search(pattern, string, flags=0):
- return compile(pattern, _fixflags(flags)).search(string)
+ return _compile(pattern, flags).search(string)
-# FIXME: etc
+def sub(pattern, repl, string, count=0):
+ return _compile(pattern).sub(repl, string, count)
+
+def subn(pattern, repl, string, count=0):
+ return _compile(pattern).subn(repl, string, count)
+
+def split(pattern, string, maxsplit=0):
+ return _compile(pattern).split(string, maxsplit)
+
+def findall(pattern, string, maxsplit=0):
+ return _compile(pattern).findall(string, maxsplit)
+
+def compile(pattern, flags=0):
+ return _compile(pattern, flags)
+
+def escape(pattern):
+ s = list(pattern)
+ for i in range(len(pattern)):
+ c = pattern[i]
+ if not ("a" <= c <= "z" or "A" <= c <= "Z" or "0" <= c <= "9"):
+ if c == "\000":
+ s[i] = "\\000"
+ else:
+ s[i] = "\\" + c
+ return pattern[:0].join(s)
# --------------------------------------------------------------------
-# helpers
+# internals
-def _fixflags(flags):
- # convert flag bitmask to sequence
- assert not flags
- return ()
+_cache = {}
+_MAXCACHE = 100
+def _compile(pattern, flags=0):
+ # internal: compile pattern
+ tp = type(pattern)
+ if tp not in (type(""), type(u"")):
+ return pattern
+ key = (tp, pattern, flags)
+ try:
+ return _cache[key]
+ except KeyError:
+ pass
+ p = sre_compile.compile(pattern, flags)
+ if len(_cache) >= _MAXCACHE:
+ _cache.clear()
+ _cache[key] = p
+ return p
+
+def _sub(pattern, template, string, count=0):
+ # internal: pattern.sub implementation hook
+ return _subn(pattern, template, string, count)[0]
+
+def _expand(match, template):
+ # internal: expand template
+ return template # FIXME
+
+def _subn(pattern, template, string, count=0):
+ # internal: pattern.subn implementation hook
+ if callable(template):
+ filter = callable
+ else:
+ # FIXME: prepare template
+ def filter(match, template=template):
+ return _expand(match, template)
+ n = i = 0
+ s = []
+ append = s.append
+ c = pattern.cursor(string)
+ while not count or n < count:
+ m = c.search()
+ if not m:
+ break
+ j = m.start()
+ if j > i:
+ append(string[i:j])
+ append(filter(m))
+ i = m.end()
+ n = n + 1
+ if i < len(string):
+ append(string[i:])
+ return string[:0].join(s), n
+
+def _split(pattern, string, maxsplit=0):
+ # internal: pattern.split implementation hook
+ n = i = 0
+ s = []
+ append = s.append
+ c = pattern.cursor(string)
+ while not maxsplit or n < maxsplit:
+ m = c.search()
+ if not m:
+ break
+ j = m.start()
+ append(string[i:j])
+ i = m.end()
+ n = n + 1
+ if i < len(string):
+ append(string[i:])
+ return s