data = []
self.data = data
self.width = None
+
def dump(self, level=0):
nl = True
seqtypes = (tuple, list)
pass
raise source.error("bad escape %s" % escape, len(escape))
+def _uniq(items):
+ if len(set(items)) == len(items):
+ return items
+ newitems = []
+ for item in items:
+ if item not in newitems:
+ newitems.append(item)
+ return newitems
+
def _parse_sub(source, state, verbose, nested=True):
# parse an alternation: a|b|c
return items[0]
subpattern = SubPattern(state)
- subpatternappend = subpattern.append
# check if all items share a common prefix
while True:
# move it out of the branch
for item in items:
del item[0]
- subpatternappend(prefix)
+ subpattern.append(prefix)
continue # check next one
break
# check if the branch can be replaced by a character set
+ set = []
for item in items:
- if len(item) != 1 or item[0][0] is not LITERAL:
+ if len(item) != 1:
+ break
+ op, av = item[0]
+ if op is LITERAL:
+ set.append((op, av))
+ elif op is IN and av[0][0] is not NEGATE:
+ set.extend(av)
+ else:
break
else:
# we can store this as a character set instead of a
# branch (the compiler may optimize this even more)
- subpatternappend((IN, [item[0] for item in items]))
+ subpattern.append((IN, _uniq(set)))
return subpattern
subpattern.append((BRANCH, (None, items)))
return subpattern
-def _parse_sub_cond(source, state, condgroup, verbose):
- item_yes = _parse(source, state, verbose)
- if source.match("|"):
- item_no = _parse(source, state, verbose)
- if source.next == "|":
- raise source.error("conditional backref with more than two branches")
- else:
- item_no = None
- subpattern = SubPattern(state)
- subpattern.append((GROUPREF_EXISTS, (condgroup, item_yes, item_no)))
- return subpattern
-
def _parse(source, state, verbose, first=False):
# parse a simple pattern
subpattern = SubPattern(state)
setappend = set.append
## if sourcematch(":"):
## pass # handle character classes
- if sourcematch("^"):
- setappend((NEGATE, None))
+ negate = sourcematch("^")
# check remaining characters
- start = set[:]
while True:
this = sourceget()
if this is None:
raise source.error("unterminated character set",
source.tell() - here)
- if this == "]" and set != start:
+ if this == "]" and set:
break
elif this[0] == "\\":
code1 = _class_escape(source, this)
code1 = code1[1][0]
setappend(code1)
+ set = _uniq(set)
# XXX: <fl> should move set optimization to compiler!
- if _len(set)==1 and set[0][0] is LITERAL:
- subpatternappend(set[0]) # optimization
- elif _len(set)==2 and set[0][0] is NEGATE and set[1][0] is LITERAL:
- subpatternappend((NOT_LITERAL, set[1][1])) # optimization
+ if _len(set) == 1 and set[0][0] is LITERAL:
+ # optimization
+ if negate:
+ subpatternappend((NOT_LITERAL, set[0][1]))
+ else:
+ subpatternappend(set[0])
else:
- # XXX: <fl> should add charmap optimization here
+ if negate:
+ set.insert(0, (NEGATE, None))
+ # charmap optimization can't be added here because
+ # global flags still are not known
subpatternappend((IN, set))
elif this in REPEAT_CHARS:
if source.next == "}":
subpatternappend((LITERAL, _ord(this)))
continue
+
min, max = 0, MAXREPEAT
lo = hi = ""
while source.next in DIGITS:
subpatternappend((LITERAL, _ord(this)))
source.seek(here)
continue
+
if lo:
min = int(lo)
if min >= MAXREPEAT:
item = subpattern[-1:]
else:
item = None
- if not item or (_len(item) == 1 and item[0][0] is AT):
+ if not item or item[0][0] is AT:
raise source.error("nothing to repeat",
source.tell() - here + len(this))
if item[0][0] in _REPEATCODES:
raise source.error("multiple repeat",
source.tell() - here + len(this))
+ if item[0][0] is SUBPATTERN:
+ group, add_flags, del_flags, p = item[0][1]
+ if group is None and not add_flags and not del_flags:
+ item = p
if sourcematch("?"):
subpattern[-1] = (MIN_REPEAT, (min, max, item))
else:
start = source.tell() - 1
group = True
name = None
- condgroup = None
add_flags = 0
del_flags = 0
if sourcematch("?"):
state.checklookbehindgroup(gid, source)
subpatternappend((GROUPREF, gid))
continue
+
else:
char = sourceget()
if char is None:
if sourceget() == ")":
break
continue
+
elif char in "=!<":
# lookahead assertions
dir = 1
else:
subpatternappend((ASSERT_NOT, (dir, p)))
continue
+
elif char == "(":
# conditional backreference group
condname = source.getuntil(")")
- group = None
if condname.isidentifier():
condgroup = state.groupdict.get(condname)
if condgroup is None:
msg = "invalid group reference %d" % condgroup
raise source.error(msg, len(condname) + 1)
state.checklookbehindgroup(condgroup, source)
+ item_yes = _parse(source, state, verbose)
+ if source.match("|"):
+ item_no = _parse(source, state, verbose)
+ if source.next == "|":
+ raise source.error("conditional backref with more than two branches")
+ else:
+ item_no = None
+ if not source.match(")"):
+ raise source.error("missing ), unterminated subpattern",
+ source.tell() - start)
+ subpatternappend((GROUPREF_EXISTS, (condgroup, item_yes, item_no)))
+ continue
+
elif char in FLAGS or char == "-":
# flags
flags = _parse_flags(source, state, char)
if (state.flags & SRE_FLAG_VERBOSE) and not verbose:
raise Verbose
continue
+
add_flags, del_flags = flags
group = None
else:
group = state.opengroup(name)
except error as err:
raise source.error(err.msg, len(name) + 1) from None
- if condgroup:
- p = _parse_sub_cond(source, state, condgroup, verbose)
- else:
- sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and
- not (del_flags & SRE_FLAG_VERBOSE))
- p = _parse_sub(source, state, sub_verbose)
+ sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and
+ not (del_flags & SRE_FLAG_VERBOSE))
+ p = _parse_sub(source, state, sub_verbose)
if not source.match(")"):
raise source.error("missing ), unterminated subpattern",
source.tell() - start)
subpatternappend((AT, AT_BEGINNING))
elif this == "$":
- subpattern.append((AT, AT_END))
+ subpatternappend((AT, AT_END))
else:
raise AssertionError("unsupported special character %r" % (char,))
+ # unpack non-capturing groups
+ for i in range(len(subpattern))[::-1]:
+ op, av = subpattern[i]
+ if op is SUBPATTERN:
+ group, add_flags, del_flags, p = av
+ if group is None and not add_flags and not del_flags:
+ subpattern[i: i+1] = p
+
return subpattern
def _parse_flags(source, state, char):
projects / python / commitdiff