1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85 "$Id: gparse.py 694 2003-04-16 02:53:50Z sc $"
86 import sys, parser, symbol, token
87
88 from symbol import test, suite, argument, arith_expr, shift_expr
89 from symbol import subscriptlist, subscript, comparison, trailer, xor_expr
90 from symbol import term, not_test, factor, atom, expr, arglist
91 from symbol import power, and_test, and_expr
92
93 from token import STAR, NAME, RPAR, LPAR, NUMBER, DOT, STRING, COMMA
94 from token import ISTERMINAL, LSQB, COLON
95
96 from parser import sequence2ast, compileast, ast2list
97
98 ParseError='Expression Parse Error'
99
100 -def munge(ast, STAR=STAR, DOT=DOT, LSQB=LSQB, COLON=COLON, trailer=trailer):
101 ast0=ast[0]
102 if ISTERMINAL(ast0): return
103 else:
104 if ast0==term and len(ast) > 2:
105 keep_going=1
106 while keep_going:
107 keep_going=0
108 start=2
109 for i in range(start,len(ast)-1):
110 if ast[i][0]==STAR:
111 ast[i-1:i+2]=[multi_munge(ast[i-1:i+2])]
112 keep_going=1
113 break
114
115 for a in ast[1:]: munge(a)
116
117 elif ast0==power:
118 keep_going=1
119 while keep_going:
120 keep_going=0
121 start=2
122 for i in range(start,len(ast)):
123 a=ast[i]
124 if a[0]==trailer:
125 if a[1][0]==DOT:
126 ast[:i+1]=dot_munge(ast,i)
127 keep_going=1
128 start=3
129 break
130 if a[1][0]==LSQB:
131 if (a[2][0] != subscriptlist or
132 a[2][1][0] != subscript):
133 raise ParseError, (
134 'Unexpected form after left square brace')
135
136 slist=a[2]
137 if len(slist)==2:
138
139 sub=slist[1]
140 if sub[1][0]==DOT:
141 raise ParseError, (
142 'ellipses are not supported')
143 l=len(sub)
144 if l < 3 and sub[1][0] != COLON:
145 ast[:i+1]=item_munge(ast, i)
146 elif l < 5: ast[:i+1]=slice_munge(ast, i)
147 else: raise ParseError, 'Invalid slice'
148
149 else: ast[:i+1]=item_munge(ast, i)
150 keep_going=1
151 start=3
152 break
153
154 for a in ast[1:]: munge(a)
155 else:
156 for a in ast[1:]: munge(a)
157 return ast
158
160
161
162 name=ast[i][2][1]
163 args=[arglist]
164 append=args.append
165
166 a=(factor, (power, (atom, (NAME, '_vars'))))
167 a=(argument, (test, (and_test, (not_test, (comparison,
168 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
169 (term, a)))))))))))
170 append(a)
171 append([COMMA,','])
172
173 a=ast[:i]
174 a=(argument, (test, (and_test, (not_test, (comparison,
175 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
176 (term, (factor, a))))))))))))
177 append(a)
178
179 sub=ast[i][2][1]
180 l=len(sub)
181 if sub[1][0]==COLON:
182 if l==3:
183 append([COMMA,','])
184 a=(argument, (test, (and_test, (not_test, (comparison,
185 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
186 (term, (factor, (power, (atom, (NUMBER, '0')))))))))))))))
187 append(a)
188 append([COMMA,','])
189 append([argument, sub[2]])
190 else:
191 append([COMMA,','])
192 append([argument, sub[1]])
193 if l==4:
194 append([COMMA,','])
195 append([argument, sub[3]])
196
197 return [power, [atom, [NAME, '__guarded_getslice__']],
198 [trailer, [LPAR, '('], args, [RPAR, ')'],
199 ]
200 ]
201
203
204 name=ast[i][2][1]
205 args=[arglist]
206 append=args.append
207
208 a=(factor, (power, (atom, (NAME, '_vars'))))
209 a=(argument, (test, (and_test, (not_test, (comparison,
210 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
211 (term, a)))))))))))
212 append(a)
213 append([COMMA,','])
214
215 a=ast[:i]
216 a=(argument, (test, (and_test, (not_test, (comparison,
217 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
218 (term, (factor, a))))))))))))
219 append(a)
220 append([COMMA,','])
221
222 for sub in ast[i][2][1:]:
223 if sub[0]==COMMA: append(sub)
224 else:
225 if len(sub) != 2: raise ParseError, 'Invalid slice in subscript'
226 append([argument, sub[1]])
227
228 return [power, [atom, [NAME, '__guarded_getitem__']],
229 [trailer, [LPAR, '('], args, [RPAR, ')'],
230 ]
231 ]
232
234
235 name=ast[i][2][1]
236 args=[arglist]
237 append=args.append
238
239 a=(factor, (power, (atom, (NAME, '_vars'))))
240 a=(argument, (test, (and_test, (not_test, (comparison,
241 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
242 (term, a)))))))))))
243 append(a)
244 append([COMMA,','])
245
246 a=ast[:i]
247 a=(argument, (test, (and_test, (not_test, (comparison,
248 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
249 (term, (factor, a))))))))))))
250 append(a)
251 append([COMMA,','])
252
253 a=(factor, (power, (atom, (STRING, `name`))))
254 a=(argument, (test, (and_test, (not_test, (comparison,
255 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
256 (term, a)))))))))))
257 append(a)
258
259 return [power, [atom, [NAME, '__guarded_getattr__']],
260 [trailer, [LPAR, '('], args, [RPAR, ')']],
261 ]
262
264
265 args=[arglist]
266
267 append=args.append
268 a=(factor, (power, (atom, (NAME, '_vars'))))
269 a=(argument, (test, (and_test, (not_test, (comparison,
270 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
271 (term, a)))))))))))
272 append(a)
273 append([COMMA,','])
274
275 for a in ast:
276 if a[0]==STAR: args.append([COMMA,','])
277 else:
278 a=(argument, (test, (and_test, (not_test, (comparison,
279 (expr, (xor_expr, (and_expr, (shift_expr, (arith_expr,
280 (term, a)))))))))))
281 append(a)
282
283 return [factor, [power,
284 [atom, [NAME, '__guarded_mul__']],
285 [trailer, [LPAR, '('], args, [RPAR, ')'],
286 ]]]
287
288 -def compile(src, file_name, ctype):
289 if ctype=='eval': ast=parser.expr(src)
290 elif ctype=='exec': ast=parser.suite(src)
291 l=ast2list(ast)
292 l=munge(l)
293 ast=sequence2ast(l)
294 return parser.compileast(ast, file_name)
295