Mercurial > cpython-lru_cache-weakref

comparison Python/Python-ast.c @ 35784:c6dbf88e4b14 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use PyErr_NoMemory() instead of rolling our own. Get rid of "int i" unused warnings from Python-ast.c which we are generating.
author Neal Norwitz <nnorwitz@gmail.com>
date Sun, 23 Oct 2005 19:22:48 +0000
parents 1c4d192f1568
children 6867995a18a7
comparison
equal deleted inserted replaced
35783:b1a0e1a2b28f 35784:c6dbf88e4b14
1 /* File automatically generated by ../Parser/asdl_c.py */ 1 /* File automatically generated by ./Parser/asdl_c.py */
2 2
3 #include "Python.h" 3 #include "Python.h"
4 #include "Python-ast.h" 4 #include "Python-ast.h"
5 5
6 mod_ty 6 mod_ty
7 Module(asdl_seq * body) 7 Module(asdl_seq * body)
8 { 8 {
9 mod_ty p; 9 mod_ty p;
10 p = (mod_ty)malloc(sizeof(*p)); 10 p = (mod_ty)malloc(sizeof(*p));
11 if (!p) { 11 if (!p) {
12 PyErr_SetString(PyExc_MemoryError, "no memory"); 12 PyErr_NoMemory();
13 return NULL; 13 return NULL;
14 } 14 }
15 p->kind = Module_kind; 15 p->kind = Module_kind;
16 p->v.Module.body = body; 16 p->v.Module.body = body;
17 return p; 17 return p;
21 Interactive(asdl_seq * body) 21 Interactive(asdl_seq * body)
22 { 22 {
23 mod_ty p; 23 mod_ty p;
24 p = (mod_ty)malloc(sizeof(*p)); 24 p = (mod_ty)malloc(sizeof(*p));
25 if (!p) { 25 if (!p) {
26 PyErr_SetString(PyExc_MemoryError, "no memory"); 26 PyErr_NoMemory();
27 return NULL; 27 return NULL;
28 } 28 }
29 p->kind = Interactive_kind; 29 p->kind = Interactive_kind;
30 p->v.Interactive.body = body; 30 p->v.Interactive.body = body;
31 return p; 31 return p;
40 "field body is required for Expression"); 40 "field body is required for Expression");
41 return NULL; 41 return NULL;
42 } 42 }
43 p = (mod_ty)malloc(sizeof(*p)); 43 p = (mod_ty)malloc(sizeof(*p));
44 if (!p) { 44 if (!p) {
45 PyErr_SetString(PyExc_MemoryError, "no memory"); 45 PyErr_NoMemory();
46 return NULL; 46 return NULL;
47 } 47 }
48 p->kind = Expression_kind; 48 p->kind = Expression_kind;
49 p->v.Expression.body = body; 49 p->v.Expression.body = body;
50 return p; 50 return p;
54 Suite(asdl_seq * body) 54 Suite(asdl_seq * body)
55 { 55 {
56 mod_ty p; 56 mod_ty p;
57 p = (mod_ty)malloc(sizeof(*p)); 57 p = (mod_ty)malloc(sizeof(*p));
58 if (!p) { 58 if (!p) {
59 PyErr_SetString(PyExc_MemoryError, "no memory"); 59 PyErr_NoMemory();
60 return NULL; 60 return NULL;
61 } 61 }
62 p->kind = Suite_kind; 62 p->kind = Suite_kind;
63 p->v.Suite.body = body; 63 p->v.Suite.body = body;
64 return p; 64 return p;
79 "field args is required for FunctionDef"); 79 "field args is required for FunctionDef");
80 return NULL; 80 return NULL;
81 } 81 }
82 p = (stmt_ty)malloc(sizeof(*p)); 82 p = (stmt_ty)malloc(sizeof(*p));
83 if (!p) { 83 if (!p) {
84 PyErr_SetString(PyExc_MemoryError, "no memory"); 84 PyErr_NoMemory();
85 return NULL; 85 return NULL;
86 } 86 }
87 p->kind = FunctionDef_kind; 87 p->kind = FunctionDef_kind;
88 p->v.FunctionDef.name = name; 88 p->v.FunctionDef.name = name;
89 p->v.FunctionDef.args = args; 89 p->v.FunctionDef.args = args;
102 "field name is required for ClassDef"); 102 "field name is required for ClassDef");
103 return NULL; 103 return NULL;
104 } 104 }
105 p = (stmt_ty)malloc(sizeof(*p)); 105 p = (stmt_ty)malloc(sizeof(*p));
106 if (!p) { 106 if (!p) {
107 PyErr_SetString(PyExc_MemoryError, "no memory"); 107 PyErr_NoMemory();
108 return NULL; 108 return NULL;
109 } 109 }
110 p->kind = ClassDef_kind; 110 p->kind = ClassDef_kind;
111 p->v.ClassDef.name = name; 111 p->v.ClassDef.name = name;
112 p->v.ClassDef.bases = bases; 112 p->v.ClassDef.bases = bases;
119 Return(expr_ty value, int lineno) 119 Return(expr_ty value, int lineno)
120 { 120 {
121 stmt_ty p; 121 stmt_ty p;
122 p = (stmt_ty)malloc(sizeof(*p)); 122 p = (stmt_ty)malloc(sizeof(*p));
123 if (!p) { 123 if (!p) {
124 PyErr_SetString(PyExc_MemoryError, "no memory"); 124 PyErr_NoMemory();
125 return NULL; 125 return NULL;
126 } 126 }
127 p->kind = Return_kind; 127 p->kind = Return_kind;
128 p->v.Return.value = value; 128 p->v.Return.value = value;
129 p->lineno = lineno; 129 p->lineno = lineno;
134 Delete(asdl_seq * targets, int lineno) 134 Delete(asdl_seq * targets, int lineno)
135 { 135 {
136 stmt_ty p; 136 stmt_ty p;
137 p = (stmt_ty)malloc(sizeof(*p)); 137 p = (stmt_ty)malloc(sizeof(*p));
138 if (!p) { 138 if (!p) {
139 PyErr_SetString(PyExc_MemoryError, "no memory"); 139 PyErr_NoMemory();
140 return NULL; 140 return NULL;
141 } 141 }
142 p->kind = Delete_kind; 142 p->kind = Delete_kind;
143 p->v.Delete.targets = targets; 143 p->v.Delete.targets = targets;
144 p->lineno = lineno; 144 p->lineno = lineno;
154 "field value is required for Assign"); 154 "field value is required for Assign");
155 return NULL; 155 return NULL;
156 } 156 }
157 p = (stmt_ty)malloc(sizeof(*p)); 157 p = (stmt_ty)malloc(sizeof(*p));
158 if (!p) { 158 if (!p) {
159 PyErr_SetString(PyExc_MemoryError, "no memory"); 159 PyErr_NoMemory();
160 return NULL; 160 return NULL;
161 } 161 }
162 p->kind = Assign_kind; 162 p->kind = Assign_kind;
163 p->v.Assign.targets = targets; 163 p->v.Assign.targets = targets;
164 p->v.Assign.value = value; 164 p->v.Assign.value = value;
185 "field value is required for AugAssign"); 185 "field value is required for AugAssign");
186 return NULL; 186 return NULL;
187 } 187 }
188 p = (stmt_ty)malloc(sizeof(*p)); 188 p = (stmt_ty)malloc(sizeof(*p));
189 if (!p) { 189 if (!p) {
190 PyErr_SetString(PyExc_MemoryError, "no memory"); 190 PyErr_NoMemory();
191 return NULL; 191 return NULL;
192 } 192 }
193 p->kind = AugAssign_kind; 193 p->kind = AugAssign_kind;
194 p->v.AugAssign.target = target; 194 p->v.AugAssign.target = target;
195 p->v.AugAssign.op = op; 195 p->v.AugAssign.op = op;
202 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno) 202 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno)
203 { 203 {
204 stmt_ty p; 204 stmt_ty p;
205 p = (stmt_ty)malloc(sizeof(*p)); 205 p = (stmt_ty)malloc(sizeof(*p));
206 if (!p) { 206 if (!p) {
207 PyErr_SetString(PyExc_MemoryError, "no memory"); 207 PyErr_NoMemory();
208 return NULL; 208 return NULL;
209 } 209 }
210 p->kind = Print_kind; 210 p->kind = Print_kind;
211 p->v.Print.dest = dest; 211 p->v.Print.dest = dest;
212 p->v.Print.values = values; 212 p->v.Print.values = values;
230 "field iter is required for For"); 230 "field iter is required for For");
231 return NULL; 231 return NULL;
232 } 232 }
233 p = (stmt_ty)malloc(sizeof(*p)); 233 p = (stmt_ty)malloc(sizeof(*p));
234 if (!p) { 234 if (!p) {
235 PyErr_SetString(PyExc_MemoryError, "no memory"); 235 PyErr_NoMemory();
236 return NULL; 236 return NULL;
237 } 237 }
238 p->kind = For_kind; 238 p->kind = For_kind;
239 p->v.For.target = target; 239 p->v.For.target = target;
240 p->v.For.iter = iter; 240 p->v.For.iter = iter;
253 "field test is required for While"); 253 "field test is required for While");
254 return NULL; 254 return NULL;
255 } 255 }
256 p = (stmt_ty)malloc(sizeof(*p)); 256 p = (stmt_ty)malloc(sizeof(*p));
257 if (!p) { 257 if (!p) {
258 PyErr_SetString(PyExc_MemoryError, "no memory"); 258 PyErr_NoMemory();
259 return NULL; 259 return NULL;
260 } 260 }
261 p->kind = While_kind; 261 p->kind = While_kind;
262 p->v.While.test = test; 262 p->v.While.test = test;
263 p->v.While.body = body; 263 p->v.While.body = body;
275 "field test is required for If"); 275 "field test is required for If");
276 return NULL; 276 return NULL;
277 } 277 }
278 p = (stmt_ty)malloc(sizeof(*p)); 278 p = (stmt_ty)malloc(sizeof(*p));
279 if (!p) { 279 if (!p) {
280 PyErr_SetString(PyExc_MemoryError, "no memory"); 280 PyErr_NoMemory();
281 return NULL; 281 return NULL;
282 } 282 }
283 p->kind = If_kind; 283 p->kind = If_kind;
284 p->v.If.test = test; 284 p->v.If.test = test;
285 p->v.If.body = body; 285 p->v.If.body = body;
292 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno) 292 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno)
293 { 293 {
294 stmt_ty p; 294 stmt_ty p;
295 p = (stmt_ty)malloc(sizeof(*p)); 295 p = (stmt_ty)malloc(sizeof(*p));
296 if (!p) { 296 if (!p) {
297 PyErr_SetString(PyExc_MemoryError, "no memory"); 297 PyErr_NoMemory();
298 return NULL; 298 return NULL;
299 } 299 }
300 p->kind = Raise_kind; 300 p->kind = Raise_kind;
301 p->v.Raise.type = type; 301 p->v.Raise.type = type;
302 p->v.Raise.inst = inst; 302 p->v.Raise.inst = inst;
309 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno) 309 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno)
310 { 310 {
311 stmt_ty p; 311 stmt_ty p;
312 p = (stmt_ty)malloc(sizeof(*p)); 312 p = (stmt_ty)malloc(sizeof(*p));
313 if (!p) { 313 if (!p) {
314 PyErr_SetString(PyExc_MemoryError, "no memory"); 314 PyErr_NoMemory();
315 return NULL; 315 return NULL;
316 } 316 }
317 p->kind = TryExcept_kind; 317 p->kind = TryExcept_kind;
318 p->v.TryExcept.body = body; 318 p->v.TryExcept.body = body;
319 p->v.TryExcept.handlers = handlers; 319 p->v.TryExcept.handlers = handlers;
326 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno) 326 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno)
327 { 327 {
328 stmt_ty p; 328 stmt_ty p;
329 p = (stmt_ty)malloc(sizeof(*p)); 329 p = (stmt_ty)malloc(sizeof(*p));
330 if (!p) { 330 if (!p) {
331 PyErr_SetString(PyExc_MemoryError, "no memory"); 331 PyErr_NoMemory();
332 return NULL; 332 return NULL;
333 } 333 }
334 p->kind = TryFinally_kind; 334 p->kind = TryFinally_kind;
335 p->v.TryFinally.body = body; 335 p->v.TryFinally.body = body;
336 p->v.TryFinally.finalbody = finalbody; 336 p->v.TryFinally.finalbody = finalbody;
347 "field test is required for Assert"); 347 "field test is required for Assert");
348 return NULL; 348 return NULL;
349 } 349 }
350 p = (stmt_ty)malloc(sizeof(*p)); 350 p = (stmt_ty)malloc(sizeof(*p));
351 if (!p) { 351 if (!p) {
352 PyErr_SetString(PyExc_MemoryError, "no memory"); 352 PyErr_NoMemory();
353 return NULL; 353 return NULL;
354 } 354 }
355 p->kind = Assert_kind; 355 p->kind = Assert_kind;
356 p->v.Assert.test = test; 356 p->v.Assert.test = test;
357 p->v.Assert.msg = msg; 357 p->v.Assert.msg = msg;
363 Import(asdl_seq * names, int lineno) 363 Import(asdl_seq * names, int lineno)
364 { 364 {
365 stmt_ty p; 365 stmt_ty p;
366 p = (stmt_ty)malloc(sizeof(*p)); 366 p = (stmt_ty)malloc(sizeof(*p));
367 if (!p) { 367 if (!p) {
368 PyErr_SetString(PyExc_MemoryError, "no memory"); 368 PyErr_NoMemory();
369 return NULL; 369 return NULL;
370 } 370 }
371 p->kind = Import_kind; 371 p->kind = Import_kind;
372 p->v.Import.names = names; 372 p->v.Import.names = names;
373 p->lineno = lineno; 373 p->lineno = lineno;
383 "field module is required for ImportFrom"); 383 "field module is required for ImportFrom");
384 return NULL; 384 return NULL;
385 } 385 }
386 p = (stmt_ty)malloc(sizeof(*p)); 386 p = (stmt_ty)malloc(sizeof(*p));
387 if (!p) { 387 if (!p) {
388 PyErr_SetString(PyExc_MemoryError, "no memory"); 388 PyErr_NoMemory();
389 return NULL; 389 return NULL;
390 } 390 }
391 p->kind = ImportFrom_kind; 391 p->kind = ImportFrom_kind;
392 p->v.ImportFrom.module = module; 392 p->v.ImportFrom.module = module;
393 p->v.ImportFrom.names = names; 393 p->v.ImportFrom.names = names;
404 "field body is required for Exec"); 404 "field body is required for Exec");
405 return NULL; 405 return NULL;
406 } 406 }
407 p = (stmt_ty)malloc(sizeof(*p)); 407 p = (stmt_ty)malloc(sizeof(*p));
408 if (!p) { 408 if (!p) {
409 PyErr_SetString(PyExc_MemoryError, "no memory"); 409 PyErr_NoMemory();
410 return NULL; 410 return NULL;
411 } 411 }
412 p->kind = Exec_kind; 412 p->kind = Exec_kind;
413 p->v.Exec.body = body; 413 p->v.Exec.body = body;
414 p->v.Exec.globals = globals; 414 p->v.Exec.globals = globals;
421 Global(asdl_seq * names, int lineno) 421 Global(asdl_seq * names, int lineno)
422 { 422 {
423 stmt_ty p; 423 stmt_ty p;
424 p = (stmt_ty)malloc(sizeof(*p)); 424 p = (stmt_ty)malloc(sizeof(*p));
425 if (!p) { 425 if (!p) {
426 PyErr_SetString(PyExc_MemoryError, "no memory"); 426 PyErr_NoMemory();
427 return NULL; 427 return NULL;
428 } 428 }
429 p->kind = Global_kind; 429 p->kind = Global_kind;
430 p->v.Global.names = names; 430 p->v.Global.names = names;
431 p->lineno = lineno; 431 p->lineno = lineno;
441 "field value is required for Expr"); 441 "field value is required for Expr");
442 return NULL; 442 return NULL;
443 } 443 }
444 p = (stmt_ty)malloc(sizeof(*p)); 444 p = (stmt_ty)malloc(sizeof(*p));
445 if (!p) { 445 if (!p) {
446 PyErr_SetString(PyExc_MemoryError, "no memory"); 446 PyErr_NoMemory();
447 return NULL; 447 return NULL;
448 } 448 }
449 p->kind = Expr_kind; 449 p->kind = Expr_kind;
450 p->v.Expr.value = value; 450 p->v.Expr.value = value;
451 p->lineno = lineno; 451 p->lineno = lineno;
456 Pass(int lineno) 456 Pass(int lineno)
457 { 457 {
458 stmt_ty p; 458 stmt_ty p;
459 p = (stmt_ty)malloc(sizeof(*p)); 459 p = (stmt_ty)malloc(sizeof(*p));
460 if (!p) { 460 if (!p) {
461 PyErr_SetString(PyExc_MemoryError, "no memory"); 461 PyErr_NoMemory();
462 return NULL; 462 return NULL;
463 } 463 }
464 p->kind = Pass_kind; 464 p->kind = Pass_kind;
465 p->lineno = lineno; 465 p->lineno = lineno;
466 return p; 466 return p;
470 Break(int lineno) 470 Break(int lineno)
471 { 471 {
472 stmt_ty p; 472 stmt_ty p;
473 p = (stmt_ty)malloc(sizeof(*p)); 473 p = (stmt_ty)malloc(sizeof(*p));
474 if (!p) { 474 if (!p) {
475 PyErr_SetString(PyExc_MemoryError, "no memory"); 475 PyErr_NoMemory();
476 return NULL; 476 return NULL;
477 } 477 }
478 p->kind = Break_kind; 478 p->kind = Break_kind;
479 p->lineno = lineno; 479 p->lineno = lineno;
480 return p; 480 return p;
484 Continue(int lineno) 484 Continue(int lineno)
485 { 485 {
486 stmt_ty p; 486 stmt_ty p;
487 p = (stmt_ty)malloc(sizeof(*p)); 487 p = (stmt_ty)malloc(sizeof(*p));
488 if (!p) { 488 if (!p) {
489 PyErr_SetString(PyExc_MemoryError, "no memory"); 489 PyErr_NoMemory();
490 return NULL; 490 return NULL;
491 } 491 }
492 p->kind = Continue_kind; 492 p->kind = Continue_kind;
493 p->lineno = lineno; 493 p->lineno = lineno;
494 return p; 494 return p;
503 "field op is required for BoolOp"); 503 "field op is required for BoolOp");
504 return NULL; 504 return NULL;
505 } 505 }
506 p = (expr_ty)malloc(sizeof(*p)); 506 p = (expr_ty)malloc(sizeof(*p));
507 if (!p) { 507 if (!p) {
508 PyErr_SetString(PyExc_MemoryError, "no memory"); 508 PyErr_NoMemory();
509 return NULL; 509 return NULL;
510 } 510 }
511 p->kind = BoolOp_kind; 511 p->kind = BoolOp_kind;
512 p->v.BoolOp.op = op; 512 p->v.BoolOp.op = op;
513 p->v.BoolOp.values = values; 513 p->v.BoolOp.values = values;
534 "field right is required for BinOp"); 534 "field right is required for BinOp");
535 return NULL; 535 return NULL;
536 } 536 }
537 p = (expr_ty)malloc(sizeof(*p)); 537 p = (expr_ty)malloc(sizeof(*p));
538 if (!p) { 538 if (!p) {
539 PyErr_SetString(PyExc_MemoryError, "no memory"); 539 PyErr_NoMemory();
540 return NULL; 540 return NULL;
541 } 541 }
542 p->kind = BinOp_kind; 542 p->kind = BinOp_kind;
543 p->v.BinOp.left = left; 543 p->v.BinOp.left = left;
544 p->v.BinOp.op = op; 544 p->v.BinOp.op = op;
561 "field operand is required for UnaryOp"); 561 "field operand is required for UnaryOp");
562 return NULL; 562 return NULL;
563 } 563 }
564 p = (expr_ty)malloc(sizeof(*p)); 564 p = (expr_ty)malloc(sizeof(*p));
565 if (!p) { 565 if (!p) {
566 PyErr_SetString(PyExc_MemoryError, "no memory"); 566 PyErr_NoMemory();
567 return NULL; 567 return NULL;
568 } 568 }
569 p->kind = UnaryOp_kind; 569 p->kind = UnaryOp_kind;
570 p->v.UnaryOp.op = op; 570 p->v.UnaryOp.op = op;
571 p->v.UnaryOp.operand = operand; 571 p->v.UnaryOp.operand = operand;
587 "field body is required for Lambda"); 587 "field body is required for Lambda");
588 return NULL; 588 return NULL;
589 } 589 }
590 p = (expr_ty)malloc(sizeof(*p)); 590 p = (expr_ty)malloc(sizeof(*p));
591 if (!p) { 591 if (!p) {
592 PyErr_SetString(PyExc_MemoryError, "no memory"); 592 PyErr_NoMemory();
593 return NULL; 593 return NULL;
594 } 594 }
595 p->kind = Lambda_kind; 595 p->kind = Lambda_kind;
596 p->v.Lambda.args = args; 596 p->v.Lambda.args = args;
597 p->v.Lambda.body = body; 597 p->v.Lambda.body = body;
603 Dict(asdl_seq * keys, asdl_seq * values, int lineno) 603 Dict(asdl_seq * keys, asdl_seq * values, int lineno)
604 { 604 {
605 expr_ty p; 605 expr_ty p;
606 p = (expr_ty)malloc(sizeof(*p)); 606 p = (expr_ty)malloc(sizeof(*p));
607 if (!p) { 607 if (!p) {
608 PyErr_SetString(PyExc_MemoryError, "no memory"); 608 PyErr_NoMemory();
609 return NULL; 609 return NULL;
610 } 610 }
611 p->kind = Dict_kind; 611 p->kind = Dict_kind;
612 p->v.Dict.keys = keys; 612 p->v.Dict.keys = keys;
613 p->v.Dict.values = values; 613 p->v.Dict.values = values;
624 "field elt is required for ListComp"); 624 "field elt is required for ListComp");
625 return NULL; 625 return NULL;
626 } 626 }
627 p = (expr_ty)malloc(sizeof(*p)); 627 p = (expr_ty)malloc(sizeof(*p));
628 if (!p) { 628 if (!p) {
629 PyErr_SetString(PyExc_MemoryError, "no memory"); 629 PyErr_NoMemory();
630 return NULL; 630 return NULL;
631 } 631 }
632 p->kind = ListComp_kind; 632 p->kind = ListComp_kind;
633 p->v.ListComp.elt = elt; 633 p->v.ListComp.elt = elt;
634 p->v.ListComp.generators = generators; 634 p->v.ListComp.generators = generators;
645 "field elt is required for GeneratorExp"); 645 "field elt is required for GeneratorExp");
646 return NULL; 646 return NULL;
647 } 647 }
648 p = (expr_ty)malloc(sizeof(*p)); 648 p = (expr_ty)malloc(sizeof(*p));
649 if (!p) { 649 if (!p) {
650 PyErr_SetString(PyExc_MemoryError, "no memory"); 650 PyErr_NoMemory();
651 return NULL; 651 return NULL;
652 } 652 }
653 p->kind = GeneratorExp_kind; 653 p->kind = GeneratorExp_kind;
654 p->v.GeneratorExp.elt = elt; 654 p->v.GeneratorExp.elt = elt;
655 p->v.GeneratorExp.generators = generators; 655 p->v.GeneratorExp.generators = generators;
661 Yield(expr_ty value, int lineno) 661 Yield(expr_ty value, int lineno)
662 { 662 {
663 expr_ty p; 663 expr_ty p;
664 p = (expr_ty)malloc(sizeof(*p)); 664 p = (expr_ty)malloc(sizeof(*p));
665 if (!p) { 665 if (!p) {
666 PyErr_SetString(PyExc_MemoryError, "no memory"); 666 PyErr_NoMemory();
667 return NULL; 667 return NULL;
668 } 668 }
669 p->kind = Yield_kind; 669 p->kind = Yield_kind;
670 p->v.Yield.value = value; 670 p->v.Yield.value = value;
671 p->lineno = lineno; 671 p->lineno = lineno;
681 "field left is required for Compare"); 681 "field left is required for Compare");
682 return NULL; 682 return NULL;
683 } 683 }
684 p = (expr_ty)malloc(sizeof(*p)); 684 p = (expr_ty)malloc(sizeof(*p));
685 if (!p) { 685 if (!p) {
686 PyErr_SetString(PyExc_MemoryError, "no memory"); 686 PyErr_NoMemory();
687 return NULL; 687 return NULL;
688 } 688 }
689 p->kind = Compare_kind; 689 p->kind = Compare_kind;
690 p->v.Compare.left = left; 690 p->v.Compare.left = left;
691 p->v.Compare.ops = ops; 691 p->v.Compare.ops = ops;
704 "field func is required for Call"); 704 "field func is required for Call");
705 return NULL; 705 return NULL;
706 } 706 }
707 p = (expr_ty)malloc(sizeof(*p)); 707 p = (expr_ty)malloc(sizeof(*p));
708 if (!p) { 708 if (!p) {
709 PyErr_SetString(PyExc_MemoryError, "no memory"); 709 PyErr_NoMemory();
710 return NULL; 710 return NULL;
711 } 711 }
712 p->kind = Call_kind; 712 p->kind = Call_kind;
713 p->v.Call.func = func; 713 p->v.Call.func = func;
714 p->v.Call.args = args; 714 p->v.Call.args = args;
728 "field value is required for Repr"); 728 "field value is required for Repr");
729 return NULL; 729 return NULL;
730 } 730 }
731 p = (expr_ty)malloc(sizeof(*p)); 731 p = (expr_ty)malloc(sizeof(*p));
732 if (!p) { 732 if (!p) {
733 PyErr_SetString(PyExc_MemoryError, "no memory"); 733 PyErr_NoMemory();
734 return NULL; 734 return NULL;
735 } 735 }
736 p->kind = Repr_kind; 736 p->kind = Repr_kind;
737 p->v.Repr.value = value; 737 p->v.Repr.value = value;
738 p->lineno = lineno; 738 p->lineno = lineno;
748 "field n is required for Num"); 748 "field n is required for Num");
749 return NULL; 749 return NULL;
750 } 750 }
751 p = (expr_ty)malloc(sizeof(*p)); 751 p = (expr_ty)malloc(sizeof(*p));
752 if (!p) { 752 if (!p) {
753 PyErr_SetString(PyExc_MemoryError, "no memory"); 753 PyErr_NoMemory();
754 return NULL; 754 return NULL;
755 } 755 }
756 p->kind = Num_kind; 756 p->kind = Num_kind;
757 p->v.Num.n = n; 757 p->v.Num.n = n;
758 p->lineno = lineno; 758 p->lineno = lineno;
768 "field s is required for Str"); 768 "field s is required for Str");
769 return NULL; 769 return NULL;
770 } 770 }
771 p = (expr_ty)malloc(sizeof(*p)); 771 p = (expr_ty)malloc(sizeof(*p));
772 if (!p) { 772 if (!p) {
773 PyErr_SetString(PyExc_MemoryError, "no memory"); 773 PyErr_NoMemory();
774 return NULL; 774 return NULL;
775 } 775 }
776 p->kind = Str_kind; 776 p->kind = Str_kind;
777 p->v.Str.s = s; 777 p->v.Str.s = s;
778 p->lineno = lineno; 778 p->lineno = lineno;
798 "field ctx is required for Attribute"); 798 "field ctx is required for Attribute");
799 return NULL; 799 return NULL;
800 } 800 }
801 p = (expr_ty)malloc(sizeof(*p)); 801 p = (expr_ty)malloc(sizeof(*p));
802 if (!p) { 802 if (!p) {
803 PyErr_SetString(PyExc_MemoryError, "no memory"); 803 PyErr_NoMemory();
804 return NULL; 804 return NULL;
805 } 805 }
806 p->kind = Attribute_kind; 806 p->kind = Attribute_kind;
807 p->v.Attribute.value = value; 807 p->v.Attribute.value = value;
808 p->v.Attribute.attr = attr; 808 p->v.Attribute.attr = attr;
830 "field ctx is required for Subscript"); 830 "field ctx is required for Subscript");
831 return NULL; 831 return NULL;
832 } 832 }
833 p = (expr_ty)malloc(sizeof(*p)); 833 p = (expr_ty)malloc(sizeof(*p));
834 if (!p) { 834 if (!p) {
835 PyErr_SetString(PyExc_MemoryError, "no memory"); 835 PyErr_NoMemory();
836 return NULL; 836 return NULL;
837 } 837 }
838 p->kind = Subscript_kind; 838 p->kind = Subscript_kind;
839 p->v.Subscript.value = value; 839 p->v.Subscript.value = value;
840 p->v.Subscript.slice = slice; 840 p->v.Subscript.slice = slice;
857 "field ctx is required for Name"); 857 "field ctx is required for Name");
858 return NULL; 858 return NULL;
859 } 859 }
860 p = (expr_ty)malloc(sizeof(*p)); 860 p = (expr_ty)malloc(sizeof(*p));
861 if (!p) { 861 if (!p) {
862 PyErr_SetString(PyExc_MemoryError, "no memory"); 862 PyErr_NoMemory();
863 return NULL; 863 return NULL;
864 } 864 }
865 p->kind = Name_kind; 865 p->kind = Name_kind;
866 p->v.Name.id = id; 866 p->v.Name.id = id;
867 p->v.Name.ctx = ctx; 867 p->v.Name.ctx = ctx;
878 "field ctx is required for List"); 878 "field ctx is required for List");
879 return NULL; 879 return NULL;
880 } 880 }
881 p = (expr_ty)malloc(sizeof(*p)); 881 p = (expr_ty)malloc(sizeof(*p));
882 if (!p) { 882 if (!p) {
883 PyErr_SetString(PyExc_MemoryError, "no memory"); 883 PyErr_NoMemory();
884 return NULL; 884 return NULL;
885 } 885 }
886 p->kind = List_kind; 886 p->kind = List_kind;
887 p->v.List.elts = elts; 887 p->v.List.elts = elts;
888 p->v.List.ctx = ctx; 888 p->v.List.ctx = ctx;
899 "field ctx is required for Tuple"); 899 "field ctx is required for Tuple");
900 return NULL; 900 return NULL;
901 } 901 }
902 p = (expr_ty)malloc(sizeof(*p)); 902 p = (expr_ty)malloc(sizeof(*p));
903 if (!p) { 903 if (!p) {
904 PyErr_SetString(PyExc_MemoryError, "no memory"); 904 PyErr_NoMemory();
905 return NULL; 905 return NULL;
906 } 906 }
907 p->kind = Tuple_kind; 907 p->kind = Tuple_kind;
908 p->v.Tuple.elts = elts; 908 p->v.Tuple.elts = elts;
909 p->v.Tuple.ctx = ctx; 909 p->v.Tuple.ctx = ctx;
915 Ellipsis() 915 Ellipsis()
916 { 916 {
917 slice_ty p; 917 slice_ty p;
918 p = (slice_ty)malloc(sizeof(*p)); 918 p = (slice_ty)malloc(sizeof(*p));
919 if (!p) { 919 if (!p) {
920 PyErr_SetString(PyExc_MemoryError, "no memory"); 920 PyErr_NoMemory();
921 return NULL; 921 return NULL;
922 } 922 }
923 p->kind = Ellipsis_kind; 923 p->kind = Ellipsis_kind;
924 return p; 924 return p;
925 } 925 }
928 Slice(expr_ty lower, expr_ty upper, expr_ty step) 928 Slice(expr_ty lower, expr_ty upper, expr_ty step)
929 { 929 {
930 slice_ty p; 930 slice_ty p;
931 p = (slice_ty)malloc(sizeof(*p)); 931 p = (slice_ty)malloc(sizeof(*p));
932 if (!p) { 932 if (!p) {
933 PyErr_SetString(PyExc_MemoryError, "no memory"); 933 PyErr_NoMemory();
934 return NULL; 934 return NULL;
935 } 935 }
936 p->kind = Slice_kind; 936 p->kind = Slice_kind;
937 p->v.Slice.lower = lower; 937 p->v.Slice.lower = lower;
938 p->v.Slice.upper = upper; 938 p->v.Slice.upper = upper;
944 ExtSlice(asdl_seq * dims) 944 ExtSlice(asdl_seq * dims)
945 { 945 {
946 slice_ty p; 946 slice_ty p;
947 p = (slice_ty)malloc(sizeof(*p)); 947 p = (slice_ty)malloc(sizeof(*p));
948 if (!p) { 948 if (!p) {
949 PyErr_SetString(PyExc_MemoryError, "no memory"); 949 PyErr_NoMemory();
950 return NULL; 950 return NULL;
951 } 951 }
952 p->kind = ExtSlice_kind; 952 p->kind = ExtSlice_kind;
953 p->v.ExtSlice.dims = dims; 953 p->v.ExtSlice.dims = dims;
954 return p; 954 return p;
963 "field value is required for Index"); 963 "field value is required for Index");
964 return NULL; 964 return NULL;
965 } 965 }
966 p = (slice_ty)malloc(sizeof(*p)); 966 p = (slice_ty)malloc(sizeof(*p));
967 if (!p) { 967 if (!p) {
968 PyErr_SetString(PyExc_MemoryError, "no memory"); 968 PyErr_NoMemory();
969 return NULL; 969 return NULL;
970 } 970 }
971 p->kind = Index_kind; 971 p->kind = Index_kind;
972 p->v.Index.value = value; 972 p->v.Index.value = value;
973 return p; 973 return p;
987 "field iter is required for comprehension"); 987 "field iter is required for comprehension");
988 return NULL; 988 return NULL;
989 } 989 }
990 p = (comprehension_ty)malloc(sizeof(*p)); 990 p = (comprehension_ty)malloc(sizeof(*p));
991 if (!p) { 991 if (!p) {
992 PyErr_SetString(PyExc_MemoryError, "no memory"); 992 PyErr_NoMemory();
993 return NULL; 993 return NULL;
994 } 994 }
995 p->target = target; 995 p->target = target;
996 p->iter = iter; 996 p->iter = iter;
997 p->ifs = ifs; 997 p->ifs = ifs;
1002 excepthandler(expr_ty type, expr_ty name, asdl_seq * body) 1002 excepthandler(expr_ty type, expr_ty name, asdl_seq * body)
1003 { 1003 {
1004 excepthandler_ty p; 1004 excepthandler_ty p;
1005 p = (excepthandler_ty)malloc(sizeof(*p)); 1005 p = (excepthandler_ty)malloc(sizeof(*p));
1006 if (!p) { 1006 if (!p) {
1007 PyErr_SetString(PyExc_MemoryError, "no memory"); 1007 PyErr_NoMemory();
1008 return NULL; 1008 return NULL;
1009 } 1009 }
1010 p->type = type; 1010 p->type = type;
1011 p->name = name; 1011 p->name = name;
1012 p->body = body; 1012 p->body = body;
1018 defaults) 1018 defaults)
1019 { 1019 {
1020 arguments_ty p; 1020 arguments_ty p;
1021 p = (arguments_ty)malloc(sizeof(*p)); 1021 p = (arguments_ty)malloc(sizeof(*p));
1022 if (!p) { 1022 if (!p) {
1023 PyErr_SetString(PyExc_MemoryError, "no memory"); 1023 PyErr_NoMemory();
1024 return NULL; 1024 return NULL;
1025 } 1025 }
1026 p->args = args; 1026 p->args = args;
1027 p->vararg = vararg; 1027 p->vararg = vararg;
1028 p->kwarg = kwarg; 1028 p->kwarg = kwarg;
1044 "field value is required for keyword"); 1044 "field value is required for keyword");
1045 return NULL; 1045 return NULL;
1046 } 1046 }
1047 p = (keyword_ty)malloc(sizeof(*p)); 1047 p = (keyword_ty)malloc(sizeof(*p));
1048 if (!p) { 1048 if (!p) {
1049 PyErr_SetString(PyExc_MemoryError, "no memory"); 1049 PyErr_NoMemory();
1050 return NULL; 1050 return NULL;
1051 } 1051 }
1052 p->arg = arg; 1052 p->arg = arg;
1053 p->value = value; 1053 p->value = value;
1054 return p; 1054 return p;
1063 "field name is required for alias"); 1063 "field name is required for alias");
1064 return NULL; 1064 return NULL;
1065 } 1065 }
1066 p = (alias_ty)malloc(sizeof(*p)); 1066 p = (alias_ty)malloc(sizeof(*p));
1067 if (!p) { 1067 if (!p) {
1068 PyErr_SetString(PyExc_MemoryError, "no memory"); 1068 PyErr_NoMemory();
1069 return NULL; 1069 return NULL;
1070 } 1070 }
1071 p->name = name; 1071 p->name = name;
1072 p->asname = asname; 1072 p->asname = asname;
1073 return p; 1073 return p;
1990 } 1990 }
1991 1991
1992 int 1992 int
1993 marshal_write_expr_context(PyObject **buf, int *off, expr_context_ty o) 1993 marshal_write_expr_context(PyObject **buf, int *off, expr_context_ty o)
1994 { 1994 {
1995 int i;
1996 switch (o) { 1995 switch (o) {
1997 case Load: 1996 case Load:
1998 marshal_write_int(buf, off, 1); 1997 marshal_write_int(buf, off, 1);
1999 break; 1998 break;
2000 case Store: 1999 case Store:
2065 } 2064 }
2066 2065
2067 int 2066 int
2068 marshal_write_boolop(PyObject **buf, int *off, boolop_ty o) 2067 marshal_write_boolop(PyObject **buf, int *off, boolop_ty o)
2069 { 2068 {
2070 int i;
2071 switch (o) { 2069 switch (o) {
2072 case And: 2070 case And:
2073 marshal_write_int(buf, off, 1); 2071 marshal_write_int(buf, off, 1);
2074 break; 2072 break;
2075 case Or: 2073 case Or:
2080 } 2078 }
2081 2079
2082 int 2080 int
2083 marshal_write_operator(PyObject **buf, int *off, operator_ty o) 2081 marshal_write_operator(PyObject **buf, int *off, operator_ty o)
2084 { 2082 {
2085 int i;
2086 switch (o) { 2083 switch (o) {
2087 case Add: 2084 case Add:
2088 marshal_write_int(buf, off, 1); 2085 marshal_write_int(buf, off, 1);
2089 break; 2086 break;
2090 case Sub: 2087 case Sub:
2125 } 2122 }
2126 2123
2127 int 2124 int
2128 marshal_write_unaryop(PyObject **buf, int *off, unaryop_ty o) 2125 marshal_write_unaryop(PyObject **buf, int *off, unaryop_ty o)
2129 { 2126 {
2130 int i;
2131 switch (o) { 2127 switch (o) {
2132 case Invert: 2128 case Invert:
2133 marshal_write_int(buf, off, 1); 2129 marshal_write_int(buf, off, 1);
2134 break; 2130 break;
2135 case Not: 2131 case Not:
2146 } 2142 }
2147 2143
2148 int 2144 int
2149 marshal_write_cmpop(PyObject **buf, int *off, cmpop_ty o) 2145 marshal_write_cmpop(PyObject **buf, int *off, cmpop_ty o)
2150 { 2146 {
2151 int i;
2152 switch (o) { 2147 switch (o) {
2153 case Eq: 2148 case Eq:
2154 marshal_write_int(buf, off, 1); 2149 marshal_write_int(buf, off, 1);
2155 break; 2150 break;
2156 case NotEq: 2151 case NotEq:
2256 } 2251 }
2257 2252
2258 int 2253 int
2259 marshal_write_keyword(PyObject **buf, int *off, keyword_ty o) 2254 marshal_write_keyword(PyObject **buf, int *off, keyword_ty o)
2260 { 2255 {
2261 int i;
2262 marshal_write_identifier(buf, off, o->arg); 2256 marshal_write_identifier(buf, off, o->arg);
2263 marshal_write_expr(buf, off, o->value); 2257 marshal_write_expr(buf, off, o->value);
2264 return 1; 2258 return 1;
2265 } 2259 }
2266 2260
2267 int 2261 int
2268 marshal_write_alias(PyObject **buf, int *off, alias_ty o) 2262 marshal_write_alias(PyObject **buf, int *off, alias_ty o)
2269 { 2263 {
2270 int i;
2271 marshal_write_identifier(buf, off, o->name); 2264 marshal_write_identifier(buf, off, o->name);
2272 if (o->asname) { 2265 if (o->asname) {
2273 marshal_write_int(buf, off, 1); 2266 marshal_write_int(buf, off, 1);
2274 marshal_write_identifier(buf, off, o->asname); 2267 marshal_write_identifier(buf, off, o->asname);
2275 } 2268 }