class RepeatOneMatchResult(MatchResult):
install_jitdriver('RepeatOne',
greens=['nextppos', 'pattern'],
reds=['ptr', 'self', 'ctx'],
debugprint=(1, 0)) # indices in 'greens'
def __init__(self, nextppos, minptr, ptr, marks):
self.nextppos = nextppos
self.minptr = minptr
self.start_ptr = ptr
self.start_marks = marks
def find_first_result(self, ctx, pattern):
ptr = self.start_ptr
nextppos = self.nextppos
while ptr >= self.minptr:
ctx.jitdriver_RepeatOne.jit_merge_point(self=self,
ptr=ptr,
ctx=ctx,
nextppos=nextppos,
pattern=pattern)
result = sre_match(ctx, pattern, nextppos, ptr, self.start_marks)
ptr -= 1
if result is not None:
self.subresult = result
self.start_ptr = ptr
return self
find_next_result = find_first_result
class MinRepeatOneMatchResult(MatchResult):
install_jitdriver('MinRepeatOne',
greens=['nextppos', 'ppos3', 'pattern'],
reds=['max_count', 'ptr', 'self', 'ctx'],
debugprint=(2, 0)) # indices in 'greens'
def __init__(self, nextppos, ppos3, max_count, ptr, marks):
self.nextppos = nextppos
self.ppos3 = ppos3
self.max_count = max_count
self.start_ptr = ptr
self.start_marks = marks
def find_first_result(self, ctx, pattern):
ptr = self.start_ptr
nextppos = self.nextppos
max_count = self.max_count
ppos3 = self.ppos3
while max_count >= 0:
ctx.jitdriver_MinRepeatOne.jit_merge_point(self=self,
ptr=ptr,
ctx=ctx,
nextppos=nextppos,
ppos3=ppos3,
max_count=max_count,
pattern=pattern)
result = sre_match(ctx, pattern, nextppos, ptr, self.start_marks)
if result is not None:
self.subresult = result
self.start_ptr = ptr
self.max_count = max_count
return self
if not self.next_char_ok(ctx, pattern, ptr, ppos3):
break
ptr = ctx.next_indirect(ptr)
max_count -= 1
def find_next_result(self, ctx, pattern):
ptr = self.start_ptr
if not self.next_char_ok(ctx, pattern, ptr, self.ppos3):
return
self.start_ptr = ctx.next_indirect(ptr)
return self.find_first_result(ctx, pattern)
def next_char_ok(self, ctx, pattern, ptr, ppos):
if ptr == ctx.end:
return False
op = pattern.pat(ppos)
for op1, checkerfn in unroll_char_checker:
if op1 == op:
return checkerfn(ctx, pattern, ptr, ppos)
# obscure case: it should be a single char pattern, but isn't
# one of the opcodes in unroll_char_checker (see test_ext_opcode)
return sre_match(ctx, pattern, ppos, ptr, self.start_marks) is not None
class MaxUntilMatchResult(AbstractUntilMatchResult):
install_jitdriver('MaxUntil',
greens=['ppos', 'tailppos', 'match_more', 'pattern'],
reds=['ptr', 'marks', 'self', 'ctx'],
debugprint=(3, 0, 2))
def find_first_result(self, ctx, pattern):
return self.search_next(ctx, pattern, match_more=True)
def find_next_result(self, ctx, pattern):
return self.search_next(ctx, pattern, match_more=False)
def search_next(self, ctx, pattern, match_more):
ppos = self.ppos
tailppos = self.tailppos
ptr = self.cur_ptr
marks = self.cur_marks
while True:
ctx.jitdriver_MaxUntil.jit_merge_point(ppos=ppos,
tailppos=tailppos,
match_more=match_more,
ptr=ptr,
marks=marks,
self=self,
ctx=ctx,
pattern=pattern)
if match_more:
max = pattern.pat(ppos + 2)
if max == rsre_char.MAXREPEAT or self.num_pending < max:
# try to match one more 'item'
enum = sre_match(ctx, pattern, ppos + 3, ptr, marks)
else:
enum = None # 'max' reached, no more matches
else:
p = self.pending
if p is None:
return
self.pending = p.next
self.num_pending -= 1
ptr = p.ptr
marks = p.marks
enum = p.enum.move_to_next_result(ctx, pattern)
#
min = pattern.pat(ppos + 1)
if enum is not None:
# matched one more 'item'. record it and continue.
last_match_length = ctx.match_end - ptr
self.pending = Pending(ptr, marks, enum, self.pending)
self.num_pending += 1
ptr = ctx.match_end
marks = ctx.match_marks
if last_match_length == 0 and self.num_pending >= min:
# zero-width protection: after an empty match, if there
# are enough matches, don't try to match more. Instead,
# fall through to trying to match 'tail'.
pass
else:
match_more = True
continue
# 'item' no longer matches.
if self.num_pending >= min:
# try to match 'tail' if we have enough 'item'
result = sre_match(ctx, pattern, tailppos, ptr, marks)
if result is not None:
self.subresult = result
self.cur_ptr = ptr
self.cur_marks = marks
return self
match_more = False
def fullmatch(pattern, string, start=0, end=sys.maxint, flags=0):
return match(pattern, string, start, end, flags, fullmatch=True)
def search(pattern, string, start=0, end=sys.maxint, flags=0):
assert isinstance(pattern, CompiledPattern)
start, end = _adjust(start, end, len(string))
ctx = StrMatchContext(string, start, end, flags)
if search_context(ctx, pattern):
return ctx
else:
return None
install_jitdriver('Match', greens=['pattern'], reds=['ctx'], debugprint=(0, ))
def match_context(ctx, pattern):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
ctx.jitdriver_Match.jit_merge_point(ctx=ctx, pattern=pattern)
return sre_match(ctx, pattern, 0, ctx.match_start, None) is not None
def search_context(ctx, pattern):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
base = 0
ctx = StrMatchContext(pattern, string, start, end, flags)
if match_context(ctx):
return ctx
else:
return None
def search(pattern, string, start=0, end=sys.maxint, flags=0):
start, end = _adjust(start, end, len(string))
ctx = StrMatchContext(pattern, string, start, end, flags)
if search_context(ctx):
return ctx
else:
return None
install_jitdriver('Match',
greens=['ctx.pattern'], reds=['ctx'],
debugprint=(0,))
def match_context(ctx):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
ctx.jitdriver_Match.jit_merge_point(ctx=ctx)
return sre_match(ctx, 0, ctx.match_start, None) is not None
def search_context(ctx):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
base = 0
charset = False
def fullmatch(pattern, string, start=0, end=sys.maxint, flags=0):
return match(pattern, string, start, end, flags, fullmatch=True)
def search(pattern, string, start=0, end=sys.maxint, flags=0):
start, end = _adjust(start, end, len(string))
ctx = StrMatchContext(pattern, string, start, end, flags)
if search_context(ctx):
return ctx
else:
return None
install_jitdriver("Match", greens=["ctx.pattern"], reds=["ctx"], debugprint=(0,))
def match_context(ctx):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
ctx.jitdriver_Match.jit_merge_point(ctx=ctx)
return sre_match(ctx, 0, ctx.match_start, None) is not None
def search_context(ctx):
ctx.original_pos = ctx.match_start
if ctx.end < ctx.match_start:
return False
base = 0