Mercurial > cpython-lru_cache-weakref

comparison Python/Python-ast.c @ 36065:ea083efdc96c legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge from ast-arena. This reduces the code in Python/ast.c by ~300 lines, simplifies a lot of error handling code, and fixes many memory leaks.
author Neal Norwitz <nnorwitz@gmail.com>
date Sat, 17 Dec 2005 20:54:49 +0000
parents 52f1d57f237d
children 85b2d804ac0a
comparison
equal deleted inserted replaced
36064:fb6e64eb86c0 36065:ea083efdc96c
17 static int marshal_write_arguments(PyObject **, int *, arguments_ty); 17 static int marshal_write_arguments(PyObject **, int *, arguments_ty);
18 static int marshal_write_keyword(PyObject **, int *, keyword_ty); 18 static int marshal_write_keyword(PyObject **, int *, keyword_ty);
19 static int marshal_write_alias(PyObject **, int *, alias_ty); 19 static int marshal_write_alias(PyObject **, int *, alias_ty);
20 20
21 mod_ty 21 mod_ty
22 Module(asdl_seq * body) 22 Module(asdl_seq * body, PyArena *arena)
23 { 23 {
24 mod_ty p; 24 mod_ty p;
25 p = (mod_ty)malloc(sizeof(*p)); 25 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
26 if (!p) { 26 if (!p) {
27 PyErr_NoMemory(); 27 PyErr_NoMemory();
28 return NULL; 28 return NULL;
29 } 29 }
30 p->kind = Module_kind; 30 p->kind = Module_kind;
31 p->v.Module.body = body; 31 p->v.Module.body = body;
32 return p; 32 return p;
33 } 33 }
34 34
35 mod_ty 35 mod_ty
36 Interactive(asdl_seq * body) 36 Interactive(asdl_seq * body, PyArena *arena)
37 { 37 {
38 mod_ty p; 38 mod_ty p;
39 p = (mod_ty)malloc(sizeof(*p)); 39 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
40 if (!p) { 40 if (!p) {
41 PyErr_NoMemory(); 41 PyErr_NoMemory();
42 return NULL; 42 return NULL;
43 } 43 }
44 p->kind = Interactive_kind; 44 p->kind = Interactive_kind;
45 p->v.Interactive.body = body; 45 p->v.Interactive.body = body;
46 return p; 46 return p;
47 } 47 }
48 48
49 mod_ty 49 mod_ty
50 Expression(expr_ty body) 50 Expression(expr_ty body, PyArena *arena)
51 { 51 {
52 mod_ty p; 52 mod_ty p;
53 if (!body) { 53 if (!body) {
54 PyErr_SetString(PyExc_ValueError, 54 PyErr_SetString(PyExc_ValueError,
55 "field body is required for Expression"); 55 "field body is required for Expression");
56 return NULL; 56 return NULL;
57 } 57 }
58 p = (mod_ty)malloc(sizeof(*p)); 58 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
59 if (!p) { 59 if (!p) {
60 PyErr_NoMemory(); 60 PyErr_NoMemory();
61 return NULL; 61 return NULL;
62 } 62 }
63 p->kind = Expression_kind; 63 p->kind = Expression_kind;
64 p->v.Expression.body = body; 64 p->v.Expression.body = body;
65 return p; 65 return p;
66 } 66 }
67 67
68 mod_ty 68 mod_ty
69 Suite(asdl_seq * body) 69 Suite(asdl_seq * body, PyArena *arena)
70 { 70 {
71 mod_ty p; 71 mod_ty p;
72 p = (mod_ty)malloc(sizeof(*p)); 72 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
73 if (!p) { 73 if (!p) {
74 PyErr_NoMemory(); 74 PyErr_NoMemory();
75 return NULL; 75 return NULL;
76 } 76 }
77 p->kind = Suite_kind; 77 p->kind = Suite_kind;
79 return p; 79 return p;
80 } 80 }
81 81
82 stmt_ty 82 stmt_ty
83 FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * 83 FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
84 decorators, int lineno) 84 decorators, int lineno, PyArena *arena)
85 { 85 {
86 stmt_ty p; 86 stmt_ty p;
87 if (!name) { 87 if (!name) {
88 PyErr_SetString(PyExc_ValueError, 88 PyErr_SetString(PyExc_ValueError,
89 "field name is required for FunctionDef"); 89 "field name is required for FunctionDef");
92 if (!args) { 92 if (!args) {
93 PyErr_SetString(PyExc_ValueError, 93 PyErr_SetString(PyExc_ValueError,
94 "field args is required for FunctionDef"); 94 "field args is required for FunctionDef");
95 return NULL; 95 return NULL;
96 } 96 }
97 p = (stmt_ty)malloc(sizeof(*p)); 97 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
98 if (!p) { 98 if (!p) {
99 PyErr_NoMemory(); 99 PyErr_NoMemory();
100 return NULL; 100 return NULL;
101 } 101 }
102 p->kind = FunctionDef_kind; 102 p->kind = FunctionDef_kind;
107 p->lineno = lineno; 107 p->lineno = lineno;
108 return p; 108 return p;
109 } 109 }
110 110
111 stmt_ty 111 stmt_ty
112 ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno) 112 ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno,
113 PyArena *arena)
113 { 114 {
114 stmt_ty p; 115 stmt_ty p;
115 if (!name) { 116 if (!name) {
116 PyErr_SetString(PyExc_ValueError, 117 PyErr_SetString(PyExc_ValueError,
117 "field name is required for ClassDef"); 118 "field name is required for ClassDef");
118 return NULL; 119 return NULL;
119 } 120 }
120 p = (stmt_ty)malloc(sizeof(*p)); 121 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
121 if (!p) { 122 if (!p) {
122 PyErr_NoMemory(); 123 PyErr_NoMemory();
123 return NULL; 124 return NULL;
124 } 125 }
125 p->kind = ClassDef_kind; 126 p->kind = ClassDef_kind;
129 p->lineno = lineno; 130 p->lineno = lineno;
130 return p; 131 return p;
131 } 132 }
132 133
133 stmt_ty 134 stmt_ty
134 Return(expr_ty value, int lineno) 135 Return(expr_ty value, int lineno, PyArena *arena)
135 { 136 {
136 stmt_ty p; 137 stmt_ty p;
137 p = (stmt_ty)malloc(sizeof(*p)); 138 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
138 if (!p) { 139 if (!p) {
139 PyErr_NoMemory(); 140 PyErr_NoMemory();
140 return NULL; 141 return NULL;
141 } 142 }
142 p->kind = Return_kind; 143 p->kind = Return_kind;
144 p->lineno = lineno; 145 p->lineno = lineno;
145 return p; 146 return p;
146 } 147 }
147 148
148 stmt_ty 149 stmt_ty
149 Delete(asdl_seq * targets, int lineno) 150 Delete(asdl_seq * targets, int lineno, PyArena *arena)
150 { 151 {
151 stmt_ty p; 152 stmt_ty p;
152 p = (stmt_ty)malloc(sizeof(*p)); 153 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
153 if (!p) { 154 if (!p) {
154 PyErr_NoMemory(); 155 PyErr_NoMemory();
155 return NULL; 156 return NULL;
156 } 157 }
157 p->kind = Delete_kind; 158 p->kind = Delete_kind;
159 p->lineno = lineno; 160 p->lineno = lineno;
160 return p; 161 return p;
161 } 162 }
162 163
163 stmt_ty 164 stmt_ty
164 Assign(asdl_seq * targets, expr_ty value, int lineno) 165 Assign(asdl_seq * targets, expr_ty value, int lineno, PyArena *arena)
165 { 166 {
166 stmt_ty p; 167 stmt_ty p;
167 if (!value) { 168 if (!value) {
168 PyErr_SetString(PyExc_ValueError, 169 PyErr_SetString(PyExc_ValueError,
169 "field value is required for Assign"); 170 "field value is required for Assign");
170 return NULL; 171 return NULL;
171 } 172 }
172 p = (stmt_ty)malloc(sizeof(*p)); 173 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
173 if (!p) { 174 if (!p) {
174 PyErr_NoMemory(); 175 PyErr_NoMemory();
175 return NULL; 176 return NULL;
176 } 177 }
177 p->kind = Assign_kind; 178 p->kind = Assign_kind;
180 p->lineno = lineno; 181 p->lineno = lineno;
181 return p; 182 return p;
182 } 183 }
183 184
184 stmt_ty 185 stmt_ty
185 AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno) 186 AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, PyArena
187 *arena)
186 { 188 {
187 stmt_ty p; 189 stmt_ty p;
188 if (!target) { 190 if (!target) {
189 PyErr_SetString(PyExc_ValueError, 191 PyErr_SetString(PyExc_ValueError,
190 "field target is required for AugAssign"); 192 "field target is required for AugAssign");
198 if (!value) { 200 if (!value) {
199 PyErr_SetString(PyExc_ValueError, 201 PyErr_SetString(PyExc_ValueError,
200 "field value is required for AugAssign"); 202 "field value is required for AugAssign");
201 return NULL; 203 return NULL;
202 } 204 }
203 p = (stmt_ty)malloc(sizeof(*p)); 205 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
204 if (!p) { 206 if (!p) {
205 PyErr_NoMemory(); 207 PyErr_NoMemory();
206 return NULL; 208 return NULL;
207 } 209 }
208 p->kind = AugAssign_kind; 210 p->kind = AugAssign_kind;
212 p->lineno = lineno; 214 p->lineno = lineno;
213 return p; 215 return p;
214 } 216 }
215 217
216 stmt_ty 218 stmt_ty
217 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno) 219 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, PyArena *arena)
218 { 220 {
219 stmt_ty p; 221 stmt_ty p;
220 p = (stmt_ty)malloc(sizeof(*p)); 222 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
221 if (!p) { 223 if (!p) {
222 PyErr_NoMemory(); 224 PyErr_NoMemory();
223 return NULL; 225 return NULL;
224 } 226 }
225 p->kind = Print_kind; 227 p->kind = Print_kind;
230 return p; 232 return p;
231 } 233 }
232 234
233 stmt_ty 235 stmt_ty
234 For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int 236 For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
235 lineno) 237 lineno, PyArena *arena)
236 { 238 {
237 stmt_ty p; 239 stmt_ty p;
238 if (!target) { 240 if (!target) {
239 PyErr_SetString(PyExc_ValueError, 241 PyErr_SetString(PyExc_ValueError,
240 "field target is required for For"); 242 "field target is required for For");
243 if (!iter) { 245 if (!iter) {
244 PyErr_SetString(PyExc_ValueError, 246 PyErr_SetString(PyExc_ValueError,
245 "field iter is required for For"); 247 "field iter is required for For");
246 return NULL; 248 return NULL;
247 } 249 }
248 p = (stmt_ty)malloc(sizeof(*p)); 250 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
249 if (!p) { 251 if (!p) {
250 PyErr_NoMemory(); 252 PyErr_NoMemory();
251 return NULL; 253 return NULL;
252 } 254 }
253 p->kind = For_kind; 255 p->kind = For_kind;
258 p->lineno = lineno; 260 p->lineno = lineno;
259 return p; 261 return p;
260 } 262 }
261 263
262 stmt_ty 264 stmt_ty
263 While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno) 265 While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, PyArena
266 *arena)
264 { 267 {
265 stmt_ty p; 268 stmt_ty p;
266 if (!test) { 269 if (!test) {
267 PyErr_SetString(PyExc_ValueError, 270 PyErr_SetString(PyExc_ValueError,
268 "field test is required for While"); 271 "field test is required for While");
269 return NULL; 272 return NULL;
270 } 273 }
271 p = (stmt_ty)malloc(sizeof(*p)); 274 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
272 if (!p) { 275 if (!p) {
273 PyErr_NoMemory(); 276 PyErr_NoMemory();
274 return NULL; 277 return NULL;
275 } 278 }
276 p->kind = While_kind; 279 p->kind = While_kind;
280 p->lineno = lineno; 283 p->lineno = lineno;
281 return p; 284 return p;
282 } 285 }
283 286
284 stmt_ty 287 stmt_ty
285 If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno) 288 If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, PyArena *arena)
286 { 289 {
287 stmt_ty p; 290 stmt_ty p;
288 if (!test) { 291 if (!test) {
289 PyErr_SetString(PyExc_ValueError, 292 PyErr_SetString(PyExc_ValueError,
290 "field test is required for If"); 293 "field test is required for If");
291 return NULL; 294 return NULL;
292 } 295 }
293 p = (stmt_ty)malloc(sizeof(*p)); 296 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
294 if (!p) { 297 if (!p) {
295 PyErr_NoMemory(); 298 PyErr_NoMemory();
296 return NULL; 299 return NULL;
297 } 300 }
298 p->kind = If_kind; 301 p->kind = If_kind;
302 p->lineno = lineno; 305 p->lineno = lineno;
303 return p; 306 return p;
304 } 307 }
305 308
306 stmt_ty 309 stmt_ty
307 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno) 310 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, PyArena *arena)
308 { 311 {
309 stmt_ty p; 312 stmt_ty p;
310 p = (stmt_ty)malloc(sizeof(*p)); 313 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
311 if (!p) { 314 if (!p) {
312 PyErr_NoMemory(); 315 PyErr_NoMemory();
313 return NULL; 316 return NULL;
314 } 317 }
315 p->kind = Raise_kind; 318 p->kind = Raise_kind;
319 p->lineno = lineno; 322 p->lineno = lineno;
320 return p; 323 return p;
321 } 324 }
322 325
323 stmt_ty 326 stmt_ty
324 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno) 327 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno,
325 { 328 PyArena *arena)
326 stmt_ty p; 329 {
327 p = (stmt_ty)malloc(sizeof(*p)); 330 stmt_ty p;
331 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
328 if (!p) { 332 if (!p) {
329 PyErr_NoMemory(); 333 PyErr_NoMemory();
330 return NULL; 334 return NULL;
331 } 335 }
332 p->kind = TryExcept_kind; 336 p->kind = TryExcept_kind;
336 p->lineno = lineno; 340 p->lineno = lineno;
337 return p; 341 return p;
338 } 342 }
339 343
340 stmt_ty 344 stmt_ty
341 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno) 345 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, PyArena *arena)
342 { 346 {
343 stmt_ty p; 347 stmt_ty p;
344 p = (stmt_ty)malloc(sizeof(*p)); 348 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
345 if (!p) { 349 if (!p) {
346 PyErr_NoMemory(); 350 PyErr_NoMemory();
347 return NULL; 351 return NULL;
348 } 352 }
349 p->kind = TryFinally_kind; 353 p->kind = TryFinally_kind;
352 p->lineno = lineno; 356 p->lineno = lineno;
353 return p; 357 return p;
354 } 358 }
355 359
356 stmt_ty 360 stmt_ty
357 Assert(expr_ty test, expr_ty msg, int lineno) 361 Assert(expr_ty test, expr_ty msg, int lineno, PyArena *arena)
358 { 362 {
359 stmt_ty p; 363 stmt_ty p;
360 if (!test) { 364 if (!test) {
361 PyErr_SetString(PyExc_ValueError, 365 PyErr_SetString(PyExc_ValueError,
362 "field test is required for Assert"); 366 "field test is required for Assert");
363 return NULL; 367 return NULL;
364 } 368 }
365 p = (stmt_ty)malloc(sizeof(*p)); 369 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
366 if (!p) { 370 if (!p) {
367 PyErr_NoMemory(); 371 PyErr_NoMemory();
368 return NULL; 372 return NULL;
369 } 373 }
370 p->kind = Assert_kind; 374 p->kind = Assert_kind;
373 p->lineno = lineno; 377 p->lineno = lineno;
374 return p; 378 return p;
375 } 379 }
376 380
377 stmt_ty 381 stmt_ty
378 Import(asdl_seq * names, int lineno) 382 Import(asdl_seq * names, int lineno, PyArena *arena)
379 { 383 {
380 stmt_ty p; 384 stmt_ty p;
381 p = (stmt_ty)malloc(sizeof(*p)); 385 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
382 if (!p) { 386 if (!p) {
383 PyErr_NoMemory(); 387 PyErr_NoMemory();
384 return NULL; 388 return NULL;
385 } 389 }
386 p->kind = Import_kind; 390 p->kind = Import_kind;
388 p->lineno = lineno; 392 p->lineno = lineno;
389 return p; 393 return p;
390 } 394 }
391 395
392 stmt_ty 396 stmt_ty
393 ImportFrom(identifier module, asdl_seq * names, int lineno) 397 ImportFrom(identifier module, asdl_seq * names, int lineno, PyArena *arena)
394 { 398 {
395 stmt_ty p; 399 stmt_ty p;
396 if (!module) { 400 if (!module) {
397 PyErr_SetString(PyExc_ValueError, 401 PyErr_SetString(PyExc_ValueError,
398 "field module is required for ImportFrom"); 402 "field module is required for ImportFrom");
399 return NULL; 403 return NULL;
400 } 404 }
401 p = (stmt_ty)malloc(sizeof(*p)); 405 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
402 if (!p) { 406 if (!p) {
403 PyErr_NoMemory(); 407 PyErr_NoMemory();
404 return NULL; 408 return NULL;
405 } 409 }
406 p->kind = ImportFrom_kind; 410 p->kind = ImportFrom_kind;
409 p->lineno = lineno; 413 p->lineno = lineno;
410 return p; 414 return p;
411 } 415 }
412 416
413 stmt_ty 417 stmt_ty
414 Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno) 418 Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, PyArena *arena)
415 { 419 {
416 stmt_ty p; 420 stmt_ty p;
417 if (!body) { 421 if (!body) {
418 PyErr_SetString(PyExc_ValueError, 422 PyErr_SetString(PyExc_ValueError,
419 "field body is required for Exec"); 423 "field body is required for Exec");
420 return NULL; 424 return NULL;
421 } 425 }
422 p = (stmt_ty)malloc(sizeof(*p)); 426 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
423 if (!p) { 427 if (!p) {
424 PyErr_NoMemory(); 428 PyErr_NoMemory();
425 return NULL; 429 return NULL;
426 } 430 }
427 p->kind = Exec_kind; 431 p->kind = Exec_kind;
431 p->lineno = lineno; 435 p->lineno = lineno;
432 return p; 436 return p;
433 } 437 }
434 438
435 stmt_ty 439 stmt_ty
436 Global(asdl_seq * names, int lineno) 440 Global(asdl_seq * names, int lineno, PyArena *arena)
437 { 441 {
438 stmt_ty p; 442 stmt_ty p;
439 p = (stmt_ty)malloc(sizeof(*p)); 443 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
440 if (!p) { 444 if (!p) {
441 PyErr_NoMemory(); 445 PyErr_NoMemory();
442 return NULL; 446 return NULL;
443 } 447 }
444 p->kind = Global_kind; 448 p->kind = Global_kind;
446 p->lineno = lineno; 450 p->lineno = lineno;
447 return p; 451 return p;
448 } 452 }
449 453
450 stmt_ty 454 stmt_ty
451 Expr(expr_ty value, int lineno) 455 Expr(expr_ty value, int lineno, PyArena *arena)
452 { 456 {
453 stmt_ty p; 457 stmt_ty p;
454 if (!value) { 458 if (!value) {
455 PyErr_SetString(PyExc_ValueError, 459 PyErr_SetString(PyExc_ValueError,
456 "field value is required for Expr"); 460 "field value is required for Expr");
457 return NULL; 461 return NULL;
458 } 462 }
459 p = (stmt_ty)malloc(sizeof(*p)); 463 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
460 if (!p) { 464 if (!p) {
461 PyErr_NoMemory(); 465 PyErr_NoMemory();
462 return NULL; 466 return NULL;
463 } 467 }
464 p->kind = Expr_kind; 468 p->kind = Expr_kind;
466 p->lineno = lineno; 470 p->lineno = lineno;
467 return p; 471 return p;
468 } 472 }
469 473
470 stmt_ty 474 stmt_ty
471 Pass(int lineno) 475 Pass(int lineno, PyArena *arena)
472 { 476 {
473 stmt_ty p; 477 stmt_ty p;
474 p = (stmt_ty)malloc(sizeof(*p)); 478 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
475 if (!p) { 479 if (!p) {
476 PyErr_NoMemory(); 480 PyErr_NoMemory();
477 return NULL; 481 return NULL;
478 } 482 }
479 p->kind = Pass_kind; 483 p->kind = Pass_kind;
480 p->lineno = lineno; 484 p->lineno = lineno;
481 return p; 485 return p;
482 } 486 }
483 487
484 stmt_ty 488 stmt_ty
485 Break(int lineno) 489 Break(int lineno, PyArena *arena)
486 { 490 {
487 stmt_ty p; 491 stmt_ty p;
488 p = (stmt_ty)malloc(sizeof(*p)); 492 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
489 if (!p) { 493 if (!p) {
490 PyErr_NoMemory(); 494 PyErr_NoMemory();
491 return NULL; 495 return NULL;
492 } 496 }
493 p->kind = Break_kind; 497 p->kind = Break_kind;
494 p->lineno = lineno; 498 p->lineno = lineno;
495 return p; 499 return p;
496 } 500 }
497 501
498 stmt_ty 502 stmt_ty
499 Continue(int lineno) 503 Continue(int lineno, PyArena *arena)
500 { 504 {
501 stmt_ty p; 505 stmt_ty p;
502 p = (stmt_ty)malloc(sizeof(*p)); 506 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
503 if (!p) { 507 if (!p) {
504 PyErr_NoMemory(); 508 PyErr_NoMemory();
505 return NULL; 509 return NULL;
506 } 510 }
507 p->kind = Continue_kind; 511 p->kind = Continue_kind;
508 p->lineno = lineno; 512 p->lineno = lineno;
509 return p; 513 return p;
510 } 514 }
511 515
512 expr_ty 516 expr_ty
513 BoolOp(boolop_ty op, asdl_seq * values, int lineno) 517 BoolOp(boolop_ty op, asdl_seq * values, int lineno, PyArena *arena)
514 { 518 {
515 expr_ty p; 519 expr_ty p;
516 if (!op) { 520 if (!op) {
517 PyErr_SetString(PyExc_ValueError, 521 PyErr_SetString(PyExc_ValueError,
518 "field op is required for BoolOp"); 522 "field op is required for BoolOp");
519 return NULL; 523 return NULL;
520 } 524 }
521 p = (expr_ty)malloc(sizeof(*p)); 525 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
522 if (!p) { 526 if (!p) {
523 PyErr_NoMemory(); 527 PyErr_NoMemory();
524 return NULL; 528 return NULL;
525 } 529 }
526 p->kind = BoolOp_kind; 530 p->kind = BoolOp_kind;
529 p->lineno = lineno; 533 p->lineno = lineno;
530 return p; 534 return p;
531 } 535 }
532 536
533 expr_ty 537 expr_ty
534 BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno) 538 BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, PyArena *arena)
535 { 539 {
536 expr_ty p; 540 expr_ty p;
537 if (!left) { 541 if (!left) {
538 PyErr_SetString(PyExc_ValueError, 542 PyErr_SetString(PyExc_ValueError,
539 "field left is required for BinOp"); 543 "field left is required for BinOp");
547 if (!right) { 551 if (!right) {
548 PyErr_SetString(PyExc_ValueError, 552 PyErr_SetString(PyExc_ValueError,
549 "field right is required for BinOp"); 553 "field right is required for BinOp");
550 return NULL; 554 return NULL;
551 } 555 }
552 p = (expr_ty)malloc(sizeof(*p)); 556 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
553 if (!p) { 557 if (!p) {
554 PyErr_NoMemory(); 558 PyErr_NoMemory();
555 return NULL; 559 return NULL;
556 } 560 }
557 p->kind = BinOp_kind; 561 p->kind = BinOp_kind;
561 p->lineno = lineno; 565 p->lineno = lineno;
562 return p; 566 return p;
563 } 567 }
564 568
565 expr_ty 569 expr_ty
566 UnaryOp(unaryop_ty op, expr_ty operand, int lineno) 570 UnaryOp(unaryop_ty op, expr_ty operand, int lineno, PyArena *arena)
567 { 571 {
568 expr_ty p; 572 expr_ty p;
569 if (!op) { 573 if (!op) {
570 PyErr_SetString(PyExc_ValueError, 574 PyErr_SetString(PyExc_ValueError,
571 "field op is required for UnaryOp"); 575 "field op is required for UnaryOp");
574 if (!operand) { 578 if (!operand) {
575 PyErr_SetString(PyExc_ValueError, 579 PyErr_SetString(PyExc_ValueError,
576 "field operand is required for UnaryOp"); 580 "field operand is required for UnaryOp");
577 return NULL; 581 return NULL;
578 } 582 }
579 p = (expr_ty)malloc(sizeof(*p)); 583 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
580 if (!p) { 584 if (!p) {
581 PyErr_NoMemory(); 585 PyErr_NoMemory();
582 return NULL; 586 return NULL;
583 } 587 }
584 p->kind = UnaryOp_kind; 588 p->kind = UnaryOp_kind;
587 p->lineno = lineno; 591 p->lineno = lineno;
588 return p; 592 return p;
589 } 593 }
590 594
591 expr_ty 595 expr_ty
592 Lambda(arguments_ty args, expr_ty body, int lineno) 596 Lambda(arguments_ty args, expr_ty body, int lineno, PyArena *arena)
593 { 597 {
594 expr_ty p; 598 expr_ty p;
595 if (!args) { 599 if (!args) {
596 PyErr_SetString(PyExc_ValueError, 600 PyErr_SetString(PyExc_ValueError,
597 "field args is required for Lambda"); 601 "field args is required for Lambda");
600 if (!body) { 604 if (!body) {
601 PyErr_SetString(PyExc_ValueError, 605 PyErr_SetString(PyExc_ValueError,
602 "field body is required for Lambda"); 606 "field body is required for Lambda");
603 return NULL; 607 return NULL;
604 } 608 }
605 p = (expr_ty)malloc(sizeof(*p)); 609 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
606 if (!p) { 610 if (!p) {
607 PyErr_NoMemory(); 611 PyErr_NoMemory();
608 return NULL; 612 return NULL;
609 } 613 }
610 p->kind = Lambda_kind; 614 p->kind = Lambda_kind;
613 p->lineno = lineno; 617 p->lineno = lineno;
614 return p; 618 return p;
615 } 619 }
616 620
617 expr_ty 621 expr_ty
618 Dict(asdl_seq * keys, asdl_seq * values, int lineno) 622 Dict(asdl_seq * keys, asdl_seq * values, int lineno, PyArena *arena)
619 { 623 {
620 expr_ty p; 624 expr_ty p;
621 p = (expr_ty)malloc(sizeof(*p)); 625 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
622 if (!p) { 626 if (!p) {
623 PyErr_NoMemory(); 627 PyErr_NoMemory();
624 return NULL; 628 return NULL;
625 } 629 }
626 p->kind = Dict_kind; 630 p->kind = Dict_kind;
629 p->lineno = lineno; 633 p->lineno = lineno;
630 return p; 634 return p;
631 } 635 }
632 636
633 expr_ty 637 expr_ty
634 ListComp(expr_ty elt, asdl_seq * generators, int lineno) 638 ListComp(expr_ty elt, asdl_seq * generators, int lineno, PyArena *arena)
635 { 639 {
636 expr_ty p; 640 expr_ty p;
637 if (!elt) { 641 if (!elt) {
638 PyErr_SetString(PyExc_ValueError, 642 PyErr_SetString(PyExc_ValueError,
639 "field elt is required for ListComp"); 643 "field elt is required for ListComp");
640 return NULL; 644 return NULL;
641 } 645 }
642 p = (expr_ty)malloc(sizeof(*p)); 646 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
643 if (!p) { 647 if (!p) {
644 PyErr_NoMemory(); 648 PyErr_NoMemory();
645 return NULL; 649 return NULL;
646 } 650 }
647 p->kind = ListComp_kind; 651 p->kind = ListComp_kind;
650 p->lineno = lineno; 654 p->lineno = lineno;
651 return p; 655 return p;
652 } 656 }
653 657
654 expr_ty 658 expr_ty
655 GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno) 659 GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, PyArena *arena)
656 { 660 {
657 expr_ty p; 661 expr_ty p;
658 if (!elt) { 662 if (!elt) {
659 PyErr_SetString(PyExc_ValueError, 663 PyErr_SetString(PyExc_ValueError,
660 "field elt is required for GeneratorExp"); 664 "field elt is required for GeneratorExp");
661 return NULL; 665 return NULL;
662 } 666 }
663 p = (expr_ty)malloc(sizeof(*p)); 667 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
664 if (!p) { 668 if (!p) {
665 PyErr_NoMemory(); 669 PyErr_NoMemory();
666 return NULL; 670 return NULL;
667 } 671 }
668 p->kind = GeneratorExp_kind; 672 p->kind = GeneratorExp_kind;
671 p->lineno = lineno; 675 p->lineno = lineno;
672 return p; 676 return p;
673 } 677 }
674 678
675 expr_ty 679 expr_ty
676 Yield(expr_ty value, int lineno) 680 Yield(expr_ty value, int lineno, PyArena *arena)
677 { 681 {
678 expr_ty p; 682 expr_ty p;
679 p = (expr_ty)malloc(sizeof(*p)); 683 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
680 if (!p) { 684 if (!p) {
681 PyErr_NoMemory(); 685 PyErr_NoMemory();
682 return NULL; 686 return NULL;
683 } 687 }
684 p->kind = Yield_kind; 688 p->kind = Yield_kind;
686 p->lineno = lineno; 690 p->lineno = lineno;
687 return p; 691 return p;
688 } 692 }
689 693
690 expr_ty 694 expr_ty
691 Compare(expr_ty left, asdl_seq * ops, asdl_seq * comparators, int lineno) 695 Compare(expr_ty left, asdl_seq * ops, asdl_seq * comparators, int lineno,
696 PyArena *arena)
692 { 697 {
693 expr_ty p; 698 expr_ty p;
694 if (!left) { 699 if (!left) {
695 PyErr_SetString(PyExc_ValueError, 700 PyErr_SetString(PyExc_ValueError,
696 "field left is required for Compare"); 701 "field left is required for Compare");
697 return NULL; 702 return NULL;
698 } 703 }
699 p = (expr_ty)malloc(sizeof(*p)); 704 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
700 if (!p) { 705 if (!p) {
701 PyErr_NoMemory(); 706 PyErr_NoMemory();
702 return NULL; 707 return NULL;
703 } 708 }
704 p->kind = Compare_kind; 709 p->kind = Compare_kind;
709 return p; 714 return p;
710 } 715 }
711 716
712 expr_ty 717 expr_ty
713 Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, 718 Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
714 expr_ty kwargs, int lineno) 719 expr_ty kwargs, int lineno, PyArena *arena)
715 { 720 {
716 expr_ty p; 721 expr_ty p;
717 if (!func) { 722 if (!func) {
718 PyErr_SetString(PyExc_ValueError, 723 PyErr_SetString(PyExc_ValueError,
719 "field func is required for Call"); 724 "field func is required for Call");
720 return NULL; 725 return NULL;
721 } 726 }
722 p = (expr_ty)malloc(sizeof(*p)); 727 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
723 if (!p) { 728 if (!p) {
724 PyErr_NoMemory(); 729 PyErr_NoMemory();
725 return NULL; 730 return NULL;
726 } 731 }
727 p->kind = Call_kind; 732 p->kind = Call_kind;
733 p->lineno = lineno; 738 p->lineno = lineno;
734 return p; 739 return p;
735 } 740 }
736 741
737 expr_ty 742 expr_ty
738 Repr(expr_ty value, int lineno) 743 Repr(expr_ty value, int lineno, PyArena *arena)
739 { 744 {
740 expr_ty p; 745 expr_ty p;
741 if (!value) { 746 if (!value) {
742 PyErr_SetString(PyExc_ValueError, 747 PyErr_SetString(PyExc_ValueError,
743 "field value is required for Repr"); 748 "field value is required for Repr");
744 return NULL; 749 return NULL;
745 } 750 }
746 p = (expr_ty)malloc(sizeof(*p)); 751 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
747 if (!p) { 752 if (!p) {
748 PyErr_NoMemory(); 753 PyErr_NoMemory();
749 return NULL; 754 return NULL;
750 } 755 }
751 p->kind = Repr_kind; 756 p->kind = Repr_kind;
753 p->lineno = lineno; 758 p->lineno = lineno;
754 return p; 759 return p;
755 } 760 }
756 761
757 expr_ty 762 expr_ty
758 Num(object n, int lineno) 763 Num(object n, int lineno, PyArena *arena)
759 { 764 {
760 expr_ty p; 765 expr_ty p;
761 if (!n) { 766 if (!n) {
762 PyErr_SetString(PyExc_ValueError, 767 PyErr_SetString(PyExc_ValueError,
763 "field n is required for Num"); 768 "field n is required for Num");
764 return NULL; 769 return NULL;
765 } 770 }
766 p = (expr_ty)malloc(sizeof(*p)); 771 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
767 if (!p) { 772 if (!p) {
768 PyErr_NoMemory(); 773 PyErr_NoMemory();
769 return NULL; 774 return NULL;
770 } 775 }
771 p->kind = Num_kind; 776 p->kind = Num_kind;
773 p->lineno = lineno; 778 p->lineno = lineno;
774 return p; 779 return p;
775 } 780 }
776 781
777 expr_ty 782 expr_ty
778 Str(string s, int lineno) 783 Str(string s, int lineno, PyArena *arena)
779 { 784 {
780 expr_ty p; 785 expr_ty p;
781 if (!s) { 786 if (!s) {
782 PyErr_SetString(PyExc_ValueError, 787 PyErr_SetString(PyExc_ValueError,
783 "field s is required for Str"); 788 "field s is required for Str");
784 return NULL; 789 return NULL;
785 } 790 }
786 p = (expr_ty)malloc(sizeof(*p)); 791 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
787 if (!p) { 792 if (!p) {
788 PyErr_NoMemory(); 793 PyErr_NoMemory();
789 return NULL; 794 return NULL;
790 } 795 }
791 p->kind = Str_kind; 796 p->kind = Str_kind;
793 p->lineno = lineno; 798 p->lineno = lineno;
794 return p; 799 return p;
795 } 800 }
796 801
797 expr_ty 802 expr_ty
798 Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno) 803 Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno,
804 PyArena *arena)
799 { 805 {
800 expr_ty p; 806 expr_ty p;
801 if (!value) { 807 if (!value) {
802 PyErr_SetString(PyExc_ValueError, 808 PyErr_SetString(PyExc_ValueError,
803 "field value is required for Attribute"); 809 "field value is required for Attribute");
811 if (!ctx) { 817 if (!ctx) {
812 PyErr_SetString(PyExc_ValueError, 818 PyErr_SetString(PyExc_ValueError,
813 "field ctx is required for Attribute"); 819 "field ctx is required for Attribute");
814 return NULL; 820 return NULL;
815 } 821 }
816 p = (expr_ty)malloc(sizeof(*p)); 822 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
817 if (!p) { 823 if (!p) {
818 PyErr_NoMemory(); 824 PyErr_NoMemory();
819 return NULL; 825 return NULL;
820 } 826 }
821 p->kind = Attribute_kind; 827 p->kind = Attribute_kind;
825 p->lineno = lineno; 831 p->lineno = lineno;
826 return p; 832 return p;
827 } 833 }
828 834
829 expr_ty 835 expr_ty
830 Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno) 836 Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno,
837 PyArena *arena)
831 { 838 {
832 expr_ty p; 839 expr_ty p;
833 if (!value) { 840 if (!value) {
834 PyErr_SetString(PyExc_ValueError, 841 PyErr_SetString(PyExc_ValueError,
835 "field value is required for Subscript"); 842 "field value is required for Subscript");
843 if (!ctx) { 850 if (!ctx) {
844 PyErr_SetString(PyExc_ValueError, 851 PyErr_SetString(PyExc_ValueError,
845 "field ctx is required for Subscript"); 852 "field ctx is required for Subscript");
846 return NULL; 853 return NULL;
847 } 854 }
848 p = (expr_ty)malloc(sizeof(*p)); 855 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
849 if (!p) { 856 if (!p) {
850 PyErr_NoMemory(); 857 PyErr_NoMemory();
851 return NULL; 858 return NULL;
852 } 859 }
853 p->kind = Subscript_kind; 860 p->kind = Subscript_kind;
857 p->lineno = lineno; 864 p->lineno = lineno;
858 return p; 865 return p;
859 } 866 }
860 867
861 expr_ty 868 expr_ty
862 Name(identifier id, expr_context_ty ctx, int lineno) 869 Name(identifier id, expr_context_ty ctx, int lineno, PyArena *arena)
863 { 870 {
864 expr_ty p; 871 expr_ty p;
865 if (!id) { 872 if (!id) {
866 PyErr_SetString(PyExc_ValueError, 873 PyErr_SetString(PyExc_ValueError,
867 "field id is required for Name"); 874 "field id is required for Name");
870 if (!ctx) { 877 if (!ctx) {
871 PyErr_SetString(PyExc_ValueError, 878 PyErr_SetString(PyExc_ValueError,
872 "field ctx is required for Name"); 879 "field ctx is required for Name");
873 return NULL; 880 return NULL;
874 } 881 }
875 p = (expr_ty)malloc(sizeof(*p)); 882 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
876 if (!p) { 883 if (!p) {
877 PyErr_NoMemory(); 884 PyErr_NoMemory();
878 return NULL; 885 return NULL;
879 } 886 }
880 p->kind = Name_kind; 887 p->kind = Name_kind;
883 p->lineno = lineno; 890 p->lineno = lineno;
884 return p; 891 return p;
885 } 892 }
886 893
887 expr_ty 894 expr_ty
888 List(asdl_seq * elts, expr_context_ty ctx, int lineno) 895 List(asdl_seq * elts, expr_context_ty ctx, int lineno, PyArena *arena)
889 { 896 {
890 expr_ty p; 897 expr_ty p;
891 if (!ctx) { 898 if (!ctx) {
892 PyErr_SetString(PyExc_ValueError, 899 PyErr_SetString(PyExc_ValueError,
893 "field ctx is required for List"); 900 "field ctx is required for List");
894 return NULL; 901 return NULL;
895 } 902 }
896 p = (expr_ty)malloc(sizeof(*p)); 903 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
897 if (!p) { 904 if (!p) {
898 PyErr_NoMemory(); 905 PyErr_NoMemory();
899 return NULL; 906 return NULL;
900 } 907 }
901 p->kind = List_kind; 908 p->kind = List_kind;
904 p->lineno = lineno; 911 p->lineno = lineno;
905 return p; 912 return p;
906 } 913 }
907 914
908 expr_ty 915 expr_ty
909 Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno) 916 Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, PyArena *arena)
910 { 917 {
911 expr_ty p; 918 expr_ty p;
912 if (!ctx) { 919 if (!ctx) {
913 PyErr_SetString(PyExc_ValueError, 920 PyErr_SetString(PyExc_ValueError,
914 "field ctx is required for Tuple"); 921 "field ctx is required for Tuple");
915 return NULL; 922 return NULL;
916 } 923 }
917 p = (expr_ty)malloc(sizeof(*p)); 924 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
918 if (!p) { 925 if (!p) {
919 PyErr_NoMemory(); 926 PyErr_NoMemory();
920 return NULL; 927 return NULL;
921 } 928 }
922 p->kind = Tuple_kind; 929 p->kind = Tuple_kind;
925 p->lineno = lineno; 932 p->lineno = lineno;
926 return p; 933 return p;
927 } 934 }
928 935
929 slice_ty 936 slice_ty
930 Ellipsis() 937 Ellipsis(PyArena *arena)
931 { 938 {
932 slice_ty p; 939 slice_ty p;
933 p = (slice_ty)malloc(sizeof(*p)); 940 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
934 if (!p) { 941 if (!p) {
935 PyErr_NoMemory(); 942 PyErr_NoMemory();
936 return NULL; 943 return NULL;
937 } 944 }
938 p->kind = Ellipsis_kind; 945 p->kind = Ellipsis_kind;
939 return p; 946 return p;
940 } 947 }
941 948
942 slice_ty 949 slice_ty
943 Slice(expr_ty lower, expr_ty upper, expr_ty step) 950 Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
944 { 951 {
945 slice_ty p; 952 slice_ty p;
946 p = (slice_ty)malloc(sizeof(*p)); 953 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
947 if (!p) { 954 if (!p) {
948 PyErr_NoMemory(); 955 PyErr_NoMemory();
949 return NULL; 956 return NULL;
950 } 957 }
951 p->kind = Slice_kind; 958 p->kind = Slice_kind;
954 p->v.Slice.step = step; 961 p->v.Slice.step = step;
955 return p; 962 return p;
956 } 963 }
957 964
958 slice_ty 965 slice_ty
959 ExtSlice(asdl_seq * dims) 966 ExtSlice(asdl_seq * dims, PyArena *arena)
960 { 967 {
961 slice_ty p; 968 slice_ty p;
962 p = (slice_ty)malloc(sizeof(*p)); 969 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
963 if (!p) { 970 if (!p) {
964 PyErr_NoMemory(); 971 PyErr_NoMemory();
965 return NULL; 972 return NULL;
966 } 973 }
967 p->kind = ExtSlice_kind; 974 p->kind = ExtSlice_kind;
968 p->v.ExtSlice.dims = dims; 975 p->v.ExtSlice.dims = dims;
969 return p; 976 return p;
970 } 977 }
971 978
972 slice_ty 979 slice_ty
973 Index(expr_ty value) 980 Index(expr_ty value, PyArena *arena)
974 { 981 {
975 slice_ty p; 982 slice_ty p;
976 if (!value) { 983 if (!value) {
977 PyErr_SetString(PyExc_ValueError, 984 PyErr_SetString(PyExc_ValueError,
978 "field value is required for Index"); 985 "field value is required for Index");
979 return NULL; 986 return NULL;
980 } 987 }
981 p = (slice_ty)malloc(sizeof(*p)); 988 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
982 if (!p) { 989 if (!p) {
983 PyErr_NoMemory(); 990 PyErr_NoMemory();
984 return NULL; 991 return NULL;
985 } 992 }
986 p->kind = Index_kind; 993 p->kind = Index_kind;
987 p->v.Index.value = value; 994 p->v.Index.value = value;
988 return p; 995 return p;
989 } 996 }
990 997
991 comprehension_ty 998 comprehension_ty
992 comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs) 999 comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena)
993 { 1000 {
994 comprehension_ty p; 1001 comprehension_ty p;
995 if (!target) { 1002 if (!target) {
996 PyErr_SetString(PyExc_ValueError, 1003 PyErr_SetString(PyExc_ValueError,
997 "field target is required for comprehension"); 1004 "field target is required for comprehension");
1000 if (!iter) { 1007 if (!iter) {
1001 PyErr_SetString(PyExc_ValueError, 1008 PyErr_SetString(PyExc_ValueError,
1002 "field iter is required for comprehension"); 1009 "field iter is required for comprehension");
1003 return NULL; 1010 return NULL;
1004 } 1011 }
1005 p = (comprehension_ty)malloc(sizeof(*p)); 1012 p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
1006 if (!p) { 1013 if (!p) {
1007 PyErr_NoMemory(); 1014 PyErr_NoMemory();
1008 return NULL; 1015 return NULL;
1009 } 1016 }
1010 p->target = target; 1017 p->target = target;
1012 p->ifs = ifs; 1019 p->ifs = ifs;
1013 return p; 1020 return p;
1014 } 1021 }
1015 1022
1016 excepthandler_ty 1023 excepthandler_ty
1017 excepthandler(expr_ty type, expr_ty name, asdl_seq * body) 1024 excepthandler(expr_ty type, expr_ty name, asdl_seq * body, PyArena *arena)
1018 { 1025 {
1019 excepthandler_ty p; 1026 excepthandler_ty p;
1020 p = (excepthandler_ty)malloc(sizeof(*p)); 1027 p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
1021 if (!p) { 1028 if (!p) {
1022 PyErr_NoMemory(); 1029 PyErr_NoMemory();
1023 return NULL; 1030 return NULL;
1024 } 1031 }
1025 p->type = type; 1032 p->type = type;
1028 return p; 1035 return p;
1029 } 1036 }
1030 1037
1031 arguments_ty 1038 arguments_ty
1032 arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq * 1039 arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
1033 defaults) 1040 defaults, PyArena *arena)
1034 { 1041 {
1035 arguments_ty p; 1042 arguments_ty p;
1036 p = (arguments_ty)malloc(sizeof(*p)); 1043 p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
1037 if (!p) { 1044 if (!p) {
1038 PyErr_NoMemory(); 1045 PyErr_NoMemory();
1039 return NULL; 1046 return NULL;
1040 } 1047 }
1041 p->args = args; 1048 p->args = args;
1044 p->defaults = defaults; 1051 p->defaults = defaults;
1045 return p; 1052 return p;
1046 } 1053 }
1047 1054
1048 keyword_ty 1055 keyword_ty
1049 keyword(identifier arg, expr_ty value) 1056 keyword(identifier arg, expr_ty value, PyArena *arena)
1050 { 1057 {
1051 keyword_ty p; 1058 keyword_ty p;
1052 if (!arg) { 1059 if (!arg) {
1053 PyErr_SetString(PyExc_ValueError, 1060 PyErr_SetString(PyExc_ValueError,
1054 "field arg is required for keyword"); 1061 "field arg is required for keyword");
1057 if (!value) { 1064 if (!value) {
1058 PyErr_SetString(PyExc_ValueError, 1065 PyErr_SetString(PyExc_ValueError,
1059 "field value is required for keyword"); 1066 "field value is required for keyword");
1060 return NULL; 1067 return NULL;
1061 } 1068 }
1062 p = (keyword_ty)malloc(sizeof(*p)); 1069 p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
1063 if (!p) { 1070 if (!p) {
1064 PyErr_NoMemory(); 1071 PyErr_NoMemory();
1065 return NULL; 1072 return NULL;
1066 } 1073 }
1067 p->arg = arg; 1074 p->arg = arg;
1068 p->value = value; 1075 p->value = value;
1069 return p; 1076 return p;
1070 } 1077 }
1071 1078
1072 alias_ty 1079 alias_ty
1073 alias(identifier name, identifier asname) 1080 alias(identifier name, identifier asname, PyArena *arena)
1074 { 1081 {
1075 alias_ty p; 1082 alias_ty p;
1076 if (!name) { 1083 if (!name) {
1077 PyErr_SetString(PyExc_ValueError, 1084 PyErr_SetString(PyExc_ValueError,
1078 "field name is required for alias"); 1085 "field name is required for alias");
1079 return NULL; 1086 return NULL;
1080 } 1087 }
1081 p = (alias_ty)malloc(sizeof(*p)); 1088 p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
1082 if (!p) { 1089 if (!p) {
1083 PyErr_NoMemory(); 1090 PyErr_NoMemory();
1084 return NULL; 1091 return NULL;
1085 } 1092 }
1086 p->name = name; 1093 p->name = name;
1087 p->asname = asname; 1094 p->asname = asname;
1088 return p; 1095 return p;
1089 }
1090
1091
1092 static void
1093 free_seq_exprs(asdl_seq *seq)
1094 {
1095 int i, n;
1096 n = asdl_seq_LEN(seq);
1097 for (i = 0; i < n; i++)
1098 free_expr((expr_ty)asdl_seq_GET(seq, i));
1099 asdl_seq_free(seq);
1100 }
1101
1102 static void
1103 free_seq_stmts(asdl_seq *seq)
1104 {
1105 int i, n;
1106 n = asdl_seq_LEN(seq);
1107 for (i = 0; i < n; i++)
1108 free_stmt((stmt_ty)asdl_seq_GET(seq, i));
1109 asdl_seq_free(seq);
1110 }
1111
1112
1113 void
1114 free_mod(mod_ty o)
1115 {
1116 if (!o)
1117 return;
1118
1119 switch (o->kind) {
1120 case Module_kind:
1121 free_seq_stmts(o->v.Module.body);
1122 break;
1123 case Interactive_kind:
1124 free_seq_stmts(o->v.Interactive.body);
1125 break;
1126 case Expression_kind:
1127 free_expr((expr_ty)o->v.Expression.body);
1128 break;
1129 case Suite_kind:
1130 free_seq_stmts(o->v.Suite.body);
1131 break;
1132 }
1133
1134 free(o);
1135 }
1136
1137 void
1138 free_stmt(stmt_ty o)
1139 {
1140 int i, n;
1141 asdl_seq *seq;
1142
1143 if (!o)
1144 return;
1145
1146 switch (o->kind) {
1147 case FunctionDef_kind:
1148 Py_DECREF((identifier)o->v.FunctionDef.name);
1149 free_arguments((arguments_ty)o->v.FunctionDef.args);
1150 free_seq_stmts(o->v.FunctionDef.body);
1151 free_seq_exprs(o->v.FunctionDef.decorators);
1152 break;
1153 case ClassDef_kind:
1154 Py_DECREF((identifier)o->v.ClassDef.name);
1155 free_seq_exprs(o->v.ClassDef.bases);
1156 free_seq_stmts(o->v.ClassDef.body);
1157 break;
1158 case Return_kind:
1159 if (o->v.Return.value) {
1160 free_expr((expr_ty)o->v.Return.value);
1161 }
1162 break;
1163 case Delete_kind:
1164 free_seq_exprs(o->v.Delete.targets);
1165 break;
1166 case Assign_kind:
1167 free_seq_exprs(o->v.Assign.targets);
1168 free_expr((expr_ty)o->v.Assign.value);
1169 break;
1170 case AugAssign_kind:
1171 free_expr((expr_ty)o->v.AugAssign.target);
1172 free_operator((operator_ty)o->v.AugAssign.op);
1173 free_expr((expr_ty)o->v.AugAssign.value);
1174 break;
1175 case Print_kind:
1176 if (o->v.Print.dest) {
1177 free_expr((expr_ty)o->v.Print.dest);
1178 }
1179 free_seq_exprs(o->v.Print.values);
1180 break;
1181 case For_kind:
1182 free_expr((expr_ty)o->v.For.target);
1183 free_expr((expr_ty)o->v.For.iter);
1184 free_seq_stmts(o->v.For.body);
1185 free_seq_stmts(o->v.For.orelse);
1186 break;
1187 case While_kind:
1188 free_expr((expr_ty)o->v.While.test);
1189 free_seq_stmts(o->v.While.body);
1190 free_seq_stmts(o->v.While.orelse);
1191 break;
1192 case If_kind:
1193 free_expr((expr_ty)o->v.If.test);
1194 free_seq_stmts(o->v.If.body);
1195 free_seq_stmts(o->v.If.orelse);
1196 break;
1197 case Raise_kind:
1198 if (o->v.Raise.type) {
1199 free_expr((expr_ty)o->v.Raise.type);
1200 }
1201 if (o->v.Raise.inst) {
1202 free_expr((expr_ty)o->v.Raise.inst);
1203 }
1204 if (o->v.Raise.tback) {
1205 free_expr((expr_ty)o->v.Raise.tback);
1206 }
1207 break;
1208 case TryExcept_kind:
1209 free_seq_stmts(o->v.TryExcept.body);
1210 seq = o->v.TryExcept.handlers;
1211 n = asdl_seq_LEN(seq);
1212 for (i = 0; i < n; i++)
1213 free_excepthandler((excepthandler_ty)asdl_seq_GET(seq,
1214 i));
1215 asdl_seq_free(seq);
1216 free_seq_stmts(o->v.TryExcept.orelse);
1217 break;
1218 case TryFinally_kind:
1219 free_seq_stmts(o->v.TryFinally.body);
1220 free_seq_stmts(o->v.TryFinally.finalbody);
1221 break;
1222 case Assert_kind:
1223 free_expr((expr_ty)o->v.Assert.test);
1224 if (o->v.Assert.msg) {
1225 free_expr((expr_ty)o->v.Assert.msg);
1226 }
1227 break;
1228 case Import_kind:
1229 seq = o->v.Import.names;
1230 n = asdl_seq_LEN(seq);
1231 for (i = 0; i < n; i++)
1232 free_alias((alias_ty)asdl_seq_GET(seq, i));
1233 asdl_seq_free(seq);
1234 break;
1235 case ImportFrom_kind:
1236 Py_DECREF((identifier)o->v.ImportFrom.module);
1237 seq = o->v.ImportFrom.names;
1238 n = asdl_seq_LEN(seq);
1239 for (i = 0; i < n; i++)
1240 free_alias((alias_ty)asdl_seq_GET(seq, i));
1241 asdl_seq_free(seq);
1242 break;
1243 case Exec_kind:
1244 free_expr((expr_ty)o->v.Exec.body);
1245 if (o->v.Exec.globals) {
1246 free_expr((expr_ty)o->v.Exec.globals);
1247 }
1248 if (o->v.Exec.locals) {
1249 free_expr((expr_ty)o->v.Exec.locals);
1250 }
1251 break;
1252 case Global_kind:
1253 seq = o->v.Global.names;
1254 n = asdl_seq_LEN(seq);
1255 for (i = 0; i < n; i++)
1256 Py_DECREF((identifier)asdl_seq_GET(seq, i));
1257 asdl_seq_free(seq);
1258 break;
1259 case Expr_kind:
1260 free_expr((expr_ty)o->v.Expr.value);
1261 break;
1262 case Pass_kind:
1263 break;
1264 case Break_kind:
1265 break;
1266 case Continue_kind:
1267 break;
1268 }
1269
1270 free(o);
1271 }
1272
1273 void
1274 free_expr(expr_ty o)
1275 {
1276 int i, n;
1277 asdl_seq *seq;
1278
1279 if (!o)
1280 return;
1281
1282 switch (o->kind) {
1283 case BoolOp_kind:
1284 free_boolop((boolop_ty)o->v.BoolOp.op);
1285 free_seq_exprs(o->v.BoolOp.values);
1286 break;
1287 case BinOp_kind:
1288 free_expr((expr_ty)o->v.BinOp.left);
1289 free_operator((operator_ty)o->v.BinOp.op);
1290 free_expr((expr_ty)o->v.BinOp.right);
1291 break;
1292 case UnaryOp_kind:
1293 free_unaryop((unaryop_ty)o->v.UnaryOp.op);
1294 free_expr((expr_ty)o->v.UnaryOp.operand);
1295 break;
1296 case Lambda_kind:
1297 free_arguments((arguments_ty)o->v.Lambda.args);
1298 free_expr((expr_ty)o->v.Lambda.body);
1299 break;
1300 case Dict_kind:
1301 free_seq_exprs(o->v.Dict.keys);
1302 free_seq_exprs(o->v.Dict.values);
1303 break;
1304 case ListComp_kind:
1305 free_expr((expr_ty)o->v.ListComp.elt);
1306 seq = o->v.ListComp.generators;
1307 n = asdl_seq_LEN(seq);
1308 for (i = 0; i < n; i++)
1309 free_comprehension((comprehension_ty)asdl_seq_GET(seq,
1310 i));
1311 asdl_seq_free(seq);
1312 break;
1313 case GeneratorExp_kind:
1314 free_expr((expr_ty)o->v.GeneratorExp.elt);
1315 seq = o->v.GeneratorExp.generators;
1316 n = asdl_seq_LEN(seq);
1317 for (i = 0; i < n; i++)
1318 free_comprehension((comprehension_ty)asdl_seq_GET(seq,
1319 i));
1320 asdl_seq_free(seq);
1321 break;
1322 case Yield_kind:
1323 if (o->v.Yield.value) {
1324 free_expr((expr_ty)o->v.Yield.value);
1325 }
1326 break;
1327 case Compare_kind:
1328 free_expr((expr_ty)o->v.Compare.left);
1329 seq = o->v.Compare.ops;
1330 n = asdl_seq_LEN(seq);
1331 for (i = 0; i < n; i++)
1332 free_cmpop((cmpop_ty)asdl_seq_GET(seq, i));
1333 asdl_seq_free(seq);
1334 free_seq_exprs(o->v.Compare.comparators);
1335 break;
1336 case Call_kind:
1337 free_expr((expr_ty)o->v.Call.func);
1338 free_seq_exprs(o->v.Call.args);
1339 seq = o->v.Call.keywords;
1340 n = asdl_seq_LEN(seq);
1341 for (i = 0; i < n; i++)
1342 free_keyword((keyword_ty)asdl_seq_GET(seq, i));
1343 asdl_seq_free(seq);
1344 if (o->v.Call.starargs) {
1345 free_expr((expr_ty)o->v.Call.starargs);
1346 }
1347 if (o->v.Call.kwargs) {
1348 free_expr((expr_ty)o->v.Call.kwargs);
1349 }
1350 break;
1351 case Repr_kind:
1352 free_expr((expr_ty)o->v.Repr.value);
1353 break;
1354 case Num_kind:
1355 Py_DECREF((object)o->v.Num.n);
1356 break;
1357 case Str_kind:
1358 Py_DECREF((string)o->v.Str.s);
1359 break;
1360 case Attribute_kind:
1361 free_expr((expr_ty)o->v.Attribute.value);
1362 Py_DECREF((identifier)o->v.Attribute.attr);
1363 free_expr_context((expr_context_ty)o->v.Attribute.ctx);
1364 break;
1365 case Subscript_kind:
1366 free_expr((expr_ty)o->v.Subscript.value);
1367 free_slice((slice_ty)o->v.Subscript.slice);
1368 free_expr_context((expr_context_ty)o->v.Subscript.ctx);
1369 break;
1370 case Name_kind:
1371 Py_DECREF((identifier)o->v.Name.id);
1372 free_expr_context((expr_context_ty)o->v.Name.ctx);
1373 break;
1374 case List_kind:
1375 free_seq_exprs(o->v.List.elts);
1376 free_expr_context((expr_context_ty)o->v.List.ctx);
1377 break;
1378 case Tuple_kind:
1379 free_seq_exprs(o->v.Tuple.elts);
1380 free_expr_context((expr_context_ty)o->v.Tuple.ctx);
1381 break;
1382 }
1383
1384 free(o);
1385 }
1386
1387 void
1388 free_expr_context(expr_context_ty o)
1389 {
1390 if (!o)
1391 return;
1392
1393 }
1394
1395 void
1396 free_slice(slice_ty o)
1397 {
1398 int i, n;
1399 asdl_seq *seq;
1400
1401 if (!o)
1402 return;
1403
1404 switch (o->kind) {
1405 case Ellipsis_kind:
1406 break;
1407 case Slice_kind:
1408 if (o->v.Slice.lower) {
1409 free_expr((expr_ty)o->v.Slice.lower);
1410 }
1411 if (o->v.Slice.upper) {
1412 free_expr((expr_ty)o->v.Slice.upper);
1413 }
1414 if (o->v.Slice.step) {
1415 free_expr((expr_ty)o->v.Slice.step);
1416 }
1417 break;
1418 case ExtSlice_kind:
1419 seq = o->v.ExtSlice.dims;
1420 n = asdl_seq_LEN(seq);
1421 for (i = 0; i < n; i++)
1422 free_slice((slice_ty)asdl_seq_GET(seq, i));
1423 asdl_seq_free(seq);
1424 break;
1425 case Index_kind:
1426 free_expr((expr_ty)o->v.Index.value);
1427 break;
1428 }
1429
1430 free(o);
1431 }
1432
1433 void
1434 free_boolop(boolop_ty o)
1435 {
1436 if (!o)
1437 return;
1438
1439 }
1440
1441 void
1442 free_operator(operator_ty o)
1443 {
1444 if (!o)
1445 return;
1446
1447 }
1448
1449 void
1450 free_unaryop(unaryop_ty o)
1451 {
1452 if (!o)
1453 return;
1454
1455 }
1456
1457 void
1458 free_cmpop(cmpop_ty o)
1459 {
1460 if (!o)
1461 return;
1462
1463 }
1464
1465 void
1466 free_comprehension(comprehension_ty o)
1467 {
1468 if (!o)
1469 return;
1470
1471 free_expr((expr_ty)o->target);
1472 free_expr((expr_ty)o->iter);
1473 free_seq_exprs(o->ifs);
1474
1475 free(o);
1476 }
1477
1478 void
1479 free_excepthandler(excepthandler_ty o)
1480 {
1481 if (!o)
1482 return;
1483
1484 if (o->type) {
1485 free_expr((expr_ty)o->type);
1486 }
1487 if (o->name) {
1488 free_expr((expr_ty)o->name);
1489 }
1490 free_seq_stmts(o->body);
1491
1492 free(o);
1493 }
1494
1495 void
1496 free_arguments(arguments_ty o)
1497 {
1498 if (!o)
1499 return;
1500
1501 free_seq_exprs(o->args);
1502 if (o->vararg) {
1503 Py_DECREF((identifier)o->vararg);
1504 }
1505 if (o->kwarg) {
1506 Py_DECREF((identifier)o->kwarg);
1507 }
1508 free_seq_exprs(o->defaults);
1509
1510 free(o);
1511 }
1512
1513 void
1514 free_keyword(keyword_ty o)
1515 {
1516 if (!o)
1517 return;
1518
1519 Py_DECREF((identifier)o->arg);
1520 free_expr((expr_ty)o->value);
1521
1522 free(o);
1523 }
1524
1525 void
1526 free_alias(alias_ty o)
1527 {
1528 if (!o)
1529 return;
1530
1531 Py_DECREF((identifier)o->name);
1532 if (o->asname) {
1533 Py_DECREF((identifier)o->asname);
1534 }
1535
1536 free(o);
1537 } 1096 }
1538 1097
1539 1098
1540 1099
1541 #define CHECKSIZE(BUF, OFF, MIN) { \ 1100 #define CHECKSIZE(BUF, OFF, MIN) { \