Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 4358b2c

Browse files
gvanrossumgvanrossum
committed
the usual
1 parent 257543c commit 4358b2c

4 files changed

Lines changed: 713 additions & 572 deletions

File tree

‎Lib/dos-8x3/sre_comp.py‎

Lines changed: 192 additions & 137 deletions
Original file line numberDiff line numberDiff line change
@@ -18,157 +18,212 @@
1818
# find an array type code that matches the engine's code size
1919
for WORDSIZE in "BHil":
2020
if len(array.array(WORDSIZE, [0]).tostring()) == _sre.getcodesize():
21-
break
21+
break
2222
else:
2323
raise RuntimeError, "cannot find a useable array type"
2424

2525
def _compile(code, pattern, flags):
26+
# internal: compile a (sub)pattern
2627
emit = code.append
2728
for op, av in pattern:
28-
if op is ANY:
29-
if flags & SRE_FLAG_DOTALL:
30-
emit(OPCODES[op])
31-
else:
32-
emit(OPCODES[CATEGORY])
33-
emit(CHCODES[CATEGORY_NOT_LINEBREAK])
34-
elif op in (SUCCESS, FAILURE):
35-
emit(OPCODES[op])
36-
elif op is AT:
37-
emit(OPCODES[op])
38-
if flags & SRE_FLAG_MULTILINE:
39-
emit(ATCODES[AT_MULTILINE[av]])
40-
else:
41-
emit(ATCODES[av])
42-
elif op is BRANCH:
43-
emit(OPCODES[op])
44-
tail = []
45-
for av in av[1]:
46-
skip = len(code); emit(0)
47-
_compile(code, av, flags)
48-
emit(OPCODES[JUMP])
49-
tail.append(len(code)); emit(0)
50-
code[skip] = len(code) - skip
51-
emit(0) # end of branch
52-
for tail in tail:
53-
code[tail] = len(code) - tail
54-
elif op is CALL:
55-
emit(OPCODES[op])
56-
skip = len(code); emit(0)
57-
_compile(code, av, flags)
58-
emit(OPCODES[SUCCESS])
59-
code[skip] = len(code) - skip
60-
elif op is CATEGORY:
61-
emit(OPCODES[op])
62-
if flags & SRE_FLAG_LOCALE:
63-
emit(CH_LOCALE[CHCODES[av]])
64-
elif flags & SRE_FLAG_UNICODE:
65-
emit(CH_UNICODE[CHCODES[av]])
66-
else:
67-
emit(CHCODES[av])
68-
elif op is GROUP:
69-
if flags & SRE_FLAG_IGNORECASE:
70-
emit(OPCODES[OP_IGNORE[op]])
71-
else:
72-
emit(OPCODES[op])
73-
emit(av-1)
74-
elif op is IN:
75-
if flags & SRE_FLAG_IGNORECASE:
76-
emit(OPCODES[OP_IGNORE[op]])
77-
def fixup(literal, flags=flags):
78-
return _sre.getlower(ord(literal), flags)
79-
else:
80-
emit(OPCODES[op])
81-
fixup = ord
82-
skip = len(code); emit(0)
83-
for op, av in av:
84-
emit(OPCODES[op])
85-
if op is NEGATE:
86-
pass
87-
elif op is LITERAL:
88-
emit(fixup(av))
89-
elif op is RANGE:
90-
emit(fixup(av[0]))
91-
emit(fixup(av[1]))
92-
elif op is CATEGORY:
93-
if flags & SRE_FLAG_LOCALE:
94-
emit(CH_LOCALE[CHCODES[av]])
95-
elif flags & SRE_FLAG_UNICODE:
96-
emit(CH_UNICODE[CHCODES[av]])
97-
else:
98-
emit(CHCODES[av])
99-
else:
100-
raise error, "internal: unsupported set operator"
101-
emit(OPCODES[FAILURE])
102-
code[skip] = len(code) - skip
103-
elif op in (LITERAL, NOT_LITERAL):
104-
if flags & SRE_FLAG_IGNORECASE:
105-
emit(OPCODES[OP_IGNORE[op]])
106-
else:
107-
emit(OPCODES[op])
108-
emit(ord(av))
109-
elif op is MARK:
110-
emit(OPCODES[op])
111-
emit(av)
112-
elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
113-
if flags & SRE_FLAG_TEMPLATE:
114-
emit(OPCODES[REPEAT])
115-
skip = len(code); emit(0)
116-
emit(av[0])
117-
emit(av[1])
118-
_compile(code, av[2], flags)
119-
emit(OPCODES[SUCCESS])
120-
code[skip] = len(code) - skip
121-
else:
122-
lo, hi = av[2].getwidth()
123-
if lo == 0:
124-
raise error, "nothing to repeat"
125-
if 0 and lo == hi == 1 and op is MAX_REPEAT:
126-
# FIXME: <fl> need a better way to figure out when
127-
# it's safe to use this one (in the parser, probably)
128-
emit(OPCODES[MAX_REPEAT_ONE])
129-
skip = len(code); emit(0)
130-
emit(av[0])
131-
emit(av[1])
132-
_compile(code, av[2], flags)
133-
emit(OPCODES[SUCCESS])
134-
code[skip] = len(code) - skip
135-
else:
136-
emit(OPCODES[op])
137-
skip = len(code); emit(0)
138-
emit(av[0])
139-
emit(av[1])
140-
_compile(code, av[2], flags)
141-
emit(OPCODES[SUCCESS])
142-
code[skip] = len(code) - skip
143-
elif op is SUBPATTERN:
144-
group = av[0]
145-
if group:
146-
emit(OPCODES[MARK])
147-
emit((group-1)*2)
148-
_compile(code, av[1], flags)
149-
if group:
150-
emit(OPCODES[MARK])
151-
emit((group-1)*2+1)
152-
else:
153-
raise ValueError, ("unsupported operand type", op)
29+
if op in (LITERAL, NOT_LITERAL):
30+
if flags & SRE_FLAG_IGNORECASE:
31+
emit(OPCODES[OP_IGNORE[op]])
32+
else:
33+
emit(OPCODES[op])
34+
emit(av)
35+
elif op is IN:
36+
if flags & SRE_FLAG_IGNORECASE:
37+
emit(OPCODES[OP_IGNORE[op]])
38+
def fixup(literal, flags=flags):
39+
return _sre.getlower(literal, flags)
40+
else:
41+
emit(OPCODES[op])
42+
fixup = lambda x: x
43+
skip = len(code); emit(0)
44+
for op, av in av:
45+
emit(OPCODES[op])
46+
if op is NEGATE:
47+
pass
48+
elif op is LITERAL:
49+
emit(fixup(av))
50+
elif op is RANGE:
51+
emit(fixup(av[0]))
52+
emit(fixup(av[1]))
53+
elif op is CATEGORY:
54+
if flags & SRE_FLAG_LOCALE:
55+
emit(CHCODES[CH_LOCALE[av]])
56+
elif flags & SRE_FLAG_UNICODE:
57+
emit(CHCODES[CH_UNICODE[av]])
58+
else:
59+
emit(CHCODES[av])
60+
else:
61+
raise error, "internal: unsupported set operator"
62+
emit(OPCODES[FAILURE])
63+
code[skip] = len(code) - skip
64+
elif op is ANY:
65+
if flags & SRE_FLAG_DOTALL:
66+
emit(OPCODES[op])
67+
else:
68+
emit(OPCODES[CATEGORY])
69+
emit(CHCODES[CATEGORY_NOT_LINEBREAK])
70+
elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
71+
if flags & SRE_FLAG_TEMPLATE:
72+
emit(OPCODES[REPEAT])
73+
skip = len(code); emit(0)
74+
emit(av[0])
75+
emit(av[1])
76+
_compile(code, av[2], flags)
77+
emit(OPCODES[SUCCESS])
78+
code[skip] = len(code) - skip
79+
else:
80+
lo, hi = av[2].getwidth()
81+
if lo == 0:
82+
raise error, "nothing to repeat"
83+
if 0 and lo == hi == 1 and op is MAX_REPEAT:
84+
# FIXME: <fl> need a better way to figure out when
85+
# it's safe to use this one (in the parser, probably)
86+
emit(OPCODES[MAX_REPEAT_ONE])
87+
skip = len(code); emit(0)
88+
emit(av[0])
89+
emit(av[1])
90+
_compile(code, av[2], flags)
91+
emit(OPCODES[SUCCESS])
92+
code[skip] = len(code) - skip
93+
else:
94+
emit(OPCODES[op])
95+
skip = len(code); emit(0)
96+
emit(av[0])
97+
emit(av[1])
98+
_compile(code, av[2], flags)
99+
emit(OPCODES[SUCCESS])
100+
code[skip] = len(code) - skip
101+
elif op is SUBPATTERN:
102+
group = av[0]
103+
if group:
104+
emit(OPCODES[MARK])
105+
emit((group-1)*2)
106+
_compile(code, av[1], flags)
107+
if group:
108+
emit(OPCODES[MARK])
109+
emit((group-1)*2+1)
110+
elif op in (SUCCESS, FAILURE):
111+
emit(OPCODES[op])
112+
elif op in (ASSERT, ASSERT_NOT, CALL):
113+
emit(OPCODES[op])
114+
skip = len(code); emit(0)
115+
_compile(code, av, flags)
116+
emit(OPCODES[SUCCESS])
117+
code[skip] = len(code) - skip
118+
elif op is AT:
119+
emit(OPCODES[op])
120+
if flags & SRE_FLAG_MULTILINE:
121+
emit(ATCODES[AT_MULTILINE[av]])
122+
else:
123+
emit(ATCODES[av])
124+
elif op is BRANCH:
125+
emit(OPCODES[op])
126+
tail = []
127+
for av in av[1]:
128+
skip = len(code); emit(0)
129+
_compile(code, av, flags)
130+
emit(OPCODES[JUMP])
131+
tail.append(len(code)); emit(0)
132+
code[skip] = len(code) - skip
133+
emit(0) # end of branch
134+
for tail in tail:
135+
code[tail] = len(code) - tail
136+
elif op is CATEGORY:
137+
emit(OPCODES[op])
138+
if flags & SRE_FLAG_LOCALE:
139+
emit(CHCODES[CH_LOCALE[av]])
140+
elif flags & SRE_FLAG_UNICODE:
141+
emit(CHCODES[CH_UNICODE[av]])
142+
else:
143+
emit(CHCODES[av])
144+
elif op is GROUP:
145+
if flags & SRE_FLAG_IGNORECASE:
146+
emit(OPCODES[OP_IGNORE[op]])
147+
else:
148+
emit(OPCODES[op])
149+
emit(av-1)
150+
elif op is MARK:
151+
emit(OPCODES[op])
152+
emit(av)
153+
else:
154+
raise ValueError, ("unsupported operand type", op)
155+
156+
def _compile_info(code, pattern, flags):
157+
# internal: compile an info block. in the current version,
158+
# this contains min/max pattern width and a literal prefix,
159+
# if any
160+
lo, hi = pattern.getwidth()
161+
if lo == 0:
162+
return # not worth it
163+
# look for a literal prefix
164+
prefix = []
165+
if not (flags & SRE_FLAG_IGNORECASE):
166+
for op, av in pattern.data:
167+
if op is LITERAL:
168+
prefix.append(av)
169+
else:
170+
break
171+
# add an info block
172+
emit = code.append
173+
emit(OPCODES[INFO])
174+
skip = len(code); emit(0)
175+
# literal flag
176+
mask = 0
177+
if len(prefix) == len(pattern.data):
178+
mask = 1
179+
emit(mask)
180+
# pattern length
181+
emit(lo)
182+
if hi < 32768:
183+
emit(hi)
184+
else:
185+
emit(0)
186+
# add literal prefix
187+
emit(len(prefix))
188+
if prefix:
189+
code.extend(prefix)
190+
# generate overlap table
191+
table = [-1] + ([0]*len(prefix))
192+
for i in range(len(prefix)):
193+
table[i+1] = table[i]+1
194+
while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
195+
table[i+1] = table[table[i+1]-1]+1
196+
code.extend(table[1:]) # don't store first entry
197+
code[skip] = len(code) - skip
154198

