|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
from __future__ import absolute_import |
|
|
|
|
|
from .Regexps import Alt, Seq, Rep, Rep1, Opt, Any, AnyBut, Bol, Eol, Char |
|
|
from .Errors import PlexError |
|
|
|
|
|
|
|
|
class RegexpSyntaxError(PlexError): |
|
|
pass |
|
|
|
|
|
|
|
|
def re(s): |
|
|
""" |
|
|
Convert traditional string representation of regular expression |s| |
|
|
into Plex representation. |
|
|
""" |
|
|
return REParser(s).parse_re() |
|
|
|
|
|
|
|
|
class REParser(object): |
|
|
def __init__(self, s): |
|
|
self.s = s |
|
|
self.i = -1 |
|
|
self.end = 0 |
|
|
self.next() |
|
|
|
|
|
def parse_re(self): |
|
|
re = self.parse_alt() |
|
|
if not self.end: |
|
|
self.error("Unexpected %s" % repr(self.c)) |
|
|
return re |
|
|
|
|
|
def parse_alt(self): |
|
|
"""Parse a set of alternative regexps.""" |
|
|
re = self.parse_seq() |
|
|
if self.c == '|': |
|
|
re_list = [re] |
|
|
while self.c == '|': |
|
|
self.next() |
|
|
re_list.append(self.parse_seq()) |
|
|
re = Alt(*re_list) |
|
|
return re |
|
|
|
|
|
def parse_seq(self): |
|
|
"""Parse a sequence of regexps.""" |
|
|
re_list = [] |
|
|
while not self.end and not self.c in "|)": |
|
|
re_list.append(self.parse_mod()) |
|
|
return Seq(*re_list) |
|
|
|
|
|
def parse_mod(self): |
|
|
"""Parse a primitive regexp followed by *, +, ? modifiers.""" |
|
|
re = self.parse_prim() |
|
|
while not self.end and self.c in "*+?": |
|
|
if self.c == '*': |
|
|
re = Rep(re) |
|
|
elif self.c == '+': |
|
|
re = Rep1(re) |
|
|
else: |
|
|
re = Opt(re) |
|
|
self.next() |
|
|
return re |
|
|
|
|
|
def parse_prim(self): |
|
|
"""Parse a primitive regexp.""" |
|
|
c = self.get() |
|
|
if c == '.': |
|
|
re = AnyBut("\n") |
|
|
elif c == '^': |
|
|
re = Bol |
|
|
elif c == '$': |
|
|
re = Eol |
|
|
elif c == '(': |
|
|
re = self.parse_alt() |
|
|
self.expect(')') |
|
|
elif c == '[': |
|
|
re = self.parse_charset() |
|
|
self.expect(']') |
|
|
else: |
|
|
if c == '\\': |
|
|
c = self.get() |
|
|
re = Char(c) |
|
|
return re |
|
|
|
|
|
def parse_charset(self): |
|
|
"""Parse a charset. Does not include the surrounding [].""" |
|
|
char_list = [] |
|
|
invert = 0 |
|
|
if self.c == '^': |
|
|
invert = 1 |
|
|
self.next() |
|
|
if self.c == ']': |
|
|
char_list.append(']') |
|
|
self.next() |
|
|
while not self.end and self.c != ']': |
|
|
c1 = self.get() |
|
|
if self.c == '-' and self.lookahead(1) != ']': |
|
|
self.next() |
|
|
c2 = self.get() |
|
|
for a in range(ord(c1), ord(c2) + 1): |
|
|
char_list.append(chr(a)) |
|
|
else: |
|
|
char_list.append(c1) |
|
|
chars = ''.join(char_list) |
|
|
if invert: |
|
|
return AnyBut(chars) |
|
|
else: |
|
|
return Any(chars) |
|
|
|
|
|
def next(self): |
|
|
"""Advance to the next char.""" |
|
|
s = self.s |
|
|
i = self.i = self.i + 1 |
|
|
if i < len(s): |
|
|
self.c = s[i] |
|
|
else: |
|
|
self.c = '' |
|
|
self.end = 1 |
|
|
|
|
|
def get(self): |
|
|
if self.end: |
|
|
self.error("Premature end of string") |
|
|
c = self.c |
|
|
self.next() |
|
|
return c |
|
|
|
|
|
def lookahead(self, n): |
|
|
"""Look ahead n chars.""" |
|
|
j = self.i + n |
|
|
if j < len(self.s): |
|
|
return self.s[j] |
|
|
else: |
|
|
return '' |
|
|
|
|
|
def expect(self, c): |
|
|
""" |
|
|
Expect to find character |c| at current position. |
|
|
Raises an exception otherwise. |
|
|
""" |
|
|
if self.c == c: |
|
|
self.next() |
|
|
else: |
|
|
self.error("Missing %s" % repr(c)) |
|
|
|
|
|
def error(self, mess): |
|
|
"""Raise exception to signal syntax error in regexp.""" |
|
|
raise RegexpSyntaxError("Syntax error in regexp %s at position %d: %s" % ( |
|
|
repr(self.s), self.i, mess)) |
|
|
|
|
|
|
|
|
|
|
|
|
