Lib/sre.py

   1 #
   2 # Secret Labs' Regular Expression Engine
   3 #
   4 # re-compatible interface for the sre matching engine
   5 #
   6 # Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
   7 #
   8 # This version of the SRE library can be redistributed under CNRI's
   9 # Python 1.6 license.  For any other use, please contact Secret Labs
  10 # AB (info@pythonware.com).
  11 #
  12 # Portions of this engine have been developed in cooperation with
  13 # CNRI.  Hewlett-Packard provided funding for 1.6 integration and
  14 # other compatibility work.
  15 #
  16
  17 import sre_compile
  18 import sre_parse
  19
  20 # public symbols
  21 __all__ = [ "match", "search", "sub", "subn", "split", "findall",
  22     "compile", "purge", "template", "escape", "I", "L", "M", "S", "X",
  23     "U", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
  24     "UNICODE", "error" ]
  25
  26 __version__ = "2.1b2"
  27
  28 # this module works under 1.5.2 and later.  don't use string methods
  29 import string
  30
  31 # flags
  32 I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
  33 L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
  34 U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale
  35 M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
  36 S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
  37 X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
  38
  39 # sre extensions (experimental, don't rely on these)
  40 T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
  41 DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
  42
  43 # sre exception
  44 error = sre_compile.error
  45
  46 # --------------------------------------------------------------------
  47 # public interface
  48
  49 def match(pattern, string, flags=0):
  50     """Try to apply the pattern at the start of the string, returning
  51     a match object, or None if no match was found."""
  52     return _compile(pattern, flags).match(string)
  53
  54 def search(pattern, string, flags=0):
  55     """Scan through string looking for a match to the pattern, returning
  56     a match object, or None if no match was found."""
  57     return _compile(pattern, flags).search(string)
  58
  59 def sub(pattern, repl, string, count=0):
  60     """Return the string obtained by replacing the leftmost
  61     non-overlapping occurrences of the pattern in string by the
  62     replacement repl"""
  63     return _compile(pattern, 0).sub(repl, string, count)
  64
  65 def subn(pattern, repl, string, count=0):
  66     """Return a 2-tuple containing (new_string, number).
  67     new_string is the string obtained by replacing the leftmost
  68     non-overlapping occurrences of the pattern in the source
  69     string by the replacement repl.  number is the number of
  70     substitutions that were made."""
  71     return _compile(pattern, 0).subn(repl, string, count)
  72
  73 def split(pattern, string, maxsplit=0):
  74     """Split the source string by the occurrences of the pattern,
  75     returning a list containing the resulting substrings."""
  76     return _compile(pattern, 0).split(string, maxsplit)
  77
  78 def findall(pattern, string, maxsplit=0):
  79     """Return a list of all non-overlapping matches in the string.
  80
  81     If one or more groups are present in the pattern, return a
  82     list of groups; this will be a list of tuples if the pattern
  83     has more than one group.
  84
  85     Empty matches are included in the result."""
  86     return _compile(pattern, 0).findall(string, maxsplit)
  87
  88 def compile(pattern, flags=0):
  89     "Compile a regular expression pattern, returning a pattern object."
  90     return _compile(pattern, flags)
  91
  92 def purge():
  93     "Clear the regular expression cache"
  94     _cache.clear()
  95     _cache_repl.clear()
  96
  97 def template(pattern, flags=0):
  98     "Compile a template pattern, returning a pattern object"
  99     return _compile(pattern, flags|T)
 100
 101 def escape(pattern):
 102     "Escape all non-alphanumeric characters in pattern."
 103     s = list(pattern)
 104     for i in range(len(pattern)):
 105         c = pattern[i]
 106         if not ("a" <= c <= "z" or "A" <= c <= "Z" or "0" <= c <= "9"):
 107             if c == "\000":
 108                 s[i] = "\\000"
 109             else:
 110                 s[i] = "\\" + c
 111     return _join(s, pattern)
 112
 113 # --------------------------------------------------------------------
 114 # internals
 115
 116 _cache = {}
 117 _cache_repl = {}
 118
 119 _MAXCACHE = 100
 120
 121 def _join(seq, sep):
 122     # internal: join into string having the same type as sep
 123     return string.join(seq, sep[:0])
 124
 125 def _compile(*key):
 126     # internal: compile pattern
 127     p = _cache.get(key)
 128     if p is not None:
 129         return p
 130     pattern, flags = key
 131     if type(pattern) not in sre_compile.STRING_TYPES:
 132         return pattern
 133     try:
 134         p = sre_compile.compile(pattern, flags)
 135     except error, v:
 136         raise error, v # invalid expression
 137     if len(_cache) >= _MAXCACHE:
 138         _cache.clear()
 139     _cache[key] = p
 140     return p
 141
 142 def _compile_repl(*key):
 143     # internal: compile replacement pattern
 144     p = _cache_repl.get(key)
 145     if p is not None:
 146         return p
 147     repl, pattern = key
 148     try:
 149         p = sre_parse.parse_template(repl, pattern)
 150     except error, v:
 151         raise error, v # invalid expression
 152     if len(_cache_repl) >= _MAXCACHE:
 153         _cache_repl.clear()
 154     _cache_repl[key] = p
 155     return p
 156
 157 def _expand(pattern, match, template):
 158     # internal: match.expand implementation hook
 159     template = sre_parse.parse_template(template, pattern)
 160     return sre_parse.expand_template(template, match)
 161
 162 def _sub(pattern, template, string, count=0):
 163     # internal: pattern.sub implementation hook
 164     return _subn(pattern, template, string, count)[0]
 165
 166 def _subn(pattern, template, string, count=0):
 167     # internal: pattern.subn implementation hook
 168     if callable(template):
 169         filter = template
 170     else:
 171         template = _compile_repl(template, pattern)
 172         def filter(match, template=template):
 173             return sre_parse.expand_template(template, match)
 174     n = i = 0
 175     s = []
 176     append = s.append
 177     c = pattern.scanner(string)
 178     while not count or n < count:
 179         m = c.search()
 180         if not m:
 181             break
 182         b, e = m.span()
 183         if i < b:
 184             append(string[i:b])
 185         append(filter(m))
 186         i = e
 187         n = n + 1
 188     append(string[i:])
 189     return _join(s, string[:0]), n
 190
 191 def _split(pattern, string, maxsplit=0):
 192     # internal: pattern.split implementation hook
 193     n = i = 0
 194     s = []
 195     append = s.append
 196     extend = s.extend
 197     c = pattern.scanner(string)
 198     g = pattern.groups
 199     while not maxsplit or n < maxsplit:
 200         m = c.search()
 201         if not m:
 202             break
 203         b, e = m.span()
 204         if b == e:
 205             if i >= len(string):
 206                 break
 207             continue
 208         append(string[i:b])
 209         if g and b != e:
 210             extend(list(m.groups()))
 211         i = e
 212         n = n + 1
 213     append(string[i:])
 214     return s
 215
 216 # register myself for pickling
 217
 218 import copy_reg
 219
 220 def _pickle(p):
 221     return _compile, (p.pattern, p.flags)
 222
 223 copy_reg.pickle(type(_compile("", 0)), _pickle, _compile)
 224
 225 # --------------------------------------------------------------------
 226 # experimental stuff (see python-dev discussions for details)
 227
 228 class Scanner:
 229     def __init__(self, lexicon):
 230         from sre_constants import BRANCH, SUBPATTERN
 231         self.lexicon = lexicon
 232         # combine phrases into a compound pattern
 233         p = []
 234         s = sre_parse.Pattern()
 235         for phrase, action in lexicon:
 236             p.append(sre_parse.SubPattern(s, [
 237                 (SUBPATTERN, (len(p), sre_parse.parse(phrase))),
 238                 ]))
 239         p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
 240         s.groups = len(p)
 241         self.scanner = sre_compile.compile(p)
 242     def scan(self, string):
 243         result = []
 244         append = result.append
 245         match = self.scanner.match
 246         i = 0
 247         while 1:
 248             m = match(string, i)
 249             if not m:
 250                 break
 251             j = m.end()
 252             if i == j:
 253                 break
 254             action = self.lexicon[m.lastindex][1]
 255             if callable(action):
 256                 self.match = m
 257                 action = action(self, m.group())
 258             if action is not None:
 259                 append(action)
 260             i = j
 261         return result, string[i:]