blob: d2fc25da372383bb993fd0a6154d28df09535ef0 [file] [log] [blame]
Guido van Rossum7627c0d2000-03-31 14:58:54 +00001#
2# Secret Labs' Regular Expression Engine
Guido van Rossum7627c0d2000-03-31 14:58:54 +00003#
4# re-compatible interface for the sre matching engine
5#
Fredrik Lundh770617b2001-01-14 15:06:11 +00006# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
Guido van Rossum7627c0d2000-03-31 14:58:54 +00007#
Fredrik Lundh29c4ba92000-08-01 18:20:07 +00008# 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#
Guido van Rossum7627c0d2000-03-31 14:58:54 +000012# Portions of this engine have been developed in cooperation with
Fredrik Lundh29c4ba92000-08-01 18:20:07 +000013# CNRI. Hewlett-Packard provided funding for 1.6 integration and
Guido van Rossum7627c0d2000-03-31 14:58:54 +000014# other compatibility work.
15#
16
Fred Drake9f5b8222001-09-04 19:20:06 +000017r"""Support for regular expressions (RE).
Fred Drakeb8f22742001-09-04 19:10:20 +000018
19This module provides regular expression matching operations similar to
Fredrik Lundhdac58492001-10-21 21:48:30 +000020those found in Perl. It supports both 8-bit and Unicode strings; both
21the pattern and the strings being processed can contain null bytes and
22characters outside the US ASCII range.
Fred Drakeb8f22742001-09-04 19:10:20 +000023
Fredrik Lundhdac58492001-10-21 21:48:30 +000024Regular expressions can contain both special and ordinary characters.
25Most ordinary characters, like "A", "a", or "0", are the simplest
26regular expressions; they simply match themselves. You can
Fred Drakeb8f22742001-09-04 19:10:20 +000027concatenate ordinary characters, so last matches the string 'last'.
28
29The special characters are:
30 "." Matches any character except a newline.
31 "^" Matches the start of the string.
Georg Brandl86def6c2008-01-21 20:36:10 +000032 "$" Matches the end of the string or just before the newline at
33 the end of the string.
Fred Drakeb8f22742001-09-04 19:10:20 +000034 "*" Matches 0 or more (greedy) repetitions of the preceding RE.
35 Greedy means that it will match as many repetitions as possible.
36 "+" Matches 1 or more (greedy) repetitions of the preceding RE.
37 "?" Matches 0 or 1 (greedy) of the preceding RE.
38 *?,+?,?? Non-greedy versions of the previous three special characters.
39 {m,n} Matches from m to n repetitions of the preceding RE.
40 {m,n}? Non-greedy version of the above.
Christian Heimesaf98da12008-01-27 15:18:18 +000041 "\\" Either escapes special characters or signals a special sequence.
Fred Drakeb8f22742001-09-04 19:10:20 +000042 [] Indicates a set of characters.
43 A "^" as the first character indicates a complementing set.
44 "|" A|B, creates an RE that will match either A or B.
45 (...) Matches the RE inside the parentheses.
46 The contents can be retrieved or matched later in the string.
Antoine Pitroufd036452008-08-19 17:56:33 +000047 (?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).
Fred Drakeb8f22742001-09-04 19:10:20 +000048 (?:...) Non-grouping version of regular parentheses.
49 (?P<name>...) The substring matched by the group is accessible by name.
50 (?P=name) Matches the text matched earlier by the group named name.
51 (?#...) A comment; ignored.
52 (?=...) Matches if ... matches next, but doesn't consume the string.
53 (?!...) Matches if ... doesn't match next.
Christian Heimesaf98da12008-01-27 15:18:18 +000054 (?<=...) Matches if preceded by ... (must be fixed length).
55 (?<!...) Matches if not preceded by ... (must be fixed length).
56 (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
57 the (optional) no pattern otherwise.
Fred Drakeb8f22742001-09-04 19:10:20 +000058
59The special sequences consist of "\\" and a character from the list
Fredrik Lundhdac58492001-10-21 21:48:30 +000060below. If the ordinary character is not on the list, then the
Fred Drakeb8f22742001-09-04 19:10:20 +000061resulting RE will match the second character.
Fred Drake9f5b8222001-09-04 19:20:06 +000062 \number Matches the contents of the group of the same number.
63 \A Matches only at the start of the string.
64 \Z Matches only at the end of the string.
65 \b Matches the empty string, but only at the start or end of a word.
66 \B Matches the empty string, but not at the start or end of a word.
Antoine Pitroufd036452008-08-19 17:56:33 +000067 \d Matches any decimal digit; equivalent to the set [0-9] in
68 bytes patterns or string patterns with the ASCII flag.
69 In string patterns without the ASCII flag, it will match the whole
70 range of Unicode digits.
71 \D Matches any non-digit character; equivalent to [^\d].
Fred Drake9f5b8222001-09-04 19:20:06 +000072 \s Matches any whitespace character; equivalent to [ \t\n\r\f\v].
73 \S Matches any non-whitespace character; equiv. to [^ \t\n\r\f\v].
Antoine Pitroufd036452008-08-19 17:56:33 +000074 \w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
75 in bytes patterns or string patterns with the ASCII flag.
76 In string patterns without the ASCII flag, it will match the
77 range of Unicode alphanumeric characters (letters plus digits
78 plus underscore).
Fred Drakeb8f22742001-09-04 19:10:20 +000079 With LOCALE, it will match the set [0-9_] plus characters defined
80 as letters for the current locale.
Fred Drake9f5b8222001-09-04 19:20:06 +000081 \W Matches the complement of \w.
82 \\ Matches a literal backslash.
Fred Drakeb8f22742001-09-04 19:10:20 +000083
84This module exports the following functions:
85 match Match a regular expression pattern to the beginning of a string.
86 search Search a string for the presence of a pattern.
87 sub Substitute occurrences of a pattern found in a string.
88 subn Same as sub, but also return the number of substitutions made.
89 split Split a string by the occurrences of a pattern.
90 findall Find all occurrences of a pattern in a string.
Christian Heimesaf98da12008-01-27 15:18:18 +000091 finditer Return an iterator yielding a match object for each match.
Fred Drakeb8f22742001-09-04 19:10:20 +000092 compile Compile a pattern into a RegexObject.
93 purge Clear the regular expression cache.
Fred Drakeb8f22742001-09-04 19:10:20 +000094 escape Backslash all non-alphanumerics in a string.
95
96Some of the functions in this module takes flags as optional parameters:
Antoine Pitroufd036452008-08-19 17:56:33 +000097 A ASCII For string patterns, make \w, \W, \b, \B, \d, \D
98 match the corresponding ASCII character categories
99 (rather than the whole Unicode categories, which is the
100 default).
101 For bytes patterns, this flag is the only available
102 behaviour and needn't be specified.
Fred Drakeb8f22742001-09-04 19:10:20 +0000103 I IGNORECASE Perform case-insensitive matching.
104 L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
Georg Brandl86def6c2008-01-21 20:36:10 +0000105 M MULTILINE "^" matches the beginning of lines (after a newline)
106 as well as the string.
107 "$" matches the end of lines (before a newline) as well
108 as the end of the string.
Fred Drakeb8f22742001-09-04 19:10:20 +0000109 S DOTALL "." matches any character at all, including the newline.
110 X VERBOSE Ignore whitespace and comments for nicer looking RE's.
Antoine Pitroufd036452008-08-19 17:56:33 +0000111 U UNICODE For compatibility only. Ignored for string patterns (it
112 is the default), and forbidden for bytes patterns.
Fred Drakeb8f22742001-09-04 19:10:20 +0000113
114This module also defines an exception 'error'.
115
116"""
Fredrik Lundh21009b92001-09-18 18:47:09 +0000117
Fredrik Lundh703ce812001-10-24 22:16:30 +0000118import sys
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000119import sre_compile
Fredrik Lundh436c3d582000-06-29 08:58:44 +0000120import sre_parse
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000121
Fredrik Lundhf2989b22001-02-18 12:05:16 +0000122# public symbols
123__all__ = [ "match", "search", "sub", "subn", "split", "findall",
Antoine Pitroufd036452008-08-19 17:56:33 +0000124 "compile", "purge", "template", "escape", "A", "I", "L", "M", "S", "X",
125 "U", "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
Fredrik Lundhf2989b22001-02-18 12:05:16 +0000126 "UNICODE", "error" ]
127
Fredrik Lundhbec95b92001-10-21 16:47:57 +0000128__version__ = "2.2.1"
Fredrik Lundhb25e1ad2001-03-22 15:50:10 +0000129
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000130# flags
Antoine Pitroufd036452008-08-19 17:56:33 +0000131A = ASCII = sre_compile.SRE_FLAG_ASCII # assume ascii "locale"
Fredrik Lundh770617b2001-01-14 15:06:11 +0000132I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
133L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
Antoine Pitroufd036452008-08-19 17:56:33 +0000134U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode "locale"
Fredrik Lundh770617b2001-01-14 15:06:11 +0000135M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
136S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
137X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000138
Fredrik Lundh770617b2001-01-14 15:06:11 +0000139# sre extensions (experimental, don't rely on these)
140T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
141DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
Fredrik Lundh436c3d582000-06-29 08:58:44 +0000142
143# sre exception
Fredrik Lundhbe2211e2000-06-29 16:57:40 +0000144error = sre_compile.error
Fredrik Lundh436c3d582000-06-29 08:58:44 +0000145
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000146# --------------------------------------------------------------------
147# public interface
148
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000149def match(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000150 """Try to apply the pattern at the start of the string, returning
151 a match object, or None if no match was found."""
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000152 return _compile(pattern, flags).match(string)
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000153
154def search(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000155 """Scan through string looking for a match to the pattern, returning
156 a match object, or None if no match was found."""
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000157 return _compile(pattern, flags).search(string)
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000158
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000159def sub(pattern, repl, string, count=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000160 """Return the string obtained by replacing the leftmost
161 non-overlapping occurrences of the pattern in string by the
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54 +0000162 replacement repl. repl can be either a string or a callable;
Benjamin Peterson75edad02009-01-01 15:05:06 +0000163 if a string, backslash escapes in it are processed. If it is
164 a callable, it's passed the match object and must return
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54 +0000165 a replacement string to be used."""
Fredrik Lundh7898c3e2000-08-07 20:59:04 +0000166 return _compile(pattern, 0).sub(repl, string, count)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000167
168def subn(pattern, repl, string, count=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000169 """Return a 2-tuple containing (new_string, number).
170 new_string is the string obtained by replacing the leftmost
171 non-overlapping occurrences of the pattern in the source
172 string by the replacement repl. number is the number of
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54 +0000173 substitutions that were made. repl can be either a string or a
Benjamin Peterson75edad02009-01-01 15:05:06 +0000174 callable; if a string, backslash escapes in it are processed.
175 If it is a callable, it's passed the match object and must
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54 +0000176 return a replacement string to be used."""
Fredrik Lundh7898c3e2000-08-07 20:59:04 +0000177 return _compile(pattern, 0).subn(repl, string, count)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000178
179def split(pattern, string, maxsplit=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000180 """Split the source string by the occurrences of the pattern,
181 returning a list containing the resulting substrings."""
Fredrik Lundh7898c3e2000-08-07 20:59:04 +0000182 return _compile(pattern, 0).split(string, maxsplit)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000183
Raymond Hettinger596ba4d2004-09-24 03:41:05 +0000184def findall(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000185 """Return a list of all non-overlapping matches in the string.
186
187 If one or more groups are present in the pattern, return a
188 list of groups; this will be a list of tuples if the pattern
189 has more than one group.
190
191 Empty matches are included in the result."""
Raymond Hettinger596ba4d2004-09-24 03:41:05 +0000192 return _compile(pattern, flags).findall(string)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000193
Fredrik Lundh703ce812001-10-24 22:16:30 +0000194if sys.hexversion >= 0x02020000:
Guido van Rossum0d976552002-10-14 12:22:17 +0000195 __all__.append("finditer")
Raymond Hettinger596ba4d2004-09-24 03:41:05 +0000196 def finditer(pattern, string, flags=0):
Fredrik Lundhb7747e22001-10-28 20:15:40 +0000197 """Return an iterator over all non-overlapping matches in the
198 string. For each match, the iterator returns a match object.
Fredrik Lundh703ce812001-10-24 22:16:30 +0000199
200 Empty matches are included in the result."""
Raymond Hettinger596ba4d2004-09-24 03:41:05 +0000201 return _compile(pattern, flags).finditer(string)
Fredrik Lundh703ce812001-10-24 22:16:30 +0000202
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000203def compile(pattern, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000204 "Compile a regular expression pattern, returning a pattern object."
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000205 return _compile(pattern, flags)
206
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000207def purge():
Fredrik Lundh770617b2001-01-14 15:06:11 +0000208 "Clear the regular expression cache"
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000209 _cache.clear()
Fredrik Lundhb25e1ad2001-03-22 15:50:10 +0000210 _cache_repl.clear()
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000211
Fredrik Lundh436c3d582000-06-29 08:58:44 +0000212def template(pattern, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000213 "Compile a template pattern, returning a pattern object"
Fredrik Lundh436c3d582000-06-29 08:58:44 +0000214 return _compile(pattern, flags|T)
215
Guido van Rossum698280d2008-09-10 17:44:35 +0000216_alphanum_str = frozenset(
217 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890")
218_alphanum_bytes = frozenset(
219 b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890")
Raymond Hettingerebb7f302005-09-12 22:50:37 +0000220
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000221def escape(pattern):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000222 "Escape all non-alphanumeric characters in pattern."
Guido van Rossum698280d2008-09-10 17:44:35 +0000223 if isinstance(pattern, str):
224 alphanum = _alphanum_str
225 s = list(pattern)
226 for i in range(len(pattern)):
227 c = pattern[i]
228 if c not in alphanum:
229 if c == "\000":
230 s[i] = "\\000"
231 else:
232 s[i] = "\\" + c
233 return "".join(s)
234 else:
235 alphanum = _alphanum_bytes
236 s = []
237 esc = ord(b"\\")
238 for c in pattern:
239 if c in alphanum:
240 s.append(c)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000241 else:
Guido van Rossum698280d2008-09-10 17:44:35 +0000242 if c == 0:
243 s.extend(b"\\000")
244 else:
245 s.append(esc)
246 s.append(c)
247 return bytes(s)
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000248
249# --------------------------------------------------------------------
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000250# internals
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000251
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000252_cache = {}
Fredrik Lundhb25e1ad2001-03-22 15:50:10 +0000253_cache_repl = {}
254
Fredrik Lundh397a6542001-10-18 19:30:16 +0000255_pattern_type = type(sre_compile.compile("", 0))
256
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000257_MAXCACHE = 100
Guido van Rossum7627c0d2000-03-31 14:58:54 +0000258
Fredrik Lundh7898c3e2000-08-07 20:59:04 +0000259def _compile(*key):
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000260 # internal: compile pattern
Hye-Shik Chang0f5bf1e2004-04-20 21:11:11 +0000261 cachekey = (type(key[0]),) + key
262 p = _cache.get(cachekey)
Fredrik Lundh7898c3e2000-08-07 20:59:04 +0000263 if p is not None:
264 return p
265 pattern, flags = key
Just van Rossum12723ba2003-07-02 20:03:04 +0000266 if isinstance(pattern, _pattern_type):
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000267 if flags:
Guido van Rossum698280d2008-09-10 17:44:35 +0000268 raise ValueError(
269 "Cannot process flags argument with a compiled pattern")
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000270 return pattern
Just van Rossum74902502003-07-02 21:37:16 +0000271 if not sre_compile.isstring(pattern):
Collin Winterce36ad82007-08-30 01:19:48 +0000272 raise TypeError("first argument must be string or compiled pattern")
273 p = sre_compile.compile(pattern, flags)
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000274 if len(_cache) >= _MAXCACHE:
275 _cache.clear()
Hye-Shik Chang0f5bf1e2004-04-20 21:11:11 +0000276 _cache[cachekey] = p
Jeremy Hyltonb1aa1952000-06-01 17:39:12 +0000277 return p
278
Fredrik Lundhb25e1ad2001-03-22 15:50:10 +0000279def _compile_repl(*key):
280 # internal: compile replacement pattern
281 p = _cache_repl.get(key)
282 if p is not None:
283 return p
284 repl, pattern = key
Collin Winterce36ad82007-08-30 01:19:48 +0000285 p = sre_parse.parse_template(repl, pattern)
Fredrik Lundhb25e1ad2001-03-22 15:50:10 +0000286 if len(_cache_repl) >= _MAXCACHE:
287 _cache_repl.clear()
288 _cache_repl[key] = p
289 return p
290
Fredrik Lundh5644b7f2000-09-21 17:03:25 +0000291def _expand(pattern, match, template):
292 # internal: match.expand implementation hook
293 template = sre_parse.parse_template(template, pattern)
294 return sre_parse.expand_template(template, match)
295
Fredrik Lundhbec95b92001-10-21 16:47:57 +0000296def _subx(pattern, template):
297 # internal: pattern.sub/subn implementation helper
Fredrik Lundhdac58492001-10-21 21:48:30 +0000298 template = _compile_repl(template, pattern)
299 if not template[0] and len(template[1]) == 1:
Fredrik Lundhbec95b92001-10-21 16:47:57 +0000300 # literal replacement
Fredrik Lundhdac58492001-10-21 21:48:30 +0000301 return template[1][0]
302 def filter(match, template=template):
303 return sre_parse.expand_template(template, match)
304 return filter
Fredrik Lundh0640e112000-06-30 13:55:15 +0000305
306# register myself for pickling
307
Alexandre Vassalottif7fa63d2008-05-11 08:55:36 +0000308import copyreg
Fredrik Lundh0640e112000-06-30 13:55:15 +0000309
310def _pickle(p):
311 return _compile, (p.pattern, p.flags)
312
Alexandre Vassalottif7fa63d2008-05-11 08:55:36 +0000313copyreg.pickle(_pattern_type, _pickle, _compile)
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000314
315# --------------------------------------------------------------------
316# experimental stuff (see python-dev discussions for details)
317
318class Scanner:
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000319 def __init__(self, lexicon, flags=0):
Fredrik Lundh29c4ba92000-08-01 18:20:07 +0000320 from sre_constants import BRANCH, SUBPATTERN
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000321 self.lexicon = lexicon
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000322 # combine phrases into a compound pattern
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000323 p = []
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000324 s = sre_parse.Pattern()
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000325 s.flags = flags
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000326 for phrase, action in lexicon:
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000327 p.append(sre_parse.SubPattern(s, [
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000328 (SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000329 ]))
Christian Heimes2202f872008-02-06 14:31:34 +0000330 s.groups = len(p)+1
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000331 p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
Fredrik Lundh8a3ebf82000-07-23 21:46:17 +0000332 self.scanner = sre_compile.compile(p)
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000333 def scan(self, string):
334 result = []
335 append = result.append
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000336 match = self.scanner.scanner(string).match
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000337 i = 0
338 while 1:
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000339 m = match()
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000340 if not m:
341 break
342 j = m.end()
343 if i == j:
344 break
Fredrik Lundh1296a8d2001-10-21 18:04:11 +0000345 action = self.lexicon[m.lastindex-1][1]
Guido van Rossum698280d2008-09-10 17:44:35 +0000346 if hasattr(action, "__call__"):
Fredrik Lundh770617b2001-01-14 15:06:11 +0000347 self.match = m
Fredrik Lundh7cafe4d2000-07-02 17:33:27 +0000348 action = action(self, m.group())
349 if action is not None:
350 append(action)
351 i = j
352 return result, string[i:]