← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/globbing.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-06-30 16:48:11 UTC
  • mfrom: (5967.9.6 regexps)
  • Revision ID: pqm@pqm.ubuntu.com-20110630164811-kpfgfqyzdzxnn8q6
(mbp) use explicit lazy regexps when appropriate (bug 608054) (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/globbing.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
 
23
23
import re
24
24
 
25
 
from bzrlib import errors
 
25
from bzrlib import (
 
26
    errors,
 
27
    lazy_regex,
 
28
    )
26
29
from bzrlib.trace import (
27
30
    mutter,
28
31
    warning,
38
41
    must not contain capturing groups.
39
42
    """
40
43
 
41
 
    _expand = re.compile(ur'\\&')
 
44
    _expand = lazy_regex.lazy_compile(ur'\\&')
42
45
 
43
46
    def __init__(self, source=None):
44
47
        self._pat = None
74
77
 
75
78
    def __call__(self, text):
76
79
        if not self._pat:
77
 
            self._pat = re.compile(
 
80
            self._pat = lazy_regex.lazy_compile(
78
81
                    u'|'.join([u'(%s)' % p for p in self._pats]),
79
82
                    re.UNICODE)
80
83
        return self._pat.sub(self._do_sub, text)
217
220
 
218
221
    def _add_patterns(self, patterns, translator, prefix=''):
219
222
        while patterns:
220
 
            grouped_rules = ['(%s)' % translator(pat) for pat in patterns[:99]]
 
223
            grouped_rules = [
 
224
                '(%s)' % translator(pat) for pat in patterns[:99]]
221
225
            joined_rule = '%s(?:%s)$' % (prefix, '|'.join(grouped_rules))
222
 
            self._regex_patterns.append((re.compile(joined_rule, re.UNICODE),
 
226
            # Explicitly use lazy_compile here, because we count on its
 
227
            # nicer error reporting.
 
228
            self._regex_patterns.append((
 
229
                lazy_regex.lazy_compile(joined_rule, re.UNICODE),
223
230
                patterns[:99]))
224
231
            patterns = patterns[99:]
225
232
 
275
282
        translator = Globster.pattern_info[Globster.identify(pattern)]["translator"]
276
283
        tpattern = '(%s)' % translator(pattern)
277
284
        try:
278
 
            re_obj = re.compile(tpattern, re.UNICODE)
 
285
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
279
286
            re_obj.search("") # force compile
280
287
        except errors.InvalidPattern, e:
281
288
            result = False
334
341
                Globster.pattern_info[t]["prefix"])
335
342
 
336
343
 
337
 
_slashes = re.compile(r'[\\/]+')
 
344
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
338
345
def normalize_pattern(pattern):
339
346
    """Converts backslashes in path patterns to forward slashes.
340
347