155199
def compile(p, flags=0):
156200
# internal: convert pattern list to internal format
201+
202+
# compile, as necessary
157203
if type(p) in (type(""), type(u"")):
158-
import sre_parse
159-
pattern = p
160-
p = sre_parse.parse(p)
204+
import sre_parse
205+
pattern = p
206+
p = sre_parse.parse(p)
161207
else:
162-
pattern = None
208+
pattern = None
209+
163210
flags = p.pattern.flags | flags
164211
code = []
212+
213+
# compile info block
214+
_compile_info(code, p, flags)
215+
216+
# compile the pattern
165217
_compile(code, p.data, flags)
218+
166219
code.append(OPCODES[SUCCESS])
167-
# FIXME: <fl> get rid of this limitation
220+
221+
# FIXME: <fl> get rid of this limitation!
168222
assert p.pattern.groups <= 100,\
169-
"sorry, but this version only supports 100 named groups"
223+
"sorry, but this version only supports 100 named groups"
224+
170225
return _sre.compile(
171-
pattern, flags,
172-
array.array(WORDSIZE, code).tostring(),
173-
p.pattern.groups-1, p.pattern.groupdict
174-
)
226+
pattern, flags,
227+
array.array(WORDSIZE, code).tostring(),
228+
p.pattern.groups-1, p.pattern.groupdict
229+
)

0 commit comments

Comments
 (0)