1 /* File automatically generated by Parser/asdl_c.py. */
2
3
4 /*
5 __version__ 82160.
6
7 This module must be committed separately after each AST grammar change;
8 The __version__ number is set to the revision number of the commit
9 containing the grammar change.
10 */
11
12 #include "Python.h"
13 #include "Python-ast.h"
14
15 static PyTypeObject AST_type;
16 static PyTypeObject *mod_type;
17 static PyObject* ast2obj_mod(void*);
18 static PyTypeObject *Module_type;
19 static char *Module_fields[]={
20 "body",
21 };
22 static PyTypeObject *Interactive_type;
23 static char *Interactive_fields[]={
24 "body",
25 };
26 static PyTypeObject *Expression_type;
27 static char *Expression_fields[]={
28 "body",
29 };
30 static PyTypeObject *Suite_type;
31 static char *Suite_fields[]={
32 "body",
33 };
34 static PyTypeObject *stmt_type;
35 static char *stmt_attributes[] = {
36 "lineno",
37 "col_offset",
38 };
39 static PyObject* ast2obj_stmt(void*);
40 static PyTypeObject *FunctionDef_type;
41 static char *FunctionDef_fields[]={
42 "name",
43 "args",
44 "body",
45 "decorator_list",
46 };
47 static PyTypeObject *ClassDef_type;
48 static char *ClassDef_fields[]={
49 "name",
50 "bases",
51 "body",
52 "decorator_list",
53 };
54 static PyTypeObject *Return_type;
55 static char *Return_fields[]={
56 "value",
57 };
58 static PyTypeObject *Delete_type;
59 static char *Delete_fields[]={
60 "targets",
61 };
62 static PyTypeObject *Assign_type;
63 static char *Assign_fields[]={
64 "targets",
65 "value",
66 };
67 static PyTypeObject *AugAssign_type;
68 static char *AugAssign_fields[]={
69 "target",
70 "op",
71 "value",
72 };
73 static PyTypeObject *Print_type;
74 static char *Print_fields[]={
75 "dest",
76 "values",
77 "nl",
78 };
79 static PyTypeObject *For_type;
80 static char *For_fields[]={
81 "target",
82 "iter",
83 "body",
84 "orelse",
85 };
86 static PyTypeObject *While_type;
87 static char *While_fields[]={
88 "test",
89 "body",
90 "orelse",
91 };
92 static PyTypeObject *If_type;
93 static char *If_fields[]={
94 "test",
95 "body",
96 "orelse",
97 };
98 static PyTypeObject *With_type;
99 static char *With_fields[]={
100 "context_expr",
101 "optional_vars",
102 "body",
103 };
104 static PyTypeObject *Raise_type;
105 static char *Raise_fields[]={
106 "type",
107 "inst",
108 "tback",
109 };
110 static PyTypeObject *TryExcept_type;
111 static char *TryExcept_fields[]={
112 "body",
113 "handlers",
114 "orelse",
115 };
116 static PyTypeObject *TryFinally_type;
117 static char *TryFinally_fields[]={
118 "body",
119 "finalbody",
120 };
121 static PyTypeObject *Assert_type;
122 static char *Assert_fields[]={
123 "test",
124 "msg",
125 };
126 static PyTypeObject *Import_type;
127 static char *Import_fields[]={
128 "names",
129 };
130 static PyTypeObject *ImportFrom_type;
131 static char *ImportFrom_fields[]={
132 "module",
133 "names",
134 "level",
135 };
136 static PyTypeObject *Exec_type;
137 static char *Exec_fields[]={
138 "body",
139 "globals",
140 "locals",
141 };
142 static PyTypeObject *Global_type;
143 static char *Global_fields[]={
144 "names",
145 };
146 static PyTypeObject *Expr_type;
147 static char *Expr_fields[]={
148 "value",
149 };
150 static PyTypeObject *Pass_type;
151 static PyTypeObject *Break_type;
152 static PyTypeObject *Continue_type;
153 static PyTypeObject *expr_type;
154 static char *expr_attributes[] = {
155 "lineno",
156 "col_offset",
157 };
158 static PyObject* ast2obj_expr(void*);
159 static PyTypeObject *BoolOp_type;
160 static char *BoolOp_fields[]={
161 "op",
162 "values",
163 };
164 static PyTypeObject *BinOp_type;
165 static char *BinOp_fields[]={
166 "left",
167 "op",
168 "right",
169 };
170 static PyTypeObject *UnaryOp_type;
171 static char *UnaryOp_fields[]={
172 "op",
173 "operand",
174 };
175 static PyTypeObject *Lambda_type;
176 static char *Lambda_fields[]={
177 "args",
178 "body",
179 };
180 static PyTypeObject *IfExp_type;
181 static char *IfExp_fields[]={
182 "test",
183 "body",
184 "orelse",
185 };
186 static PyTypeObject *Dict_type;
187 static char *Dict_fields[]={
188 "keys",
189 "values",
190 };
191 static PyTypeObject *Set_type;
192 static char *Set_fields[]={
193 "elts",
194 };
195 static PyTypeObject *ListComp_type;
196 static char *ListComp_fields[]={
197 "elt",
198 "generators",
199 };
200 static PyTypeObject *SetComp_type;
201 static char *SetComp_fields[]={
202 "elt",
203 "generators",
204 };
205 static PyTypeObject *DictComp_type;
206 static char *DictComp_fields[]={
207 "key",
208 "value",
209 "generators",
210 };
211 static PyTypeObject *GeneratorExp_type;
212 static char *GeneratorExp_fields[]={
213 "elt",
214 "generators",
215 };
216 static PyTypeObject *Yield_type;
217 static char *Yield_fields[]={
218 "value",
219 };
220 static PyTypeObject *Compare_type;
221 static char *Compare_fields[]={
222 "left",
223 "ops",
224 "comparators",
225 };
226 static PyTypeObject *Call_type;
227 static char *Call_fields[]={
228 "func",
229 "args",
230 "keywords",
231 "starargs",
232 "kwargs",
233 };
234 static PyTypeObject *Repr_type;
235 static char *Repr_fields[]={
236 "value",
237 };
238 static PyTypeObject *Num_type;
239 static char *Num_fields[]={
240 "n",
241 };
242 static PyTypeObject *Str_type;
243 static char *Str_fields[]={
244 "s",
245 };
246 static PyTypeObject *Attribute_type;
247 static char *Attribute_fields[]={
248 "value",
249 "attr",
250 "ctx",
251 };
252 static PyTypeObject *Subscript_type;
253 static char *Subscript_fields[]={
254 "value",
255 "slice",
256 "ctx",
257 };
258 static PyTypeObject *Name_type;
259 static char *Name_fields[]={
260 "id",
261 "ctx",
262 };
263 static PyTypeObject *List_type;
264 static char *List_fields[]={
265 "elts",
266 "ctx",
267 };
268 static PyTypeObject *Tuple_type;
269 static char *Tuple_fields[]={
270 "elts",
271 "ctx",
272 };
273 static PyTypeObject *expr_context_type;
274 static PyObject *Load_singleton, *Store_singleton, *Del_singleton,
275 *AugLoad_singleton, *AugStore_singleton, *Param_singleton;
276 static PyObject* ast2obj_expr_context(expr_context_ty);
277 static PyTypeObject *Load_type;
278 static PyTypeObject *Store_type;
279 static PyTypeObject *Del_type;
280 static PyTypeObject *AugLoad_type;
281 static PyTypeObject *AugStore_type;
282 static PyTypeObject *Param_type;
283 static PyTypeObject *slice_type;
284 static PyObject* ast2obj_slice(void*);
285 static PyTypeObject *Ellipsis_type;
286 static PyTypeObject *Slice_type;
287 static char *Slice_fields[]={
288 "lower",
289 "upper",
290 "step",
291 };
292 static PyTypeObject *ExtSlice_type;
293 static char *ExtSlice_fields[]={
294 "dims",
295 };
296 static PyTypeObject *Index_type;
297 static char *Index_fields[]={
298 "value",
299 };
300 static PyTypeObject *boolop_type;
301 static PyObject *And_singleton, *Or_singleton;
302 static PyObject* ast2obj_boolop(boolop_ty);
303 static PyTypeObject *And_type;
304 static PyTypeObject *Or_type;
305 static PyTypeObject *operator_type;
306 static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,
307 *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton,
308 *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton,
309 *FloorDiv_singleton;
310 static PyObject* ast2obj_operator(operator_ty);
311 static PyTypeObject *Add_type;
312 static PyTypeObject *Sub_type;
313 static PyTypeObject *Mult_type;
314 static PyTypeObject *Div_type;
315 static PyTypeObject *Mod_type;
316 static PyTypeObject *Pow_type;
317 static PyTypeObject *LShift_type;
318 static PyTypeObject *RShift_type;
319 static PyTypeObject *BitOr_type;
320 static PyTypeObject *BitXor_type;
321 static PyTypeObject *BitAnd_type;
322 static PyTypeObject *FloorDiv_type;
323 static PyTypeObject *unaryop_type;
324 static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,
325 *USub_singleton;
326 static PyObject* ast2obj_unaryop(unaryop_ty);
327 static PyTypeObject *Invert_type;
328 static PyTypeObject *Not_type;
329 static PyTypeObject *UAdd_type;
330 static PyTypeObject *USub_type;
331 static PyTypeObject *cmpop_type;
332 static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton,
333 *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton,
334 *NotIn_singleton;
335 static PyObject* ast2obj_cmpop(cmpop_ty);
336 static PyTypeObject *Eq_type;
337 static PyTypeObject *NotEq_type;
338 static PyTypeObject *Lt_type;
339 static PyTypeObject *LtE_type;
340 static PyTypeObject *Gt_type;
341 static PyTypeObject *GtE_type;
342 static PyTypeObject *Is_type;
343 static PyTypeObject *IsNot_type;
344 static PyTypeObject *In_type;
345 static PyTypeObject *NotIn_type;
346 static PyTypeObject *comprehension_type;
347 static PyObject* ast2obj_comprehension(void*);
348 static char *comprehension_fields[]={
349 "target",
350 "iter",
351 "ifs",
352 };
353 static PyTypeObject *excepthandler_type;
354 static char *excepthandler_attributes[] = {
355 "lineno",
356 "col_offset",
357 };
358 static PyObject* ast2obj_excepthandler(void*);
359 static PyTypeObject *ExceptHandler_type;
360 static char *ExceptHandler_fields[]={
361 "type",
362 "name",
363 "body",
364 };
365 static PyTypeObject *arguments_type;
366 static PyObject* ast2obj_arguments(void*);
367 static char *arguments_fields[]={
368 "args",
369 "vararg",
370 "kwarg",
371 "defaults",
372 };
373 static PyTypeObject *keyword_type;
374 static PyObject* ast2obj_keyword(void*);
375 static char *keyword_fields[]={
376 "arg",
377 "value",
378 };
379 static PyTypeObject *alias_type;
380 static PyObject* ast2obj_alias(void*);
381 static char *alias_fields[]={
382 "name",
383 "asname",
384 };
385
386
387 static int
ast_type_init(PyObject * self,PyObject * args,PyObject * kw)388 ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
389 {
390 Py_ssize_t i, numfields = 0;
391 int res = -1;
392 PyObject *key, *value, *fields;
393 fields = PyObject_GetAttrString((PyObject*)Py_TYPE(self), "_fields");
394 if (!fields)
395 PyErr_Clear();
396 if (fields) {
397 numfields = PySequence_Size(fields);
398 if (numfields == -1)
399 goto cleanup;
400 }
401 res = 0; /* if no error occurs, this stays 0 to the end */
402 if (PyTuple_GET_SIZE(args) > 0) {
403 if (numfields != PyTuple_GET_SIZE(args)) {
404 PyErr_Format(PyExc_TypeError, "%.400s constructor takes %s"
405 "%zd positional argument%s",
406 Py_TYPE(self)->tp_name,
407 numfields == 0 ? "" : "either 0 or ",
408 numfields, numfields == 1 ? "" : "s");
409 res = -1;
410 goto cleanup;
411 }
412 for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
413 /* cannot be reached when fields is NULL */
414 PyObject *name = PySequence_GetItem(fields, i);
415 if (!name) {
416 res = -1;
417 goto cleanup;
418 }
419 res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
420 Py_DECREF(name);
421 if (res < 0)
422 goto cleanup;
423 }
424 }
425 if (kw) {
426 i = 0; /* needed by PyDict_Next */
427 while (PyDict_Next(kw, &i, &key, &value)) {
428 res = PyObject_SetAttr(self, key, value);
429 if (res < 0)
430 goto cleanup;
431 }
432 }
433 cleanup:
434 Py_XDECREF(fields);
435 return res;
436 }
437
438 /* Pickling support */
439 static PyObject *
ast_type_reduce(PyObject * self,PyObject * unused)440 ast_type_reduce(PyObject *self, PyObject *unused)
441 {
442 PyObject *res;
443 PyObject *dict = PyObject_GetAttrString(self, "__dict__");
444 if (dict == NULL) {
445 if (PyErr_ExceptionMatches(PyExc_AttributeError))
446 PyErr_Clear();
447 else
448 return NULL;
449 }
450 if (dict) {
451 res = Py_BuildValue("O()O", Py_TYPE(self), dict);
452 Py_DECREF(dict);
453 return res;
454 }
455 return Py_BuildValue("O()", Py_TYPE(self));
456 }
457
458 static PyMethodDef ast_type_methods[] = {
459 {"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
460 {NULL}
461 };
462
463 static PyTypeObject AST_type = {
464 PyVarObject_HEAD_INIT(&PyType_Type, 0)
465 "_ast.AST",
466 sizeof(PyObject),
467 0,
468 0, /* tp_dealloc */
469 0, /* tp_print */
470 0, /* tp_getattr */
471 0, /* tp_setattr */
472 0, /* tp_compare */
473 0, /* tp_repr */
474 0, /* tp_as_number */
475 0, /* tp_as_sequence */
476 0, /* tp_as_mapping */
477 0, /* tp_hash */
478 0, /* tp_call */
479 0, /* tp_str */
480 PyObject_GenericGetAttr, /* tp_getattro */
481 PyObject_GenericSetAttr, /* tp_setattro */
482 0, /* tp_as_buffer */
483 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
484 0, /* tp_doc */
485 0, /* tp_traverse */
486 0, /* tp_clear */
487 0, /* tp_richcompare */
488 0, /* tp_weaklistoffset */
489 0, /* tp_iter */
490 0, /* tp_iternext */
491 ast_type_methods, /* tp_methods */
492 0, /* tp_members */
493 0, /* tp_getset */
494 0, /* tp_base */
495 0, /* tp_dict */
496 0, /* tp_descr_get */
497 0, /* tp_descr_set */
498 0, /* tp_dictoffset */
499 (initproc)ast_type_init, /* tp_init */
500 PyType_GenericAlloc, /* tp_alloc */
501 PyType_GenericNew, /* tp_new */
502 PyObject_Del, /* tp_free */
503 };
504
505
make_type(char * type,PyTypeObject * base,char ** fields,int num_fields)506 static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields)
507 {
508 PyObject *fnames, *result;
509 int i;
510 fnames = PyTuple_New(num_fields);
511 if (!fnames) return NULL;
512 for (i = 0; i < num_fields; i++) {
513 PyObject *field = PyString_FromString(fields[i]);
514 if (!field) {
515 Py_DECREF(fnames);
516 return NULL;
517 }
518 PyTuple_SET_ITEM(fnames, i, field);
519 }
520 result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
521 type, base, "_fields", fnames, "__module__", "_ast");
522 Py_DECREF(fnames);
523 return (PyTypeObject*)result;
524 }
525
add_attributes(PyTypeObject * type,char ** attrs,int num_fields)526 static int add_attributes(PyTypeObject* type, char**attrs, int num_fields)
527 {
528 int i, result;
529 PyObject *s, *l = PyTuple_New(num_fields);
530 if (!l)
531 return 0;
532 for (i = 0; i < num_fields; i++) {
533 s = PyString_FromString(attrs[i]);
534 if (!s) {
535 Py_DECREF(l);
536 return 0;
537 }
538 PyTuple_SET_ITEM(l, i, s);
539 }
540 result = PyObject_SetAttrString((PyObject*)type, "_attributes", l) >= 0;
541 Py_DECREF(l);
542 return result;
543 }
544
545 /* Conversion AST -> Python */
546
ast2obj_list(asdl_seq * seq,PyObject * (* func)(void *))547 static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*))
548 {
549 int i, n = asdl_seq_LEN(seq);
550 PyObject *result = PyList_New(n);
551 PyObject *value;
552 if (!result)
553 return NULL;
554 for (i = 0; i < n; i++) {
555 value = func(asdl_seq_GET(seq, i));
556 if (!value) {
557 Py_DECREF(result);
558 return NULL;
559 }
560 PyList_SET_ITEM(result, i, value);
561 }
562 return result;
563 }
564
ast2obj_object(void * o)565 static PyObject* ast2obj_object(void *o)
566 {
567 if (!o)
568 o = Py_None;
569 Py_INCREF((PyObject*)o);
570 return (PyObject*)o;
571 }
572 #define ast2obj_identifier ast2obj_object
573 #define ast2obj_string ast2obj_object
ast2obj_bool(bool b)574 static PyObject* ast2obj_bool(bool b)
575 {
576 return PyBool_FromLong(b);
577 }
578
ast2obj_int(long b)579 static PyObject* ast2obj_int(long b)
580 {
581 return PyInt_FromLong(b);
582 }
583
584 /* Conversion Python -> AST */
585
obj2ast_object(PyObject * obj,PyObject ** out,PyArena * arena)586 static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena)
587 {
588 if (obj == Py_None)
589 obj = NULL;
590 if (obj)
591 PyArena_AddPyObject(arena, obj);
592 Py_XINCREF(obj);
593 *out = obj;
594 return 0;
595 }
596
obj2ast_identifier(PyObject * obj,PyObject ** out,PyArena * arena)597 static int obj2ast_identifier(PyObject* obj, PyObject** out, PyArena* arena)
598 {
599 if (!PyString_CheckExact(obj) && obj != Py_None) {
600 PyErr_Format(PyExc_TypeError,
601 "AST identifier must be of type str");
602 return 1;
603 }
604 return obj2ast_object(obj, out, arena);
605 }
606
obj2ast_string(PyObject * obj,PyObject ** out,PyArena * arena)607 static int obj2ast_string(PyObject* obj, PyObject** out, PyArena* arena)
608 {
609 if (!PyString_CheckExact(obj) && !PyUnicode_CheckExact(obj)) {
610 PyErr_SetString(PyExc_TypeError,
611 "AST string must be of type str or unicode");
612 return 1;
613 }
614 return obj2ast_object(obj, out, arena);
615 }
616
obj2ast_int(PyObject * obj,int * out,PyArena * arena)617 static int obj2ast_int(PyObject* obj, int* out, PyArena* arena)
618 {
619 int i;
620 if (!PyInt_Check(obj) && !PyLong_Check(obj)) {
621 PyObject *s = PyObject_Repr(obj);
622 if (s == NULL) return 1;
623 PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s",
624 PyString_AS_STRING(s));
625 Py_DECREF(s);
626 return 1;
627 }
628
629 i = (int)PyLong_AsLong(obj);
630 if (i == -1 && PyErr_Occurred())
631 return 1;
632 *out = i;
633 return 0;
634 }
635
obj2ast_bool(PyObject * obj,bool * out,PyArena * arena)636 static int obj2ast_bool(PyObject* obj, bool* out, PyArena* arena)
637 {
638 if (!PyBool_Check(obj)) {
639 PyObject *s = PyObject_Repr(obj);
640 if (s == NULL) return 1;
641 PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s",
642 PyString_AS_STRING(s));
643 Py_DECREF(s);
644 return 1;
645 }
646
647 *out = (obj == Py_True);
648 return 0;
649 }
650
add_ast_fields(void)651 static int add_ast_fields(void)
652 {
653 PyObject *empty_tuple, *d;
654 if (PyType_Ready(&AST_type) < 0)
655 return -1;
656 d = AST_type.tp_dict;
657 empty_tuple = PyTuple_New(0);
658 if (!empty_tuple ||
659 PyDict_SetItemString(d, "_fields", empty_tuple) < 0 ||
660 PyDict_SetItemString(d, "_attributes", empty_tuple) < 0) {
661 Py_XDECREF(empty_tuple);
662 return -1;
663 }
664 Py_DECREF(empty_tuple);
665 return 0;
666 }
667
668
init_types(void)669 static int init_types(void)
670 {
671 static int initialized;
672 if (initialized) return 1;
673 if (add_ast_fields() < 0) return 0;
674 mod_type = make_type("mod", &AST_type, NULL, 0);
675 if (!mod_type) return 0;
676 if (!add_attributes(mod_type, NULL, 0)) return 0;
677 Module_type = make_type("Module", mod_type, Module_fields, 1);
678 if (!Module_type) return 0;
679 Interactive_type = make_type("Interactive", mod_type,
680 Interactive_fields, 1);
681 if (!Interactive_type) return 0;
682 Expression_type = make_type("Expression", mod_type, Expression_fields,
683 1);
684 if (!Expression_type) return 0;
685 Suite_type = make_type("Suite", mod_type, Suite_fields, 1);
686 if (!Suite_type) return 0;
687 stmt_type = make_type("stmt", &AST_type, NULL, 0);
688 if (!stmt_type) return 0;
689 if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0;
690 FunctionDef_type = make_type("FunctionDef", stmt_type,
691 FunctionDef_fields, 4);
692 if (!FunctionDef_type) return 0;
693 ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 4);
694 if (!ClassDef_type) return 0;
695 Return_type = make_type("Return", stmt_type, Return_fields, 1);
696 if (!Return_type) return 0;
697 Delete_type = make_type("Delete", stmt_type, Delete_fields, 1);
698 if (!Delete_type) return 0;
699 Assign_type = make_type("Assign", stmt_type, Assign_fields, 2);
700 if (!Assign_type) return 0;
701 AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);
702 if (!AugAssign_type) return 0;
703 Print_type = make_type("Print", stmt_type, Print_fields, 3);
704 if (!Print_type) return 0;
705 For_type = make_type("For", stmt_type, For_fields, 4);
706 if (!For_type) return 0;
707 While_type = make_type("While", stmt_type, While_fields, 3);
708 if (!While_type) return 0;
709 If_type = make_type("If", stmt_type, If_fields, 3);
710 if (!If_type) return 0;
711 With_type = make_type("With", stmt_type, With_fields, 3);
712 if (!With_type) return 0;
713 Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);
714 if (!Raise_type) return 0;
715 TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);
716 if (!TryExcept_type) return 0;
717 TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields,
718 2);
719 if (!TryFinally_type) return 0;
720 Assert_type = make_type("Assert", stmt_type, Assert_fields, 2);
721 if (!Assert_type) return 0;
722 Import_type = make_type("Import", stmt_type, Import_fields, 1);
723 if (!Import_type) return 0;
724 ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields,
725 3);
726 if (!ImportFrom_type) return 0;
727 Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);
728 if (!Exec_type) return 0;
729 Global_type = make_type("Global", stmt_type, Global_fields, 1);
730 if (!Global_type) return 0;
731 Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);
732 if (!Expr_type) return 0;
733 Pass_type = make_type("Pass", stmt_type, NULL, 0);
734 if (!Pass_type) return 0;
735 Break_type = make_type("Break", stmt_type, NULL, 0);
736 if (!Break_type) return 0;
737 Continue_type = make_type("Continue", stmt_type, NULL, 0);
738 if (!Continue_type) return 0;
739 expr_type = make_type("expr", &AST_type, NULL, 0);
740 if (!expr_type) return 0;
741 if (!add_attributes(expr_type, expr_attributes, 2)) return 0;
742 BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);
743 if (!BoolOp_type) return 0;
744 BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);
745 if (!BinOp_type) return 0;
746 UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2);
747 if (!UnaryOp_type) return 0;
748 Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2);
749 if (!Lambda_type) return 0;
750 IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3);
751 if (!IfExp_type) return 0;
752 Dict_type = make_type("Dict", expr_type, Dict_fields, 2);
753 if (!Dict_type) return 0;
754 Set_type = make_type("Set", expr_type, Set_fields, 1);
755 if (!Set_type) return 0;
756 ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2);
757 if (!ListComp_type) return 0;
758 SetComp_type = make_type("SetComp", expr_type, SetComp_fields, 2);
759 if (!SetComp_type) return 0;
760 DictComp_type = make_type("DictComp", expr_type, DictComp_fields, 3);
761 if (!DictComp_type) return 0;
762 GeneratorExp_type = make_type("GeneratorExp", expr_type,
763 GeneratorExp_fields, 2);
764 if (!GeneratorExp_type) return 0;
765 Yield_type = make_type("Yield", expr_type, Yield_fields, 1);
766 if (!Yield_type) return 0;
767 Compare_type = make_type("Compare", expr_type, Compare_fields, 3);
768 if (!Compare_type) return 0;
769 Call_type = make_type("Call", expr_type, Call_fields, 5);
770 if (!Call_type) return 0;
771 Repr_type = make_type("Repr", expr_type, Repr_fields, 1);
772 if (!Repr_type) return 0;
773 Num_type = make_type("Num", expr_type, Num_fields, 1);
774 if (!Num_type) return 0;
775 Str_type = make_type("Str", expr_type, Str_fields, 1);
776 if (!Str_type) return 0;
777 Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3);
778 if (!Attribute_type) return 0;
779 Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3);
780 if (!Subscript_type) return 0;
781 Name_type = make_type("Name", expr_type, Name_fields, 2);
782 if (!Name_type) return 0;
783 List_type = make_type("List", expr_type, List_fields, 2);
784 if (!List_type) return 0;
785 Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);
786 if (!Tuple_type) return 0;
787 expr_context_type = make_type("expr_context", &AST_type, NULL, 0);
788 if (!expr_context_type) return 0;
789 if (!add_attributes(expr_context_type, NULL, 0)) return 0;
790 Load_type = make_type("Load", expr_context_type, NULL, 0);
791 if (!Load_type) return 0;
792 Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);
793 if (!Load_singleton) return 0;
794 Store_type = make_type("Store", expr_context_type, NULL, 0);
795 if (!Store_type) return 0;
796 Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);
797 if (!Store_singleton) return 0;
798 Del_type = make_type("Del", expr_context_type, NULL, 0);
799 if (!Del_type) return 0;
800 Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);
801 if (!Del_singleton) return 0;
802 AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);
803 if (!AugLoad_type) return 0;
804 AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);
805 if (!AugLoad_singleton) return 0;
806 AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);
807 if (!AugStore_type) return 0;
808 AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);
809 if (!AugStore_singleton) return 0;
810 Param_type = make_type("Param", expr_context_type, NULL, 0);
811 if (!Param_type) return 0;
812 Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);
813 if (!Param_singleton) return 0;
814 slice_type = make_type("slice", &AST_type, NULL, 0);
815 if (!slice_type) return 0;
816 if (!add_attributes(slice_type, NULL, 0)) return 0;
817 Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0);
818 if (!Ellipsis_type) return 0;
819 Slice_type = make_type("Slice", slice_type, Slice_fields, 3);
820 if (!Slice_type) return 0;
821 ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);
822 if (!ExtSlice_type) return 0;
823 Index_type = make_type("Index", slice_type, Index_fields, 1);
824 if (!Index_type) return 0;
825 boolop_type = make_type("boolop", &AST_type, NULL, 0);
826 if (!boolop_type) return 0;
827 if (!add_attributes(boolop_type, NULL, 0)) return 0;
828 And_type = make_type("And", boolop_type, NULL, 0);
829 if (!And_type) return 0;
830 And_singleton = PyType_GenericNew(And_type, NULL, NULL);
831 if (!And_singleton) return 0;
832 Or_type = make_type("Or", boolop_type, NULL, 0);
833 if (!Or_type) return 0;
834 Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);
835 if (!Or_singleton) return 0;
836 operator_type = make_type("operator", &AST_type, NULL, 0);
837 if (!operator_type) return 0;
838 if (!add_attributes(operator_type, NULL, 0)) return 0;
839 Add_type = make_type("Add", operator_type, NULL, 0);
840 if (!Add_type) return 0;
841 Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);
842 if (!Add_singleton) return 0;
843 Sub_type = make_type("Sub", operator_type, NULL, 0);
844 if (!Sub_type) return 0;
845 Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);
846 if (!Sub_singleton) return 0;
847 Mult_type = make_type("Mult", operator_type, NULL, 0);
848 if (!Mult_type) return 0;
849 Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);
850 if (!Mult_singleton) return 0;
851 Div_type = make_type("Div", operator_type, NULL, 0);
852 if (!Div_type) return 0;
853 Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);
854 if (!Div_singleton) return 0;
855 Mod_type = make_type("Mod", operator_type, NULL, 0);
856 if (!Mod_type) return 0;
857 Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);
858 if (!Mod_singleton) return 0;
859 Pow_type = make_type("Pow", operator_type, NULL, 0);
860 if (!Pow_type) return 0;
861 Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);
862 if (!Pow_singleton) return 0;
863 LShift_type = make_type("LShift", operator_type, NULL, 0);
864 if (!LShift_type) return 0;
865 LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);
866 if (!LShift_singleton) return 0;
867 RShift_type = make_type("RShift", operator_type, NULL, 0);
868 if (!RShift_type) return 0;
869 RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);
870 if (!RShift_singleton) return 0;
871 BitOr_type = make_type("BitOr", operator_type, NULL, 0);
872 if (!BitOr_type) return 0;
873 BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);
874 if (!BitOr_singleton) return 0;
875 BitXor_type = make_type("BitXor", operator_type, NULL, 0);
876 if (!BitXor_type) return 0;
877 BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);
878 if (!BitXor_singleton) return 0;
879 BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);
880 if (!BitAnd_type) return 0;
881 BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);
882 if (!BitAnd_singleton) return 0;
883 FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);
884 if (!FloorDiv_type) return 0;
885 FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);
886 if (!FloorDiv_singleton) return 0;
887 unaryop_type = make_type("unaryop", &AST_type, NULL, 0);
888 if (!unaryop_type) return 0;
889 if (!add_attributes(unaryop_type, NULL, 0)) return 0;
890 Invert_type = make_type("Invert", unaryop_type, NULL, 0);
891 if (!Invert_type) return 0;
892 Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);
893 if (!Invert_singleton) return 0;
894 Not_type = make_type("Not", unaryop_type, NULL, 0);
895 if (!Not_type) return 0;
896 Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);
897 if (!Not_singleton) return 0;
898 UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);
899 if (!UAdd_type) return 0;
900 UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);
901 if (!UAdd_singleton) return 0;
902 USub_type = make_type("USub", unaryop_type, NULL, 0);
903 if (!USub_type) return 0;
904 USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);
905 if (!USub_singleton) return 0;
906 cmpop_type = make_type("cmpop", &AST_type, NULL, 0);
907 if (!cmpop_type) return 0;
908 if (!add_attributes(cmpop_type, NULL, 0)) return 0;
909 Eq_type = make_type("Eq", cmpop_type, NULL, 0);
910 if (!Eq_type) return 0;
911 Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);
912 if (!Eq_singleton) return 0;
913 NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);
914 if (!NotEq_type) return 0;
915 NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);
916 if (!NotEq_singleton) return 0;
917 Lt_type = make_type("Lt", cmpop_type, NULL, 0);
918 if (!Lt_type) return 0;
919 Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);
920 if (!Lt_singleton) return 0;
921 LtE_type = make_type("LtE", cmpop_type, NULL, 0);
922 if (!LtE_type) return 0;
923 LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);
924 if (!LtE_singleton) return 0;
925 Gt_type = make_type("Gt", cmpop_type, NULL, 0);
926 if (!Gt_type) return 0;
927 Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);
928 if (!Gt_singleton) return 0;
929 GtE_type = make_type("GtE", cmpop_type, NULL, 0);
930 if (!GtE_type) return 0;
931 GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);
932 if (!GtE_singleton) return 0;
933 Is_type = make_type("Is", cmpop_type, NULL, 0);
934 if (!Is_type) return 0;
935 Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);
936 if (!Is_singleton) return 0;
937 IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);
938 if (!IsNot_type) return 0;
939 IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);
940 if (!IsNot_singleton) return 0;
941 In_type = make_type("In", cmpop_type, NULL, 0);
942 if (!In_type) return 0;
943 In_singleton = PyType_GenericNew(In_type, NULL, NULL);
944 if (!In_singleton) return 0;
945 NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);
946 if (!NotIn_type) return 0;
947 NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);
948 if (!NotIn_singleton) return 0;
949 comprehension_type = make_type("comprehension", &AST_type,
950 comprehension_fields, 3);
951 if (!comprehension_type) return 0;
952 excepthandler_type = make_type("excepthandler", &AST_type, NULL, 0);
953 if (!excepthandler_type) return 0;
954 if (!add_attributes(excepthandler_type, excepthandler_attributes, 2))
955 return 0;
956 ExceptHandler_type = make_type("ExceptHandler", excepthandler_type,
957 ExceptHandler_fields, 3);
958 if (!ExceptHandler_type) return 0;
959 arguments_type = make_type("arguments", &AST_type, arguments_fields, 4);
960 if (!arguments_type) return 0;
961 keyword_type = make_type("keyword", &AST_type, keyword_fields, 2);
962 if (!keyword_type) return 0;
963 alias_type = make_type("alias", &AST_type, alias_fields, 2);
964 if (!alias_type) return 0;
965 initialized = 1;
966 return 1;
967 }
968
969 static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena);
970 static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena);
971 static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena);
972 static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena*
973 arena);
974 static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena);
975 static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena);
976 static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena);
977 static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena);
978 static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena);
979 static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena*
980 arena);
981 static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena*
982 arena);
983 static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena);
984 static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena);
985 static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena);
986
987 mod_ty
Module(asdl_seq * body,PyArena * arena)988 Module(asdl_seq * body, PyArena *arena)
989 {
990 mod_ty p;
991 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
992 if (!p)
993 return NULL;
994 p->kind = Module_kind;
995 p->v.Module.body = body;
996 return p;
997 }
998
999 mod_ty
Interactive(asdl_seq * body,PyArena * arena)1000 Interactive(asdl_seq * body, PyArena *arena)
1001 {
1002 mod_ty p;
1003 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
1004 if (!p)
1005 return NULL;
1006 p->kind = Interactive_kind;
1007 p->v.Interactive.body = body;
1008 return p;
1009 }
1010
1011 mod_ty
Expression(expr_ty body,PyArena * arena)1012 Expression(expr_ty body, PyArena *arena)
1013 {
1014 mod_ty p;
1015 if (!body) {
1016 PyErr_SetString(PyExc_ValueError,
1017 "field body is required for Expression");
1018 return NULL;
1019 }
1020 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
1021 if (!p)
1022 return NULL;
1023 p->kind = Expression_kind;
1024 p->v.Expression.body = body;
1025 return p;
1026 }
1027
1028 mod_ty
Suite(asdl_seq * body,PyArena * arena)1029 Suite(asdl_seq * body, PyArena *arena)
1030 {
1031 mod_ty p;
1032 p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
1033 if (!p)
1034 return NULL;
1035 p->kind = Suite_kind;
1036 p->v.Suite.body = body;
1037 return p;
1038 }
1039
1040 stmt_ty
FunctionDef(identifier name,arguments_ty args,asdl_seq * body,asdl_seq * decorator_list,int lineno,int col_offset,PyArena * arena)1041 FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
1042 decorator_list, int lineno, int col_offset, PyArena *arena)
1043 {
1044 stmt_ty p;
1045 if (!name) {
1046 PyErr_SetString(PyExc_ValueError,
1047 "field name is required for FunctionDef");
1048 return NULL;
1049 }
1050 if (!args) {
1051 PyErr_SetString(PyExc_ValueError,
1052 "field args is required for FunctionDef");
1053 return NULL;
1054 }
1055 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1056 if (!p)
1057 return NULL;
1058 p->kind = FunctionDef_kind;
1059 p->v.FunctionDef.name = name;
1060 p->v.FunctionDef.args = args;
1061 p->v.FunctionDef.body = body;
1062 p->v.FunctionDef.decorator_list = decorator_list;
1063 p->lineno = lineno;
1064 p->col_offset = col_offset;
1065 return p;
1066 }
1067
1068 stmt_ty
ClassDef(identifier name,asdl_seq * bases,asdl_seq * body,asdl_seq * decorator_list,int lineno,int col_offset,PyArena * arena)1069 ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, asdl_seq *
1070 decorator_list, int lineno, int col_offset, PyArena *arena)
1071 {
1072 stmt_ty p;
1073 if (!name) {
1074 PyErr_SetString(PyExc_ValueError,
1075 "field name is required for ClassDef");
1076 return NULL;
1077 }
1078 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1079 if (!p)
1080 return NULL;
1081 p->kind = ClassDef_kind;
1082 p->v.ClassDef.name = name;
1083 p->v.ClassDef.bases = bases;
1084 p->v.ClassDef.body = body;
1085 p->v.ClassDef.decorator_list = decorator_list;
1086 p->lineno = lineno;
1087 p->col_offset = col_offset;
1088 return p;
1089 }
1090
1091 stmt_ty
Return(expr_ty value,int lineno,int col_offset,PyArena * arena)1092 Return(expr_ty value, int lineno, int col_offset, PyArena *arena)
1093 {
1094 stmt_ty p;
1095 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1096 if (!p)
1097 return NULL;
1098 p->kind = Return_kind;
1099 p->v.Return.value = value;
1100 p->lineno = lineno;
1101 p->col_offset = col_offset;
1102 return p;
1103 }
1104
1105 stmt_ty
Delete(asdl_seq * targets,int lineno,int col_offset,PyArena * arena)1106 Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena)
1107 {
1108 stmt_ty p;
1109 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1110 if (!p)
1111 return NULL;
1112 p->kind = Delete_kind;
1113 p->v.Delete.targets = targets;
1114 p->lineno = lineno;
1115 p->col_offset = col_offset;
1116 return p;
1117 }
1118
1119 stmt_ty
Assign(asdl_seq * targets,expr_ty value,int lineno,int col_offset,PyArena * arena)1120 Assign(asdl_seq * targets, expr_ty value, int lineno, int col_offset, PyArena
1121 *arena)
1122 {
1123 stmt_ty p;
1124 if (!value) {
1125 PyErr_SetString(PyExc_ValueError,
1126 "field value is required for Assign");
1127 return NULL;
1128 }
1129 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1130 if (!p)
1131 return NULL;
1132 p->kind = Assign_kind;
1133 p->v.Assign.targets = targets;
1134 p->v.Assign.value = value;
1135 p->lineno = lineno;
1136 p->col_offset = col_offset;
1137 return p;
1138 }
1139
1140 stmt_ty
AugAssign(expr_ty target,operator_ty op,expr_ty value,int lineno,int col_offset,PyArena * arena)1141 AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
1142 col_offset, PyArena *arena)
1143 {
1144 stmt_ty p;
1145 if (!target) {
1146 PyErr_SetString(PyExc_ValueError,
1147 "field target is required for AugAssign");
1148 return NULL;
1149 }
1150 if (!op) {
1151 PyErr_SetString(PyExc_ValueError,
1152 "field op is required for AugAssign");
1153 return NULL;
1154 }
1155 if (!value) {
1156 PyErr_SetString(PyExc_ValueError,
1157 "field value is required for AugAssign");
1158 return NULL;
1159 }
1160 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1161 if (!p)
1162 return NULL;
1163 p->kind = AugAssign_kind;
1164 p->v.AugAssign.target = target;
1165 p->v.AugAssign.op = op;
1166 p->v.AugAssign.value = value;
1167 p->lineno = lineno;
1168 p->col_offset = col_offset;
1169 return p;
1170 }
1171
1172 stmt_ty
Print(expr_ty dest,asdl_seq * values,bool nl,int lineno,int col_offset,PyArena * arena)1173 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset,
1174 PyArena *arena)
1175 {
1176 stmt_ty p;
1177 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1178 if (!p)
1179 return NULL;
1180 p->kind = Print_kind;
1181 p->v.Print.dest = dest;
1182 p->v.Print.values = values;
1183 p->v.Print.nl = nl;
1184 p->lineno = lineno;
1185 p->col_offset = col_offset;
1186 return p;
1187 }
1188
1189 stmt_ty
For(expr_ty target,expr_ty iter,asdl_seq * body,asdl_seq * orelse,int lineno,int col_offset,PyArena * arena)1190 For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
1191 lineno, int col_offset, PyArena *arena)
1192 {
1193 stmt_ty p;
1194 if (!target) {
1195 PyErr_SetString(PyExc_ValueError,
1196 "field target is required for For");
1197 return NULL;
1198 }
1199 if (!iter) {
1200 PyErr_SetString(PyExc_ValueError,
1201 "field iter is required for For");
1202 return NULL;
1203 }
1204 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1205 if (!p)
1206 return NULL;
1207 p->kind = For_kind;
1208 p->v.For.target = target;
1209 p->v.For.iter = iter;
1210 p->v.For.body = body;
1211 p->v.For.orelse = orelse;
1212 p->lineno = lineno;
1213 p->col_offset = col_offset;
1214 return p;
1215 }
1216
1217 stmt_ty
While(expr_ty test,asdl_seq * body,asdl_seq * orelse,int lineno,int col_offset,PyArena * arena)1218 While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
1219 col_offset, PyArena *arena)
1220 {
1221 stmt_ty p;
1222 if (!test) {
1223 PyErr_SetString(PyExc_ValueError,
1224 "field test is required for While");
1225 return NULL;
1226 }
1227 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1228 if (!p)
1229 return NULL;
1230 p->kind = While_kind;
1231 p->v.While.test = test;
1232 p->v.While.body = body;
1233 p->v.While.orelse = orelse;
1234 p->lineno = lineno;
1235 p->col_offset = col_offset;
1236 return p;
1237 }
1238
1239 stmt_ty
If(expr_ty test,asdl_seq * body,asdl_seq * orelse,int lineno,int col_offset,PyArena * arena)1240 If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
1241 col_offset, PyArena *arena)
1242 {
1243 stmt_ty p;
1244 if (!test) {
1245 PyErr_SetString(PyExc_ValueError,
1246 "field test is required for If");
1247 return NULL;
1248 }
1249 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1250 if (!p)
1251 return NULL;
1252 p->kind = If_kind;
1253 p->v.If.test = test;
1254 p->v.If.body = body;
1255 p->v.If.orelse = orelse;
1256 p->lineno = lineno;
1257 p->col_offset = col_offset;
1258 return p;
1259 }
1260
1261 stmt_ty
With(expr_ty context_expr,expr_ty optional_vars,asdl_seq * body,int lineno,int col_offset,PyArena * arena)1262 With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body, int lineno,
1263 int col_offset, PyArena *arena)
1264 {
1265 stmt_ty p;
1266 if (!context_expr) {
1267 PyErr_SetString(PyExc_ValueError,
1268 "field context_expr is required for With");
1269 return NULL;
1270 }
1271 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1272 if (!p)
1273 return NULL;
1274 p->kind = With_kind;
1275 p->v.With.context_expr = context_expr;
1276 p->v.With.optional_vars = optional_vars;
1277 p->v.With.body = body;
1278 p->lineno = lineno;
1279 p->col_offset = col_offset;
1280 return p;
1281 }
1282
1283 stmt_ty
Raise(expr_ty type,expr_ty inst,expr_ty tback,int lineno,int col_offset,PyArena * arena)1284 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset,
1285 PyArena *arena)
1286 {
1287 stmt_ty p;
1288 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1289 if (!p)
1290 return NULL;
1291 p->kind = Raise_kind;
1292 p->v.Raise.type = type;
1293 p->v.Raise.inst = inst;
1294 p->v.Raise.tback = tback;
1295 p->lineno = lineno;
1296 p->col_offset = col_offset;
1297 return p;
1298 }
1299
1300 stmt_ty
TryExcept(asdl_seq * body,asdl_seq * handlers,asdl_seq * orelse,int lineno,int col_offset,PyArena * arena)1301 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno,
1302 int col_offset, PyArena *arena)
1303 {
1304 stmt_ty p;
1305 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1306 if (!p)
1307 return NULL;
1308 p->kind = TryExcept_kind;
1309 p->v.TryExcept.body = body;
1310 p->v.TryExcept.handlers = handlers;
1311 p->v.TryExcept.orelse = orelse;
1312 p->lineno = lineno;
1313 p->col_offset = col_offset;
1314 return p;
1315 }
1316
1317 stmt_ty
TryFinally(asdl_seq * body,asdl_seq * finalbody,int lineno,int col_offset,PyArena * arena)1318 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int col_offset,
1319 PyArena *arena)
1320 {
1321 stmt_ty p;
1322 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1323 if (!p)
1324 return NULL;
1325 p->kind = TryFinally_kind;
1326 p->v.TryFinally.body = body;
1327 p->v.TryFinally.finalbody = finalbody;
1328 p->lineno = lineno;
1329 p->col_offset = col_offset;
1330 return p;
1331 }
1332
1333 stmt_ty
Assert(expr_ty test,expr_ty msg,int lineno,int col_offset,PyArena * arena)1334 Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena)
1335 {
1336 stmt_ty p;
1337 if (!test) {
1338 PyErr_SetString(PyExc_ValueError,
1339 "field test is required for Assert");
1340 return NULL;
1341 }
1342 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1343 if (!p)
1344 return NULL;
1345 p->kind = Assert_kind;
1346 p->v.Assert.test = test;
1347 p->v.Assert.msg = msg;
1348 p->lineno = lineno;
1349 p->col_offset = col_offset;
1350 return p;
1351 }
1352
1353 stmt_ty
Import(asdl_seq * names,int lineno,int col_offset,PyArena * arena)1354 Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1355 {
1356 stmt_ty p;
1357 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1358 if (!p)
1359 return NULL;
1360 p->kind = Import_kind;
1361 p->v.Import.names = names;
1362 p->lineno = lineno;
1363 p->col_offset = col_offset;
1364 return p;
1365 }
1366
1367 stmt_ty
ImportFrom(identifier module,asdl_seq * names,int level,int lineno,int col_offset,PyArena * arena)1368 ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
1369 col_offset, PyArena *arena)
1370 {
1371 stmt_ty p;
1372 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1373 if (!p)
1374 return NULL;
1375 p->kind = ImportFrom_kind;
1376 p->v.ImportFrom.module = module;
1377 p->v.ImportFrom.names = names;
1378 p->v.ImportFrom.level = level;
1379 p->lineno = lineno;
1380 p->col_offset = col_offset;
1381 return p;
1382 }
1383
1384 stmt_ty
Exec(expr_ty body,expr_ty globals,expr_ty locals,int lineno,int col_offset,PyArena * arena)1385 Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int col_offset,
1386 PyArena *arena)
1387 {
1388 stmt_ty p;
1389 if (!body) {
1390 PyErr_SetString(PyExc_ValueError,
1391 "field body is required for Exec");
1392 return NULL;
1393 }
1394 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1395 if (!p)
1396 return NULL;
1397 p->kind = Exec_kind;
1398 p->v.Exec.body = body;
1399 p->v.Exec.globals = globals;
1400 p->v.Exec.locals = locals;
1401 p->lineno = lineno;
1402 p->col_offset = col_offset;
1403 return p;
1404 }
1405
1406 stmt_ty
Global(asdl_seq * names,int lineno,int col_offset,PyArena * arena)1407 Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1408 {
1409 stmt_ty p;
1410 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1411 if (!p)
1412 return NULL;
1413 p->kind = Global_kind;
1414 p->v.Global.names = names;
1415 p->lineno = lineno;
1416 p->col_offset = col_offset;
1417 return p;
1418 }
1419
1420 stmt_ty
Expr(expr_ty value,int lineno,int col_offset,PyArena * arena)1421 Expr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1422 {
1423 stmt_ty p;
1424 if (!value) {
1425 PyErr_SetString(PyExc_ValueError,
1426 "field value is required for Expr");
1427 return NULL;
1428 }
1429 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1430 if (!p)
1431 return NULL;
1432 p->kind = Expr_kind;
1433 p->v.Expr.value = value;
1434 p->lineno = lineno;
1435 p->col_offset = col_offset;
1436 return p;
1437 }
1438
1439 stmt_ty
Pass(int lineno,int col_offset,PyArena * arena)1440 Pass(int lineno, int col_offset, PyArena *arena)
1441 {
1442 stmt_ty p;
1443 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1444 if (!p)
1445 return NULL;
1446 p->kind = Pass_kind;
1447 p->lineno = lineno;
1448 p->col_offset = col_offset;
1449 return p;
1450 }
1451
1452 stmt_ty
Break(int lineno,int col_offset,PyArena * arena)1453 Break(int lineno, int col_offset, PyArena *arena)
1454 {
1455 stmt_ty p;
1456 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1457 if (!p)
1458 return NULL;
1459 p->kind = Break_kind;
1460 p->lineno = lineno;
1461 p->col_offset = col_offset;
1462 return p;
1463 }
1464
1465 stmt_ty
Continue(int lineno,int col_offset,PyArena * arena)1466 Continue(int lineno, int col_offset, PyArena *arena)
1467 {
1468 stmt_ty p;
1469 p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1470 if (!p)
1471 return NULL;
1472 p->kind = Continue_kind;
1473 p->lineno = lineno;
1474 p->col_offset = col_offset;
1475 return p;
1476 }
1477
1478 expr_ty
BoolOp(boolop_ty op,asdl_seq * values,int lineno,int col_offset,PyArena * arena)1479 BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena
1480 *arena)
1481 {
1482 expr_ty p;
1483 if (!op) {
1484 PyErr_SetString(PyExc_ValueError,
1485 "field op is required for BoolOp");
1486 return NULL;
1487 }
1488 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1489 if (!p)
1490 return NULL;
1491 p->kind = BoolOp_kind;
1492 p->v.BoolOp.op = op;
1493 p->v.BoolOp.values = values;
1494 p->lineno = lineno;
1495 p->col_offset = col_offset;
1496 return p;
1497 }
1498
1499 expr_ty
BinOp(expr_ty left,operator_ty op,expr_ty right,int lineno,int col_offset,PyArena * arena)1500 BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
1501 PyArena *arena)
1502 {
1503 expr_ty p;
1504 if (!left) {
1505 PyErr_SetString(PyExc_ValueError,
1506 "field left is required for BinOp");
1507 return NULL;
1508 }
1509 if (!op) {
1510 PyErr_SetString(PyExc_ValueError,
1511 "field op is required for BinOp");
1512 return NULL;
1513 }
1514 if (!right) {
1515 PyErr_SetString(PyExc_ValueError,
1516 "field right is required for BinOp");
1517 return NULL;
1518 }
1519 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1520 if (!p)
1521 return NULL;
1522 p->kind = BinOp_kind;
1523 p->v.BinOp.left = left;
1524 p->v.BinOp.op = op;
1525 p->v.BinOp.right = right;
1526 p->lineno = lineno;
1527 p->col_offset = col_offset;
1528 return p;
1529 }
1530
1531 expr_ty
UnaryOp(unaryop_ty op,expr_ty operand,int lineno,int col_offset,PyArena * arena)1532 UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena
1533 *arena)
1534 {
1535 expr_ty p;
1536 if (!op) {
1537 PyErr_SetString(PyExc_ValueError,
1538 "field op is required for UnaryOp");
1539 return NULL;
1540 }
1541 if (!operand) {
1542 PyErr_SetString(PyExc_ValueError,
1543 "field operand is required for UnaryOp");
1544 return NULL;
1545 }
1546 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1547 if (!p)
1548 return NULL;
1549 p->kind = UnaryOp_kind;
1550 p->v.UnaryOp.op = op;
1551 p->v.UnaryOp.operand = operand;
1552 p->lineno = lineno;
1553 p->col_offset = col_offset;
1554 return p;
1555 }
1556
1557 expr_ty
Lambda(arguments_ty args,expr_ty body,int lineno,int col_offset,PyArena * arena)1558 Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena
1559 *arena)
1560 {
1561 expr_ty p;
1562 if (!args) {
1563 PyErr_SetString(PyExc_ValueError,
1564 "field args is required for Lambda");
1565 return NULL;
1566 }
1567 if (!body) {
1568 PyErr_SetString(PyExc_ValueError,
1569 "field body is required for Lambda");
1570 return NULL;
1571 }
1572 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1573 if (!p)
1574 return NULL;
1575 p->kind = Lambda_kind;
1576 p->v.Lambda.args = args;
1577 p->v.Lambda.body = body;
1578 p->lineno = lineno;
1579 p->col_offset = col_offset;
1580 return p;
1581 }
1582
1583 expr_ty
IfExp(expr_ty test,expr_ty body,expr_ty orelse,int lineno,int col_offset,PyArena * arena)1584 IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
1585 PyArena *arena)
1586 {
1587 expr_ty p;
1588 if (!test) {
1589 PyErr_SetString(PyExc_ValueError,
1590 "field test is required for IfExp");
1591 return NULL;
1592 }
1593 if (!body) {
1594 PyErr_SetString(PyExc_ValueError,
1595 "field body is required for IfExp");
1596 return NULL;
1597 }
1598 if (!orelse) {
1599 PyErr_SetString(PyExc_ValueError,
1600 "field orelse is required for IfExp");
1601 return NULL;
1602 }
1603 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1604 if (!p)
1605 return NULL;
1606 p->kind = IfExp_kind;
1607 p->v.IfExp.test = test;
1608 p->v.IfExp.body = body;
1609 p->v.IfExp.orelse = orelse;
1610 p->lineno = lineno;
1611 p->col_offset = col_offset;
1612 return p;
1613 }
1614
1615 expr_ty
Dict(asdl_seq * keys,asdl_seq * values,int lineno,int col_offset,PyArena * arena)1616 Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena
1617 *arena)
1618 {
1619 expr_ty p;
1620 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1621 if (!p)
1622 return NULL;
1623 p->kind = Dict_kind;
1624 p->v.Dict.keys = keys;
1625 p->v.Dict.values = values;
1626 p->lineno = lineno;
1627 p->col_offset = col_offset;
1628 return p;
1629 }
1630
1631 expr_ty
Set(asdl_seq * elts,int lineno,int col_offset,PyArena * arena)1632 Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena)
1633 {
1634 expr_ty p;
1635 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1636 if (!p)
1637 return NULL;
1638 p->kind = Set_kind;
1639 p->v.Set.elts = elts;
1640 p->lineno = lineno;
1641 p->col_offset = col_offset;
1642 return p;
1643 }
1644
1645 expr_ty
ListComp(expr_ty elt,asdl_seq * generators,int lineno,int col_offset,PyArena * arena)1646 ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1647 PyArena *arena)
1648 {
1649 expr_ty p;
1650 if (!elt) {
1651 PyErr_SetString(PyExc_ValueError,
1652 "field elt is required for ListComp");
1653 return NULL;
1654 }
1655 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1656 if (!p)
1657 return NULL;
1658 p->kind = ListComp_kind;
1659 p->v.ListComp.elt = elt;
1660 p->v.ListComp.generators = generators;
1661 p->lineno = lineno;
1662 p->col_offset = col_offset;
1663 return p;
1664 }
1665
1666 expr_ty
SetComp(expr_ty elt,asdl_seq * generators,int lineno,int col_offset,PyArena * arena)1667 SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena
1668 *arena)
1669 {
1670 expr_ty p;
1671 if (!elt) {
1672 PyErr_SetString(PyExc_ValueError,
1673 "field elt is required for SetComp");
1674 return NULL;
1675 }
1676 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1677 if (!p)
1678 return NULL;
1679 p->kind = SetComp_kind;
1680 p->v.SetComp.elt = elt;
1681 p->v.SetComp.generators = generators;
1682 p->lineno = lineno;
1683 p->col_offset = col_offset;
1684 return p;
1685 }
1686
1687 expr_ty
DictComp(expr_ty key,expr_ty value,asdl_seq * generators,int lineno,int col_offset,PyArena * arena)1688 DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int
1689 col_offset, PyArena *arena)
1690 {
1691 expr_ty p;
1692 if (!key) {
1693 PyErr_SetString(PyExc_ValueError,
1694 "field key is required for DictComp");
1695 return NULL;
1696 }
1697 if (!value) {
1698 PyErr_SetString(PyExc_ValueError,
1699 "field value is required for DictComp");
1700 return NULL;
1701 }
1702 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1703 if (!p)
1704 return NULL;
1705 p->kind = DictComp_kind;
1706 p->v.DictComp.key = key;
1707 p->v.DictComp.value = value;
1708 p->v.DictComp.generators = generators;
1709 p->lineno = lineno;
1710 p->col_offset = col_offset;
1711 return p;
1712 }
1713
1714 expr_ty
GeneratorExp(expr_ty elt,asdl_seq * generators,int lineno,int col_offset,PyArena * arena)1715 GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1716 PyArena *arena)
1717 {
1718 expr_ty p;
1719 if (!elt) {
1720 PyErr_SetString(PyExc_ValueError,
1721 "field elt is required for GeneratorExp");
1722 return NULL;
1723 }
1724 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1725 if (!p)
1726 return NULL;
1727 p->kind = GeneratorExp_kind;
1728 p->v.GeneratorExp.elt = elt;
1729 p->v.GeneratorExp.generators = generators;
1730 p->lineno = lineno;
1731 p->col_offset = col_offset;
1732 return p;
1733 }
1734
1735 expr_ty
Yield(expr_ty value,int lineno,int col_offset,PyArena * arena)1736 Yield(expr_ty value, int lineno, int col_offset, PyArena *arena)
1737 {
1738 expr_ty p;
1739 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1740 if (!p)
1741 return NULL;
1742 p->kind = Yield_kind;
1743 p->v.Yield.value = value;
1744 p->lineno = lineno;
1745 p->col_offset = col_offset;
1746 return p;
1747 }
1748
1749 expr_ty
Compare(expr_ty left,asdl_int_seq * ops,asdl_seq * comparators,int lineno,int col_offset,PyArena * arena)1750 Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
1751 int col_offset, PyArena *arena)
1752 {
1753 expr_ty p;
1754 if (!left) {
1755 PyErr_SetString(PyExc_ValueError,
1756 "field left is required for Compare");
1757 return NULL;
1758 }
1759 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1760 if (!p)
1761 return NULL;
1762 p->kind = Compare_kind;
1763 p->v.Compare.left = left;
1764 p->v.Compare.ops = ops;
1765 p->v.Compare.comparators = comparators;
1766 p->lineno = lineno;
1767 p->col_offset = col_offset;
1768 return p;
1769 }
1770
1771 expr_ty
Call(expr_ty func,asdl_seq * args,asdl_seq * keywords,expr_ty starargs,expr_ty kwargs,int lineno,int col_offset,PyArena * arena)1772 Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
1773 expr_ty kwargs, int lineno, int col_offset, PyArena *arena)
1774 {
1775 expr_ty p;
1776 if (!func) {
1777 PyErr_SetString(PyExc_ValueError,
1778 "field func is required for Call");
1779 return NULL;
1780 }
1781 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1782 if (!p)
1783 return NULL;
1784 p->kind = Call_kind;
1785 p->v.Call.func = func;
1786 p->v.Call.args = args;
1787 p->v.Call.keywords = keywords;
1788 p->v.Call.starargs = starargs;
1789 p->v.Call.kwargs = kwargs;
1790 p->lineno = lineno;
1791 p->col_offset = col_offset;
1792 return p;
1793 }
1794
1795 expr_ty
Repr(expr_ty value,int lineno,int col_offset,PyArena * arena)1796 Repr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1797 {
1798 expr_ty p;
1799 if (!value) {
1800 PyErr_SetString(PyExc_ValueError,
1801 "field value is required for Repr");
1802 return NULL;
1803 }
1804 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1805 if (!p)
1806 return NULL;
1807 p->kind = Repr_kind;
1808 p->v.Repr.value = value;
1809 p->lineno = lineno;
1810 p->col_offset = col_offset;
1811 return p;
1812 }
1813
1814 expr_ty
Num(object n,int lineno,int col_offset,PyArena * arena)1815 Num(object n, int lineno, int col_offset, PyArena *arena)
1816 {
1817 expr_ty p;
1818 if (!n) {
1819 PyErr_SetString(PyExc_ValueError,
1820 "field n is required for Num");
1821 return NULL;
1822 }
1823 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1824 if (!p)
1825 return NULL;
1826 p->kind = Num_kind;
1827 p->v.Num.n = n;
1828 p->lineno = lineno;
1829 p->col_offset = col_offset;
1830 return p;
1831 }
1832
1833 expr_ty
Str(string s,int lineno,int col_offset,PyArena * arena)1834 Str(string s, int lineno, int col_offset, PyArena *arena)
1835 {
1836 expr_ty p;
1837 if (!s) {
1838 PyErr_SetString(PyExc_ValueError,
1839 "field s is required for Str");
1840 return NULL;
1841 }
1842 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1843 if (!p)
1844 return NULL;
1845 p->kind = Str_kind;
1846 p->v.Str.s = s;
1847 p->lineno = lineno;
1848 p->col_offset = col_offset;
1849 return p;
1850 }
1851
1852 expr_ty
Attribute(expr_ty value,identifier attr,expr_context_ty ctx,int lineno,int col_offset,PyArena * arena)1853 Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
1854 col_offset, PyArena *arena)
1855 {
1856 expr_ty p;
1857 if (!value) {
1858 PyErr_SetString(PyExc_ValueError,
1859 "field value is required for Attribute");
1860 return NULL;
1861 }
1862 if (!attr) {
1863 PyErr_SetString(PyExc_ValueError,
1864 "field attr is required for Attribute");
1865 return NULL;
1866 }
1867 if (!ctx) {
1868 PyErr_SetString(PyExc_ValueError,
1869 "field ctx is required for Attribute");
1870 return NULL;
1871 }
1872 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1873 if (!p)
1874 return NULL;
1875 p->kind = Attribute_kind;
1876 p->v.Attribute.value = value;
1877 p->v.Attribute.attr = attr;
1878 p->v.Attribute.ctx = ctx;
1879 p->lineno = lineno;
1880 p->col_offset = col_offset;
1881 return p;
1882 }
1883
1884 expr_ty
Subscript(expr_ty value,slice_ty slice,expr_context_ty ctx,int lineno,int col_offset,PyArena * arena)1885 Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int
1886 col_offset, PyArena *arena)
1887 {
1888 expr_ty p;
1889 if (!value) {
1890 PyErr_SetString(PyExc_ValueError,
1891 "field value is required for Subscript");
1892 return NULL;
1893 }
1894 if (!slice) {
1895 PyErr_SetString(PyExc_ValueError,
1896 "field slice is required for Subscript");
1897 return NULL;
1898 }
1899 if (!ctx) {
1900 PyErr_SetString(PyExc_ValueError,
1901 "field ctx is required for Subscript");
1902 return NULL;
1903 }
1904 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1905 if (!p)
1906 return NULL;
1907 p->kind = Subscript_kind;
1908 p->v.Subscript.value = value;
1909 p->v.Subscript.slice = slice;
1910 p->v.Subscript.ctx = ctx;
1911 p->lineno = lineno;
1912 p->col_offset = col_offset;
1913 return p;
1914 }
1915
1916 expr_ty
Name(identifier id,expr_context_ty ctx,int lineno,int col_offset,PyArena * arena)1917 Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena
1918 *arena)
1919 {
1920 expr_ty p;
1921 if (!id) {
1922 PyErr_SetString(PyExc_ValueError,
1923 "field id is required for Name");
1924 return NULL;
1925 }
1926 if (!ctx) {
1927 PyErr_SetString(PyExc_ValueError,
1928 "field ctx is required for Name");
1929 return NULL;
1930 }
1931 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1932 if (!p)
1933 return NULL;
1934 p->kind = Name_kind;
1935 p->v.Name.id = id;
1936 p->v.Name.ctx = ctx;
1937 p->lineno = lineno;
1938 p->col_offset = col_offset;
1939 return p;
1940 }
1941
1942 expr_ty
List(asdl_seq * elts,expr_context_ty ctx,int lineno,int col_offset,PyArena * arena)1943 List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1944 *arena)
1945 {
1946 expr_ty p;
1947 if (!ctx) {
1948 PyErr_SetString(PyExc_ValueError,
1949 "field ctx is required for List");
1950 return NULL;
1951 }
1952 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1953 if (!p)
1954 return NULL;
1955 p->kind = List_kind;
1956 p->v.List.elts = elts;
1957 p->v.List.ctx = ctx;
1958 p->lineno = lineno;
1959 p->col_offset = col_offset;
1960 return p;
1961 }
1962
1963 expr_ty
Tuple(asdl_seq * elts,expr_context_ty ctx,int lineno,int col_offset,PyArena * arena)1964 Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1965 *arena)
1966 {
1967 expr_ty p;
1968 if (!ctx) {
1969 PyErr_SetString(PyExc_ValueError,
1970 "field ctx is required for Tuple");
1971 return NULL;
1972 }
1973 p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1974 if (!p)
1975 return NULL;
1976 p->kind = Tuple_kind;
1977 p->v.Tuple.elts = elts;
1978 p->v.Tuple.ctx = ctx;
1979 p->lineno = lineno;
1980 p->col_offset = col_offset;
1981 return p;
1982 }
1983
1984 slice_ty
Ellipsis(PyArena * arena)1985 Ellipsis(PyArena *arena)
1986 {
1987 slice_ty p;
1988 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1989 if (!p)
1990 return NULL;
1991 p->kind = Ellipsis_kind;
1992 return p;
1993 }
1994
1995 slice_ty
Slice(expr_ty lower,expr_ty upper,expr_ty step,PyArena * arena)1996 Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
1997 {
1998 slice_ty p;
1999 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
2000 if (!p)
2001 return NULL;
2002 p->kind = Slice_kind;
2003 p->v.Slice.lower = lower;
2004 p->v.Slice.upper = upper;
2005 p->v.Slice.step = step;
2006 return p;
2007 }
2008
2009 slice_ty
ExtSlice(asdl_seq * dims,PyArena * arena)2010 ExtSlice(asdl_seq * dims, PyArena *arena)
2011 {
2012 slice_ty p;
2013 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
2014 if (!p)
2015 return NULL;
2016 p->kind = ExtSlice_kind;
2017 p->v.ExtSlice.dims = dims;
2018 return p;
2019 }
2020
2021 slice_ty
Index(expr_ty value,PyArena * arena)2022 Index(expr_ty value, PyArena *arena)
2023 {
2024 slice_ty p;
2025 if (!value) {
2026 PyErr_SetString(PyExc_ValueError,
2027 "field value is required for Index");
2028 return NULL;
2029 }
2030 p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
2031 if (!p)
2032 return NULL;
2033 p->kind = Index_kind;
2034 p->v.Index.value = value;
2035 return p;
2036 }
2037
2038 comprehension_ty
comprehension(expr_ty target,expr_ty iter,asdl_seq * ifs,PyArena * arena)2039 comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena)
2040 {
2041 comprehension_ty p;
2042 if (!target) {
2043 PyErr_SetString(PyExc_ValueError,
2044 "field target is required for comprehension");
2045 return NULL;
2046 }
2047 if (!iter) {
2048 PyErr_SetString(PyExc_ValueError,
2049 "field iter is required for comprehension");
2050 return NULL;
2051 }
2052 p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
2053 if (!p)
2054 return NULL;
2055 p->target = target;
2056 p->iter = iter;
2057 p->ifs = ifs;
2058 return p;
2059 }
2060
2061 excepthandler_ty
ExceptHandler(expr_ty type,expr_ty name,asdl_seq * body,int lineno,int col_offset,PyArena * arena)2062 ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int
2063 col_offset, PyArena *arena)
2064 {
2065 excepthandler_ty p;
2066 p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
2067 if (!p)
2068 return NULL;
2069 p->kind = ExceptHandler_kind;
2070 p->v.ExceptHandler.type = type;
2071 p->v.ExceptHandler.name = name;
2072 p->v.ExceptHandler.body = body;
2073 p->lineno = lineno;
2074 p->col_offset = col_offset;
2075 return p;
2076 }
2077
2078 arguments_ty
arguments(asdl_seq * args,identifier vararg,identifier kwarg,asdl_seq * defaults,PyArena * arena)2079 arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
2080 defaults, PyArena *arena)
2081 {
2082 arguments_ty p;
2083 p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
2084 if (!p)
2085 return NULL;
2086 p->args = args;
2087 p->vararg = vararg;
2088 p->kwarg = kwarg;
2089 p->defaults = defaults;
2090 return p;
2091 }
2092
2093 keyword_ty
keyword(identifier arg,expr_ty value,PyArena * arena)2094 keyword(identifier arg, expr_ty value, PyArena *arena)
2095 {
2096 keyword_ty p;
2097 if (!arg) {
2098 PyErr_SetString(PyExc_ValueError,
2099 "field arg is required for keyword");
2100 return NULL;
2101 }
2102 if (!value) {
2103 PyErr_SetString(PyExc_ValueError,
2104 "field value is required for keyword");
2105 return NULL;
2106 }
2107 p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
2108 if (!p)
2109 return NULL;
2110 p->arg = arg;
2111 p->value = value;
2112 return p;
2113 }
2114
2115 alias_ty
alias(identifier name,identifier asname,PyArena * arena)2116 alias(identifier name, identifier asname, PyArena *arena)
2117 {
2118 alias_ty p;
2119 if (!name) {
2120 PyErr_SetString(PyExc_ValueError,
2121 "field name is required for alias");
2122 return NULL;
2123 }
2124 p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
2125 if (!p)
2126 return NULL;
2127 p->name = name;
2128 p->asname = asname;
2129 return p;
2130 }
2131
2132
2133 PyObject*
ast2obj_mod(void * _o)2134 ast2obj_mod(void* _o)
2135 {
2136 mod_ty o = (mod_ty)_o;
2137 PyObject *result = NULL, *value = NULL;
2138 if (!o) {
2139 Py_INCREF(Py_None);
2140 return Py_None;
2141 }
2142
2143 switch (o->kind) {
2144 case Module_kind:
2145 result = PyType_GenericNew(Module_type, NULL, NULL);
2146 if (!result) goto failed;
2147 value = ast2obj_list(o->v.Module.body, ast2obj_stmt);
2148 if (!value) goto failed;
2149 if (PyObject_SetAttrString(result, "body", value) == -1)
2150 goto failed;
2151 Py_DECREF(value);
2152 break;
2153 case Interactive_kind:
2154 result = PyType_GenericNew(Interactive_type, NULL, NULL);
2155 if (!result) goto failed;
2156 value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt);
2157 if (!value) goto failed;
2158 if (PyObject_SetAttrString(result, "body", value) == -1)
2159 goto failed;
2160 Py_DECREF(value);
2161 break;
2162 case Expression_kind:
2163 result = PyType_GenericNew(Expression_type, NULL, NULL);
2164 if (!result) goto failed;
2165 value = ast2obj_expr(o->v.Expression.body);
2166 if (!value) goto failed;
2167 if (PyObject_SetAttrString(result, "body", value) == -1)
2168 goto failed;
2169 Py_DECREF(value);
2170 break;
2171 case Suite_kind:
2172 result = PyType_GenericNew(Suite_type, NULL, NULL);
2173 if (!result) goto failed;
2174 value = ast2obj_list(o->v.Suite.body, ast2obj_stmt);
2175 if (!value) goto failed;
2176 if (PyObject_SetAttrString(result, "body", value) == -1)
2177 goto failed;
2178 Py_DECREF(value);
2179 break;
2180 }
2181 return result;
2182 failed:
2183 Py_XDECREF(value);
2184 Py_XDECREF(result);
2185 return NULL;
2186 }
2187
2188 PyObject*
ast2obj_stmt(void * _o)2189 ast2obj_stmt(void* _o)
2190 {
2191 stmt_ty o = (stmt_ty)_o;
2192 PyObject *result = NULL, *value = NULL;
2193 if (!o) {
2194 Py_INCREF(Py_None);
2195 return Py_None;
2196 }
2197
2198 switch (o->kind) {
2199 case FunctionDef_kind:
2200 result = PyType_GenericNew(FunctionDef_type, NULL, NULL);
2201 if (!result) goto failed;
2202 value = ast2obj_identifier(o->v.FunctionDef.name);
2203 if (!value) goto failed;
2204 if (PyObject_SetAttrString(result, "name", value) == -1)
2205 goto failed;
2206 Py_DECREF(value);
2207 value = ast2obj_arguments(o->v.FunctionDef.args);
2208 if (!value) goto failed;
2209 if (PyObject_SetAttrString(result, "args", value) == -1)
2210 goto failed;
2211 Py_DECREF(value);
2212 value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt);
2213 if (!value) goto failed;
2214 if (PyObject_SetAttrString(result, "body", value) == -1)
2215 goto failed;
2216 Py_DECREF(value);
2217 value = ast2obj_list(o->v.FunctionDef.decorator_list,
2218 ast2obj_expr);
2219 if (!value) goto failed;
2220 if (PyObject_SetAttrString(result, "decorator_list", value) ==
2221 -1)
2222 goto failed;
2223 Py_DECREF(value);
2224 break;
2225 case ClassDef_kind:
2226 result = PyType_GenericNew(ClassDef_type, NULL, NULL);
2227 if (!result) goto failed;
2228 value = ast2obj_identifier(o->v.ClassDef.name);
2229 if (!value) goto failed;
2230 if (PyObject_SetAttrString(result, "name", value) == -1)
2231 goto failed;
2232 Py_DECREF(value);
2233 value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr);
2234 if (!value) goto failed;
2235 if (PyObject_SetAttrString(result, "bases", value) == -1)
2236 goto failed;
2237 Py_DECREF(value);
2238 value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt);
2239 if (!value) goto failed;
2240 if (PyObject_SetAttrString(result, "body", value) == -1)
2241 goto failed;
2242 Py_DECREF(value);
2243 value = ast2obj_list(o->v.ClassDef.decorator_list,
2244 ast2obj_expr);
2245 if (!value) goto failed;
2246 if (PyObject_SetAttrString(result, "decorator_list", value) ==
2247 -1)
2248 goto failed;
2249 Py_DECREF(value);
2250 break;
2251 case Return_kind:
2252 result = PyType_GenericNew(Return_type, NULL, NULL);
2253 if (!result) goto failed;
2254 value = ast2obj_expr(o->v.Return.value);
2255 if (!value) goto failed;
2256 if (PyObject_SetAttrString(result, "value", value) == -1)
2257 goto failed;
2258 Py_DECREF(value);
2259 break;
2260 case Delete_kind:
2261 result = PyType_GenericNew(Delete_type, NULL, NULL);
2262 if (!result) goto failed;
2263 value = ast2obj_list(o->v.Delete.targets, ast2obj_expr);
2264 if (!value) goto failed;
2265 if (PyObject_SetAttrString(result, "targets", value) == -1)
2266 goto failed;
2267 Py_DECREF(value);
2268 break;
2269 case Assign_kind:
2270 result = PyType_GenericNew(Assign_type, NULL, NULL);
2271 if (!result) goto failed;
2272 value = ast2obj_list(o->v.Assign.targets, ast2obj_expr);
2273 if (!value) goto failed;
2274 if (PyObject_SetAttrString(result, "targets", value) == -1)
2275 goto failed;
2276 Py_DECREF(value);
2277 value = ast2obj_expr(o->v.Assign.value);
2278 if (!value) goto failed;
2279 if (PyObject_SetAttrString(result, "value", value) == -1)
2280 goto failed;
2281 Py_DECREF(value);
2282 break;
2283 case AugAssign_kind:
2284 result = PyType_GenericNew(AugAssign_type, NULL, NULL);
2285 if (!result) goto failed;
2286 value = ast2obj_expr(o->v.AugAssign.target);
2287 if (!value) goto failed;
2288 if (PyObject_SetAttrString(result, "target", value) == -1)
2289 goto failed;
2290 Py_DECREF(value);
2291 value = ast2obj_operator(o->v.AugAssign.op);
2292 if (!value) goto failed;
2293 if (PyObject_SetAttrString(result, "op", value) == -1)
2294 goto failed;
2295 Py_DECREF(value);
2296 value = ast2obj_expr(o->v.AugAssign.value);
2297 if (!value) goto failed;
2298 if (PyObject_SetAttrString(result, "value", value) == -1)
2299 goto failed;
2300 Py_DECREF(value);
2301 break;
2302 case Print_kind:
2303 result = PyType_GenericNew(Print_type, NULL, NULL);
2304 if (!result) goto failed;
2305 value = ast2obj_expr(o->v.Print.dest);
2306 if (!value) goto failed;
2307 if (PyObject_SetAttrString(result, "dest", value) == -1)
2308 goto failed;
2309 Py_DECREF(value);
2310 value = ast2obj_list(o->v.Print.values, ast2obj_expr);
2311 if (!value) goto failed;
2312 if (PyObject_SetAttrString(result, "values", value) == -1)
2313 goto failed;
2314 Py_DECREF(value);
2315 value = ast2obj_bool(o->v.Print.nl);
2316 if (!value) goto failed;
2317 if (PyObject_SetAttrString(result, "nl", value) == -1)
2318 goto failed;
2319 Py_DECREF(value);
2320 break;
2321 case For_kind:
2322 result = PyType_GenericNew(For_type, NULL, NULL);
2323 if (!result) goto failed;
2324 value = ast2obj_expr(o->v.For.target);
2325 if (!value) goto failed;
2326 if (PyObject_SetAttrString(result, "target", value) == -1)
2327 goto failed;
2328 Py_DECREF(value);
2329 value = ast2obj_expr(o->v.For.iter);
2330 if (!value) goto failed;
2331 if (PyObject_SetAttrString(result, "iter", value) == -1)
2332 goto failed;
2333 Py_DECREF(value);
2334 value = ast2obj_list(o->v.For.body, ast2obj_stmt);
2335 if (!value) goto failed;
2336 if (PyObject_SetAttrString(result, "body", value) == -1)
2337 goto failed;
2338 Py_DECREF(value);
2339 value = ast2obj_list(o->v.For.orelse, ast2obj_stmt);
2340 if (!value) goto failed;
2341 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2342 goto failed;
2343 Py_DECREF(value);
2344 break;
2345 case While_kind:
2346 result = PyType_GenericNew(While_type, NULL, NULL);
2347 if (!result) goto failed;
2348 value = ast2obj_expr(o->v.While.test);
2349 if (!value) goto failed;
2350 if (PyObject_SetAttrString(result, "test", value) == -1)
2351 goto failed;
2352 Py_DECREF(value);
2353 value = ast2obj_list(o->v.While.body, ast2obj_stmt);
2354 if (!value) goto failed;
2355 if (PyObject_SetAttrString(result, "body", value) == -1)
2356 goto failed;
2357 Py_DECREF(value);
2358 value = ast2obj_list(o->v.While.orelse, ast2obj_stmt);
2359 if (!value) goto failed;
2360 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2361 goto failed;
2362 Py_DECREF(value);
2363 break;
2364 case If_kind:
2365 result = PyType_GenericNew(If_type, NULL, NULL);
2366 if (!result) goto failed;
2367 value = ast2obj_expr(o->v.If.test);
2368 if (!value) goto failed;
2369 if (PyObject_SetAttrString(result, "test", value) == -1)
2370 goto failed;
2371 Py_DECREF(value);
2372 value = ast2obj_list(o->v.If.body, ast2obj_stmt);
2373 if (!value) goto failed;
2374 if (PyObject_SetAttrString(result, "body", value) == -1)
2375 goto failed;
2376 Py_DECREF(value);
2377 value = ast2obj_list(o->v.If.orelse, ast2obj_stmt);
2378 if (!value) goto failed;
2379 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2380 goto failed;
2381 Py_DECREF(value);
2382 break;
2383 case With_kind:
2384 result = PyType_GenericNew(With_type, NULL, NULL);
2385 if (!result) goto failed;
2386 value = ast2obj_expr(o->v.With.context_expr);
2387 if (!value) goto failed;
2388 if (PyObject_SetAttrString(result, "context_expr", value) == -1)
2389 goto failed;
2390 Py_DECREF(value);
2391 value = ast2obj_expr(o->v.With.optional_vars);
2392 if (!value) goto failed;
2393 if (PyObject_SetAttrString(result, "optional_vars", value) ==
2394 -1)
2395 goto failed;
2396 Py_DECREF(value);
2397 value = ast2obj_list(o->v.With.body, ast2obj_stmt);
2398 if (!value) goto failed;
2399 if (PyObject_SetAttrString(result, "body", value) == -1)
2400 goto failed;
2401 Py_DECREF(value);
2402 break;
2403 case Raise_kind:
2404 result = PyType_GenericNew(Raise_type, NULL, NULL);
2405 if (!result) goto failed;
2406 value = ast2obj_expr(o->v.Raise.type);
2407 if (!value) goto failed;
2408 if (PyObject_SetAttrString(result, "type", value) == -1)
2409 goto failed;
2410 Py_DECREF(value);
2411 value = ast2obj_expr(o->v.Raise.inst);
2412 if (!value) goto failed;
2413 if (PyObject_SetAttrString(result, "inst", value) == -1)
2414 goto failed;
2415 Py_DECREF(value);
2416 value = ast2obj_expr(o->v.Raise.tback);
2417 if (!value) goto failed;
2418 if (PyObject_SetAttrString(result, "tback", value) == -1)
2419 goto failed;
2420 Py_DECREF(value);
2421 break;
2422 case TryExcept_kind:
2423 result = PyType_GenericNew(TryExcept_type, NULL, NULL);
2424 if (!result) goto failed;
2425 value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt);
2426 if (!value) goto failed;
2427 if (PyObject_SetAttrString(result, "body", value) == -1)
2428 goto failed;
2429 Py_DECREF(value);
2430 value = ast2obj_list(o->v.TryExcept.handlers,
2431 ast2obj_excepthandler);
2432 if (!value) goto failed;
2433 if (PyObject_SetAttrString(result, "handlers", value) == -1)
2434 goto failed;
2435 Py_DECREF(value);
2436 value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt);
2437 if (!value) goto failed;
2438 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2439 goto failed;
2440 Py_DECREF(value);
2441 break;
2442 case TryFinally_kind:
2443 result = PyType_GenericNew(TryFinally_type, NULL, NULL);
2444 if (!result) goto failed;
2445 value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt);
2446 if (!value) goto failed;
2447 if (PyObject_SetAttrString(result, "body", value) == -1)
2448 goto failed;
2449 Py_DECREF(value);
2450 value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt);
2451 if (!value) goto failed;
2452 if (PyObject_SetAttrString(result, "finalbody", value) == -1)
2453 goto failed;
2454 Py_DECREF(value);
2455 break;
2456 case Assert_kind:
2457 result = PyType_GenericNew(Assert_type, NULL, NULL);
2458 if (!result) goto failed;
2459 value = ast2obj_expr(o->v.Assert.test);
2460 if (!value) goto failed;
2461 if (PyObject_SetAttrString(result, "test", value) == -1)
2462 goto failed;
2463 Py_DECREF(value);
2464 value = ast2obj_expr(o->v.Assert.msg);
2465 if (!value) goto failed;
2466 if (PyObject_SetAttrString(result, "msg", value) == -1)
2467 goto failed;
2468 Py_DECREF(value);
2469 break;
2470 case Import_kind:
2471 result = PyType_GenericNew(Import_type, NULL, NULL);
2472 if (!result) goto failed;
2473 value = ast2obj_list(o->v.Import.names, ast2obj_alias);
2474 if (!value) goto failed;
2475 if (PyObject_SetAttrString(result, "names", value) == -1)
2476 goto failed;
2477 Py_DECREF(value);
2478 break;
2479 case ImportFrom_kind:
2480 result = PyType_GenericNew(ImportFrom_type, NULL, NULL);
2481 if (!result) goto failed;
2482 value = ast2obj_identifier(o->v.ImportFrom.module);
2483 if (!value) goto failed;
2484 if (PyObject_SetAttrString(result, "module", value) == -1)
2485 goto failed;
2486 Py_DECREF(value);
2487 value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias);
2488 if (!value) goto failed;
2489 if (PyObject_SetAttrString(result, "names", value) == -1)
2490 goto failed;
2491 Py_DECREF(value);
2492 value = ast2obj_int(o->v.ImportFrom.level);
2493 if (!value) goto failed;
2494 if (PyObject_SetAttrString(result, "level", value) == -1)
2495 goto failed;
2496 Py_DECREF(value);
2497 break;
2498 case Exec_kind:
2499 result = PyType_GenericNew(Exec_type, NULL, NULL);
2500 if (!result) goto failed;
2501 value = ast2obj_expr(o->v.Exec.body);
2502 if (!value) goto failed;
2503 if (PyObject_SetAttrString(result, "body", value) == -1)
2504 goto failed;
2505 Py_DECREF(value);
2506 value = ast2obj_expr(o->v.Exec.globals);
2507 if (!value) goto failed;
2508 if (PyObject_SetAttrString(result, "globals", value) == -1)
2509 goto failed;
2510 Py_DECREF(value);
2511 value = ast2obj_expr(o->v.Exec.locals);
2512 if (!value) goto failed;
2513 if (PyObject_SetAttrString(result, "locals", value) == -1)
2514 goto failed;
2515 Py_DECREF(value);
2516 break;
2517 case Global_kind:
2518 result = PyType_GenericNew(Global_type, NULL, NULL);
2519 if (!result) goto failed;
2520 value = ast2obj_list(o->v.Global.names, ast2obj_identifier);
2521 if (!value) goto failed;
2522 if (PyObject_SetAttrString(result, "names", value) == -1)
2523 goto failed;
2524 Py_DECREF(value);
2525 break;
2526 case Expr_kind:
2527 result = PyType_GenericNew(Expr_type, NULL, NULL);
2528 if (!result) goto failed;
2529 value = ast2obj_expr(o->v.Expr.value);
2530 if (!value) goto failed;
2531 if (PyObject_SetAttrString(result, "value", value) == -1)
2532 goto failed;
2533 Py_DECREF(value);
2534 break;
2535 case Pass_kind:
2536 result = PyType_GenericNew(Pass_type, NULL, NULL);
2537 if (!result) goto failed;
2538 break;
2539 case Break_kind:
2540 result = PyType_GenericNew(Break_type, NULL, NULL);
2541 if (!result) goto failed;
2542 break;
2543 case Continue_kind:
2544 result = PyType_GenericNew(Continue_type, NULL, NULL);
2545 if (!result) goto failed;
2546 break;
2547 }
2548 value = ast2obj_int(o->lineno);
2549 if (!value) goto failed;
2550 if (PyObject_SetAttrString(result, "lineno", value) < 0)
2551 goto failed;
2552 Py_DECREF(value);
2553 value = ast2obj_int(o->col_offset);
2554 if (!value) goto failed;
2555 if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2556 goto failed;
2557 Py_DECREF(value);
2558 return result;
2559 failed:
2560 Py_XDECREF(value);
2561 Py_XDECREF(result);
2562 return NULL;
2563 }
2564
2565 PyObject*
ast2obj_expr(void * _o)2566 ast2obj_expr(void* _o)
2567 {
2568 expr_ty o = (expr_ty)_o;
2569 PyObject *result = NULL, *value = NULL;
2570 if (!o) {
2571 Py_INCREF(Py_None);
2572 return Py_None;
2573 }
2574
2575 switch (o->kind) {
2576 case BoolOp_kind:
2577 result = PyType_GenericNew(BoolOp_type, NULL, NULL);
2578 if (!result) goto failed;
2579 value = ast2obj_boolop(o->v.BoolOp.op);
2580 if (!value) goto failed;
2581 if (PyObject_SetAttrString(result, "op", value) == -1)
2582 goto failed;
2583 Py_DECREF(value);
2584 value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr);
2585 if (!value) goto failed;
2586 if (PyObject_SetAttrString(result, "values", value) == -1)
2587 goto failed;
2588 Py_DECREF(value);
2589 break;
2590 case BinOp_kind:
2591 result = PyType_GenericNew(BinOp_type, NULL, NULL);
2592 if (!result) goto failed;
2593 value = ast2obj_expr(o->v.BinOp.left);
2594 if (!value) goto failed;
2595 if (PyObject_SetAttrString(result, "left", value) == -1)
2596 goto failed;
2597 Py_DECREF(value);
2598 value = ast2obj_operator(o->v.BinOp.op);
2599 if (!value) goto failed;
2600 if (PyObject_SetAttrString(result, "op", value) == -1)
2601 goto failed;
2602 Py_DECREF(value);
2603 value = ast2obj_expr(o->v.BinOp.right);
2604 if (!value) goto failed;
2605 if (PyObject_SetAttrString(result, "right", value) == -1)
2606 goto failed;
2607 Py_DECREF(value);
2608 break;
2609 case UnaryOp_kind:
2610 result = PyType_GenericNew(UnaryOp_type, NULL, NULL);
2611 if (!result) goto failed;
2612 value = ast2obj_unaryop(o->v.UnaryOp.op);
2613 if (!value) goto failed;
2614 if (PyObject_SetAttrString(result, "op", value) == -1)
2615 goto failed;
2616 Py_DECREF(value);
2617 value = ast2obj_expr(o->v.UnaryOp.operand);
2618 if (!value) goto failed;
2619 if (PyObject_SetAttrString(result, "operand", value) == -1)
2620 goto failed;
2621 Py_DECREF(value);
2622 break;
2623 case Lambda_kind:
2624 result = PyType_GenericNew(Lambda_type, NULL, NULL);
2625 if (!result) goto failed;
2626 value = ast2obj_arguments(o->v.Lambda.args);
2627 if (!value) goto failed;
2628 if (PyObject_SetAttrString(result, "args", value) == -1)
2629 goto failed;
2630 Py_DECREF(value);
2631 value = ast2obj_expr(o->v.Lambda.body);
2632 if (!value) goto failed;
2633 if (PyObject_SetAttrString(result, "body", value) == -1)
2634 goto failed;
2635 Py_DECREF(value);
2636 break;
2637 case IfExp_kind:
2638 result = PyType_GenericNew(IfExp_type, NULL, NULL);
2639 if (!result) goto failed;
2640 value = ast2obj_expr(o->v.IfExp.test);
2641 if (!value) goto failed;
2642 if (PyObject_SetAttrString(result, "test", value) == -1)
2643 goto failed;
2644 Py_DECREF(value);
2645 value = ast2obj_expr(o->v.IfExp.body);
2646 if (!value) goto failed;
2647 if (PyObject_SetAttrString(result, "body", value) == -1)
2648 goto failed;
2649 Py_DECREF(value);
2650 value = ast2obj_expr(o->v.IfExp.orelse);
2651 if (!value) goto failed;
2652 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2653 goto failed;
2654 Py_DECREF(value);
2655 break;
2656 case Dict_kind:
2657 result = PyType_GenericNew(Dict_type, NULL, NULL);
2658 if (!result) goto failed;
2659 value = ast2obj_list(o->v.Dict.keys, ast2obj_expr);
2660 if (!value) goto failed;
2661 if (PyObject_SetAttrString(result, "keys", value) == -1)
2662 goto failed;
2663 Py_DECREF(value);
2664 value = ast2obj_list(o->v.Dict.values, ast2obj_expr);
2665 if (!value) goto failed;
2666 if (PyObject_SetAttrString(result, "values", value) == -1)
2667 goto failed;
2668 Py_DECREF(value);
2669 break;
2670 case Set_kind:
2671 result = PyType_GenericNew(Set_type, NULL, NULL);
2672 if (!result) goto failed;
2673 value = ast2obj_list(o->v.Set.elts, ast2obj_expr);
2674 if (!value) goto failed;
2675 if (PyObject_SetAttrString(result, "elts", value) == -1)
2676 goto failed;
2677 Py_DECREF(value);
2678 break;
2679 case ListComp_kind:
2680 result = PyType_GenericNew(ListComp_type, NULL, NULL);
2681 if (!result) goto failed;
2682 value = ast2obj_expr(o->v.ListComp.elt);
2683 if (!value) goto failed;
2684 if (PyObject_SetAttrString(result, "elt", value) == -1)
2685 goto failed;
2686 Py_DECREF(value);
2687 value = ast2obj_list(o->v.ListComp.generators,
2688 ast2obj_comprehension);
2689 if (!value) goto failed;
2690 if (PyObject_SetAttrString(result, "generators", value) == -1)
2691 goto failed;
2692 Py_DECREF(value);
2693 break;
2694 case SetComp_kind:
2695 result = PyType_GenericNew(SetComp_type, NULL, NULL);
2696 if (!result) goto failed;
2697 value = ast2obj_expr(o->v.SetComp.elt);
2698 if (!value) goto failed;
2699 if (PyObject_SetAttrString(result, "elt", value) == -1)
2700 goto failed;
2701 Py_DECREF(value);
2702 value = ast2obj_list(o->v.SetComp.generators,
2703 ast2obj_comprehension);
2704 if (!value) goto failed;
2705 if (PyObject_SetAttrString(result, "generators", value) == -1)
2706 goto failed;
2707 Py_DECREF(value);
2708 break;
2709 case DictComp_kind:
2710 result = PyType_GenericNew(DictComp_type, NULL, NULL);
2711 if (!result) goto failed;
2712 value = ast2obj_expr(o->v.DictComp.key);
2713 if (!value) goto failed;
2714 if (PyObject_SetAttrString(result, "key", value) == -1)
2715 goto failed;
2716 Py_DECREF(value);
2717 value = ast2obj_expr(o->v.DictComp.value);
2718 if (!value) goto failed;
2719 if (PyObject_SetAttrString(result, "value", value) == -1)
2720 goto failed;
2721 Py_DECREF(value);
2722 value = ast2obj_list(o->v.DictComp.generators,
2723 ast2obj_comprehension);
2724 if (!value) goto failed;
2725 if (PyObject_SetAttrString(result, "generators", value) == -1)
2726 goto failed;
2727 Py_DECREF(value);
2728 break;
2729 case GeneratorExp_kind:
2730 result = PyType_GenericNew(GeneratorExp_type, NULL, NULL);
2731 if (!result) goto failed;
2732 value = ast2obj_expr(o->v.GeneratorExp.elt);
2733 if (!value) goto failed;
2734 if (PyObject_SetAttrString(result, "elt", value) == -1)
2735 goto failed;
2736 Py_DECREF(value);
2737 value = ast2obj_list(o->v.GeneratorExp.generators,
2738 ast2obj_comprehension);
2739 if (!value) goto failed;
2740 if (PyObject_SetAttrString(result, "generators", value) == -1)
2741 goto failed;
2742 Py_DECREF(value);
2743 break;
2744 case Yield_kind:
2745 result = PyType_GenericNew(Yield_type, NULL, NULL);
2746 if (!result) goto failed;
2747 value = ast2obj_expr(o->v.Yield.value);
2748 if (!value) goto failed;
2749 if (PyObject_SetAttrString(result, "value", value) == -1)
2750 goto failed;
2751 Py_DECREF(value);
2752 break;
2753 case Compare_kind:
2754 result = PyType_GenericNew(Compare_type, NULL, NULL);
2755 if (!result) goto failed;
2756 value = ast2obj_expr(o->v.Compare.left);
2757 if (!value) goto failed;
2758 if (PyObject_SetAttrString(result, "left", value) == -1)
2759 goto failed;
2760 Py_DECREF(value);
2761 {
2762 int i, n = asdl_seq_LEN(o->v.Compare.ops);
2763 value = PyList_New(n);
2764 if (!value) goto failed;
2765 for(i = 0; i < n; i++)
2766 PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
2767 }
2768 if (!value) goto failed;
2769 if (PyObject_SetAttrString(result, "ops", value) == -1)
2770 goto failed;
2771 Py_DECREF(value);
2772 value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr);
2773 if (!value) goto failed;
2774 if (PyObject_SetAttrString(result, "comparators", value) == -1)
2775 goto failed;
2776 Py_DECREF(value);
2777 break;
2778 case Call_kind:
2779 result = PyType_GenericNew(Call_type, NULL, NULL);
2780 if (!result) goto failed;
2781 value = ast2obj_expr(o->v.Call.func);
2782 if (!value) goto failed;
2783 if (PyObject_SetAttrString(result, "func", value) == -1)
2784 goto failed;
2785 Py_DECREF(value);
2786 value = ast2obj_list(o->v.Call.args, ast2obj_expr);
2787 if (!value) goto failed;
2788 if (PyObject_SetAttrString(result, "args", value) == -1)
2789 goto failed;
2790 Py_DECREF(value);
2791 value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword);
2792 if (!value) goto failed;
2793 if (PyObject_SetAttrString(result, "keywords", value) == -1)
2794 goto failed;
2795 Py_DECREF(value);
2796 value = ast2obj_expr(o->v.Call.starargs);
2797 if (!value) goto failed;
2798 if (PyObject_SetAttrString(result, "starargs", value) == -1)
2799 goto failed;
2800 Py_DECREF(value);
2801 value = ast2obj_expr(o->v.Call.kwargs);
2802 if (!value) goto failed;
2803 if (PyObject_SetAttrString(result, "kwargs", value) == -1)
2804 goto failed;
2805 Py_DECREF(value);
2806 break;
2807 case Repr_kind:
2808 result = PyType_GenericNew(Repr_type, NULL, NULL);
2809 if (!result) goto failed;
2810 value = ast2obj_expr(o->v.Repr.value);
2811 if (!value) goto failed;
2812 if (PyObject_SetAttrString(result, "value", value) == -1)
2813 goto failed;
2814 Py_DECREF(value);
2815 break;
2816 case Num_kind:
2817 result = PyType_GenericNew(Num_type, NULL, NULL);
2818 if (!result) goto failed;
2819 value = ast2obj_object(o->v.Num.n);
2820 if (!value) goto failed;
2821 if (PyObject_SetAttrString(result, "n", value) == -1)
2822 goto failed;
2823 Py_DECREF(value);
2824 break;
2825 case Str_kind:
2826 result = PyType_GenericNew(Str_type, NULL, NULL);
2827 if (!result) goto failed;
2828 value = ast2obj_string(o->v.Str.s);
2829 if (!value) goto failed;
2830 if (PyObject_SetAttrString(result, "s", value) == -1)
2831 goto failed;
2832 Py_DECREF(value);
2833 break;
2834 case Attribute_kind:
2835 result = PyType_GenericNew(Attribute_type, NULL, NULL);
2836 if (!result) goto failed;
2837 value = ast2obj_expr(o->v.Attribute.value);
2838 if (!value) goto failed;
2839 if (PyObject_SetAttrString(result, "value", value) == -1)
2840 goto failed;
2841 Py_DECREF(value);
2842 value = ast2obj_identifier(o->v.Attribute.attr);
2843 if (!value) goto failed;
2844 if (PyObject_SetAttrString(result, "attr", value) == -1)
2845 goto failed;
2846 Py_DECREF(value);
2847 value = ast2obj_expr_context(o->v.Attribute.ctx);
2848 if (!value) goto failed;
2849 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2850 goto failed;
2851 Py_DECREF(value);
2852 break;
2853 case Subscript_kind:
2854 result = PyType_GenericNew(Subscript_type, NULL, NULL);
2855 if (!result) goto failed;
2856 value = ast2obj_expr(o->v.Subscript.value);
2857 if (!value) goto failed;
2858 if (PyObject_SetAttrString(result, "value", value) == -1)
2859 goto failed;
2860 Py_DECREF(value);
2861 value = ast2obj_slice(o->v.Subscript.slice);
2862 if (!value) goto failed;
2863 if (PyObject_SetAttrString(result, "slice", value) == -1)
2864 goto failed;
2865 Py_DECREF(value);
2866 value = ast2obj_expr_context(o->v.Subscript.ctx);
2867 if (!value) goto failed;
2868 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2869 goto failed;
2870 Py_DECREF(value);
2871 break;
2872 case Name_kind:
2873 result = PyType_GenericNew(Name_type, NULL, NULL);
2874 if (!result) goto failed;
2875 value = ast2obj_identifier(o->v.Name.id);
2876 if (!value) goto failed;
2877 if (PyObject_SetAttrString(result, "id", value) == -1)
2878 goto failed;
2879 Py_DECREF(value);
2880 value = ast2obj_expr_context(o->v.Name.ctx);
2881 if (!value) goto failed;
2882 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2883 goto failed;
2884 Py_DECREF(value);
2885 break;
2886 case List_kind:
2887 result = PyType_GenericNew(List_type, NULL, NULL);
2888 if (!result) goto failed;
2889 value = ast2obj_list(o->v.List.elts, ast2obj_expr);
2890 if (!value) goto failed;
2891 if (PyObject_SetAttrString(result, "elts", value) == -1)
2892 goto failed;
2893 Py_DECREF(value);
2894 value = ast2obj_expr_context(o->v.List.ctx);
2895 if (!value) goto failed;
2896 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2897 goto failed;
2898 Py_DECREF(value);
2899 break;
2900 case Tuple_kind:
2901 result = PyType_GenericNew(Tuple_type, NULL, NULL);
2902 if (!result) goto failed;
2903 value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr);
2904 if (!value) goto failed;
2905 if (PyObject_SetAttrString(result, "elts", value) == -1)
2906 goto failed;
2907 Py_DECREF(value);
2908 value = ast2obj_expr_context(o->v.Tuple.ctx);
2909 if (!value) goto failed;
2910 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2911 goto failed;
2912 Py_DECREF(value);
2913 break;
2914 }
2915 value = ast2obj_int(o->lineno);
2916 if (!value) goto failed;
2917 if (PyObject_SetAttrString(result, "lineno", value) < 0)
2918 goto failed;
2919 Py_DECREF(value);
2920 value = ast2obj_int(o->col_offset);
2921 if (!value) goto failed;
2922 if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2923 goto failed;
2924 Py_DECREF(value);
2925 return result;
2926 failed:
2927 Py_XDECREF(value);
2928 Py_XDECREF(result);
2929 return NULL;
2930 }
2931
ast2obj_expr_context(expr_context_ty o)2932 PyObject* ast2obj_expr_context(expr_context_ty o)
2933 {
2934 switch(o) {
2935 case Load:
2936 Py_INCREF(Load_singleton);
2937 return Load_singleton;
2938 case Store:
2939 Py_INCREF(Store_singleton);
2940 return Store_singleton;
2941 case Del:
2942 Py_INCREF(Del_singleton);
2943 return Del_singleton;
2944 case AugLoad:
2945 Py_INCREF(AugLoad_singleton);
2946 return AugLoad_singleton;
2947 case AugStore:
2948 Py_INCREF(AugStore_singleton);
2949 return AugStore_singleton;
2950 case Param:
2951 Py_INCREF(Param_singleton);
2952 return Param_singleton;
2953 default:
2954 /* should never happen, but just in case ... */
2955 PyErr_Format(PyExc_SystemError, "unknown expr_context found");
2956 return NULL;
2957 }
2958 }
2959 PyObject*
ast2obj_slice(void * _o)2960 ast2obj_slice(void* _o)
2961 {
2962 slice_ty o = (slice_ty)_o;
2963 PyObject *result = NULL, *value = NULL;
2964 if (!o) {
2965 Py_INCREF(Py_None);
2966 return Py_None;
2967 }
2968
2969 switch (o->kind) {
2970 case Ellipsis_kind:
2971 result = PyType_GenericNew(Ellipsis_type, NULL, NULL);
2972 if (!result) goto failed;
2973 break;
2974 case Slice_kind:
2975 result = PyType_GenericNew(Slice_type, NULL, NULL);
2976 if (!result) goto failed;
2977 value = ast2obj_expr(o->v.Slice.lower);
2978 if (!value) goto failed;
2979 if (PyObject_SetAttrString(result, "lower", value) == -1)
2980 goto failed;
2981 Py_DECREF(value);
2982 value = ast2obj_expr(o->v.Slice.upper);
2983 if (!value) goto failed;
2984 if (PyObject_SetAttrString(result, "upper", value) == -1)
2985 goto failed;
2986 Py_DECREF(value);
2987 value = ast2obj_expr(o->v.Slice.step);
2988 if (!value) goto failed;
2989 if (PyObject_SetAttrString(result, "step", value) == -1)
2990 goto failed;
2991 Py_DECREF(value);
2992 break;
2993 case ExtSlice_kind:
2994 result = PyType_GenericNew(ExtSlice_type, NULL, NULL);
2995 if (!result) goto failed;
2996 value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice);
2997 if (!value) goto failed;
2998 if (PyObject_SetAttrString(result, "dims", value) == -1)
2999 goto failed;
3000 Py_DECREF(value);
3001 break;
3002 case Index_kind:
3003 result = PyType_GenericNew(Index_type, NULL, NULL);
3004 if (!result) goto failed;
3005 value = ast2obj_expr(o->v.Index.value);
3006 if (!value) goto failed;
3007 if (PyObject_SetAttrString(result, "value", value) == -1)
3008 goto failed;
3009 Py_DECREF(value);
3010 break;
3011 }
3012 return result;
3013 failed:
3014 Py_XDECREF(value);
3015 Py_XDECREF(result);
3016 return NULL;
3017 }
3018
ast2obj_boolop(boolop_ty o)3019 PyObject* ast2obj_boolop(boolop_ty o)
3020 {
3021 switch(o) {
3022 case And:
3023 Py_INCREF(And_singleton);
3024 return And_singleton;
3025 case Or:
3026 Py_INCREF(Or_singleton);
3027 return Or_singleton;
3028 default:
3029 /* should never happen, but just in case ... */
3030 PyErr_Format(PyExc_SystemError, "unknown boolop found");
3031 return NULL;
3032 }
3033 }
ast2obj_operator(operator_ty o)3034 PyObject* ast2obj_operator(operator_ty o)
3035 {
3036 switch(o) {
3037 case Add:
3038 Py_INCREF(Add_singleton);
3039 return Add_singleton;
3040 case Sub:
3041 Py_INCREF(Sub_singleton);
3042 return Sub_singleton;
3043 case Mult:
3044 Py_INCREF(Mult_singleton);
3045 return Mult_singleton;
3046 case Div:
3047 Py_INCREF(Div_singleton);
3048 return Div_singleton;
3049 case Mod:
3050 Py_INCREF(Mod_singleton);
3051 return Mod_singleton;
3052 case Pow:
3053 Py_INCREF(Pow_singleton);
3054 return Pow_singleton;
3055 case LShift:
3056 Py_INCREF(LShift_singleton);
3057 return LShift_singleton;
3058 case RShift:
3059 Py_INCREF(RShift_singleton);
3060 return RShift_singleton;
3061 case BitOr:
3062 Py_INCREF(BitOr_singleton);
3063 return BitOr_singleton;
3064 case BitXor:
3065 Py_INCREF(BitXor_singleton);
3066 return BitXor_singleton;
3067 case BitAnd:
3068 Py_INCREF(BitAnd_singleton);
3069 return BitAnd_singleton;
3070 case FloorDiv:
3071 Py_INCREF(FloorDiv_singleton);
3072 return FloorDiv_singleton;
3073 default:
3074 /* should never happen, but just in case ... */
3075 PyErr_Format(PyExc_SystemError, "unknown operator found");
3076 return NULL;
3077 }
3078 }
ast2obj_unaryop(unaryop_ty o)3079 PyObject* ast2obj_unaryop(unaryop_ty o)
3080 {
3081 switch(o) {
3082 case Invert:
3083 Py_INCREF(Invert_singleton);
3084 return Invert_singleton;
3085 case Not:
3086 Py_INCREF(Not_singleton);
3087 return Not_singleton;
3088 case UAdd:
3089 Py_INCREF(UAdd_singleton);
3090 return UAdd_singleton;
3091 case USub:
3092 Py_INCREF(USub_singleton);
3093 return USub_singleton;
3094 default:
3095 /* should never happen, but just in case ... */
3096 PyErr_Format(PyExc_SystemError, "unknown unaryop found");
3097 return NULL;
3098 }
3099 }
ast2obj_cmpop(cmpop_ty o)3100 PyObject* ast2obj_cmpop(cmpop_ty o)
3101 {
3102 switch(o) {
3103 case Eq:
3104 Py_INCREF(Eq_singleton);
3105 return Eq_singleton;
3106 case NotEq:
3107 Py_INCREF(NotEq_singleton);
3108 return NotEq_singleton;
3109 case Lt:
3110 Py_INCREF(Lt_singleton);
3111 return Lt_singleton;
3112 case LtE:
3113 Py_INCREF(LtE_singleton);
3114 return LtE_singleton;
3115 case Gt:
3116 Py_INCREF(Gt_singleton);
3117 return Gt_singleton;
3118 case GtE:
3119 Py_INCREF(GtE_singleton);
3120 return GtE_singleton;
3121 case Is:
3122 Py_INCREF(Is_singleton);
3123 return Is_singleton;
3124 case IsNot:
3125 Py_INCREF(IsNot_singleton);
3126 return IsNot_singleton;
3127 case In:
3128 Py_INCREF(In_singleton);
3129 return In_singleton;
3130 case NotIn:
3131 Py_INCREF(NotIn_singleton);
3132 return NotIn_singleton;
3133 default:
3134 /* should never happen, but just in case ... */
3135 PyErr_Format(PyExc_SystemError, "unknown cmpop found");
3136 return NULL;
3137 }
3138 }
3139 PyObject*
ast2obj_comprehension(void * _o)3140 ast2obj_comprehension(void* _o)
3141 {
3142 comprehension_ty o = (comprehension_ty)_o;
3143 PyObject *result = NULL, *value = NULL;
3144 if (!o) {
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 result = PyType_GenericNew(comprehension_type, NULL, NULL);
3150 if (!result) return NULL;
3151 value = ast2obj_expr(o->target);
3152 if (!value) goto failed;
3153 if (PyObject_SetAttrString(result, "target", value) == -1)
3154 goto failed;
3155 Py_DECREF(value);
3156 value = ast2obj_expr(o->iter);
3157 if (!value) goto failed;
3158 if (PyObject_SetAttrString(result, "iter", value) == -1)
3159 goto failed;
3160 Py_DECREF(value);
3161 value = ast2obj_list(o->ifs, ast2obj_expr);
3162 if (!value) goto failed;
3163 if (PyObject_SetAttrString(result, "ifs", value) == -1)
3164 goto failed;
3165 Py_DECREF(value);
3166 return result;
3167 failed:
3168 Py_XDECREF(value);
3169 Py_XDECREF(result);
3170 return NULL;
3171 }
3172
3173 PyObject*
ast2obj_excepthandler(void * _o)3174 ast2obj_excepthandler(void* _o)
3175 {
3176 excepthandler_ty o = (excepthandler_ty)_o;
3177 PyObject *result = NULL, *value = NULL;
3178 if (!o) {
3179 Py_INCREF(Py_None);
3180 return Py_None;
3181 }
3182
3183 switch (o->kind) {
3184 case ExceptHandler_kind:
3185 result = PyType_GenericNew(ExceptHandler_type, NULL, NULL);
3186 if (!result) goto failed;
3187 value = ast2obj_expr(o->v.ExceptHandler.type);
3188 if (!value) goto failed;
3189 if (PyObject_SetAttrString(result, "type", value) == -1)
3190 goto failed;
3191 Py_DECREF(value);
3192 value = ast2obj_expr(o->v.ExceptHandler.name);
3193 if (!value) goto failed;
3194 if (PyObject_SetAttrString(result, "name", value) == -1)
3195 goto failed;
3196 Py_DECREF(value);
3197 value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt);
3198 if (!value) goto failed;
3199 if (PyObject_SetAttrString(result, "body", value) == -1)
3200 goto failed;
3201 Py_DECREF(value);
3202 break;
3203 }
3204 value = ast2obj_int(o->lineno);
3205 if (!value) goto failed;
3206 if (PyObject_SetAttrString(result, "lineno", value) < 0)
3207 goto failed;
3208 Py_DECREF(value);
3209 value = ast2obj_int(o->col_offset);
3210 if (!value) goto failed;
3211 if (PyObject_SetAttrString(result, "col_offset", value) < 0)
3212 goto failed;
3213 Py_DECREF(value);
3214 return result;
3215 failed:
3216 Py_XDECREF(value);
3217 Py_XDECREF(result);
3218 return NULL;
3219 }
3220
3221 PyObject*
ast2obj_arguments(void * _o)3222 ast2obj_arguments(void* _o)
3223 {
3224 arguments_ty o = (arguments_ty)_o;
3225 PyObject *result = NULL, *value = NULL;
3226 if (!o) {
3227 Py_INCREF(Py_None);
3228 return Py_None;
3229 }
3230
3231 result = PyType_GenericNew(arguments_type, NULL, NULL);
3232 if (!result) return NULL;
3233 value = ast2obj_list(o->args, ast2obj_expr);
3234 if (!value) goto failed;
3235 if (PyObject_SetAttrString(result, "args", value) == -1)
3236 goto failed;
3237 Py_DECREF(value);
3238 value = ast2obj_identifier(o->vararg);
3239 if (!value) goto failed;
3240 if (PyObject_SetAttrString(result, "vararg", value) == -1)
3241 goto failed;
3242 Py_DECREF(value);
3243 value = ast2obj_identifier(o->kwarg);
3244 if (!value) goto failed;
3245 if (PyObject_SetAttrString(result, "kwarg", value) == -1)
3246 goto failed;
3247 Py_DECREF(value);
3248 value = ast2obj_list(o->defaults, ast2obj_expr);
3249 if (!value) goto failed;
3250 if (PyObject_SetAttrString(result, "defaults", value) == -1)
3251 goto failed;
3252 Py_DECREF(value);
3253 return result;
3254 failed:
3255 Py_XDECREF(value);
3256 Py_XDECREF(result);
3257 return NULL;
3258 }
3259
3260 PyObject*
ast2obj_keyword(void * _o)3261 ast2obj_keyword(void* _o)
3262 {
3263 keyword_ty o = (keyword_ty)_o;
3264 PyObject *result = NULL, *value = NULL;
3265 if (!o) {
3266 Py_INCREF(Py_None);
3267 return Py_None;
3268 }
3269
3270 result = PyType_GenericNew(keyword_type, NULL, NULL);
3271 if (!result) return NULL;
3272 value = ast2obj_identifier(o->arg);
3273 if (!value) goto failed;
3274 if (PyObject_SetAttrString(result, "arg", value) == -1)
3275 goto failed;
3276 Py_DECREF(value);
3277 value = ast2obj_expr(o->value);
3278 if (!value) goto failed;
3279 if (PyObject_SetAttrString(result, "value", value) == -1)
3280 goto failed;
3281 Py_DECREF(value);
3282 return result;
3283 failed:
3284 Py_XDECREF(value);
3285 Py_XDECREF(result);
3286 return NULL;
3287 }
3288
3289 PyObject*
ast2obj_alias(void * _o)3290 ast2obj_alias(void* _o)
3291 {
3292 alias_ty o = (alias_ty)_o;
3293 PyObject *result = NULL, *value = NULL;
3294 if (!o) {
3295 Py_INCREF(Py_None);
3296 return Py_None;
3297 }
3298
3299 result = PyType_GenericNew(alias_type, NULL, NULL);
3300 if (!result) return NULL;
3301 value = ast2obj_identifier(o->name);
3302 if (!value) goto failed;
3303 if (PyObject_SetAttrString(result, "name", value) == -1)
3304 goto failed;
3305 Py_DECREF(value);
3306 value = ast2obj_identifier(o->asname);
3307 if (!value) goto failed;
3308 if (PyObject_SetAttrString(result, "asname", value) == -1)
3309 goto failed;
3310 Py_DECREF(value);
3311 return result;
3312 failed:
3313 Py_XDECREF(value);
3314 Py_XDECREF(result);
3315 return NULL;
3316 }
3317
3318
3319 int
obj2ast_mod(PyObject * obj,mod_ty * out,PyArena * arena)3320 obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena)
3321 {
3322 PyObject* tmp = NULL;
3323 int isinstance;
3324
3325
3326 if (obj == Py_None) {
3327 *out = NULL;
3328 return 0;
3329 }
3330 isinstance = PyObject_IsInstance(obj, (PyObject*)Module_type);
3331 if (isinstance == -1) {
3332 return 1;
3333 }
3334 if (isinstance) {
3335 asdl_seq* body;
3336
3337 if (PyObject_HasAttrString(obj, "body")) {
3338 int res;
3339 Py_ssize_t len;
3340 Py_ssize_t i;
3341 tmp = PyObject_GetAttrString(obj, "body");
3342 if (tmp == NULL) goto failed;
3343 if (!PyList_Check(tmp)) {
3344 PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3345 goto failed;
3346 }
3347 len = PyList_GET_SIZE(tmp);
3348 body = asdl_seq_new(len, arena);
3349 if (body == NULL) goto failed;
3350 for (i = 0; i < len; i++) {
3351 stmt_ty value;
3352 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3353 if (res != 0) goto failed;
3354 if (len != PyList_GET_SIZE(tmp)) {
3355 PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
3356 goto failed;
3357 }
3358 asdl_seq_SET(body, i, value);
3359 }
3360 Py_XDECREF(tmp);
3361 tmp = NULL;
3362 } else {
3363 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module");
3364 return 1;
3365 }
3366 *out = Module(body, arena);
3367 if (*out == NULL) goto failed;
3368 return 0;
3369 }
3370 isinstance = PyObject_IsInstance(obj, (PyObject*)Interactive_type);
3371 if (isinstance == -1) {
3372 return 1;
3373 }
3374 if (isinstance) {
3375 asdl_seq* body;
3376
3377 if (PyObject_HasAttrString(obj, "body")) {
3378 int res;
3379 Py_ssize_t len;
3380 Py_ssize_t i;
3381 tmp = PyObject_GetAttrString(obj, "body");
3382 if (tmp == NULL) goto failed;
3383 if (!PyList_Check(tmp)) {
3384 PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3385 goto failed;
3386 }
3387 len = PyList_GET_SIZE(tmp);
3388 body = asdl_seq_new(len, arena);
3389 if (body == NULL) goto failed;
3390 for (i = 0; i < len; i++) {
3391 stmt_ty value;
3392 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3393 if (res != 0) goto failed;
3394 if (len != PyList_GET_SIZE(tmp)) {
3395 PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
3396 goto failed;
3397 }
3398 asdl_seq_SET(body, i, value);
3399 }
3400 Py_XDECREF(tmp);
3401 tmp = NULL;
3402 } else {
3403 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive");
3404 return 1;
3405 }
3406 *out = Interactive(body, arena);
3407 if (*out == NULL) goto failed;
3408 return 0;
3409 }
3410 isinstance = PyObject_IsInstance(obj, (PyObject*)Expression_type);
3411 if (isinstance == -1) {
3412 return 1;
3413 }
3414 if (isinstance) {
3415 expr_ty body;
3416
3417 if (PyObject_HasAttrString(obj, "body")) {
3418 int res;
3419 tmp = PyObject_GetAttrString(obj, "body");
3420 if (tmp == NULL) goto failed;
3421 res = obj2ast_expr(tmp, &body, arena);
3422 if (res != 0) goto failed;
3423 Py_XDECREF(tmp);
3424 tmp = NULL;
3425 } else {
3426 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression");
3427 return 1;
3428 }
3429 *out = Expression(body, arena);
3430 if (*out == NULL) goto failed;
3431 return 0;
3432 }
3433 isinstance = PyObject_IsInstance(obj, (PyObject*)Suite_type);
3434 if (isinstance == -1) {
3435 return 1;
3436 }
3437 if (isinstance) {
3438 asdl_seq* body;
3439
3440 if (PyObject_HasAttrString(obj, "body")) {
3441 int res;
3442 Py_ssize_t len;
3443 Py_ssize_t i;
3444 tmp = PyObject_GetAttrString(obj, "body");
3445 if (tmp == NULL) goto failed;
3446 if (!PyList_Check(tmp)) {
3447 PyErr_Format(PyExc_TypeError, "Suite field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3448 goto failed;
3449 }
3450 len = PyList_GET_SIZE(tmp);
3451 body = asdl_seq_new(len, arena);
3452 if (body == NULL) goto failed;
3453 for (i = 0; i < len; i++) {
3454 stmt_ty value;
3455 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3456 if (res != 0) goto failed;
3457 if (len != PyList_GET_SIZE(tmp)) {
3458 PyErr_SetString(PyExc_RuntimeError, "Suite field \"body\" changed size during iteration");
3459 goto failed;
3460 }
3461 asdl_seq_SET(body, i, value);
3462 }
3463 Py_XDECREF(tmp);
3464 tmp = NULL;
3465 } else {
3466 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Suite");
3467 return 1;
3468 }
3469 *out = Suite(body, arena);
3470 if (*out == NULL) goto failed;
3471 return 0;
3472 }
3473
3474 tmp = PyObject_Repr(obj);
3475 if (tmp == NULL) goto failed;
3476 PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %.400s", PyString_AS_STRING(tmp));
3477 failed:
3478 Py_XDECREF(tmp);
3479 return 1;
3480 }
3481
3482 int
obj2ast_stmt(PyObject * obj,stmt_ty * out,PyArena * arena)3483 obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena)
3484 {
3485 PyObject* tmp = NULL;
3486 int isinstance;
3487
3488 int lineno;
3489 int col_offset;
3490
3491 if (obj == Py_None) {
3492 *out = NULL;
3493 return 0;
3494 }
3495 if (PyObject_HasAttrString(obj, "lineno")) {
3496 int res;
3497 tmp = PyObject_GetAttrString(obj, "lineno");
3498 if (tmp == NULL) goto failed;
3499 res = obj2ast_int(tmp, &lineno, arena);
3500 if (res != 0) goto failed;
3501 Py_XDECREF(tmp);
3502 tmp = NULL;
3503 } else {
3504 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt");
3505 return 1;
3506 }
3507 if (PyObject_HasAttrString(obj, "col_offset")) {
3508 int res;
3509 tmp = PyObject_GetAttrString(obj, "col_offset");
3510 if (tmp == NULL) goto failed;
3511 res = obj2ast_int(tmp, &col_offset, arena);
3512 if (res != 0) goto failed;
3513 Py_XDECREF(tmp);
3514 tmp = NULL;
3515 } else {
3516 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt");
3517 return 1;
3518 }
3519 isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionDef_type);
3520 if (isinstance == -1) {
3521 return 1;
3522 }
3523 if (isinstance) {
3524 identifier name;
3525 arguments_ty args;
3526 asdl_seq* body;
3527 asdl_seq* decorator_list;
3528
3529 if (PyObject_HasAttrString(obj, "name")) {
3530 int res;
3531 tmp = PyObject_GetAttrString(obj, "name");
3532 if (tmp == NULL) goto failed;
3533 res = obj2ast_identifier(tmp, &name, arena);
3534 if (res != 0) goto failed;
3535 Py_XDECREF(tmp);
3536 tmp = NULL;
3537 } else {
3538 PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef");
3539 return 1;
3540 }
3541 if (PyObject_HasAttrString(obj, "args")) {
3542 int res;
3543 tmp = PyObject_GetAttrString(obj, "args");
3544 if (tmp == NULL) goto failed;
3545 res = obj2ast_arguments(tmp, &args, arena);
3546 if (res != 0) goto failed;
3547 Py_XDECREF(tmp);
3548 tmp = NULL;
3549 } else {
3550 PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef");
3551 return 1;
3552 }
3553 if (PyObject_HasAttrString(obj, "body")) {
3554 int res;
3555 Py_ssize_t len;
3556 Py_ssize_t i;
3557 tmp = PyObject_GetAttrString(obj, "body");
3558 if (tmp == NULL) goto failed;
3559 if (!PyList_Check(tmp)) {
3560 PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3561 goto failed;
3562 }
3563 len = PyList_GET_SIZE(tmp);
3564 body = asdl_seq_new(len, arena);
3565 if (body == NULL) goto failed;
3566 for (i = 0; i < len; i++) {
3567 stmt_ty value;
3568 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3569 if (res != 0) goto failed;
3570 if (len != PyList_GET_SIZE(tmp)) {
3571 PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
3572 goto failed;
3573 }
3574 asdl_seq_SET(body, i, value);
3575 }
3576 Py_XDECREF(tmp);
3577 tmp = NULL;
3578 } else {
3579 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef");
3580 return 1;
3581 }
3582 if (PyObject_HasAttrString(obj, "decorator_list")) {
3583 int res;
3584 Py_ssize_t len;
3585 Py_ssize_t i;
3586 tmp = PyObject_GetAttrString(obj, "decorator_list");
3587 if (tmp == NULL) goto failed;
3588 if (!PyList_Check(tmp)) {
3589 PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3590 goto failed;
3591 }
3592 len = PyList_GET_SIZE(tmp);
3593 decorator_list = asdl_seq_new(len, arena);
3594 if (decorator_list == NULL) goto failed;
3595 for (i = 0; i < len; i++) {
3596 expr_ty value;
3597 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3598 if (res != 0) goto failed;
3599 if (len != PyList_GET_SIZE(tmp)) {
3600 PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
3601 goto failed;
3602 }
3603 asdl_seq_SET(decorator_list, i, value);
3604 }
3605 Py_XDECREF(tmp);
3606 tmp = NULL;
3607 } else {
3608 PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef");
3609 return 1;
3610 }
3611 *out = FunctionDef(name, args, body, decorator_list, lineno,
3612 col_offset, arena);
3613 if (*out == NULL) goto failed;
3614 return 0;
3615 }
3616 isinstance = PyObject_IsInstance(obj, (PyObject*)ClassDef_type);
3617 if (isinstance == -1) {
3618 return 1;
3619 }
3620 if (isinstance) {
3621 identifier name;
3622 asdl_seq* bases;
3623 asdl_seq* body;
3624 asdl_seq* decorator_list;
3625
3626 if (PyObject_HasAttrString(obj, "name")) {
3627 int res;
3628 tmp = PyObject_GetAttrString(obj, "name");
3629 if (tmp == NULL) goto failed;
3630 res = obj2ast_identifier(tmp, &name, arena);
3631 if (res != 0) goto failed;
3632 Py_XDECREF(tmp);
3633 tmp = NULL;
3634 } else {
3635 PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef");
3636 return 1;
3637 }
3638 if (PyObject_HasAttrString(obj, "bases")) {
3639 int res;
3640 Py_ssize_t len;
3641 Py_ssize_t i;
3642 tmp = PyObject_GetAttrString(obj, "bases");
3643 if (tmp == NULL) goto failed;
3644 if (!PyList_Check(tmp)) {
3645 PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3646 goto failed;
3647 }
3648 len = PyList_GET_SIZE(tmp);
3649 bases = asdl_seq_new(len, arena);
3650 if (bases == NULL) goto failed;
3651 for (i = 0; i < len; i++) {
3652 expr_ty value;
3653 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3654 if (res != 0) goto failed;
3655 if (len != PyList_GET_SIZE(tmp)) {
3656 PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
3657 goto failed;
3658 }
3659 asdl_seq_SET(bases, i, value);
3660 }
3661 Py_XDECREF(tmp);
3662 tmp = NULL;
3663 } else {
3664 PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef");
3665 return 1;
3666 }
3667 if (PyObject_HasAttrString(obj, "body")) {
3668 int res;
3669 Py_ssize_t len;
3670 Py_ssize_t i;
3671 tmp = PyObject_GetAttrString(obj, "body");
3672 if (tmp == NULL) goto failed;
3673 if (!PyList_Check(tmp)) {
3674 PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3675 goto failed;
3676 }
3677 len = PyList_GET_SIZE(tmp);
3678 body = asdl_seq_new(len, arena);
3679 if (body == NULL) goto failed;
3680 for (i = 0; i < len; i++) {
3681 stmt_ty value;
3682 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3683 if (res != 0) goto failed;
3684 if (len != PyList_GET_SIZE(tmp)) {
3685 PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
3686 goto failed;
3687 }
3688 asdl_seq_SET(body, i, value);
3689 }
3690 Py_XDECREF(tmp);
3691 tmp = NULL;
3692 } else {
3693 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef");
3694 return 1;
3695 }
3696 if (PyObject_HasAttrString(obj, "decorator_list")) {
3697 int res;
3698 Py_ssize_t len;
3699 Py_ssize_t i;
3700 tmp = PyObject_GetAttrString(obj, "decorator_list");
3701 if (tmp == NULL) goto failed;
3702 if (!PyList_Check(tmp)) {
3703 PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3704 goto failed;
3705 }
3706 len = PyList_GET_SIZE(tmp);
3707 decorator_list = asdl_seq_new(len, arena);
3708 if (decorator_list == NULL) goto failed;
3709 for (i = 0; i < len; i++) {
3710 expr_ty value;
3711 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3712 if (res != 0) goto failed;
3713 if (len != PyList_GET_SIZE(tmp)) {
3714 PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
3715 goto failed;
3716 }
3717 asdl_seq_SET(decorator_list, i, value);
3718 }
3719 Py_XDECREF(tmp);
3720 tmp = NULL;
3721 } else {
3722 PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef");
3723 return 1;
3724 }
3725 *out = ClassDef(name, bases, body, decorator_list, lineno,
3726 col_offset, arena);
3727 if (*out == NULL) goto failed;
3728 return 0;
3729 }
3730 isinstance = PyObject_IsInstance(obj, (PyObject*)Return_type);
3731 if (isinstance == -1) {
3732 return 1;
3733 }
3734 if (isinstance) {
3735 expr_ty value;
3736
3737 if (PyObject_HasAttrString(obj, "value")) {
3738 int res;
3739 tmp = PyObject_GetAttrString(obj, "value");
3740 if (tmp == NULL) goto failed;
3741 res = obj2ast_expr(tmp, &value, arena);
3742 if (res != 0) goto failed;
3743 Py_XDECREF(tmp);
3744 tmp = NULL;
3745 } else {
3746 value = NULL;
3747 }
3748 *out = Return(value, lineno, col_offset, arena);
3749 if (*out == NULL) goto failed;
3750 return 0;
3751 }
3752 isinstance = PyObject_IsInstance(obj, (PyObject*)Delete_type);
3753 if (isinstance == -1) {
3754 return 1;
3755 }
3756 if (isinstance) {
3757 asdl_seq* targets;
3758
3759 if (PyObject_HasAttrString(obj, "targets")) {
3760 int res;
3761 Py_ssize_t len;
3762 Py_ssize_t i;
3763 tmp = PyObject_GetAttrString(obj, "targets");
3764 if (tmp == NULL) goto failed;
3765 if (!PyList_Check(tmp)) {
3766 PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3767 goto failed;
3768 }
3769 len = PyList_GET_SIZE(tmp);
3770 targets = asdl_seq_new(len, arena);
3771 if (targets == NULL) goto failed;
3772 for (i = 0; i < len; i++) {
3773 expr_ty value;
3774 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3775 if (res != 0) goto failed;
3776 if (len != PyList_GET_SIZE(tmp)) {
3777 PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
3778 goto failed;
3779 }
3780 asdl_seq_SET(targets, i, value);
3781 }
3782 Py_XDECREF(tmp);
3783 tmp = NULL;
3784 } else {
3785 PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete");
3786 return 1;
3787 }
3788 *out = Delete(targets, lineno, col_offset, arena);
3789 if (*out == NULL) goto failed;
3790 return 0;
3791 }
3792 isinstance = PyObject_IsInstance(obj, (PyObject*)Assign_type);
3793 if (isinstance == -1) {
3794 return 1;
3795 }
3796 if (isinstance) {
3797 asdl_seq* targets;
3798 expr_ty value;
3799
3800 if (PyObject_HasAttrString(obj, "targets")) {
3801 int res;
3802 Py_ssize_t len;
3803 Py_ssize_t i;
3804 tmp = PyObject_GetAttrString(obj, "targets");
3805 if (tmp == NULL) goto failed;
3806 if (!PyList_Check(tmp)) {
3807 PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3808 goto failed;
3809 }
3810 len = PyList_GET_SIZE(tmp);
3811 targets = asdl_seq_new(len, arena);
3812 if (targets == NULL) goto failed;
3813 for (i = 0; i < len; i++) {
3814 expr_ty value;
3815 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3816 if (res != 0) goto failed;
3817 if (len != PyList_GET_SIZE(tmp)) {
3818 PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
3819 goto failed;
3820 }
3821 asdl_seq_SET(targets, i, value);
3822 }
3823 Py_XDECREF(tmp);
3824 tmp = NULL;
3825 } else {
3826 PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign");
3827 return 1;
3828 }
3829 if (PyObject_HasAttrString(obj, "value")) {
3830 int res;
3831 tmp = PyObject_GetAttrString(obj, "value");
3832 if (tmp == NULL) goto failed;
3833 res = obj2ast_expr(tmp, &value, arena);
3834 if (res != 0) goto failed;
3835 Py_XDECREF(tmp);
3836 tmp = NULL;
3837 } else {
3838 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign");
3839 return 1;
3840 }
3841 *out = Assign(targets, value, lineno, col_offset, arena);
3842 if (*out == NULL) goto failed;
3843 return 0;
3844 }
3845 isinstance = PyObject_IsInstance(obj, (PyObject*)AugAssign_type);
3846 if (isinstance == -1) {
3847 return 1;
3848 }
3849 if (isinstance) {
3850 expr_ty target;
3851 operator_ty op;
3852 expr_ty value;
3853
3854 if (PyObject_HasAttrString(obj, "target")) {
3855 int res;
3856 tmp = PyObject_GetAttrString(obj, "target");
3857 if (tmp == NULL) goto failed;
3858 res = obj2ast_expr(tmp, &target, arena);
3859 if (res != 0) goto failed;
3860 Py_XDECREF(tmp);
3861 tmp = NULL;
3862 } else {
3863 PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign");
3864 return 1;
3865 }
3866 if (PyObject_HasAttrString(obj, "op")) {
3867 int res;
3868 tmp = PyObject_GetAttrString(obj, "op");
3869 if (tmp == NULL) goto failed;
3870 res = obj2ast_operator(tmp, &op, arena);
3871 if (res != 0) goto failed;
3872 Py_XDECREF(tmp);
3873 tmp = NULL;
3874 } else {
3875 PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign");
3876 return 1;
3877 }
3878 if (PyObject_HasAttrString(obj, "value")) {
3879 int res;
3880 tmp = PyObject_GetAttrString(obj, "value");
3881 if (tmp == NULL) goto failed;
3882 res = obj2ast_expr(tmp, &value, arena);
3883 if (res != 0) goto failed;
3884 Py_XDECREF(tmp);
3885 tmp = NULL;
3886 } else {
3887 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign");
3888 return 1;
3889 }
3890 *out = AugAssign(target, op, value, lineno, col_offset, arena);
3891 if (*out == NULL) goto failed;
3892 return 0;
3893 }
3894 isinstance = PyObject_IsInstance(obj, (PyObject*)Print_type);
3895 if (isinstance == -1) {
3896 return 1;
3897 }
3898 if (isinstance) {
3899 expr_ty dest;
3900 asdl_seq* values;
3901 bool nl;
3902
3903 if (PyObject_HasAttrString(obj, "dest")) {
3904 int res;
3905 tmp = PyObject_GetAttrString(obj, "dest");
3906 if (tmp == NULL) goto failed;
3907 res = obj2ast_expr(tmp, &dest, arena);
3908 if (res != 0) goto failed;
3909 Py_XDECREF(tmp);
3910 tmp = NULL;
3911 } else {
3912 dest = NULL;
3913 }
3914 if (PyObject_HasAttrString(obj, "values")) {
3915 int res;
3916 Py_ssize_t len;
3917 Py_ssize_t i;
3918 tmp = PyObject_GetAttrString(obj, "values");
3919 if (tmp == NULL) goto failed;
3920 if (!PyList_Check(tmp)) {
3921 PyErr_Format(PyExc_TypeError, "Print field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3922 goto failed;
3923 }
3924 len = PyList_GET_SIZE(tmp);
3925 values = asdl_seq_new(len, arena);
3926 if (values == NULL) goto failed;
3927 for (i = 0; i < len; i++) {
3928 expr_ty value;
3929 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3930 if (res != 0) goto failed;
3931 if (len != PyList_GET_SIZE(tmp)) {
3932 PyErr_SetString(PyExc_RuntimeError, "Print field \"values\" changed size during iteration");
3933 goto failed;
3934 }
3935 asdl_seq_SET(values, i, value);
3936 }
3937 Py_XDECREF(tmp);
3938 tmp = NULL;
3939 } else {
3940 PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Print");
3941 return 1;
3942 }
3943 if (PyObject_HasAttrString(obj, "nl")) {
3944 int res;
3945 tmp = PyObject_GetAttrString(obj, "nl");
3946 if (tmp == NULL) goto failed;
3947 res = obj2ast_bool(tmp, &nl, arena);
3948 if (res != 0) goto failed;
3949 Py_XDECREF(tmp);
3950 tmp = NULL;
3951 } else {
3952 PyErr_SetString(PyExc_TypeError, "required field \"nl\" missing from Print");
3953 return 1;
3954 }
3955 *out = Print(dest, values, nl, lineno, col_offset, arena);
3956 if (*out == NULL) goto failed;
3957 return 0;
3958 }
3959 isinstance = PyObject_IsInstance(obj, (PyObject*)For_type);
3960 if (isinstance == -1) {
3961 return 1;
3962 }
3963 if (isinstance) {
3964 expr_ty target;
3965 expr_ty iter;
3966 asdl_seq* body;
3967 asdl_seq* orelse;
3968
3969 if (PyObject_HasAttrString(obj, "target")) {
3970 int res;
3971 tmp = PyObject_GetAttrString(obj, "target");
3972 if (tmp == NULL) goto failed;
3973 res = obj2ast_expr(tmp, &target, arena);
3974 if (res != 0) goto failed;
3975 Py_XDECREF(tmp);
3976 tmp = NULL;
3977 } else {
3978 PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For");
3979 return 1;
3980 }
3981 if (PyObject_HasAttrString(obj, "iter")) {
3982 int res;
3983 tmp = PyObject_GetAttrString(obj, "iter");
3984 if (tmp == NULL) goto failed;
3985 res = obj2ast_expr(tmp, &iter, arena);
3986 if (res != 0) goto failed;
3987 Py_XDECREF(tmp);
3988 tmp = NULL;
3989 } else {
3990 PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For");
3991 return 1;
3992 }
3993 if (PyObject_HasAttrString(obj, "body")) {
3994 int res;
3995 Py_ssize_t len;
3996 Py_ssize_t i;
3997 tmp = PyObject_GetAttrString(obj, "body");
3998 if (tmp == NULL) goto failed;
3999 if (!PyList_Check(tmp)) {
4000 PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4001 goto failed;
4002 }
4003 len = PyList_GET_SIZE(tmp);
4004 body = asdl_seq_new(len, arena);
4005 if (body == NULL) goto failed;
4006 for (i = 0; i < len; i++) {
4007 stmt_ty value;
4008 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4009 if (res != 0) goto failed;
4010 if (len != PyList_GET_SIZE(tmp)) {
4011 PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
4012 goto failed;
4013 }
4014 asdl_seq_SET(body, i, value);
4015 }
4016 Py_XDECREF(tmp);
4017 tmp = NULL;
4018 } else {
4019 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For");
4020 return 1;
4021 }
4022 if (PyObject_HasAttrString(obj, "orelse")) {
4023 int res;
4024 Py_ssize_t len;
4025 Py_ssize_t i;
4026 tmp = PyObject_GetAttrString(obj, "orelse");
4027 if (tmp == NULL) goto failed;
4028 if (!PyList_Check(tmp)) {
4029 PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4030 goto failed;
4031 }
4032 len = PyList_GET_SIZE(tmp);
4033 orelse = asdl_seq_new(len, arena);
4034 if (orelse == NULL) goto failed;
4035 for (i = 0; i < len; i++) {
4036 stmt_ty value;
4037 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4038 if (res != 0) goto failed;
4039 if (len != PyList_GET_SIZE(tmp)) {
4040 PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
4041 goto failed;
4042 }
4043 asdl_seq_SET(orelse, i, value);
4044 }
4045 Py_XDECREF(tmp);
4046 tmp = NULL;
4047 } else {
4048 PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For");
4049 return 1;
4050 }
4051 *out = For(target, iter, body, orelse, lineno, col_offset,
4052 arena);
4053 if (*out == NULL) goto failed;
4054 return 0;
4055 }
4056 isinstance = PyObject_IsInstance(obj, (PyObject*)While_type);
4057 if (isinstance == -1) {
4058 return 1;
4059 }
4060 if (isinstance) {
4061 expr_ty test;
4062 asdl_seq* body;
4063 asdl_seq* orelse;
4064
4065 if (PyObject_HasAttrString(obj, "test")) {
4066 int res;
4067 tmp = PyObject_GetAttrString(obj, "test");
4068 if (tmp == NULL) goto failed;
4069 res = obj2ast_expr(tmp, &test, arena);
4070 if (res != 0) goto failed;
4071 Py_XDECREF(tmp);
4072 tmp = NULL;
4073 } else {
4074 PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While");
4075 return 1;
4076 }
4077 if (PyObject_HasAttrString(obj, "body")) {
4078 int res;
4079 Py_ssize_t len;
4080 Py_ssize_t i;
4081 tmp = PyObject_GetAttrString(obj, "body");
4082 if (tmp == NULL) goto failed;
4083 if (!PyList_Check(tmp)) {
4084 PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4085 goto failed;
4086 }
4087 len = PyList_GET_SIZE(tmp);
4088 body = asdl_seq_new(len, arena);
4089 if (body == NULL) goto failed;
4090 for (i = 0; i < len; i++) {
4091 stmt_ty value;
4092 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4093 if (res != 0) goto failed;
4094 if (len != PyList_GET_SIZE(tmp)) {
4095 PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
4096 goto failed;
4097 }
4098 asdl_seq_SET(body, i, value);
4099 }
4100 Py_XDECREF(tmp);
4101 tmp = NULL;
4102 } else {
4103 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While");
4104 return 1;
4105 }
4106 if (PyObject_HasAttrString(obj, "orelse")) {
4107 int res;
4108 Py_ssize_t len;
4109 Py_ssize_t i;
4110 tmp = PyObject_GetAttrString(obj, "orelse");
4111 if (tmp == NULL) goto failed;
4112 if (!PyList_Check(tmp)) {
4113 PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4114 goto failed;
4115 }
4116 len = PyList_GET_SIZE(tmp);
4117 orelse = asdl_seq_new(len, arena);
4118 if (orelse == NULL) goto failed;
4119 for (i = 0; i < len; i++) {
4120 stmt_ty value;
4121 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4122 if (res != 0) goto failed;
4123 if (len != PyList_GET_SIZE(tmp)) {
4124 PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
4125 goto failed;
4126 }
4127 asdl_seq_SET(orelse, i, value);
4128 }
4129 Py_XDECREF(tmp);
4130 tmp = NULL;
4131 } else {
4132 PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While");
4133 return 1;
4134 }
4135 *out = While(test, body, orelse, lineno, col_offset, arena);
4136 if (*out == NULL) goto failed;
4137 return 0;
4138 }
4139 isinstance = PyObject_IsInstance(obj, (PyObject*)If_type);
4140 if (isinstance == -1) {
4141 return 1;
4142 }
4143 if (isinstance) {
4144 expr_ty test;
4145 asdl_seq* body;
4146 asdl_seq* orelse;
4147
4148 if (PyObject_HasAttrString(obj, "test")) {
4149 int res;
4150 tmp = PyObject_GetAttrString(obj, "test");
4151 if (tmp == NULL) goto failed;
4152 res = obj2ast_expr(tmp, &test, arena);
4153 if (res != 0) goto failed;
4154 Py_XDECREF(tmp);
4155 tmp = NULL;
4156 } else {
4157 PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If");
4158 return 1;
4159 }
4160 if (PyObject_HasAttrString(obj, "body")) {
4161 int res;
4162 Py_ssize_t len;
4163 Py_ssize_t i;
4164 tmp = PyObject_GetAttrString(obj, "body");
4165 if (tmp == NULL) goto failed;
4166 if (!PyList_Check(tmp)) {
4167 PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4168 goto failed;
4169 }
4170 len = PyList_GET_SIZE(tmp);
4171 body = asdl_seq_new(len, arena);
4172 if (body == NULL) goto failed;
4173 for (i = 0; i < len; i++) {
4174 stmt_ty value;
4175 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4176 if (res != 0) goto failed;
4177 if (len != PyList_GET_SIZE(tmp)) {
4178 PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
4179 goto failed;
4180 }
4181 asdl_seq_SET(body, i, value);
4182 }
4183 Py_XDECREF(tmp);
4184 tmp = NULL;
4185 } else {
4186 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If");
4187 return 1;
4188 }
4189 if (PyObject_HasAttrString(obj, "orelse")) {
4190 int res;
4191 Py_ssize_t len;
4192 Py_ssize_t i;
4193 tmp = PyObject_GetAttrString(obj, "orelse");
4194 if (tmp == NULL) goto failed;
4195 if (!PyList_Check(tmp)) {
4196 PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4197 goto failed;
4198 }
4199 len = PyList_GET_SIZE(tmp);
4200 orelse = asdl_seq_new(len, arena);
4201 if (orelse == NULL) goto failed;
4202 for (i = 0; i < len; i++) {
4203 stmt_ty value;
4204 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4205 if (res != 0) goto failed;
4206 if (len != PyList_GET_SIZE(tmp)) {
4207 PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
4208 goto failed;
4209 }
4210 asdl_seq_SET(orelse, i, value);
4211 }
4212 Py_XDECREF(tmp);
4213 tmp = NULL;
4214 } else {
4215 PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If");
4216 return 1;
4217 }
4218 *out = If(test, body, orelse, lineno, col_offset, arena);
4219 if (*out == NULL) goto failed;
4220 return 0;
4221 }
4222 isinstance = PyObject_IsInstance(obj, (PyObject*)With_type);
4223 if (isinstance == -1) {
4224 return 1;
4225 }
4226 if (isinstance) {
4227 expr_ty context_expr;
4228 expr_ty optional_vars;
4229 asdl_seq* body;
4230
4231 if (PyObject_HasAttrString(obj, "context_expr")) {
4232 int res;
4233 tmp = PyObject_GetAttrString(obj, "context_expr");
4234 if (tmp == NULL) goto failed;
4235 res = obj2ast_expr(tmp, &context_expr, arena);
4236 if (res != 0) goto failed;
4237 Py_XDECREF(tmp);
4238 tmp = NULL;
4239 } else {
4240 PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from With");
4241 return 1;
4242 }
4243 if (PyObject_HasAttrString(obj, "optional_vars")) {
4244 int res;
4245 tmp = PyObject_GetAttrString(obj, "optional_vars");
4246 if (tmp == NULL) goto failed;
4247 res = obj2ast_expr(tmp, &optional_vars, arena);
4248 if (res != 0) goto failed;
4249 Py_XDECREF(tmp);
4250 tmp = NULL;
4251 } else {
4252 optional_vars = NULL;
4253 }
4254 if (PyObject_HasAttrString(obj, "body")) {
4255 int res;
4256 Py_ssize_t len;
4257 Py_ssize_t i;
4258 tmp = PyObject_GetAttrString(obj, "body");
4259 if (tmp == NULL) goto failed;
4260 if (!PyList_Check(tmp)) {
4261 PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4262 goto failed;
4263 }
4264 len = PyList_GET_SIZE(tmp);
4265 body = asdl_seq_new(len, arena);
4266 if (body == NULL) goto failed;
4267 for (i = 0; i < len; i++) {
4268 stmt_ty value;
4269 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4270 if (res != 0) goto failed;
4271 if (len != PyList_GET_SIZE(tmp)) {
4272 PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
4273 goto failed;
4274 }
4275 asdl_seq_SET(body, i, value);
4276 }
4277 Py_XDECREF(tmp);
4278 tmp = NULL;
4279 } else {
4280 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With");
4281 return 1;
4282 }
4283 *out = With(context_expr, optional_vars, body, lineno,
4284 col_offset, arena);
4285 if (*out == NULL) goto failed;
4286 return 0;
4287 }
4288 isinstance = PyObject_IsInstance(obj, (PyObject*)Raise_type);
4289 if (isinstance == -1) {
4290 return 1;
4291 }
4292 if (isinstance) {
4293 expr_ty type;
4294 expr_ty inst;
4295 expr_ty tback;
4296
4297 if (PyObject_HasAttrString(obj, "type")) {
4298 int res;
4299 tmp = PyObject_GetAttrString(obj, "type");
4300 if (tmp == NULL) goto failed;
4301 res = obj2ast_expr(tmp, &type, arena);
4302 if (res != 0) goto failed;
4303 Py_XDECREF(tmp);
4304 tmp = NULL;
4305 } else {
4306 type = NULL;
4307 }
4308 if (PyObject_HasAttrString(obj, "inst")) {
4309 int res;
4310 tmp = PyObject_GetAttrString(obj, "inst");
4311 if (tmp == NULL) goto failed;
4312 res = obj2ast_expr(tmp, &inst, arena);
4313 if (res != 0) goto failed;
4314 Py_XDECREF(tmp);
4315 tmp = NULL;
4316 } else {
4317 inst = NULL;
4318 }
4319 if (PyObject_HasAttrString(obj, "tback")) {
4320 int res;
4321 tmp = PyObject_GetAttrString(obj, "tback");
4322 if (tmp == NULL) goto failed;
4323 res = obj2ast_expr(tmp, &tback, arena);
4324 if (res != 0) goto failed;
4325 Py_XDECREF(tmp);
4326 tmp = NULL;
4327 } else {
4328 tback = NULL;
4329 }
4330 *out = Raise(type, inst, tback, lineno, col_offset, arena);
4331 if (*out == NULL) goto failed;
4332 return 0;
4333 }
4334 isinstance = PyObject_IsInstance(obj, (PyObject*)TryExcept_type);
4335 if (isinstance == -1) {
4336 return 1;
4337 }
4338 if (isinstance) {
4339 asdl_seq* body;
4340 asdl_seq* handlers;
4341 asdl_seq* orelse;
4342
4343 if (PyObject_HasAttrString(obj, "body")) {
4344 int res;
4345 Py_ssize_t len;
4346 Py_ssize_t i;
4347 tmp = PyObject_GetAttrString(obj, "body");
4348 if (tmp == NULL) goto failed;
4349 if (!PyList_Check(tmp)) {
4350 PyErr_Format(PyExc_TypeError, "TryExcept field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4351 goto failed;
4352 }
4353 len = PyList_GET_SIZE(tmp);
4354 body = asdl_seq_new(len, arena);
4355 if (body == NULL) goto failed;
4356 for (i = 0; i < len; i++) {
4357 stmt_ty value;
4358 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4359 if (res != 0) goto failed;
4360 if (len != PyList_GET_SIZE(tmp)) {
4361 PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"body\" changed size during iteration");
4362 goto failed;
4363 }
4364 asdl_seq_SET(body, i, value);
4365 }
4366 Py_XDECREF(tmp);
4367 tmp = NULL;
4368 } else {
4369 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryExcept");
4370 return 1;
4371 }
4372 if (PyObject_HasAttrString(obj, "handlers")) {
4373 int res;
4374 Py_ssize_t len;
4375 Py_ssize_t i;
4376 tmp = PyObject_GetAttrString(obj, "handlers");
4377 if (tmp == NULL) goto failed;
4378 if (!PyList_Check(tmp)) {
4379 PyErr_Format(PyExc_TypeError, "TryExcept field \"handlers\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4380 goto failed;
4381 }
4382 len = PyList_GET_SIZE(tmp);
4383 handlers = asdl_seq_new(len, arena);
4384 if (handlers == NULL) goto failed;
4385 for (i = 0; i < len; i++) {
4386 excepthandler_ty value;
4387 res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &value, arena);
4388 if (res != 0) goto failed;
4389 if (len != PyList_GET_SIZE(tmp)) {
4390 PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"handlers\" changed size during iteration");
4391 goto failed;
4392 }
4393 asdl_seq_SET(handlers, i, value);
4394 }
4395 Py_XDECREF(tmp);
4396 tmp = NULL;
4397 } else {
4398 PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from TryExcept");
4399 return 1;
4400 }
4401 if (PyObject_HasAttrString(obj, "orelse")) {
4402 int res;
4403 Py_ssize_t len;
4404 Py_ssize_t i;
4405 tmp = PyObject_GetAttrString(obj, "orelse");
4406 if (tmp == NULL) goto failed;
4407 if (!PyList_Check(tmp)) {
4408 PyErr_Format(PyExc_TypeError, "TryExcept field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4409 goto failed;
4410 }
4411 len = PyList_GET_SIZE(tmp);
4412 orelse = asdl_seq_new(len, arena);
4413 if (orelse == NULL) goto failed;
4414 for (i = 0; i < len; i++) {
4415 stmt_ty value;
4416 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4417 if (res != 0) goto failed;
4418 if (len != PyList_GET_SIZE(tmp)) {
4419 PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"orelse\" changed size during iteration");
4420 goto failed;
4421 }
4422 asdl_seq_SET(orelse, i, value);
4423 }
4424 Py_XDECREF(tmp);
4425 tmp = NULL;
4426 } else {
4427 PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from TryExcept");
4428 return 1;
4429 }
4430 *out = TryExcept(body, handlers, orelse, lineno, col_offset,
4431 arena);
4432 if (*out == NULL) goto failed;
4433 return 0;
4434 }
4435 isinstance = PyObject_IsInstance(obj, (PyObject*)TryFinally_type);
4436 if (isinstance == -1) {
4437 return 1;
4438 }
4439 if (isinstance) {
4440 asdl_seq* body;
4441 asdl_seq* finalbody;
4442
4443 if (PyObject_HasAttrString(obj, "body")) {
4444 int res;
4445 Py_ssize_t len;
4446 Py_ssize_t i;
4447 tmp = PyObject_GetAttrString(obj, "body");
4448 if (tmp == NULL) goto failed;
4449 if (!PyList_Check(tmp)) {
4450 PyErr_Format(PyExc_TypeError, "TryFinally field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4451 goto failed;
4452 }
4453 len = PyList_GET_SIZE(tmp);
4454 body = asdl_seq_new(len, arena);
4455 if (body == NULL) goto failed;
4456 for (i = 0; i < len; i++) {
4457 stmt_ty value;
4458 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4459 if (res != 0) goto failed;
4460 if (len != PyList_GET_SIZE(tmp)) {
4461 PyErr_SetString(PyExc_RuntimeError, "TryFinally field \"body\" changed size during iteration");
4462 goto failed;
4463 }
4464 asdl_seq_SET(body, i, value);
4465 }
4466 Py_XDECREF(tmp);
4467 tmp = NULL;
4468 } else {
4469 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryFinally");
4470 return 1;
4471 }
4472 if (PyObject_HasAttrString(obj, "finalbody")) {
4473 int res;
4474 Py_ssize_t len;
4475 Py_ssize_t i;
4476 tmp = PyObject_GetAttrString(obj, "finalbody");
4477 if (tmp == NULL) goto failed;
4478 if (!PyList_Check(tmp)) {
4479 PyErr_Format(PyExc_TypeError, "TryFinally field \"finalbody\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4480 goto failed;
4481 }
4482 len = PyList_GET_SIZE(tmp);
4483 finalbody = asdl_seq_new(len, arena);
4484 if (finalbody == NULL) goto failed;
4485 for (i = 0; i < len; i++) {
4486 stmt_ty value;
4487 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4488 if (res != 0) goto failed;
4489 if (len != PyList_GET_SIZE(tmp)) {
4490 PyErr_SetString(PyExc_RuntimeError, "TryFinally field \"finalbody\" changed size during iteration");
4491 goto failed;
4492 }
4493 asdl_seq_SET(finalbody, i, value);
4494 }
4495 Py_XDECREF(tmp);
4496 tmp = NULL;
4497 } else {
4498 PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from TryFinally");
4499 return 1;
4500 }
4501 *out = TryFinally(body, finalbody, lineno, col_offset, arena);
4502 if (*out == NULL) goto failed;
4503 return 0;
4504 }
4505 isinstance = PyObject_IsInstance(obj, (PyObject*)Assert_type);
4506 if (isinstance == -1) {
4507 return 1;
4508 }
4509 if (isinstance) {
4510 expr_ty test;
4511 expr_ty msg;
4512
4513 if (PyObject_HasAttrString(obj, "test")) {
4514 int res;
4515 tmp = PyObject_GetAttrString(obj, "test");
4516 if (tmp == NULL) goto failed;
4517 res = obj2ast_expr(tmp, &test, arena);
4518 if (res != 0) goto failed;
4519 Py_XDECREF(tmp);
4520 tmp = NULL;
4521 } else {
4522 PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert");
4523 return 1;
4524 }
4525 if (PyObject_HasAttrString(obj, "msg")) {
4526 int res;
4527 tmp = PyObject_GetAttrString(obj, "msg");
4528 if (tmp == NULL) goto failed;
4529 res = obj2ast_expr(tmp, &msg, arena);
4530 if (res != 0) goto failed;
4531 Py_XDECREF(tmp);
4532 tmp = NULL;
4533 } else {
4534 msg = NULL;
4535 }
4536 *out = Assert(test, msg, lineno, col_offset, arena);
4537 if (*out == NULL) goto failed;
4538 return 0;
4539 }
4540 isinstance = PyObject_IsInstance(obj, (PyObject*)Import_type);
4541 if (isinstance == -1) {
4542 return 1;
4543 }
4544 if (isinstance) {
4545 asdl_seq* names;
4546
4547 if (PyObject_HasAttrString(obj, "names")) {
4548 int res;
4549 Py_ssize_t len;
4550 Py_ssize_t i;
4551 tmp = PyObject_GetAttrString(obj, "names");
4552 if (tmp == NULL) goto failed;
4553 if (!PyList_Check(tmp)) {
4554 PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4555 goto failed;
4556 }
4557 len = PyList_GET_SIZE(tmp);
4558 names = asdl_seq_new(len, arena);
4559 if (names == NULL) goto failed;
4560 for (i = 0; i < len; i++) {
4561 alias_ty value;
4562 res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
4563 if (res != 0) goto failed;
4564 if (len != PyList_GET_SIZE(tmp)) {
4565 PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
4566 goto failed;
4567 }
4568 asdl_seq_SET(names, i, value);
4569 }
4570 Py_XDECREF(tmp);
4571 tmp = NULL;
4572 } else {
4573 PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import");
4574 return 1;
4575 }
4576 *out = Import(names, lineno, col_offset, arena);
4577 if (*out == NULL) goto failed;
4578 return 0;
4579 }
4580 isinstance = PyObject_IsInstance(obj, (PyObject*)ImportFrom_type);
4581 if (isinstance == -1) {
4582 return 1;
4583 }
4584 if (isinstance) {
4585 identifier module;
4586 asdl_seq* names;
4587 int level;
4588
4589 if (PyObject_HasAttrString(obj, "module")) {
4590 int res;
4591 tmp = PyObject_GetAttrString(obj, "module");
4592 if (tmp == NULL) goto failed;
4593 res = obj2ast_identifier(tmp, &module, arena);
4594 if (res != 0) goto failed;
4595 Py_XDECREF(tmp);
4596 tmp = NULL;
4597 } else {
4598 module = NULL;
4599 }
4600 if (PyObject_HasAttrString(obj, "names")) {
4601 int res;
4602 Py_ssize_t len;
4603 Py_ssize_t i;
4604 tmp = PyObject_GetAttrString(obj, "names");
4605 if (tmp == NULL) goto failed;
4606 if (!PyList_Check(tmp)) {
4607 PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4608 goto failed;
4609 }
4610 len = PyList_GET_SIZE(tmp);
4611 names = asdl_seq_new(len, arena);
4612 if (names == NULL) goto failed;
4613 for (i = 0; i < len; i++) {
4614 alias_ty value;
4615 res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
4616 if (res != 0) goto failed;
4617 if (len != PyList_GET_SIZE(tmp)) {
4618 PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
4619 goto failed;
4620 }
4621 asdl_seq_SET(names, i, value);
4622 }
4623 Py_XDECREF(tmp);
4624 tmp = NULL;
4625 } else {
4626 PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom");
4627 return 1;
4628 }
4629 if (PyObject_HasAttrString(obj, "level")) {
4630 int res;
4631 tmp = PyObject_GetAttrString(obj, "level");
4632 if (tmp == NULL) goto failed;
4633 res = obj2ast_int(tmp, &level, arena);
4634 if (res != 0) goto failed;
4635 Py_XDECREF(tmp);
4636 tmp = NULL;
4637 } else {
4638 level = 0;
4639 }
4640 *out = ImportFrom(module, names, level, lineno, col_offset,
4641 arena);
4642 if (*out == NULL) goto failed;
4643 return 0;
4644 }
4645 isinstance = PyObject_IsInstance(obj, (PyObject*)Exec_type);
4646 if (isinstance == -1) {
4647 return 1;
4648 }
4649 if (isinstance) {
4650 expr_ty body;
4651 expr_ty globals;
4652 expr_ty locals;
4653
4654 if (PyObject_HasAttrString(obj, "body")) {
4655 int res;
4656 tmp = PyObject_GetAttrString(obj, "body");
4657 if (tmp == NULL) goto failed;
4658 res = obj2ast_expr(tmp, &body, arena);
4659 if (res != 0) goto failed;
4660 Py_XDECREF(tmp);
4661 tmp = NULL;
4662 } else {
4663 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Exec");
4664 return 1;
4665 }
4666 if (PyObject_HasAttrString(obj, "globals")) {
4667 int res;
4668 tmp = PyObject_GetAttrString(obj, "globals");
4669 if (tmp == NULL) goto failed;
4670 res = obj2ast_expr(tmp, &globals, arena);
4671 if (res != 0) goto failed;
4672 Py_XDECREF(tmp);
4673 tmp = NULL;
4674 } else {
4675 globals = NULL;
4676 }
4677 if (PyObject_HasAttrString(obj, "locals")) {
4678 int res;
4679 tmp = PyObject_GetAttrString(obj, "locals");
4680 if (tmp == NULL) goto failed;
4681 res = obj2ast_expr(tmp, &locals, arena);
4682 if (res != 0) goto failed;
4683 Py_XDECREF(tmp);
4684 tmp = NULL;
4685 } else {
4686 locals = NULL;
4687 }
4688 *out = Exec(body, globals, locals, lineno, col_offset, arena);
4689 if (*out == NULL) goto failed;
4690 return 0;
4691 }
4692 isinstance = PyObject_IsInstance(obj, (PyObject*)Global_type);
4693 if (isinstance == -1) {
4694 return 1;
4695 }
4696 if (isinstance) {
4697 asdl_seq* names;
4698
4699 if (PyObject_HasAttrString(obj, "names")) {
4700 int res;
4701 Py_ssize_t len;
4702 Py_ssize_t i;
4703 tmp = PyObject_GetAttrString(obj, "names");
4704 if (tmp == NULL) goto failed;
4705 if (!PyList_Check(tmp)) {
4706 PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4707 goto failed;
4708 }
4709 len = PyList_GET_SIZE(tmp);
4710 names = asdl_seq_new(len, arena);
4711 if (names == NULL) goto failed;
4712 for (i = 0; i < len; i++) {
4713 identifier value;
4714 res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena);
4715 if (res != 0) goto failed;
4716 if (len != PyList_GET_SIZE(tmp)) {
4717 PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
4718 goto failed;
4719 }
4720 asdl_seq_SET(names, i, value);
4721 }
4722 Py_XDECREF(tmp);
4723 tmp = NULL;
4724 } else {
4725 PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global");
4726 return 1;
4727 }
4728 *out = Global(names, lineno, col_offset, arena);
4729 if (*out == NULL) goto failed;
4730 return 0;
4731 }
4732 isinstance = PyObject_IsInstance(obj, (PyObject*)Expr_type);
4733 if (isinstance == -1) {
4734 return 1;
4735 }
4736 if (isinstance) {
4737 expr_ty value;
4738
4739 if (PyObject_HasAttrString(obj, "value")) {
4740 int res;
4741 tmp = PyObject_GetAttrString(obj, "value");
4742 if (tmp == NULL) goto failed;
4743 res = obj2ast_expr(tmp, &value, arena);
4744 if (res != 0) goto failed;
4745 Py_XDECREF(tmp);
4746 tmp = NULL;
4747 } else {
4748 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr");
4749 return 1;
4750 }
4751 *out = Expr(value, lineno, col_offset, arena);
4752 if (*out == NULL) goto failed;
4753 return 0;
4754 }
4755 isinstance = PyObject_IsInstance(obj, (PyObject*)Pass_type);
4756 if (isinstance == -1) {
4757 return 1;
4758 }
4759 if (isinstance) {
4760
4761 *out = Pass(lineno, col_offset, arena);
4762 if (*out == NULL) goto failed;
4763 return 0;
4764 }
4765 isinstance = PyObject_IsInstance(obj, (PyObject*)Break_type);
4766 if (isinstance == -1) {
4767 return 1;
4768 }
4769 if (isinstance) {
4770
4771 *out = Break(lineno, col_offset, arena);
4772 if (*out == NULL) goto failed;
4773 return 0;
4774 }
4775 isinstance = PyObject_IsInstance(obj, (PyObject*)Continue_type);
4776 if (isinstance == -1) {
4777 return 1;
4778 }
4779 if (isinstance) {
4780
4781 *out = Continue(lineno, col_offset, arena);
4782 if (*out == NULL) goto failed;
4783 return 0;
4784 }
4785
4786 tmp = PyObject_Repr(obj);
4787 if (tmp == NULL) goto failed;
4788 PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %.400s", PyString_AS_STRING(tmp));
4789 failed:
4790 Py_XDECREF(tmp);
4791 return 1;
4792 }
4793
4794 int
obj2ast_expr(PyObject * obj,expr_ty * out,PyArena * arena)4795 obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena)
4796 {
4797 PyObject* tmp = NULL;
4798 int isinstance;
4799
4800 int lineno;
4801 int col_offset;
4802
4803 if (obj == Py_None) {
4804 *out = NULL;
4805 return 0;
4806 }
4807 if (PyObject_HasAttrString(obj, "lineno")) {
4808 int res;
4809 tmp = PyObject_GetAttrString(obj, "lineno");
4810 if (tmp == NULL) goto failed;
4811 res = obj2ast_int(tmp, &lineno, arena);
4812 if (res != 0) goto failed;
4813 Py_XDECREF(tmp);
4814 tmp = NULL;
4815 } else {
4816 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr");
4817 return 1;
4818 }
4819 if (PyObject_HasAttrString(obj, "col_offset")) {
4820 int res;
4821 tmp = PyObject_GetAttrString(obj, "col_offset");
4822 if (tmp == NULL) goto failed;
4823 res = obj2ast_int(tmp, &col_offset, arena);
4824 if (res != 0) goto failed;
4825 Py_XDECREF(tmp);
4826 tmp = NULL;
4827 } else {
4828 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr");
4829 return 1;
4830 }
4831 isinstance = PyObject_IsInstance(obj, (PyObject*)BoolOp_type);
4832 if (isinstance == -1) {
4833 return 1;
4834 }
4835 if (isinstance) {
4836 boolop_ty op;
4837 asdl_seq* values;
4838
4839 if (PyObject_HasAttrString(obj, "op")) {
4840 int res;
4841 tmp = PyObject_GetAttrString(obj, "op");
4842 if (tmp == NULL) goto failed;
4843 res = obj2ast_boolop(tmp, &op, arena);
4844 if (res != 0) goto failed;
4845 Py_XDECREF(tmp);
4846 tmp = NULL;
4847 } else {
4848 PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp");
4849 return 1;
4850 }
4851 if (PyObject_HasAttrString(obj, "values")) {
4852 int res;
4853 Py_ssize_t len;
4854 Py_ssize_t i;
4855 tmp = PyObject_GetAttrString(obj, "values");
4856 if (tmp == NULL) goto failed;
4857 if (!PyList_Check(tmp)) {
4858 PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4859 goto failed;
4860 }
4861 len = PyList_GET_SIZE(tmp);
4862 values = asdl_seq_new(len, arena);
4863 if (values == NULL) goto failed;
4864 for (i = 0; i < len; i++) {
4865 expr_ty value;
4866 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
4867 if (res != 0) goto failed;
4868 if (len != PyList_GET_SIZE(tmp)) {
4869 PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
4870 goto failed;
4871 }
4872 asdl_seq_SET(values, i, value);
4873 }
4874 Py_XDECREF(tmp);
4875 tmp = NULL;
4876 } else {
4877 PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp");
4878 return 1;
4879 }
4880 *out = BoolOp(op, values, lineno, col_offset, arena);
4881 if (*out == NULL) goto failed;
4882 return 0;
4883 }
4884 isinstance = PyObject_IsInstance(obj, (PyObject*)BinOp_type);
4885 if (isinstance == -1) {
4886 return 1;
4887 }
4888 if (isinstance) {
4889 expr_ty left;
4890 operator_ty op;
4891 expr_ty right;
4892
4893 if (PyObject_HasAttrString(obj, "left")) {
4894 int res;
4895 tmp = PyObject_GetAttrString(obj, "left");
4896 if (tmp == NULL) goto failed;
4897 res = obj2ast_expr(tmp, &left, arena);
4898 if (res != 0) goto failed;
4899 Py_XDECREF(tmp);
4900 tmp = NULL;
4901 } else {
4902 PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp");
4903 return 1;
4904 }
4905 if (PyObject_HasAttrString(obj, "op")) {
4906 int res;
4907 tmp = PyObject_GetAttrString(obj, "op");
4908 if (tmp == NULL) goto failed;
4909 res = obj2ast_operator(tmp, &op, arena);
4910 if (res != 0) goto failed;
4911 Py_XDECREF(tmp);
4912 tmp = NULL;
4913 } else {
4914 PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp");
4915 return 1;
4916 }
4917 if (PyObject_HasAttrString(obj, "right")) {
4918 int res;
4919 tmp = PyObject_GetAttrString(obj, "right");
4920 if (tmp == NULL) goto failed;
4921 res = obj2ast_expr(tmp, &right, arena);
4922 if (res != 0) goto failed;
4923 Py_XDECREF(tmp);
4924 tmp = NULL;
4925 } else {
4926 PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp");
4927 return 1;
4928 }
4929 *out = BinOp(left, op, right, lineno, col_offset, arena);
4930 if (*out == NULL) goto failed;
4931 return 0;
4932 }
4933 isinstance = PyObject_IsInstance(obj, (PyObject*)UnaryOp_type);
4934 if (isinstance == -1) {
4935 return 1;
4936 }
4937 if (isinstance) {
4938 unaryop_ty op;
4939 expr_ty operand;
4940
4941 if (PyObject_HasAttrString(obj, "op")) {
4942 int res;
4943 tmp = PyObject_GetAttrString(obj, "op");
4944 if (tmp == NULL) goto failed;
4945 res = obj2ast_unaryop(tmp, &op, arena);
4946 if (res != 0) goto failed;
4947 Py_XDECREF(tmp);
4948 tmp = NULL;
4949 } else {
4950 PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp");
4951 return 1;
4952 }
4953 if (PyObject_HasAttrString(obj, "operand")) {
4954 int res;
4955 tmp = PyObject_GetAttrString(obj, "operand");
4956 if (tmp == NULL) goto failed;
4957 res = obj2ast_expr(tmp, &operand, arena);
4958 if (res != 0) goto failed;
4959 Py_XDECREF(tmp);
4960 tmp = NULL;
4961 } else {
4962 PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp");
4963 return 1;
4964 }
4965 *out = UnaryOp(op, operand, lineno, col_offset, arena);
4966 if (*out == NULL) goto failed;
4967 return 0;
4968 }
4969 isinstance = PyObject_IsInstance(obj, (PyObject*)Lambda_type);
4970 if (isinstance == -1) {
4971 return 1;
4972 }
4973 if (isinstance) {
4974 arguments_ty args;
4975 expr_ty body;
4976
4977 if (PyObject_HasAttrString(obj, "args")) {
4978 int res;
4979 tmp = PyObject_GetAttrString(obj, "args");
4980 if (tmp == NULL) goto failed;
4981 res = obj2ast_arguments(tmp, &args, arena);
4982 if (res != 0) goto failed;
4983 Py_XDECREF(tmp);
4984 tmp = NULL;
4985 } else {
4986 PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda");
4987 return 1;
4988 }
4989 if (PyObject_HasAttrString(obj, "body")) {
4990 int res;
4991 tmp = PyObject_GetAttrString(obj, "body");
4992 if (tmp == NULL) goto failed;
4993 res = obj2ast_expr(tmp, &body, arena);
4994 if (res != 0) goto failed;
4995 Py_XDECREF(tmp);
4996 tmp = NULL;
4997 } else {
4998 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda");
4999 return 1;
5000 }
5001 *out = Lambda(args, body, lineno, col_offset, arena);
5002 if (*out == NULL) goto failed;
5003 return 0;
5004 }
5005 isinstance = PyObject_IsInstance(obj, (PyObject*)IfExp_type);
5006 if (isinstance == -1) {
5007 return 1;
5008 }
5009 if (isinstance) {
5010 expr_ty test;
5011 expr_ty body;
5012 expr_ty orelse;
5013
5014 if (PyObject_HasAttrString(obj, "test")) {
5015 int res;
5016 tmp = PyObject_GetAttrString(obj, "test");
5017 if (tmp == NULL) goto failed;
5018 res = obj2ast_expr(tmp, &test, arena);
5019 if (res != 0) goto failed;
5020 Py_XDECREF(tmp);
5021 tmp = NULL;
5022 } else {
5023 PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp");
5024 return 1;
5025 }
5026 if (PyObject_HasAttrString(obj, "body")) {
5027 int res;
5028 tmp = PyObject_GetAttrString(obj, "body");
5029 if (tmp == NULL) goto failed;
5030 res = obj2ast_expr(tmp, &body, arena);
5031 if (res != 0) goto failed;
5032 Py_XDECREF(tmp);
5033 tmp = NULL;
5034 } else {
5035 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp");
5036 return 1;
5037 }
5038 if (PyObject_HasAttrString(obj, "orelse")) {
5039 int res;
5040 tmp = PyObject_GetAttrString(obj, "orelse");
5041 if (tmp == NULL) goto failed;
5042 res = obj2ast_expr(tmp, &orelse, arena);
5043 if (res != 0) goto failed;
5044 Py_XDECREF(tmp);
5045 tmp = NULL;
5046 } else {
5047 PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp");
5048 return 1;
5049 }
5050 *out = IfExp(test, body, orelse, lineno, col_offset, arena);
5051 if (*out == NULL) goto failed;
5052 return 0;
5053 }
5054 isinstance = PyObject_IsInstance(obj, (PyObject*)Dict_type);
5055 if (isinstance == -1) {
5056 return 1;
5057 }
5058 if (isinstance) {
5059 asdl_seq* keys;
5060 asdl_seq* values;
5061
5062 if (PyObject_HasAttrString(obj, "keys")) {
5063 int res;
5064 Py_ssize_t len;
5065 Py_ssize_t i;
5066 tmp = PyObject_GetAttrString(obj, "keys");
5067 if (tmp == NULL) goto failed;
5068 if (!PyList_Check(tmp)) {
5069 PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5070 goto failed;
5071 }
5072 len = PyList_GET_SIZE(tmp);
5073 keys = asdl_seq_new(len, arena);
5074 if (keys == NULL) goto failed;
5075 for (i = 0; i < len; i++) {
5076 expr_ty value;
5077 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5078 if (res != 0) goto failed;
5079 if (len != PyList_GET_SIZE(tmp)) {
5080 PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
5081 goto failed;
5082 }
5083 asdl_seq_SET(keys, i, value);
5084 }
5085 Py_XDECREF(tmp);
5086 tmp = NULL;
5087 } else {
5088 PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict");
5089 return 1;
5090 }
5091 if (PyObject_HasAttrString(obj, "values")) {
5092 int res;
5093 Py_ssize_t len;
5094 Py_ssize_t i;
5095 tmp = PyObject_GetAttrString(obj, "values");
5096 if (tmp == NULL) goto failed;
5097 if (!PyList_Check(tmp)) {
5098 PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5099 goto failed;
5100 }
5101 len = PyList_GET_SIZE(tmp);
5102 values = asdl_seq_new(len, arena);
5103 if (values == NULL) goto failed;
5104 for (i = 0; i < len; i++) {
5105 expr_ty value;
5106 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5107 if (res != 0) goto failed;
5108 if (len != PyList_GET_SIZE(tmp)) {
5109 PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
5110 goto failed;
5111 }
5112 asdl_seq_SET(values, i, value);
5113 }
5114 Py_XDECREF(tmp);
5115 tmp = NULL;
5116 } else {
5117 PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict");
5118 return 1;
5119 }
5120 *out = Dict(keys, values, lineno, col_offset, arena);
5121 if (*out == NULL) goto failed;
5122 return 0;
5123 }
5124 isinstance = PyObject_IsInstance(obj, (PyObject*)Set_type);
5125 if (isinstance == -1) {
5126 return 1;
5127 }
5128 if (isinstance) {
5129 asdl_seq* elts;
5130
5131 if (PyObject_HasAttrString(obj, "elts")) {
5132 int res;
5133 Py_ssize_t len;
5134 Py_ssize_t i;
5135 tmp = PyObject_GetAttrString(obj, "elts");
5136 if (tmp == NULL) goto failed;
5137 if (!PyList_Check(tmp)) {
5138 PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5139 goto failed;
5140 }
5141 len = PyList_GET_SIZE(tmp);
5142 elts = asdl_seq_new(len, arena);
5143 if (elts == NULL) goto failed;
5144 for (i = 0; i < len; i++) {
5145 expr_ty value;
5146 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5147 if (res != 0) goto failed;
5148 if (len != PyList_GET_SIZE(tmp)) {
5149 PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
5150 goto failed;
5151 }
5152 asdl_seq_SET(elts, i, value);
5153 }
5154 Py_XDECREF(tmp);
5155 tmp = NULL;
5156 } else {
5157 PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set");
5158 return 1;
5159 }
5160 *out = Set(elts, lineno, col_offset, arena);
5161 if (*out == NULL) goto failed;
5162 return 0;
5163 }
5164 isinstance = PyObject_IsInstance(obj, (PyObject*)ListComp_type);
5165 if (isinstance == -1) {
5166 return 1;
5167 }
5168 if (isinstance) {
5169 expr_ty elt;
5170 asdl_seq* generators;
5171
5172 if (PyObject_HasAttrString(obj, "elt")) {
5173 int res;
5174 tmp = PyObject_GetAttrString(obj, "elt");
5175 if (tmp == NULL) goto failed;
5176 res = obj2ast_expr(tmp, &elt, arena);
5177 if (res != 0) goto failed;
5178 Py_XDECREF(tmp);
5179 tmp = NULL;
5180 } else {
5181 PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp");
5182 return 1;
5183 }
5184 if (PyObject_HasAttrString(obj, "generators")) {
5185 int res;
5186 Py_ssize_t len;
5187 Py_ssize_t i;
5188 tmp = PyObject_GetAttrString(obj, "generators");
5189 if (tmp == NULL) goto failed;
5190 if (!PyList_Check(tmp)) {
5191 PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5192 goto failed;
5193 }
5194 len = PyList_GET_SIZE(tmp);
5195 generators = asdl_seq_new(len, arena);
5196 if (generators == NULL) goto failed;
5197 for (i = 0; i < len; i++) {
5198 comprehension_ty value;
5199 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5200 if (res != 0) goto failed;
5201 if (len != PyList_GET_SIZE(tmp)) {
5202 PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
5203 goto failed;
5204 }
5205 asdl_seq_SET(generators, i, value);
5206 }
5207 Py_XDECREF(tmp);
5208 tmp = NULL;
5209 } else {
5210 PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp");
5211 return 1;
5212 }
5213 *out = ListComp(elt, generators, lineno, col_offset, arena);
5214 if (*out == NULL) goto failed;
5215 return 0;
5216 }
5217 isinstance = PyObject_IsInstance(obj, (PyObject*)SetComp_type);
5218 if (isinstance == -1) {
5219 return 1;
5220 }
5221 if (isinstance) {
5222 expr_ty elt;
5223 asdl_seq* generators;
5224
5225 if (PyObject_HasAttrString(obj, "elt")) {
5226 int res;
5227 tmp = PyObject_GetAttrString(obj, "elt");
5228 if (tmp == NULL) goto failed;
5229 res = obj2ast_expr(tmp, &elt, arena);
5230 if (res != 0) goto failed;
5231 Py_XDECREF(tmp);
5232 tmp = NULL;
5233 } else {
5234 PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp");
5235 return 1;
5236 }
5237 if (PyObject_HasAttrString(obj, "generators")) {
5238 int res;
5239 Py_ssize_t len;
5240 Py_ssize_t i;
5241 tmp = PyObject_GetAttrString(obj, "generators");
5242 if (tmp == NULL) goto failed;
5243 if (!PyList_Check(tmp)) {
5244 PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5245 goto failed;
5246 }
5247 len = PyList_GET_SIZE(tmp);
5248 generators = asdl_seq_new(len, arena);
5249 if (generators == NULL) goto failed;
5250 for (i = 0; i < len; i++) {
5251 comprehension_ty value;
5252 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5253 if (res != 0) goto failed;
5254 if (len != PyList_GET_SIZE(tmp)) {
5255 PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
5256 goto failed;
5257 }
5258 asdl_seq_SET(generators, i, value);
5259 }
5260 Py_XDECREF(tmp);
5261 tmp = NULL;
5262 } else {
5263 PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp");
5264 return 1;
5265 }
5266 *out = SetComp(elt, generators, lineno, col_offset, arena);
5267 if (*out == NULL) goto failed;
5268 return 0;
5269 }
5270 isinstance = PyObject_IsInstance(obj, (PyObject*)DictComp_type);
5271 if (isinstance == -1) {
5272 return 1;
5273 }
5274 if (isinstance) {
5275 expr_ty key;
5276 expr_ty value;
5277 asdl_seq* generators;
5278
5279 if (PyObject_HasAttrString(obj, "key")) {
5280 int res;
5281 tmp = PyObject_GetAttrString(obj, "key");
5282 if (tmp == NULL) goto failed;
5283 res = obj2ast_expr(tmp, &key, arena);
5284 if (res != 0) goto failed;
5285 Py_XDECREF(tmp);
5286 tmp = NULL;
5287 } else {
5288 PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp");
5289 return 1;
5290 }
5291 if (PyObject_HasAttrString(obj, "value")) {
5292 int res;
5293 tmp = PyObject_GetAttrString(obj, "value");
5294 if (tmp == NULL) goto failed;
5295 res = obj2ast_expr(tmp, &value, arena);
5296 if (res != 0) goto failed;
5297 Py_XDECREF(tmp);
5298 tmp = NULL;
5299 } else {
5300 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp");
5301 return 1;
5302 }
5303 if (PyObject_HasAttrString(obj, "generators")) {
5304 int res;
5305 Py_ssize_t len;
5306 Py_ssize_t i;
5307 tmp = PyObject_GetAttrString(obj, "generators");
5308 if (tmp == NULL) goto failed;
5309 if (!PyList_Check(tmp)) {
5310 PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5311 goto failed;
5312 }
5313 len = PyList_GET_SIZE(tmp);
5314 generators = asdl_seq_new(len, arena);
5315 if (generators == NULL) goto failed;
5316 for (i = 0; i < len; i++) {
5317 comprehension_ty value;
5318 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5319 if (res != 0) goto failed;
5320 if (len != PyList_GET_SIZE(tmp)) {
5321 PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
5322 goto failed;
5323 }
5324 asdl_seq_SET(generators, i, value);
5325 }
5326 Py_XDECREF(tmp);
5327 tmp = NULL;
5328 } else {
5329 PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp");
5330 return 1;
5331 }
5332 *out = DictComp(key, value, generators, lineno, col_offset,
5333 arena);
5334 if (*out == NULL) goto failed;
5335 return 0;
5336 }
5337 isinstance = PyObject_IsInstance(obj, (PyObject*)GeneratorExp_type);
5338 if (isinstance == -1) {
5339 return 1;
5340 }
5341 if (isinstance) {
5342 expr_ty elt;
5343 asdl_seq* generators;
5344
5345 if (PyObject_HasAttrString(obj, "elt")) {
5346 int res;
5347 tmp = PyObject_GetAttrString(obj, "elt");
5348 if (tmp == NULL) goto failed;
5349 res = obj2ast_expr(tmp, &elt, arena);
5350 if (res != 0) goto failed;
5351 Py_XDECREF(tmp);
5352 tmp = NULL;
5353 } else {
5354 PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp");
5355 return 1;
5356 }
5357 if (PyObject_HasAttrString(obj, "generators")) {
5358 int res;
5359 Py_ssize_t len;
5360 Py_ssize_t i;
5361 tmp = PyObject_GetAttrString(obj, "generators");
5362 if (tmp == NULL) goto failed;
5363 if (!PyList_Check(tmp)) {
5364 PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5365 goto failed;
5366 }
5367 len = PyList_GET_SIZE(tmp);
5368 generators = asdl_seq_new(len, arena);
5369 if (generators == NULL) goto failed;
5370 for (i = 0; i < len; i++) {
5371 comprehension_ty value;
5372 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5373 if (res != 0) goto failed;
5374 if (len != PyList_GET_SIZE(tmp)) {
5375 PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
5376 goto failed;
5377 }
5378 asdl_seq_SET(generators, i, value);
5379 }
5380 Py_XDECREF(tmp);
5381 tmp = NULL;
5382 } else {
5383 PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp");
5384 return 1;
5385 }
5386 *out = GeneratorExp(elt, generators, lineno, col_offset, arena);
5387 if (*out == NULL) goto failed;
5388 return 0;
5389 }
5390 isinstance = PyObject_IsInstance(obj, (PyObject*)Yield_type);
5391 if (isinstance == -1) {
5392 return 1;
5393 }
5394 if (isinstance) {
5395 expr_ty value;
5396
5397 if (PyObject_HasAttrString(obj, "value")) {
5398 int res;
5399 tmp = PyObject_GetAttrString(obj, "value");
5400 if (tmp == NULL) goto failed;
5401 res = obj2ast_expr(tmp, &value, arena);
5402 if (res != 0) goto failed;
5403 Py_XDECREF(tmp);
5404 tmp = NULL;
5405 } else {
5406 value = NULL;
5407 }
5408 *out = Yield(value, lineno, col_offset, arena);
5409 if (*out == NULL) goto failed;
5410 return 0;
5411 }
5412 isinstance = PyObject_IsInstance(obj, (PyObject*)Compare_type);
5413 if (isinstance == -1) {
5414 return 1;
5415 }
5416 if (isinstance) {
5417 expr_ty left;
5418 asdl_int_seq* ops;
5419 asdl_seq* comparators;
5420
5421 if (PyObject_HasAttrString(obj, "left")) {
5422 int res;
5423 tmp = PyObject_GetAttrString(obj, "left");
5424 if (tmp == NULL) goto failed;
5425 res = obj2ast_expr(tmp, &left, arena);
5426 if (res != 0) goto failed;
5427 Py_XDECREF(tmp);
5428 tmp = NULL;
5429 } else {
5430 PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare");
5431 return 1;
5432 }
5433 if (PyObject_HasAttrString(obj, "ops")) {
5434 int res;
5435 Py_ssize_t len;
5436 Py_ssize_t i;
5437 tmp = PyObject_GetAttrString(obj, "ops");
5438 if (tmp == NULL) goto failed;
5439 if (!PyList_Check(tmp)) {
5440 PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5441 goto failed;
5442 }
5443 len = PyList_GET_SIZE(tmp);
5444 ops = asdl_int_seq_new(len, arena);
5445 if (ops == NULL) goto failed;
5446 for (i = 0; i < len; i++) {
5447 cmpop_ty value;
5448 res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &value, arena);
5449 if (res != 0) goto failed;
5450 if (len != PyList_GET_SIZE(tmp)) {
5451 PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
5452 goto failed;
5453 }
5454 asdl_seq_SET(ops, i, value);
5455 }
5456 Py_XDECREF(tmp);
5457 tmp = NULL;
5458 } else {
5459 PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare");
5460 return 1;
5461 }
5462 if (PyObject_HasAttrString(obj, "comparators")) {
5463 int res;
5464 Py_ssize_t len;
5465 Py_ssize_t i;
5466 tmp = PyObject_GetAttrString(obj, "comparators");
5467 if (tmp == NULL) goto failed;
5468 if (!PyList_Check(tmp)) {
5469 PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5470 goto failed;
5471 }
5472 len = PyList_GET_SIZE(tmp);
5473 comparators = asdl_seq_new(len, arena);
5474 if (comparators == NULL) goto failed;
5475 for (i = 0; i < len; i++) {
5476 expr_ty value;
5477 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5478 if (res != 0) goto failed;
5479 if (len != PyList_GET_SIZE(tmp)) {
5480 PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
5481 goto failed;
5482 }
5483 asdl_seq_SET(comparators, i, value);
5484 }
5485 Py_XDECREF(tmp);
5486 tmp = NULL;
5487 } else {
5488 PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare");
5489 return 1;
5490 }
5491 *out = Compare(left, ops, comparators, lineno, col_offset,
5492 arena);
5493 if (*out == NULL) goto failed;
5494 return 0;
5495 }
5496 isinstance = PyObject_IsInstance(obj, (PyObject*)Call_type);
5497 if (isinstance == -1) {
5498 return 1;
5499 }
5500 if (isinstance) {
5501 expr_ty func;
5502 asdl_seq* args;
5503 asdl_seq* keywords;
5504 expr_ty starargs;
5505 expr_ty kwargs;
5506
5507 if (PyObject_HasAttrString(obj, "func")) {
5508 int res;
5509 tmp = PyObject_GetAttrString(obj, "func");
5510 if (tmp == NULL) goto failed;
5511 res = obj2ast_expr(tmp, &func, arena);
5512 if (res != 0) goto failed;
5513 Py_XDECREF(tmp);
5514 tmp = NULL;
5515 } else {
5516 PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call");
5517 return 1;
5518 }
5519 if (PyObject_HasAttrString(obj, "args")) {
5520 int res;
5521 Py_ssize_t len;
5522 Py_ssize_t i;
5523 tmp = PyObject_GetAttrString(obj, "args");
5524 if (tmp == NULL) goto failed;
5525 if (!PyList_Check(tmp)) {
5526 PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5527 goto failed;
5528 }
5529 len = PyList_GET_SIZE(tmp);
5530 args = asdl_seq_new(len, arena);
5531 if (args == NULL) goto failed;
5532 for (i = 0; i < len; i++) {
5533 expr_ty value;
5534 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5535 if (res != 0) goto failed;
5536 if (len != PyList_GET_SIZE(tmp)) {
5537 PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
5538 goto failed;
5539 }
5540 asdl_seq_SET(args, i, value);
5541 }
5542 Py_XDECREF(tmp);
5543 tmp = NULL;
5544 } else {
5545 PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call");
5546 return 1;
5547 }
5548 if (PyObject_HasAttrString(obj, "keywords")) {
5549 int res;
5550 Py_ssize_t len;
5551 Py_ssize_t i;
5552 tmp = PyObject_GetAttrString(obj, "keywords");
5553 if (tmp == NULL) goto failed;
5554 if (!PyList_Check(tmp)) {
5555 PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5556 goto failed;
5557 }
5558 len = PyList_GET_SIZE(tmp);
5559 keywords = asdl_seq_new(len, arena);
5560 if (keywords == NULL) goto failed;
5561 for (i = 0; i < len; i++) {
5562 keyword_ty value;
5563 res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena);
5564 if (res != 0) goto failed;
5565 if (len != PyList_GET_SIZE(tmp)) {
5566 PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
5567 goto failed;
5568 }
5569 asdl_seq_SET(keywords, i, value);
5570 }
5571 Py_XDECREF(tmp);
5572 tmp = NULL;
5573 } else {
5574 PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call");
5575 return 1;
5576 }
5577 if (PyObject_HasAttrString(obj, "starargs")) {
5578 int res;
5579 tmp = PyObject_GetAttrString(obj, "starargs");
5580 if (tmp == NULL) goto failed;
5581 res = obj2ast_expr(tmp, &starargs, arena);
5582 if (res != 0) goto failed;
5583 Py_XDECREF(tmp);
5584 tmp = NULL;
5585 } else {
5586 starargs = NULL;
5587 }
5588 if (PyObject_HasAttrString(obj, "kwargs")) {
5589 int res;
5590 tmp = PyObject_GetAttrString(obj, "kwargs");
5591 if (tmp == NULL) goto failed;
5592 res = obj2ast_expr(tmp, &kwargs, arena);
5593 if (res != 0) goto failed;
5594 Py_XDECREF(tmp);
5595 tmp = NULL;
5596 } else {
5597 kwargs = NULL;
5598 }
5599 *out = Call(func, args, keywords, starargs, kwargs, lineno,
5600 col_offset, arena);
5601 if (*out == NULL) goto failed;
5602 return 0;
5603 }
5604 isinstance = PyObject_IsInstance(obj, (PyObject*)Repr_type);
5605 if (isinstance == -1) {
5606 return 1;
5607 }
5608 if (isinstance) {
5609 expr_ty value;
5610
5611 if (PyObject_HasAttrString(obj, "value")) {
5612 int res;
5613 tmp = PyObject_GetAttrString(obj, "value");
5614 if (tmp == NULL) goto failed;
5615 res = obj2ast_expr(tmp, &value, arena);
5616 if (res != 0) goto failed;
5617 Py_XDECREF(tmp);
5618 tmp = NULL;
5619 } else {
5620 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Repr");
5621 return 1;
5622 }
5623 *out = Repr(value, lineno, col_offset, arena);
5624 if (*out == NULL) goto failed;
5625 return 0;
5626 }
5627 isinstance = PyObject_IsInstance(obj, (PyObject*)Num_type);
5628 if (isinstance == -1) {
5629 return 1;
5630 }
5631 if (isinstance) {
5632 object n;
5633
5634 if (PyObject_HasAttrString(obj, "n")) {
5635 int res;
5636 tmp = PyObject_GetAttrString(obj, "n");
5637 if (tmp == NULL) goto failed;
5638 res = obj2ast_object(tmp, &n, arena);
5639 if (res != 0) goto failed;
5640 Py_XDECREF(tmp);
5641 tmp = NULL;
5642 } else {
5643 PyErr_SetString(PyExc_TypeError, "required field \"n\" missing from Num");
5644 return 1;
5645 }
5646 *out = Num(n, lineno, col_offset, arena);
5647 if (*out == NULL) goto failed;
5648 return 0;
5649 }
5650 isinstance = PyObject_IsInstance(obj, (PyObject*)Str_type);
5651 if (isinstance == -1) {
5652 return 1;
5653 }
5654 if (isinstance) {
5655 string s;
5656
5657 if (PyObject_HasAttrString(obj, "s")) {
5658 int res;
5659 tmp = PyObject_GetAttrString(obj, "s");
5660 if (tmp == NULL) goto failed;
5661 res = obj2ast_string(tmp, &s, arena);
5662 if (res != 0) goto failed;
5663 Py_XDECREF(tmp);
5664 tmp = NULL;
5665 } else {
5666 PyErr_SetString(PyExc_TypeError, "required field \"s\" missing from Str");
5667 return 1;
5668 }
5669 *out = Str(s, lineno, col_offset, arena);
5670 if (*out == NULL) goto failed;
5671 return 0;
5672 }
5673 isinstance = PyObject_IsInstance(obj, (PyObject*)Attribute_type);
5674 if (isinstance == -1) {
5675 return 1;
5676 }
5677 if (isinstance) {
5678 expr_ty value;
5679 identifier attr;
5680 expr_context_ty ctx;
5681
5682 if (PyObject_HasAttrString(obj, "value")) {
5683 int res;
5684 tmp = PyObject_GetAttrString(obj, "value");
5685 if (tmp == NULL) goto failed;
5686 res = obj2ast_expr(tmp, &value, arena);
5687 if (res != 0) goto failed;
5688 Py_XDECREF(tmp);
5689 tmp = NULL;
5690 } else {
5691 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute");
5692 return 1;
5693 }
5694 if (PyObject_HasAttrString(obj, "attr")) {
5695 int res;
5696 tmp = PyObject_GetAttrString(obj, "attr");
5697 if (tmp == NULL) goto failed;
5698 res = obj2ast_identifier(tmp, &attr, arena);
5699 if (res != 0) goto failed;
5700 Py_XDECREF(tmp);
5701 tmp = NULL;
5702 } else {
5703 PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute");
5704 return 1;
5705 }
5706 if (PyObject_HasAttrString(obj, "ctx")) {
5707 int res;
5708 tmp = PyObject_GetAttrString(obj, "ctx");
5709 if (tmp == NULL) goto failed;
5710 res = obj2ast_expr_context(tmp, &ctx, arena);
5711 if (res != 0) goto failed;
5712 Py_XDECREF(tmp);
5713 tmp = NULL;
5714 } else {
5715 PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute");
5716 return 1;
5717 }
5718 *out = Attribute(value, attr, ctx, lineno, col_offset, arena);
5719 if (*out == NULL) goto failed;
5720 return 0;
5721 }
5722 isinstance = PyObject_IsInstance(obj, (PyObject*)Subscript_type);
5723 if (isinstance == -1) {
5724 return 1;
5725 }
5726 if (isinstance) {
5727 expr_ty value;
5728 slice_ty slice;
5729 expr_context_ty ctx;
5730
5731 if (PyObject_HasAttrString(obj, "value")) {
5732 int res;
5733 tmp = PyObject_GetAttrString(obj, "value");
5734 if (tmp == NULL) goto failed;
5735 res = obj2ast_expr(tmp, &value, arena);
5736 if (res != 0) goto failed;
5737 Py_XDECREF(tmp);
5738 tmp = NULL;
5739 } else {
5740 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript");
5741 return 1;
5742 }
5743 if (PyObject_HasAttrString(obj, "slice")) {
5744 int res;
5745 tmp = PyObject_GetAttrString(obj, "slice");
5746 if (tmp == NULL) goto failed;
5747 res = obj2ast_slice(tmp, &slice, arena);
5748 if (res != 0) goto failed;
5749 Py_XDECREF(tmp);
5750 tmp = NULL;
5751 } else {
5752 PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript");
5753 return 1;
5754 }
5755 if (PyObject_HasAttrString(obj, "ctx")) {
5756 int res;
5757 tmp = PyObject_GetAttrString(obj, "ctx");
5758 if (tmp == NULL) goto failed;
5759 res = obj2ast_expr_context(tmp, &ctx, arena);
5760 if (res != 0) goto failed;
5761 Py_XDECREF(tmp);
5762 tmp = NULL;
5763 } else {
5764 PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript");
5765 return 1;
5766 }
5767 *out = Subscript(value, slice, ctx, lineno, col_offset, arena);
5768 if (*out == NULL) goto failed;
5769 return 0;
5770 }
5771 isinstance = PyObject_IsInstance(obj, (PyObject*)Name_type);
5772 if (isinstance == -1) {
5773 return 1;
5774 }
5775 if (isinstance) {
5776 identifier id;
5777 expr_context_ty ctx;
5778
5779 if (PyObject_HasAttrString(obj, "id")) {
5780 int res;
5781 tmp = PyObject_GetAttrString(obj, "id");
5782 if (tmp == NULL) goto failed;
5783 res = obj2ast_identifier(tmp, &id, arena);
5784 if (res != 0) goto failed;
5785 Py_XDECREF(tmp);
5786 tmp = NULL;
5787 } else {
5788 PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name");
5789 return 1;
5790 }
5791 if (PyObject_HasAttrString(obj, "ctx")) {
5792 int res;
5793 tmp = PyObject_GetAttrString(obj, "ctx");
5794 if (tmp == NULL) goto failed;
5795 res = obj2ast_expr_context(tmp, &ctx, arena);
5796 if (res != 0) goto failed;
5797 Py_XDECREF(tmp);
5798 tmp = NULL;
5799 } else {
5800 PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name");
5801 return 1;
5802 }
5803 *out = Name(id, ctx, lineno, col_offset, arena);
5804 if (*out == NULL) goto failed;
5805 return 0;
5806 }
5807 isinstance = PyObject_IsInstance(obj, (PyObject*)List_type);
5808 if (isinstance == -1) {
5809 return 1;
5810 }
5811 if (isinstance) {
5812 asdl_seq* elts;
5813 expr_context_ty ctx;
5814
5815 if (PyObject_HasAttrString(obj, "elts")) {
5816 int res;
5817 Py_ssize_t len;
5818 Py_ssize_t i;
5819 tmp = PyObject_GetAttrString(obj, "elts");
5820 if (tmp == NULL) goto failed;
5821 if (!PyList_Check(tmp)) {
5822 PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5823 goto failed;
5824 }
5825 len = PyList_GET_SIZE(tmp);
5826 elts = asdl_seq_new(len, arena);
5827 if (elts == NULL) goto failed;
5828 for (i = 0; i < len; i++) {
5829 expr_ty value;
5830 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5831 if (res != 0) goto failed;
5832 if (len != PyList_GET_SIZE(tmp)) {
5833 PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
5834 goto failed;
5835 }
5836 asdl_seq_SET(elts, i, value);
5837 }
5838 Py_XDECREF(tmp);
5839 tmp = NULL;
5840 } else {
5841 PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List");
5842 return 1;
5843 }
5844 if (PyObject_HasAttrString(obj, "ctx")) {
5845 int res;
5846 tmp = PyObject_GetAttrString(obj, "ctx");
5847 if (tmp == NULL) goto failed;
5848 res = obj2ast_expr_context(tmp, &ctx, arena);
5849 if (res != 0) goto failed;
5850 Py_XDECREF(tmp);
5851 tmp = NULL;
5852 } else {
5853 PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List");
5854 return 1;
5855 }
5856 *out = List(elts, ctx, lineno, col_offset, arena);
5857 if (*out == NULL) goto failed;
5858 return 0;
5859 }
5860 isinstance = PyObject_IsInstance(obj, (PyObject*)Tuple_type);
5861 if (isinstance == -1) {
5862 return 1;
5863 }
5864 if (isinstance) {
5865 asdl_seq* elts;
5866 expr_context_ty ctx;
5867
5868 if (PyObject_HasAttrString(obj, "elts")) {
5869 int res;
5870 Py_ssize_t len;
5871 Py_ssize_t i;
5872 tmp = PyObject_GetAttrString(obj, "elts");
5873 if (tmp == NULL) goto failed;
5874 if (!PyList_Check(tmp)) {
5875 PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5876 goto failed;
5877 }
5878 len = PyList_GET_SIZE(tmp);
5879 elts = asdl_seq_new(len, arena);
5880 if (elts == NULL) goto failed;
5881 for (i = 0; i < len; i++) {
5882 expr_ty value;
5883 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5884 if (res != 0) goto failed;
5885 if (len != PyList_GET_SIZE(tmp)) {
5886 PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
5887 goto failed;
5888 }
5889 asdl_seq_SET(elts, i, value);
5890 }
5891 Py_XDECREF(tmp);
5892 tmp = NULL;
5893 } else {
5894 PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple");
5895 return 1;
5896 }
5897 if (PyObject_HasAttrString(obj, "ctx")) {
5898 int res;
5899 tmp = PyObject_GetAttrString(obj, "ctx");
5900 if (tmp == NULL) goto failed;
5901 res = obj2ast_expr_context(tmp, &ctx, arena);
5902 if (res != 0) goto failed;
5903 Py_XDECREF(tmp);
5904 tmp = NULL;
5905 } else {
5906 PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple");
5907 return 1;
5908 }
5909 *out = Tuple(elts, ctx, lineno, col_offset, arena);
5910 if (*out == NULL) goto failed;
5911 return 0;
5912 }
5913
5914 tmp = PyObject_Repr(obj);
5915 if (tmp == NULL) goto failed;
5916 PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %.400s", PyString_AS_STRING(tmp));
5917 failed:
5918 Py_XDECREF(tmp);
5919 return 1;
5920 }
5921
5922 int
obj2ast_expr_context(PyObject * obj,expr_context_ty * out,PyArena * arena)5923 obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena)
5924 {
5925 PyObject* tmp = NULL;
5926 int isinstance;
5927
5928 isinstance = PyObject_IsInstance(obj, (PyObject *)Load_type);
5929 if (isinstance == -1) {
5930 return 1;
5931 }
5932 if (isinstance) {
5933 *out = Load;
5934 return 0;
5935 }
5936 isinstance = PyObject_IsInstance(obj, (PyObject *)Store_type);
5937 if (isinstance == -1) {
5938 return 1;
5939 }
5940 if (isinstance) {
5941 *out = Store;
5942 return 0;
5943 }
5944 isinstance = PyObject_IsInstance(obj, (PyObject *)Del_type);
5945 if (isinstance == -1) {
5946 return 1;
5947 }
5948 if (isinstance) {
5949 *out = Del;
5950 return 0;
5951 }
5952 isinstance = PyObject_IsInstance(obj, (PyObject *)AugLoad_type);
5953 if (isinstance == -1) {
5954 return 1;
5955 }
5956 if (isinstance) {
5957 *out = AugLoad;
5958 return 0;
5959 }
5960 isinstance = PyObject_IsInstance(obj, (PyObject *)AugStore_type);
5961 if (isinstance == -1) {
5962 return 1;
5963 }
5964 if (isinstance) {
5965 *out = AugStore;
5966 return 0;
5967 }
5968 isinstance = PyObject_IsInstance(obj, (PyObject *)Param_type);
5969 if (isinstance == -1) {
5970 return 1;
5971 }
5972 if (isinstance) {
5973 *out = Param;
5974 return 0;
5975 }
5976
5977 tmp = PyObject_Repr(obj);
5978 if (tmp == NULL) goto failed;
5979 PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %.400s", PyString_AS_STRING(tmp));
5980 failed:
5981 Py_XDECREF(tmp);
5982 return 1;
5983 }
5984
5985 int
obj2ast_slice(PyObject * obj,slice_ty * out,PyArena * arena)5986 obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena)
5987 {
5988 PyObject* tmp = NULL;
5989 int isinstance;
5990
5991
5992 if (obj == Py_None) {
5993 *out = NULL;
5994 return 0;
5995 }
5996 isinstance = PyObject_IsInstance(obj, (PyObject*)Ellipsis_type);
5997 if (isinstance == -1) {
5998 return 1;
5999 }
6000 if (isinstance) {
6001
6002 *out = Ellipsis(arena);
6003 if (*out == NULL) goto failed;
6004 return 0;
6005 }
6006 isinstance = PyObject_IsInstance(obj, (PyObject*)Slice_type);
6007 if (isinstance == -1) {
6008 return 1;
6009 }
6010 if (isinstance) {
6011 expr_ty lower;
6012 expr_ty upper;
6013 expr_ty step;
6014
6015 if (PyObject_HasAttrString(obj, "lower")) {
6016 int res;
6017 tmp = PyObject_GetAttrString(obj, "lower");
6018 if (tmp == NULL) goto failed;
6019 res = obj2ast_expr(tmp, &lower, arena);
6020 if (res != 0) goto failed;
6021 Py_XDECREF(tmp);
6022 tmp = NULL;
6023 } else {
6024 lower = NULL;
6025 }
6026 if (PyObject_HasAttrString(obj, "upper")) {
6027 int res;
6028 tmp = PyObject_GetAttrString(obj, "upper");
6029 if (tmp == NULL) goto failed;
6030 res = obj2ast_expr(tmp, &upper, arena);
6031 if (res != 0) goto failed;
6032 Py_XDECREF(tmp);
6033 tmp = NULL;
6034 } else {
6035 upper = NULL;
6036 }
6037 if (PyObject_HasAttrString(obj, "step")) {
6038 int res;
6039 tmp = PyObject_GetAttrString(obj, "step");
6040 if (tmp == NULL) goto failed;
6041 res = obj2ast_expr(tmp, &step, arena);
6042 if (res != 0) goto failed;
6043 Py_XDECREF(tmp);
6044 tmp = NULL;
6045 } else {
6046 step = NULL;
6047 }
6048 *out = Slice(lower, upper, step, arena);
6049 if (*out == NULL) goto failed;
6050 return 0;
6051 }
6052 isinstance = PyObject_IsInstance(obj, (PyObject*)ExtSlice_type);
6053 if (isinstance == -1) {
6054 return 1;
6055 }
6056 if (isinstance) {
6057 asdl_seq* dims;
6058
6059 if (PyObject_HasAttrString(obj, "dims")) {
6060 int res;
6061 Py_ssize_t len;
6062 Py_ssize_t i;
6063 tmp = PyObject_GetAttrString(obj, "dims");
6064 if (tmp == NULL) goto failed;
6065 if (!PyList_Check(tmp)) {
6066 PyErr_Format(PyExc_TypeError, "ExtSlice field \"dims\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6067 goto failed;
6068 }
6069 len = PyList_GET_SIZE(tmp);
6070 dims = asdl_seq_new(len, arena);
6071 if (dims == NULL) goto failed;
6072 for (i = 0; i < len; i++) {
6073 slice_ty value;
6074 res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &value, arena);
6075 if (res != 0) goto failed;
6076 if (len != PyList_GET_SIZE(tmp)) {
6077 PyErr_SetString(PyExc_RuntimeError, "ExtSlice field \"dims\" changed size during iteration");
6078 goto failed;
6079 }
6080 asdl_seq_SET(dims, i, value);
6081 }
6082 Py_XDECREF(tmp);
6083 tmp = NULL;
6084 } else {
6085 PyErr_SetString(PyExc_TypeError, "required field \"dims\" missing from ExtSlice");
6086 return 1;
6087 }
6088 *out = ExtSlice(dims, arena);
6089 if (*out == NULL) goto failed;
6090 return 0;
6091 }
6092 isinstance = PyObject_IsInstance(obj, (PyObject*)Index_type);
6093 if (isinstance == -1) {
6094 return 1;
6095 }
6096 if (isinstance) {
6097 expr_ty value;
6098
6099 if (PyObject_HasAttrString(obj, "value")) {
6100 int res;
6101 tmp = PyObject_GetAttrString(obj, "value");
6102 if (tmp == NULL) goto failed;
6103 res = obj2ast_expr(tmp, &value, arena);
6104 if (res != 0) goto failed;
6105 Py_XDECREF(tmp);
6106 tmp = NULL;
6107 } else {
6108 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Index");
6109 return 1;
6110 }
6111 *out = Index(value, arena);
6112 if (*out == NULL) goto failed;
6113 return 0;
6114 }
6115
6116 tmp = PyObject_Repr(obj);
6117 if (tmp == NULL) goto failed;
6118 PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %.400s", PyString_AS_STRING(tmp));
6119 failed:
6120 Py_XDECREF(tmp);
6121 return 1;
6122 }
6123
6124 int
obj2ast_boolop(PyObject * obj,boolop_ty * out,PyArena * arena)6125 obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena)
6126 {
6127 PyObject* tmp = NULL;
6128 int isinstance;
6129
6130 isinstance = PyObject_IsInstance(obj, (PyObject *)And_type);
6131 if (isinstance == -1) {
6132 return 1;
6133 }
6134 if (isinstance) {
6135 *out = And;
6136 return 0;
6137 }
6138 isinstance = PyObject_IsInstance(obj, (PyObject *)Or_type);
6139 if (isinstance == -1) {
6140 return 1;
6141 }
6142 if (isinstance) {
6143 *out = Or;
6144 return 0;
6145 }
6146
6147 tmp = PyObject_Repr(obj);
6148 if (tmp == NULL) goto failed;
6149 PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %.400s", PyString_AS_STRING(tmp));
6150 failed:
6151 Py_XDECREF(tmp);
6152 return 1;
6153 }
6154
6155 int
obj2ast_operator(PyObject * obj,operator_ty * out,PyArena * arena)6156 obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena)
6157 {
6158 PyObject* tmp = NULL;
6159 int isinstance;
6160
6161 isinstance = PyObject_IsInstance(obj, (PyObject *)Add_type);
6162 if (isinstance == -1) {
6163 return 1;
6164 }
6165 if (isinstance) {
6166 *out = Add;
6167 return 0;
6168 }
6169 isinstance = PyObject_IsInstance(obj, (PyObject *)Sub_type);
6170 if (isinstance == -1) {
6171 return 1;
6172 }
6173 if (isinstance) {
6174 *out = Sub;
6175 return 0;
6176 }
6177 isinstance = PyObject_IsInstance(obj, (PyObject *)Mult_type);
6178 if (isinstance == -1) {
6179 return 1;
6180 }
6181 if (isinstance) {
6182 *out = Mult;
6183 return 0;
6184 }
6185 isinstance = PyObject_IsInstance(obj, (PyObject *)Div_type);
6186 if (isinstance == -1) {
6187 return 1;
6188 }
6189 if (isinstance) {
6190 *out = Div;
6191 return 0;
6192 }
6193 isinstance = PyObject_IsInstance(obj, (PyObject *)Mod_type);
6194 if (isinstance == -1) {
6195 return 1;
6196 }
6197 if (isinstance) {
6198 *out = Mod;
6199 return 0;
6200 }
6201 isinstance = PyObject_IsInstance(obj, (PyObject *)Pow_type);
6202 if (isinstance == -1) {
6203 return 1;
6204 }
6205 if (isinstance) {
6206 *out = Pow;
6207 return 0;
6208 }
6209 isinstance = PyObject_IsInstance(obj, (PyObject *)LShift_type);
6210 if (isinstance == -1) {
6211 return 1;
6212 }
6213 if (isinstance) {
6214 *out = LShift;
6215 return 0;
6216 }
6217 isinstance = PyObject_IsInstance(obj, (PyObject *)RShift_type);
6218 if (isinstance == -1) {
6219 return 1;
6220 }
6221 if (isinstance) {
6222 *out = RShift;
6223 return 0;
6224 }
6225 isinstance = PyObject_IsInstance(obj, (PyObject *)BitOr_type);
6226 if (isinstance == -1) {
6227 return 1;
6228 }
6229 if (isinstance) {
6230 *out = BitOr;
6231 return 0;
6232 }
6233 isinstance = PyObject_IsInstance(obj, (PyObject *)BitXor_type);
6234 if (isinstance == -1) {
6235 return 1;
6236 }
6237 if (isinstance) {
6238 *out = BitXor;
6239 return 0;
6240 }
6241 isinstance = PyObject_IsInstance(obj, (PyObject *)BitAnd_type);
6242 if (isinstance == -1) {
6243 return 1;
6244 }
6245 if (isinstance) {
6246 *out = BitAnd;
6247 return 0;
6248 }
6249 isinstance = PyObject_IsInstance(obj, (PyObject *)FloorDiv_type);
6250 if (isinstance == -1) {
6251 return 1;
6252 }
6253 if (isinstance) {
6254 *out = FloorDiv;
6255 return 0;
6256 }
6257
6258 tmp = PyObject_Repr(obj);
6259 if (tmp == NULL) goto failed;
6260 PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %.400s", PyString_AS_STRING(tmp));
6261 failed:
6262 Py_XDECREF(tmp);
6263 return 1;
6264 }
6265
6266 int
obj2ast_unaryop(PyObject * obj,unaryop_ty * out,PyArena * arena)6267 obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena)
6268 {
6269 PyObject* tmp = NULL;
6270 int isinstance;
6271
6272 isinstance = PyObject_IsInstance(obj, (PyObject *)Invert_type);
6273 if (isinstance == -1) {
6274 return 1;
6275 }
6276 if (isinstance) {
6277 *out = Invert;
6278 return 0;
6279 }
6280 isinstance = PyObject_IsInstance(obj, (PyObject *)Not_type);
6281 if (isinstance == -1) {
6282 return 1;
6283 }
6284 if (isinstance) {
6285 *out = Not;
6286 return 0;
6287 }
6288 isinstance = PyObject_IsInstance(obj, (PyObject *)UAdd_type);
6289 if (isinstance == -1) {
6290 return 1;
6291 }
6292 if (isinstance) {
6293 *out = UAdd;
6294 return 0;
6295 }
6296 isinstance = PyObject_IsInstance(obj, (PyObject *)USub_type);
6297 if (isinstance == -1) {
6298 return 1;
6299 }
6300 if (isinstance) {
6301 *out = USub;
6302 return 0;
6303 }
6304
6305 tmp = PyObject_Repr(obj);
6306 if (tmp == NULL) goto failed;
6307 PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %.400s", PyString_AS_STRING(tmp));
6308 failed:
6309 Py_XDECREF(tmp);
6310 return 1;
6311 }
6312
6313 int
obj2ast_cmpop(PyObject * obj,cmpop_ty * out,PyArena * arena)6314 obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena)
6315 {
6316 PyObject* tmp = NULL;
6317 int isinstance;
6318
6319 isinstance = PyObject_IsInstance(obj, (PyObject *)Eq_type);
6320 if (isinstance == -1) {
6321 return 1;
6322 }
6323 if (isinstance) {
6324 *out = Eq;
6325 return 0;
6326 }
6327 isinstance = PyObject_IsInstance(obj, (PyObject *)NotEq_type);
6328 if (isinstance == -1) {
6329 return 1;
6330 }
6331 if (isinstance) {
6332 *out = NotEq;
6333 return 0;
6334 }
6335 isinstance = PyObject_IsInstance(obj, (PyObject *)Lt_type);
6336 if (isinstance == -1) {
6337 return 1;
6338 }
6339 if (isinstance) {
6340 *out = Lt;
6341 return 0;
6342 }
6343 isinstance = PyObject_IsInstance(obj, (PyObject *)LtE_type);
6344 if (isinstance == -1) {
6345 return 1;
6346 }
6347 if (isinstance) {
6348 *out = LtE;
6349 return 0;
6350 }
6351 isinstance = PyObject_IsInstance(obj, (PyObject *)Gt_type);
6352 if (isinstance == -1) {
6353 return 1;
6354 }
6355 if (isinstance) {
6356 *out = Gt;
6357 return 0;
6358 }
6359 isinstance = PyObject_IsInstance(obj, (PyObject *)GtE_type);
6360 if (isinstance == -1) {
6361 return 1;
6362 }
6363 if (isinstance) {
6364 *out = GtE;
6365 return 0;
6366 }
6367 isinstance = PyObject_IsInstance(obj, (PyObject *)Is_type);
6368 if (isinstance == -1) {
6369 return 1;
6370 }
6371 if (isinstance) {
6372 *out = Is;
6373 return 0;
6374 }
6375 isinstance = PyObject_IsInstance(obj, (PyObject *)IsNot_type);
6376 if (isinstance == -1) {
6377 return 1;
6378 }
6379 if (isinstance) {
6380 *out = IsNot;
6381 return 0;
6382 }
6383 isinstance = PyObject_IsInstance(obj, (PyObject *)In_type);
6384 if (isinstance == -1) {
6385 return 1;
6386 }
6387 if (isinstance) {
6388 *out = In;
6389 return 0;
6390 }
6391 isinstance = PyObject_IsInstance(obj, (PyObject *)NotIn_type);
6392 if (isinstance == -1) {
6393 return 1;
6394 }
6395 if (isinstance) {
6396 *out = NotIn;
6397 return 0;
6398 }
6399
6400 tmp = PyObject_Repr(obj);
6401 if (tmp == NULL) goto failed;
6402 PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %.400s", PyString_AS_STRING(tmp));
6403 failed:
6404 Py_XDECREF(tmp);
6405 return 1;
6406 }
6407
6408 int
obj2ast_comprehension(PyObject * obj,comprehension_ty * out,PyArena * arena)6409 obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena)
6410 {
6411 PyObject* tmp = NULL;
6412 expr_ty target;
6413 expr_ty iter;
6414 asdl_seq* ifs;
6415
6416 if (PyObject_HasAttrString(obj, "target")) {
6417 int res;
6418 tmp = PyObject_GetAttrString(obj, "target");
6419 if (tmp == NULL) goto failed;
6420 res = obj2ast_expr(tmp, &target, arena);
6421 if (res != 0) goto failed;
6422 Py_XDECREF(tmp);
6423 tmp = NULL;
6424 } else {
6425 PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension");
6426 return 1;
6427 }
6428 if (PyObject_HasAttrString(obj, "iter")) {
6429 int res;
6430 tmp = PyObject_GetAttrString(obj, "iter");
6431 if (tmp == NULL) goto failed;
6432 res = obj2ast_expr(tmp, &iter, arena);
6433 if (res != 0) goto failed;
6434 Py_XDECREF(tmp);
6435 tmp = NULL;
6436 } else {
6437 PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension");
6438 return 1;
6439 }
6440 if (PyObject_HasAttrString(obj, "ifs")) {
6441 int res;
6442 Py_ssize_t len;
6443 Py_ssize_t i;
6444 tmp = PyObject_GetAttrString(obj, "ifs");
6445 if (tmp == NULL) goto failed;
6446 if (!PyList_Check(tmp)) {
6447 PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6448 goto failed;
6449 }
6450 len = PyList_GET_SIZE(tmp);
6451 ifs = asdl_seq_new(len, arena);
6452 if (ifs == NULL) goto failed;
6453 for (i = 0; i < len; i++) {
6454 expr_ty value;
6455 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6456 if (res != 0) goto failed;
6457 if (len != PyList_GET_SIZE(tmp)) {
6458 PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
6459 goto failed;
6460 }
6461 asdl_seq_SET(ifs, i, value);
6462 }
6463 Py_XDECREF(tmp);
6464 tmp = NULL;
6465 } else {
6466 PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension");
6467 return 1;
6468 }
6469 *out = comprehension(target, iter, ifs, arena);
6470 return 0;
6471 failed:
6472 Py_XDECREF(tmp);
6473 return 1;
6474 }
6475
6476 int
obj2ast_excepthandler(PyObject * obj,excepthandler_ty * out,PyArena * arena)6477 obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena)
6478 {
6479 PyObject* tmp = NULL;
6480 int isinstance;
6481
6482 int lineno;
6483 int col_offset;
6484
6485 if (obj == Py_None) {
6486 *out = NULL;
6487 return 0;
6488 }
6489 if (PyObject_HasAttrString(obj, "lineno")) {
6490 int res;
6491 tmp = PyObject_GetAttrString(obj, "lineno");
6492 if (tmp == NULL) goto failed;
6493 res = obj2ast_int(tmp, &lineno, arena);
6494 if (res != 0) goto failed;
6495 Py_XDECREF(tmp);
6496 tmp = NULL;
6497 } else {
6498 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler");
6499 return 1;
6500 }
6501 if (PyObject_HasAttrString(obj, "col_offset")) {
6502 int res;
6503 tmp = PyObject_GetAttrString(obj, "col_offset");
6504 if (tmp == NULL) goto failed;
6505 res = obj2ast_int(tmp, &col_offset, arena);
6506 if (res != 0) goto failed;
6507 Py_XDECREF(tmp);
6508 tmp = NULL;
6509 } else {
6510 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler");
6511 return 1;
6512 }
6513 isinstance = PyObject_IsInstance(obj, (PyObject*)ExceptHandler_type);
6514 if (isinstance == -1) {
6515 return 1;
6516 }
6517 if (isinstance) {
6518 expr_ty type;
6519 expr_ty name;
6520 asdl_seq* body;
6521
6522 if (PyObject_HasAttrString(obj, "type")) {
6523 int res;
6524 tmp = PyObject_GetAttrString(obj, "type");
6525 if (tmp == NULL) goto failed;
6526 res = obj2ast_expr(tmp, &type, arena);
6527 if (res != 0) goto failed;
6528 Py_XDECREF(tmp);
6529 tmp = NULL;
6530 } else {
6531 type = NULL;
6532 }
6533 if (PyObject_HasAttrString(obj, "name")) {
6534 int res;
6535 tmp = PyObject_GetAttrString(obj, "name");
6536 if (tmp == NULL) goto failed;
6537 res = obj2ast_expr(tmp, &name, arena);
6538 if (res != 0) goto failed;
6539 Py_XDECREF(tmp);
6540 tmp = NULL;
6541 } else {
6542 name = NULL;
6543 }
6544 if (PyObject_HasAttrString(obj, "body")) {
6545 int res;
6546 Py_ssize_t len;
6547 Py_ssize_t i;
6548 tmp = PyObject_GetAttrString(obj, "body");
6549 if (tmp == NULL) goto failed;
6550 if (!PyList_Check(tmp)) {
6551 PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6552 goto failed;
6553 }
6554 len = PyList_GET_SIZE(tmp);
6555 body = asdl_seq_new(len, arena);
6556 if (body == NULL) goto failed;
6557 for (i = 0; i < len; i++) {
6558 stmt_ty value;
6559 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
6560 if (res != 0) goto failed;
6561 if (len != PyList_GET_SIZE(tmp)) {
6562 PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
6563 goto failed;
6564 }
6565 asdl_seq_SET(body, i, value);
6566 }
6567 Py_XDECREF(tmp);
6568 tmp = NULL;
6569 } else {
6570 PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler");
6571 return 1;
6572 }
6573 *out = ExceptHandler(type, name, body, lineno, col_offset,
6574 arena);
6575 if (*out == NULL) goto failed;
6576 return 0;
6577 }
6578
6579 tmp = PyObject_Repr(obj);
6580 if (tmp == NULL) goto failed;
6581 PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %.400s", PyString_AS_STRING(tmp));
6582 failed:
6583 Py_XDECREF(tmp);
6584 return 1;
6585 }
6586
6587 int
obj2ast_arguments(PyObject * obj,arguments_ty * out,PyArena * arena)6588 obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena)
6589 {
6590 PyObject* tmp = NULL;
6591 asdl_seq* args;
6592 identifier vararg;
6593 identifier kwarg;
6594 asdl_seq* defaults;
6595
6596 if (PyObject_HasAttrString(obj, "args")) {
6597 int res;
6598 Py_ssize_t len;
6599 Py_ssize_t i;
6600 tmp = PyObject_GetAttrString(obj, "args");
6601 if (tmp == NULL) goto failed;
6602 if (!PyList_Check(tmp)) {
6603 PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6604 goto failed;
6605 }
6606 len = PyList_GET_SIZE(tmp);
6607 args = asdl_seq_new(len, arena);
6608 if (args == NULL) goto failed;
6609 for (i = 0; i < len; i++) {
6610 expr_ty value;
6611 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6612 if (res != 0) goto failed;
6613 if (len != PyList_GET_SIZE(tmp)) {
6614 PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
6615 goto failed;
6616 }
6617 asdl_seq_SET(args, i, value);
6618 }
6619 Py_XDECREF(tmp);
6620 tmp = NULL;
6621 } else {
6622 PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments");
6623 return 1;
6624 }
6625 if (PyObject_HasAttrString(obj, "vararg")) {
6626 int res;
6627 tmp = PyObject_GetAttrString(obj, "vararg");
6628 if (tmp == NULL) goto failed;
6629 res = obj2ast_identifier(tmp, &vararg, arena);
6630 if (res != 0) goto failed;
6631 Py_XDECREF(tmp);
6632 tmp = NULL;
6633 } else {
6634 vararg = NULL;
6635 }
6636 if (PyObject_HasAttrString(obj, "kwarg")) {
6637 int res;
6638 tmp = PyObject_GetAttrString(obj, "kwarg");
6639 if (tmp == NULL) goto failed;
6640 res = obj2ast_identifier(tmp, &kwarg, arena);
6641 if (res != 0) goto failed;
6642 Py_XDECREF(tmp);
6643 tmp = NULL;
6644 } else {
6645 kwarg = NULL;
6646 }
6647 if (PyObject_HasAttrString(obj, "defaults")) {
6648 int res;
6649 Py_ssize_t len;
6650 Py_ssize_t i;
6651 tmp = PyObject_GetAttrString(obj, "defaults");
6652 if (tmp == NULL) goto failed;
6653 if (!PyList_Check(tmp)) {
6654 PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6655 goto failed;
6656 }
6657 len = PyList_GET_SIZE(tmp);
6658 defaults = asdl_seq_new(len, arena);
6659 if (defaults == NULL) goto failed;
6660 for (i = 0; i < len; i++) {
6661 expr_ty value;
6662 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6663 if (res != 0) goto failed;
6664 if (len != PyList_GET_SIZE(tmp)) {
6665 PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
6666 goto failed;
6667 }
6668 asdl_seq_SET(defaults, i, value);
6669 }
6670 Py_XDECREF(tmp);
6671 tmp = NULL;
6672 } else {
6673 PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments");
6674 return 1;
6675 }
6676 *out = arguments(args, vararg, kwarg, defaults, arena);
6677 return 0;
6678 failed:
6679 Py_XDECREF(tmp);
6680 return 1;
6681 }
6682
6683 int
obj2ast_keyword(PyObject * obj,keyword_ty * out,PyArena * arena)6684 obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena)
6685 {
6686 PyObject* tmp = NULL;
6687 identifier arg;
6688 expr_ty value;
6689
6690 if (PyObject_HasAttrString(obj, "arg")) {
6691 int res;
6692 tmp = PyObject_GetAttrString(obj, "arg");
6693 if (tmp == NULL) goto failed;
6694 res = obj2ast_identifier(tmp, &arg, arena);
6695 if (res != 0) goto failed;
6696 Py_XDECREF(tmp);
6697 tmp = NULL;
6698 } else {
6699 PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from keyword");
6700 return 1;
6701 }
6702 if (PyObject_HasAttrString(obj, "value")) {
6703 int res;
6704 tmp = PyObject_GetAttrString(obj, "value");
6705 if (tmp == NULL) goto failed;
6706 res = obj2ast_expr(tmp, &value, arena);
6707 if (res != 0) goto failed;
6708 Py_XDECREF(tmp);
6709 tmp = NULL;
6710 } else {
6711 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword");
6712 return 1;
6713 }
6714 *out = keyword(arg, value, arena);
6715 return 0;
6716 failed:
6717 Py_XDECREF(tmp);
6718 return 1;
6719 }
6720
6721 int
obj2ast_alias(PyObject * obj,alias_ty * out,PyArena * arena)6722 obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena)
6723 {
6724 PyObject* tmp = NULL;
6725 identifier name;
6726 identifier asname;
6727
6728 if (PyObject_HasAttrString(obj, "name")) {
6729 int res;
6730 tmp = PyObject_GetAttrString(obj, "name");
6731 if (tmp == NULL) goto failed;
6732 res = obj2ast_identifier(tmp, &name, arena);
6733 if (res != 0) goto failed;
6734 Py_XDECREF(tmp);
6735 tmp = NULL;
6736 } else {
6737 PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias");
6738 return 1;
6739 }
6740 if (PyObject_HasAttrString(obj, "asname")) {
6741 int res;
6742 tmp = PyObject_GetAttrString(obj, "asname");
6743 if (tmp == NULL) goto failed;
6744 res = obj2ast_identifier(tmp, &asname, arena);
6745 if (res != 0) goto failed;
6746 Py_XDECREF(tmp);
6747 tmp = NULL;
6748 } else {
6749 asname = NULL;
6750 }
6751 *out = alias(name, asname, arena);
6752 return 0;
6753 failed:
6754 Py_XDECREF(tmp);
6755 return 1;
6756 }
6757
6758
6759 PyMODINIT_FUNC
init_ast(void)6760 init_ast(void)
6761 {
6762 PyObject *m, *d;
6763 if (!init_types()) return;
6764 m = Py_InitModule3("_ast", NULL, NULL);
6765 if (!m) return;
6766 d = PyModule_GetDict(m);
6767 if (PyDict_SetItemString(d, "AST", (PyObject*)&AST_type) < 0) return;
6768 if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)
6769 return;
6770 if (PyModule_AddStringConstant(m, "__version__", "82160") < 0)
6771 return;
6772 if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return;
6773 if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0)
6774 return;
6775 if (PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type)
6776 < 0) return;
6777 if (PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) <
6778 0) return;
6779 if (PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return;
6780 if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return;
6781 if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type)
6782 < 0) return;
6783 if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0)
6784 return;
6785 if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0)
6786 return;
6787 if (PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0)
6788 return;
6789 if (PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0)
6790 return;
6791 if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) <
6792 0) return;
6793 if (PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return;
6794 if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return;
6795 if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return;
6796 if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return;
6797 if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return;
6798 if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return;
6799 if (PyDict_SetItemString(d, "TryExcept", (PyObject*)TryExcept_type) <
6800 0) return;
6801 if (PyDict_SetItemString(d, "TryFinally", (PyObject*)TryFinally_type) <
6802 0) return;
6803 if (PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0)
6804 return;
6805 if (PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0)
6806 return;
6807 if (PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) <
6808 0) return;
6809 if (PyDict_SetItemString(d, "Exec", (PyObject*)Exec_type) < 0) return;
6810 if (PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0)
6811 return;
6812 if (PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return;
6813 if (PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return;
6814 if (PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return;
6815 if (PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0)
6816 return;
6817 if (PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return;
6818 if (PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0)
6819 return;
6820 if (PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return;
6821 if (PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0)
6822 return;
6823 if (PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0)
6824 return;
6825 if (PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return;
6826 if (PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return;
6827 if (PyDict_SetItemString(d, "Set", (PyObject*)Set_type) < 0) return;
6828 if (PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0)
6829 return;
6830 if (PyDict_SetItemString(d, "SetComp", (PyObject*)SetComp_type) < 0)
6831 return;
6832 if (PyDict_SetItemString(d, "DictComp", (PyObject*)DictComp_type) < 0)
6833 return;
6834 if (PyDict_SetItemString(d, "GeneratorExp",
6835 (PyObject*)GeneratorExp_type) < 0) return;
6836 if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return;
6837 if (PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0)
6838 return;
6839 if (PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return;
6840 if (PyDict_SetItemString(d, "Repr", (PyObject*)Repr_type) < 0) return;
6841 if (PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return;
6842 if (PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return;
6843 if (PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) <
6844 0) return;
6845 if (PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) <
6846 0) return;
6847 if (PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return;
6848 if (PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return;
6849 if (PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return;
6850 if (PyDict_SetItemString(d, "expr_context",
6851 (PyObject*)expr_context_type) < 0) return;
6852 if (PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return;
6853 if (PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return;
6854 if (PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return;
6855 if (PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0)
6856 return;
6857 if (PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0)
6858 return;
6859 if (PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return;
6860 if (PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return;
6861 if (PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0)
6862 return;
6863 if (PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return;
6864 if (PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0)
6865 return;
6866 if (PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return;
6867 if (PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0)
6868 return;
6869 if (PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return;
6870 if (PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return;
6871 if (PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0)
6872 return;
6873 if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return;
6874 if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return;
6875 if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return;
6876 if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return;
6877 if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return;
6878 if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return;
6879 if (PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0)
6880 return;
6881 if (PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0)
6882 return;
6883 if (PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return;
6884 if (PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0)
6885 return;
6886 if (PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0)
6887 return;
6888 if (PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0)
6889 return;
6890 if (PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0)
6891 return;
6892 if (PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0)
6893 return;
6894 if (PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return;
6895 if (PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return;
6896 if (PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return;
6897 if (PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return;
6898 if (PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return;
6899 if (PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return;
6900 if (PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return;
6901 if (PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return;
6902 if (PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return;
6903 if (PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return;
6904 if (PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return;
6905 if (PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return;
6906 if (PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return;
6907 if (PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return;
6908 if (PyDict_SetItemString(d, "comprehension",
6909 (PyObject*)comprehension_type) < 0) return;
6910 if (PyDict_SetItemString(d, "excepthandler",
6911 (PyObject*)excepthandler_type) < 0) return;
6912 if (PyDict_SetItemString(d, "ExceptHandler",
6913 (PyObject*)ExceptHandler_type) < 0) return;
6914 if (PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) <
6915 0) return;
6916 if (PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0)
6917 return;
6918 if (PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return;
6919 }
6920
6921
PyAST_mod2obj(mod_ty t)6922 PyObject* PyAST_mod2obj(mod_ty t)
6923 {
6924 init_types();
6925 return ast2obj_mod(t);
6926 }
6927
6928 /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
PyAST_obj2mod(PyObject * ast,PyArena * arena,int mode)6929 mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
6930 {
6931 mod_ty res;
6932 PyObject *req_type[3];
6933 char *req_name[3];
6934 int isinstance;
6935
6936 req_type[0] = (PyObject*)Module_type;
6937 req_type[1] = (PyObject*)Expression_type;
6938 req_type[2] = (PyObject*)Interactive_type;
6939
6940 req_name[0] = "Module";
6941 req_name[1] = "Expression";
6942 req_name[2] = "Interactive";
6943
6944 assert(0 <= mode && mode <= 2);
6945
6946 init_types();
6947
6948 isinstance = PyObject_IsInstance(ast, req_type[mode]);
6949 if (isinstance == -1)
6950 return NULL;
6951 if (!isinstance) {
6952 PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
6953 req_name[mode], Py_TYPE(ast)->tp_name);
6954 return NULL;
6955 }
6956 if (obj2ast_mod(ast, &res, arena) != 0)
6957 return NULL;
6958 else
6959 return res;
6960 }
6961
PyAST_Check(PyObject * obj)6962 int PyAST_Check(PyObject* obj)
6963 {
6964 init_types();
6965 return PyObject_IsInstance(obj, (PyObject*)&AST_type);
6966 }
6967
6968
6969