Google Git
Sign in
chromium / external / github.com / python / cpython / refs/tags/2.7 / . / Lib / re.py
blob: 671a90404a6de18c5b4ac554c4e77e7a14c41bfa [file] [log] [blame]
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]1#
2# Secret Labs' Regular Expression Engine
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]3#
4# re-compatible interface for the sre matching engine
5#
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]6# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]7#
Fredrik Lundh29c4ba92000-08-01 18:20:07[diff] [blame]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#
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]12# Portions of this engine have been developed in cooperation with
Fredrik Lundh29c4ba92000-08-01 18:20:07[diff] [blame]13# CNRI. Hewlett-Packard provided funding for 1.6 integration and
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]14# other compatibility work.
15#
16
Fred Drake9f5b8222001-09-04 19:20:06[diff] [blame]17r"""Support for regular expressions (RE).
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]18
19This module provides regular expression matching operations similar to
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]20those 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[diff] [blame]23
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]24Regular 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[diff] [blame]27concatenate 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 Brandle4216912008-01-21 17:29:23[diff] [blame]32 "$" 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[diff] [blame]34 "*" 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.
Georg Brandl42231992008-01-26 11:00:18[diff] [blame]41 "\\" Either escapes special characters or signals a special sequence.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]42 [] 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.
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]47 (?iLmsux) Set the I, L, M, S, U, or X flag for the RE (see below).
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]48 (?:...) 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.
Georg Brandl42231992008-01-26 11:00:18[diff] [blame]54 (?<=...) 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[diff] [blame]58
59The special sequences consist of "\\" and a character from the list
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]60below. If the ordinary character is not on the list, then the
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]61resulting RE will match the second character.
Fred Drake9f5b8222001-09-04 19:20:06[diff] [blame]62 \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.
67 \d Matches any decimal digit; equivalent to the set [0-9].
68 \D Matches any non-digit character; equivalent to the set [^0-9].
69 \s Matches any whitespace character; equivalent to [ \t\n\r\f\v].
70 \S Matches any non-whitespace character; equiv. to [^ \t\n\r\f\v].
71 \w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_].
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]72 With LOCALE, it will match the set [0-9_] plus characters defined
73 as letters for the current locale.
Fred Drake9f5b8222001-09-04 19:20:06[diff] [blame]74 \W Matches the complement of \w.
75 \\ Matches a literal backslash.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]76
77This module exports the following functions:
78 match Match a regular expression pattern to the beginning of a string.
79 search Search a string for the presence of a pattern.
80 sub Substitute occurrences of a pattern found in a string.
81 subn Same as sub, but also return the number of substitutions made.
82 split Split a string by the occurrences of a pattern.
83 findall Find all occurrences of a pattern in a string.
Georg Brandl42231992008-01-26 11:00:18[diff] [blame]84 finditer Return an iterator yielding a match object for each match.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]85 compile Compile a pattern into a RegexObject.
86 purge Clear the regular expression cache.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]87 escape Backslash all non-alphanumerics in a string.
88
89Some of the functions in this module takes flags as optional parameters:
90 I IGNORECASE Perform case-insensitive matching.
91 L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
Georg Brandle4216912008-01-21 17:29:23[diff] [blame]92 M MULTILINE "^" matches the beginning of lines (after a newline)
93 as well as the string.
94 "$" matches the end of lines (before a newline) as well
95 as the end of the string.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]96 S DOTALL "." matches any character at all, including the newline.
97 X VERBOSE Ignore whitespace and comments for nicer looking RE's.
Fredrik Lundh21009b92001-09-18 18:47:09[diff] [blame]98 U UNICODE Make \w, \W, \b, \B, dependent on the Unicode locale.
Fred Drakeb8f22742001-09-04 19:10:20[diff] [blame]99
100This module also defines an exception 'error'.
101
102"""
Fredrik Lundh21009b92001-09-18 18:47:09[diff] [blame]103
Fredrik Lundh703ce812001-10-24 22:16:30[diff] [blame]104import sys
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]105import sre_compile
Fredrik Lundh436c3d582000-06-29 08:58:44[diff] [blame]106import sre_parse
Serhiy Storchakae969b1b2014-10-30 23:31:33[diff] [blame]107try:
108 import _locale
109except ImportError:
110 _locale = None
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]111
Fredrik Lundhf2989b22001-02-18 12:05:16[diff] [blame]112# public symbols
113__all__ = [ "match", "search", "sub", "subn", "split", "findall",
114 "compile", "purge", "template", "escape", "I", "L", "M", "S", "X",
115 "U", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
116 "UNICODE", "error" ]
117
Fredrik Lundhbec95b92001-10-21 16:47:57[diff] [blame]118__version__ = "2.2.1"
Fredrik Lundhb25e1ad2001-03-22 15:50:10[diff] [blame]119
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]120# flags
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]121I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
122L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
123U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale
124M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
125S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
126X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]127
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]128# sre extensions (experimental, don't rely on these)
129T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
130DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
Fredrik Lundh436c3d582000-06-29 08:58:44[diff] [blame]131
132# sre exception
Fredrik Lundhbe2211e2000-06-29 16:57:40[diff] [blame]133error = sre_compile.error
Fredrik Lundh436c3d582000-06-29 08:58:44[diff] [blame]134
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]135# --------------------------------------------------------------------
136# public interface
137
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]138def match(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]139 """Try to apply the pattern at the start of the string, returning
140 a match object, or None if no match was found."""
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]141 return _compile(pattern, flags).match(string)
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]142
143def search(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]144 """Scan through string looking for a match to the pattern, returning
145 a match object, or None if no match was found."""
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]146 return _compile(pattern, flags).search(string)
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]147
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]148def sub(pattern, repl, string, count=0, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]149 """Return the string obtained by replacing the leftmost
150 non-overlapping occurrences of the pattern in string by the
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54[diff] [blame]151 replacement repl. repl can be either a string or a callable;
Georg Brandl2adde052009-01-01 12:00:19[diff] [blame]152 if a string, backslash escapes in it are processed. If it is
153 a callable, it's passed the match object and must return
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54[diff] [blame]154 a replacement string to be used."""
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]155 return _compile(pattern, flags).sub(repl, string, count)
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]156
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]157def subn(pattern, repl, string, count=0, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]158 """Return a 2-tuple containing (new_string, number).
159 new_string is the string obtained by replacing the leftmost
160 non-overlapping occurrences of the pattern in the source
161 string by the replacement repl. number is the number of
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54[diff] [blame]162 substitutions that were made. repl can be either a string or a
Georg Brandl2adde052009-01-01 12:00:19[diff] [blame]163 callable; if a string, backslash escapes in it are processed.
164 If it is a callable, it's passed the match object and must
Andrew M. Kuchling43ab0cd2004-08-07 17:41:54[diff] [blame]165 return a replacement string to be used."""
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]166 return _compile(pattern, flags).subn(repl, string, count)
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]167
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]168def split(pattern, string, maxsplit=0, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]169 """Split the source string by the occurrences of the pattern,
170 returning a list containing the resulting substrings."""
Gregory P. Smithae91d092009-03-02 05:13:57[diff] [blame]171 return _compile(pattern, flags).split(string, maxsplit)
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]172
Raymond Hettinger596ba4d2004-09-24 03:41:05[diff] [blame]173def findall(pattern, string, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]174 """Return a list of all non-overlapping matches in the string.
175
176 If one or more groups are present in the pattern, return a
177 list of groups; this will be a list of tuples if the pattern
178 has more than one group.
179
180 Empty matches are included in the result."""
Raymond Hettinger596ba4d2004-09-24 03:41:05[diff] [blame]181 return _compile(pattern, flags).findall(string)
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]182
Fredrik Lundh703ce812001-10-24 22:16:30[diff] [blame]183if sys.hexversion >= 0x02020000:
Guido van Rossum0d976552002-10-14 12:22:17[diff] [blame]184 __all__.append("finditer")
Raymond Hettinger596ba4d2004-09-24 03:41:05[diff] [blame]185 def finditer(pattern, string, flags=0):
Fredrik Lundhb7747e22001-10-28 20:15:40[diff] [blame]186 """Return an iterator over all non-overlapping matches in the
187 string. For each match, the iterator returns a match object.
Fredrik Lundh703ce812001-10-24 22:16:30[diff] [blame]188
189 Empty matches are included in the result."""
Raymond Hettinger596ba4d2004-09-24 03:41:05[diff] [blame]190 return _compile(pattern, flags).finditer(string)
Fredrik Lundh703ce812001-10-24 22:16:30[diff] [blame]191
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]192def compile(pattern, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]193 "Compile a regular expression pattern, returning a pattern object."
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]194 return _compile(pattern, flags)
195
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]196def purge():
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]197 "Clear the regular expression cache"
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]198 _cache.clear()
Fredrik Lundhb25e1ad2001-03-22 15:50:10[diff] [blame]199 _cache_repl.clear()
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]200
Fredrik Lundh436c3d582000-06-29 08:58:44[diff] [blame]201def template(pattern, flags=0):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]202 "Compile a template pattern, returning a pattern object"
Fredrik Lundh436c3d582000-06-29 08:58:44[diff] [blame]203 return _compile(pattern, flags|T)
204
Benjamin Petersonc59df7d2012-02-21 04:13:20[diff] [blame]205_alphanum = frozenset(
Benjamin Petersonb6596c52012-02-21 13:08:29[diff] [blame]206 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
Raymond Hettingerebb7f302005-09-12 22:50:37[diff] [blame]207
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]208def escape(pattern):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]209 "Escape all non-alphanumeric characters in pattern."
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]210 s = list(pattern)
Raymond Hettingerebb7f302005-09-12 22:50:37[diff] [blame]211 alphanum = _alphanum
Ezio Melotti46645632011-03-25 12:50:52[diff] [blame]212 for i, c in enumerate(pattern):
Raymond Hettingerebb7f302005-09-12 22:50:37[diff] [blame]213 if c not in alphanum:
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]214 if c == "\000":
215 s[i] = "\\000"
216 else:
217 s[i] = "\\" + c
Barry Warsaw8bee7612004-08-25 02:22:30[diff] [blame]218 return pattern[:0].join(s)
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]219
220# --------------------------------------------------------------------
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]221# internals
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]222
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]223_cache = {}
Fredrik Lundhb25e1ad2001-03-22 15:50:10[diff] [blame]224_cache_repl = {}
225
Fredrik Lundh397a6542001-10-18 19:30:16[diff] [blame]226_pattern_type = type(sre_compile.compile("", 0))
227
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]228_MAXCACHE = 100
Guido van Rossum7627c0d2000-03-31 14:58:54[diff] [blame]229
Fredrik Lundh7898c3e2000-08-07 20:59:04[diff] [blame]230def _compile(*key):
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]231 # internal: compile pattern
Fredrik Lundh7898c3e2000-08-07 20:59:04[diff] [blame]232 pattern, flags = key
Antoine Pitrouf5814112014-02-03 19:59:59[diff] [blame]233 bypass_cache = flags & DEBUG
234 if not bypass_cache:
235 cachekey = (type(key[0]),) + key
Serhiy Storchakad4c72902014-10-30 22:53:19[diff] [blame]236 try:
237 p, loc = _cache[cachekey]
238 if loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):
239 return p
240 except KeyError:
241 pass
Just van Rossum12723ba2003-07-02 20:03:04[diff] [blame]242 if isinstance(pattern, _pattern_type):
Raymond Hettinger80016c92007-12-19 18:13:31[diff] [blame]243 if flags:
244 raise ValueError('Cannot process flags argument with a compiled pattern')
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]245 return pattern
Just van Rossum74902502003-07-02 21:37:16[diff] [blame]246 if not sre_compile.isstring(pattern):
Fredrik Lundh397a6542001-10-18 19:30:16[diff] [blame]247 raise TypeError, "first argument must be string or compiled pattern"
Fredrik Lundhe1869832000-08-01 22:47:49[diff] [blame]248 try:
249 p = sre_compile.compile(pattern, flags)
250 except error, v:
251 raise error, v # invalid expression
Antoine Pitrouf5814112014-02-03 19:59:59[diff] [blame]252 if not bypass_cache:
253 if len(_cache) >= _MAXCACHE:
254 _cache.clear()
Serhiy Storchakad4c72902014-10-30 22:53:19[diff] [blame]255 if p.flags & LOCALE:
Serhiy Storchakae969b1b2014-10-30 23:31:33[diff] [blame]256 if not _locale:
257 return p
Serhiy Storchakad4c72902014-10-30 22:53:19[diff] [blame]258 loc = _locale.setlocale(_locale.LC_CTYPE)
259 else:
260 loc = None
261 _cache[cachekey] = p, loc
Jeremy Hyltonb1aa1952000-06-01 17:39:12[diff] [blame]262 return p
263
Fredrik Lundhb25e1ad2001-03-22 15:50:10[diff] [blame]264def _compile_repl(*key):
265 # internal: compile replacement pattern
266 p = _cache_repl.get(key)
267 if p is not None:
268 return p
269 repl, pattern = key
270 try:
271 p = sre_parse.parse_template(repl, pattern)
272 except error, v:
273 raise error, v # invalid expression
274 if len(_cache_repl) >= _MAXCACHE:
275 _cache_repl.clear()
276 _cache_repl[key] = p
277 return p
278
Fredrik Lundh5644b7f2000-09-21 17:03:25[diff] [blame]279def _expand(pattern, match, template):
280 # internal: match.expand implementation hook
281 template = sre_parse.parse_template(template, pattern)
282 return sre_parse.expand_template(template, match)
283
Fredrik Lundhbec95b92001-10-21 16:47:57[diff] [blame]284def _subx(pattern, template):
285 # internal: pattern.sub/subn implementation helper
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]286 template = _compile_repl(template, pattern)
287 if not template[0] and len(template[1]) == 1:
Fredrik Lundhbec95b92001-10-21 16:47:57[diff] [blame]288 # literal replacement
Fredrik Lundhdac58492001-10-21 21:48:30[diff] [blame]289 return template[1][0]
290 def filter(match, template=template):
291 return sre_parse.expand_template(template, match)
292 return filter
Fredrik Lundh0640e112000-06-30 13:55:15[diff] [blame]293
294# register myself for pickling
295
Georg Brandldffbf5f2008-05-20 07:49:57[diff] [blame]296import copy_reg
Fredrik Lundh0640e112000-06-30 13:55:15[diff] [blame]297
298def _pickle(p):
299 return _compile, (p.pattern, p.flags)
300
Georg Brandldffbf5f2008-05-20 07:49:57[diff] [blame]301copy_reg.pickle(_pattern_type, _pickle, _compile)
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]302
303# --------------------------------------------------------------------
304# experimental stuff (see python-dev discussions for details)
305
306class Scanner:
Fredrik Lundh1296a8d2001-10-21 18:04:11[diff] [blame]307 def __init__(self, lexicon, flags=0):
Fredrik Lundh29c4ba92000-08-01 18:20:07[diff] [blame]308 from sre_constants import BRANCH, SUBPATTERN
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]309 self.lexicon = lexicon
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]310 # combine phrases into a compound pattern
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]311 p = []
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]312 s = sre_parse.Pattern()
Fredrik Lundh1296a8d2001-10-21 18:04:11[diff] [blame]313 s.flags = flags
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]314 for phrase, action in lexicon:
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]315 p.append(sre_parse.SubPattern(s, [
Benjamin Petersonf8c8d2e2014-11-30 16:47:54[diff] [blame]316 (SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]317 ]))
Benjamin Petersonf8c8d2e2014-11-30 16:47:54[diff] [blame]318 s.groups = len(p)+1
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]319 p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
Fredrik Lundh8a3ebf82000-07-23 21:46:17[diff] [blame]320 self.scanner = sre_compile.compile(p)
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]321 def scan(self, string):
322 result = []
323 append = result.append
Fredrik Lundh1296a8d2001-10-21 18:04:11[diff] [blame]324 match = self.scanner.scanner(string).match
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]325 i = 0
326 while 1:
Fredrik Lundh1296a8d2001-10-21 18:04:11[diff] [blame]327 m = match()
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]328 if not m:
329 break
330 j = m.end()
331 if i == j:
332 break
Fredrik Lundh1296a8d2001-10-21 18:04:11[diff] [blame]333 action = self.lexicon[m.lastindex-1][1]
Brett Cannond9636e12008-08-04 21:07:59[diff] [blame]334 if hasattr(action, '__call__'):
Fredrik Lundh770617b2001-01-14 15:06:11[diff] [blame]335 self.match = m
Fredrik Lundh7cafe4d2000-07-02 17:33:27[diff] [blame]336 action = action(self, m.group())
337 if action is not None:
338 append(action)
339 i = j
340 return result, string[i:]