History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/Python-ast.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/Python-ast.c+3202−0
@@ -0,0 +1,3202 @@
1+/* File automatically generated by Parser/asdl_c.py */
2+
3+#include "Python.h"
4+#include "Python-ast.h"
5+
6+static PyTypeObject* AST_type;
7+static PyTypeObject *mod_type;
8+static PyObject* ast2obj_mod(void*);
9+static PyTypeObject *Module_type;
10+static char *Module_fields[]={
11+ "body",
12+};
13+static PyTypeObject *Interactive_type;
14+static char *Interactive_fields[]={
15+ "body",
16+};
17+static PyTypeObject *Expression_type;
18+static char *Expression_fields[]={
19+ "body",
20+};
21+static PyTypeObject *Suite_type;
22+static char *Suite_fields[]={
23+ "body",
24+};
25+static PyTypeObject *stmt_type;
26+static char *stmt_attributes[] = {
27+ "lineno",
28+ "col_offset",
29+};
30+static PyObject* ast2obj_stmt(void*);
31+static PyTypeObject *FunctionDef_type;
32+static char *FunctionDef_fields[]={
33+ "name",
34+ "args",
35+ "body",
36+ "decorators",
37+};
38+static PyTypeObject *ClassDef_type;
39+static char *ClassDef_fields[]={
40+ "name",
41+ "bases",
42+ "body",
43+};
44+static PyTypeObject *Return_type;
45+static char *Return_fields[]={
46+ "value",
47+};
48+static PyTypeObject *Delete_type;
49+static char *Delete_fields[]={
50+ "targets",
51+};
52+static PyTypeObject *Assign_type;
53+static char *Assign_fields[]={
54+ "targets",
55+ "value",
56+};
57+static PyTypeObject *AugAssign_type;
58+static char *AugAssign_fields[]={
59+ "target",
60+ "op",
61+ "value",
62+};
63+static PyTypeObject *Print_type;
64+static char *Print_fields[]={
65+ "dest",
66+ "values",
67+ "nl",
68+};
69+static PyTypeObject *For_type;
70+static char *For_fields[]={
71+ "target",
72+ "iter",
73+ "body",
74+ "orelse",
75+};
76+static PyTypeObject *While_type;
77+static char *While_fields[]={
78+ "test",
79+ "body",
80+ "orelse",
81+};
82+static PyTypeObject *If_type;
83+static char *If_fields[]={
84+ "test",
85+ "body",
86+ "orelse",
87+};
88+static PyTypeObject *With_type;
89+static char *With_fields[]={
90+ "context_expr",
91+ "optional_vars",
92+ "body",
93+};
94+static PyTypeObject *Raise_type;
95+static char *Raise_fields[]={
96+ "type",
97+ "inst",
98+ "tback",
99+};
100+static PyTypeObject *TryExcept_type;
101+static char *TryExcept_fields[]={
102+ "body",
103+ "handlers",
104+ "orelse",
105+};
106+static PyTypeObject *TryFinally_type;
107+static char *TryFinally_fields[]={
108+ "body",
109+ "finalbody",
110+};
111+static PyTypeObject *Assert_type;
112+static char *Assert_fields[]={
113+ "test",
114+ "msg",
115+};
116+static PyTypeObject *Import_type;
117+static char *Import_fields[]={
118+ "names",
119+};
120+static PyTypeObject *ImportFrom_type;
121+static char *ImportFrom_fields[]={
122+ "module",
123+ "names",
124+ "level",
125+};
126+static PyTypeObject *Exec_type;
127+static char *Exec_fields[]={
128+ "body",
129+ "globals",
130+ "locals",
131+};
132+static PyTypeObject *Global_type;
133+static char *Global_fields[]={
134+ "names",
135+};
136+static PyTypeObject *Expr_type;
137+static char *Expr_fields[]={
138+ "value",
139+};
140+static PyTypeObject *Pass_type;
141+static PyTypeObject *Break_type;
142+static PyTypeObject *Continue_type;
143+static PyTypeObject *expr_type;
144+static char *expr_attributes[] = {
145+ "lineno",
146+ "col_offset",
147+};
148+static PyObject* ast2obj_expr(void*);
149+static PyTypeObject *BoolOp_type;
150+static char *BoolOp_fields[]={
151+ "op",
152+ "values",
153+};
154+static PyTypeObject *BinOp_type;
155+static char *BinOp_fields[]={
156+ "left",
157+ "op",
158+ "right",
159+};
160+static PyTypeObject *UnaryOp_type;
161+static char *UnaryOp_fields[]={
162+ "op",
163+ "operand",
164+};
165+static PyTypeObject *Lambda_type;
166+static char *Lambda_fields[]={
167+ "args",
168+ "body",
169+};
170+static PyTypeObject *IfExp_type;
171+static char *IfExp_fields[]={
172+ "test",
173+ "body",
174+ "orelse",
175+};
176+static PyTypeObject *Dict_type;
177+static char *Dict_fields[]={
178+ "keys",
179+ "values",
180+};
181+static PyTypeObject *ListComp_type;
182+static char *ListComp_fields[]={
183+ "elt",
184+ "generators",
185+};
186+static PyTypeObject *GeneratorExp_type;
187+static char *GeneratorExp_fields[]={
188+ "elt",
189+ "generators",
190+};
191+static PyTypeObject *Yield_type;
192+static char *Yield_fields[]={
193+ "value",
194+};
195+static PyTypeObject *Compare_type;
196+static char *Compare_fields[]={
197+ "left",
198+ "ops",
199+ "comparators",
200+};
201+static PyTypeObject *Call_type;
202+static char *Call_fields[]={
203+ "func",
204+ "args",
205+ "keywords",
206+ "starargs",
207+ "kwargs",
208+};
209+static PyTypeObject *Repr_type;
210+static char *Repr_fields[]={
211+ "value",
212+};
213+static PyTypeObject *Num_type;
214+static char *Num_fields[]={
215+ "n",
216+};
217+static PyTypeObject *Str_type;
218+static char *Str_fields[]={
219+ "s",
220+};
221+static PyTypeObject *Attribute_type;
222+static char *Attribute_fields[]={
223+ "value",
224+ "attr",
225+ "ctx",
226+};
227+static PyTypeObject *Subscript_type;
228+static char *Subscript_fields[]={
229+ "value",
230+ "slice",
231+ "ctx",
232+};
233+static PyTypeObject *Name_type;
234+static char *Name_fields[]={
235+ "id",
236+ "ctx",
237+};
238+static PyTypeObject *List_type;
239+static char *List_fields[]={
240+ "elts",
241+ "ctx",
242+};
243+static PyTypeObject *Tuple_type;
244+static char *Tuple_fields[]={
245+ "elts",
246+ "ctx",
247+};
248+static PyTypeObject *expr_context_type;
249+static PyObject *Load_singleton, *Store_singleton, *Del_singleton,
250+*AugLoad_singleton, *AugStore_singleton, *Param_singleton;
251+static PyObject* ast2obj_expr_context(expr_context_ty);
252+static PyTypeObject *Load_type;
253+static PyTypeObject *Store_type;
254+static PyTypeObject *Del_type;
255+static PyTypeObject *AugLoad_type;
256+static PyTypeObject *AugStore_type;
257+static PyTypeObject *Param_type;
258+static PyTypeObject *slice_type;
259+static PyObject* ast2obj_slice(void*);
260+static PyTypeObject *Ellipsis_type;
261+static PyTypeObject *Slice_type;
262+static char *Slice_fields[]={
263+ "lower",
264+ "upper",
265+ "step",
266+};
267+static PyTypeObject *ExtSlice_type;
268+static char *ExtSlice_fields[]={
269+ "dims",
270+};
271+static PyTypeObject *Index_type;
272+static char *Index_fields[]={
273+ "value",
274+};
275+static PyTypeObject *boolop_type;
276+static PyObject *And_singleton, *Or_singleton;
277+static PyObject* ast2obj_boolop(boolop_ty);
278+static PyTypeObject *And_type;
279+static PyTypeObject *Or_type;
280+static PyTypeObject *operator_type;
281+static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,
282+*Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton,
283+*RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton,
284+*FloorDiv_singleton;
285+static PyObject* ast2obj_operator(operator_ty);
286+static PyTypeObject *Add_type;
287+static PyTypeObject *Sub_type;
288+static PyTypeObject *Mult_type;
289+static PyTypeObject *Div_type;
290+static PyTypeObject *Mod_type;
291+static PyTypeObject *Pow_type;
292+static PyTypeObject *LShift_type;
293+static PyTypeObject *RShift_type;
294+static PyTypeObject *BitOr_type;
295+static PyTypeObject *BitXor_type;
296+static PyTypeObject *BitAnd_type;
297+static PyTypeObject *FloorDiv_type;
298+static PyTypeObject *unaryop_type;
299+static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,
300+*USub_singleton;
301+static PyObject* ast2obj_unaryop(unaryop_ty);
302+static PyTypeObject *Invert_type;
303+static PyTypeObject *Not_type;
304+static PyTypeObject *UAdd_type;
305+static PyTypeObject *USub_type;
306+static PyTypeObject *cmpop_type;
307+static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton,
308+*Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton,
309+*NotIn_singleton;
310+static PyObject* ast2obj_cmpop(cmpop_ty);
311+static PyTypeObject *Eq_type;
312+static PyTypeObject *NotEq_type;
313+static PyTypeObject *Lt_type;
314+static PyTypeObject *LtE_type;
315+static PyTypeObject *Gt_type;
316+static PyTypeObject *GtE_type;
317+static PyTypeObject *Is_type;
318+static PyTypeObject *IsNot_type;
319+static PyTypeObject *In_type;
320+static PyTypeObject *NotIn_type;
321+static PyTypeObject *comprehension_type;
322+static PyObject* ast2obj_comprehension(void*);
323+static char *comprehension_fields[]={
324+ "target",
325+ "iter",
326+ "ifs",
327+};
328+static PyTypeObject *excepthandler_type;
329+static PyObject* ast2obj_excepthandler(void*);
330+static char *excepthandler_fields[]={
331+ "type",
332+ "name",
333+ "body",
334+ "lineno",
335+ "col_offset",
336+};
337+static PyTypeObject *arguments_type;
338+static PyObject* ast2obj_arguments(void*);
339+static char *arguments_fields[]={
340+ "args",
341+ "vararg",
342+ "kwarg",
343+ "defaults",
344+};
345+static PyTypeObject *keyword_type;
346+static PyObject* ast2obj_keyword(void*);
347+static char *keyword_fields[]={
348+ "arg",
349+ "value",
350+};
351+static PyTypeObject *alias_type;
352+static PyObject* ast2obj_alias(void*);
353+static char *alias_fields[]={
354+ "name",
355+ "asname",
356+};
357+
358+
359+static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields)
360+{
361+ PyObject *fnames, *result;
362+ int i;
363+ if (num_fields) {
364+ fnames = PyTuple_New(num_fields);
365+ if (!fnames) return NULL;
366+ } else {
367+ fnames = Py_None;
368+ Py_INCREF(Py_None);
369+ }
370+ for(i=0; i < num_fields; i++) {
371+ PyObject *field = PyString_FromString(fields[i]);
372+ if (!field) {
373+ Py_DECREF(fnames);
374+ return NULL;
375+ }
376+ PyTuple_SET_ITEM(fnames, i, field);
377+ }
378+ result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
379+ type, base, "_fields", fnames, "__module__", "_ast");
380+ Py_DECREF(fnames);
381+ return (PyTypeObject*)result;
382+}
383+
384+static int add_attributes(PyTypeObject* type, char**attrs, int num_fields)
385+{
386+ int i, result;
387+ PyObject *s, *l = PyList_New(num_fields);
388+ if (!l) return 0;
389+ for(i = 0; i < num_fields; i++) {
390+ s = PyString_FromString(attrs[i]);
391+ if (!s) {
392+ Py_DECREF(l);
393+ return 0;
394+ }
395+ PyList_SET_ITEM(l, i, s);
396+ }
397+ result = PyObject_SetAttrString((PyObject*)type, "_attributes", l) >= 0;
398+ Py_DECREF(l);
399+ return result;
400+}
401+
402+static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*))
403+{
404+ int i, n = asdl_seq_LEN(seq);
405+ PyObject *result = PyList_New(n);
406+ PyObject *value;
407+ if (!result)
408+ return NULL;
409+ for (i = 0; i < n; i++) {
410+ value = func(asdl_seq_GET(seq, i));
411+ if (!value) {
412+ Py_DECREF(result);
413+ return NULL;
414+ }
415+ PyList_SET_ITEM(result, i, value);
416+ }
417+ return result;
418+}
419+
420+static PyObject* ast2obj_object(void *o)
421+{
422+ if (!o)
423+ o = Py_None;
424+ Py_INCREF((PyObject*)o);
425+ return (PyObject*)o;
426+}
427+#define ast2obj_identifier ast2obj_object
428+#define ast2obj_string ast2obj_object
429+static PyObject* ast2obj_bool(bool b)
430+{
431+ return PyBool_FromLong(b);
432+}
433+
434+static PyObject* ast2obj_int(bool b)
435+{
436+ return PyInt_FromLong(b);
437+}
438+
439+static int init_types(void)
440+{
441+ static int initialized;
442+ if (initialized) return 1;
443+ AST_type = make_type("AST", &PyBaseObject_Type, NULL, 0);
444+ mod_type = make_type("mod", AST_type, NULL, 0);
445+ if (!mod_type) return 0;
446+ if (!add_attributes(mod_type, NULL, 0)) return 0;
447+ Module_type = make_type("Module", mod_type, Module_fields, 1);
448+ if (!Module_type) return 0;
449+ Interactive_type = make_type("Interactive", mod_type,
450+ Interactive_fields, 1);
451+ if (!Interactive_type) return 0;
452+ Expression_type = make_type("Expression", mod_type, Expression_fields,
453+ 1);
454+ if (!Expression_type) return 0;
455+ Suite_type = make_type("Suite", mod_type, Suite_fields, 1);
456+ if (!Suite_type) return 0;
457+ stmt_type = make_type("stmt", AST_type, NULL, 0);
458+ if (!stmt_type) return 0;
459+ if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0;
460+ FunctionDef_type = make_type("FunctionDef", stmt_type,
461+ FunctionDef_fields, 4);
462+ if (!FunctionDef_type) return 0;
463+ ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 3);
464+ if (!ClassDef_type) return 0;
465+ Return_type = make_type("Return", stmt_type, Return_fields, 1);
466+ if (!Return_type) return 0;
467+ Delete_type = make_type("Delete", stmt_type, Delete_fields, 1);
468+ if (!Delete_type) return 0;
469+ Assign_type = make_type("Assign", stmt_type, Assign_fields, 2);
470+ if (!Assign_type) return 0;
471+ AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);
472+ if (!AugAssign_type) return 0;
473+ Print_type = make_type("Print", stmt_type, Print_fields, 3);
474+ if (!Print_type) return 0;
475+ For_type = make_type("For", stmt_type, For_fields, 4);
476+ if (!For_type) return 0;
477+ While_type = make_type("While", stmt_type, While_fields, 3);
478+ if (!While_type) return 0;
479+ If_type = make_type("If", stmt_type, If_fields, 3);
480+ if (!If_type) return 0;
481+ With_type = make_type("With", stmt_type, With_fields, 3);
482+ if (!With_type) return 0;
483+ Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);
484+ if (!Raise_type) return 0;
485+ TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);
486+ if (!TryExcept_type) return 0;
487+ TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields,
488+ 2);
489+ if (!TryFinally_type) return 0;
490+ Assert_type = make_type("Assert", stmt_type, Assert_fields, 2);
491+ if (!Assert_type) return 0;
492+ Import_type = make_type("Import", stmt_type, Import_fields, 1);
493+ if (!Import_type) return 0;
494+ ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields,
495+ 3);
496+ if (!ImportFrom_type) return 0;
497+ Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);
498+ if (!Exec_type) return 0;
499+ Global_type = make_type("Global", stmt_type, Global_fields, 1);
500+ if (!Global_type) return 0;
501+ Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);
502+ if (!Expr_type) return 0;
503+ Pass_type = make_type("Pass", stmt_type, NULL, 0);
504+ if (!Pass_type) return 0;
505+ Break_type = make_type("Break", stmt_type, NULL, 0);
506+ if (!Break_type) return 0;
507+ Continue_type = make_type("Continue", stmt_type, NULL, 0);
508+ if (!Continue_type) return 0;
509+ expr_type = make_type("expr", AST_type, NULL, 0);
510+ if (!expr_type) return 0;
511+ if (!add_attributes(expr_type, expr_attributes, 2)) return 0;
512+ BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);
513+ if (!BoolOp_type) return 0;
514+ BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);
515+ if (!BinOp_type) return 0;
516+ UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2);
517+ if (!UnaryOp_type) return 0;
518+ Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2);
519+ if (!Lambda_type) return 0;
520+ IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3);
521+ if (!IfExp_type) return 0;
522+ Dict_type = make_type("Dict", expr_type, Dict_fields, 2);
523+ if (!Dict_type) return 0;
524+ ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2);
525+ if (!ListComp_type) return 0;
526+ GeneratorExp_type = make_type("GeneratorExp", expr_type,
527+ GeneratorExp_fields, 2);
528+ if (!GeneratorExp_type) return 0;
529+ Yield_type = make_type("Yield", expr_type, Yield_fields, 1);
530+ if (!Yield_type) return 0;
531+ Compare_type = make_type("Compare", expr_type, Compare_fields, 3);
532+ if (!Compare_type) return 0;
533+ Call_type = make_type("Call", expr_type, Call_fields, 5);
534+ if (!Call_type) return 0;
535+ Repr_type = make_type("Repr", expr_type, Repr_fields, 1);
536+ if (!Repr_type) return 0;
537+ Num_type = make_type("Num", expr_type, Num_fields, 1);
538+ if (!Num_type) return 0;
539+ Str_type = make_type("Str", expr_type, Str_fields, 1);
540+ if (!Str_type) return 0;
541+ Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3);
542+ if (!Attribute_type) return 0;
543+ Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3);
544+ if (!Subscript_type) return 0;
545+ Name_type = make_type("Name", expr_type, Name_fields, 2);
546+ if (!Name_type) return 0;
547+ List_type = make_type("List", expr_type, List_fields, 2);
548+ if (!List_type) return 0;
549+ Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);
550+ if (!Tuple_type) return 0;
551+ expr_context_type = make_type("expr_context", AST_type, NULL, 0);
552+ if (!expr_context_type) return 0;
553+ if (!add_attributes(expr_context_type, NULL, 0)) return 0;
554+ Load_type = make_type("Load", expr_context_type, NULL, 0);
555+ if (!Load_type) return 0;
556+ Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);
557+ if (!Load_singleton) return 0;
558+ Store_type = make_type("Store", expr_context_type, NULL, 0);
559+ if (!Store_type) return 0;
560+ Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);
561+ if (!Store_singleton) return 0;
562+ Del_type = make_type("Del", expr_context_type, NULL, 0);
563+ if (!Del_type) return 0;
564+ Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);
565+ if (!Del_singleton) return 0;
566+ AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);
567+ if (!AugLoad_type) return 0;
568+ AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);
569+ if (!AugLoad_singleton) return 0;
570+ AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);
571+ if (!AugStore_type) return 0;
572+ AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);
573+ if (!AugStore_singleton) return 0;
574+ Param_type = make_type("Param", expr_context_type, NULL, 0);
575+ if (!Param_type) return 0;
576+ Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);
577+ if (!Param_singleton) return 0;
578+ slice_type = make_type("slice", AST_type, NULL, 0);
579+ if (!slice_type) return 0;
580+ if (!add_attributes(slice_type, NULL, 0)) return 0;
581+ Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0);
582+ if (!Ellipsis_type) return 0;
583+ Slice_type = make_type("Slice", slice_type, Slice_fields, 3);
584+ if (!Slice_type) return 0;
585+ ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);
586+ if (!ExtSlice_type) return 0;
587+ Index_type = make_type("Index", slice_type, Index_fields, 1);
588+ if (!Index_type) return 0;
589+ boolop_type = make_type("boolop", AST_type, NULL, 0);
590+ if (!boolop_type) return 0;
591+ if (!add_attributes(boolop_type, NULL, 0)) return 0;
592+ And_type = make_type("And", boolop_type, NULL, 0);
593+ if (!And_type) return 0;
594+ And_singleton = PyType_GenericNew(And_type, NULL, NULL);
595+ if (!And_singleton) return 0;
596+ Or_type = make_type("Or", boolop_type, NULL, 0);
597+ if (!Or_type) return 0;
598+ Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);
599+ if (!Or_singleton) return 0;
600+ operator_type = make_type("operator", AST_type, NULL, 0);
601+ if (!operator_type) return 0;
602+ if (!add_attributes(operator_type, NULL, 0)) return 0;
603+ Add_type = make_type("Add", operator_type, NULL, 0);
604+ if (!Add_type) return 0;
605+ Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);
606+ if (!Add_singleton) return 0;
607+ Sub_type = make_type("Sub", operator_type, NULL, 0);
608+ if (!Sub_type) return 0;
609+ Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);
610+ if (!Sub_singleton) return 0;
611+ Mult_type = make_type("Mult", operator_type, NULL, 0);
612+ if (!Mult_type) return 0;
613+ Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);
614+ if (!Mult_singleton) return 0;
615+ Div_type = make_type("Div", operator_type, NULL, 0);
616+ if (!Div_type) return 0;
617+ Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);
618+ if (!Div_singleton) return 0;
619+ Mod_type = make_type("Mod", operator_type, NULL, 0);
620+ if (!Mod_type) return 0;
621+ Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);
622+ if (!Mod_singleton) return 0;
623+ Pow_type = make_type("Pow", operator_type, NULL, 0);
624+ if (!Pow_type) return 0;
625+ Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);
626+ if (!Pow_singleton) return 0;
627+ LShift_type = make_type("LShift", operator_type, NULL, 0);
628+ if (!LShift_type) return 0;
629+ LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);
630+ if (!LShift_singleton) return 0;
631+ RShift_type = make_type("RShift", operator_type, NULL, 0);
632+ if (!RShift_type) return 0;
633+ RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);
634+ if (!RShift_singleton) return 0;
635+ BitOr_type = make_type("BitOr", operator_type, NULL, 0);
636+ if (!BitOr_type) return 0;
637+ BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);
638+ if (!BitOr_singleton) return 0;
639+ BitXor_type = make_type("BitXor", operator_type, NULL, 0);
640+ if (!BitXor_type) return 0;
641+ BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);
642+ if (!BitXor_singleton) return 0;
643+ BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);
644+ if (!BitAnd_type) return 0;
645+ BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);
646+ if (!BitAnd_singleton) return 0;
647+ FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);
648+ if (!FloorDiv_type) return 0;
649+ FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);
650+ if (!FloorDiv_singleton) return 0;
651+ unaryop_type = make_type("unaryop", AST_type, NULL, 0);
652+ if (!unaryop_type) return 0;
653+ if (!add_attributes(unaryop_type, NULL, 0)) return 0;
654+ Invert_type = make_type("Invert", unaryop_type, NULL, 0);
655+ if (!Invert_type) return 0;
656+ Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);
657+ if (!Invert_singleton) return 0;
658+ Not_type = make_type("Not", unaryop_type, NULL, 0);
659+ if (!Not_type) return 0;
660+ Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);
661+ if (!Not_singleton) return 0;
662+ UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);
663+ if (!UAdd_type) return 0;
664+ UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);
665+ if (!UAdd_singleton) return 0;
666+ USub_type = make_type("USub", unaryop_type, NULL, 0);
667+ if (!USub_type) return 0;
668+ USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);
669+ if (!USub_singleton) return 0;
670+ cmpop_type = make_type("cmpop", AST_type, NULL, 0);
671+ if (!cmpop_type) return 0;
672+ if (!add_attributes(cmpop_type, NULL, 0)) return 0;
673+ Eq_type = make_type("Eq", cmpop_type, NULL, 0);
674+ if (!Eq_type) return 0;
675+ Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);
676+ if (!Eq_singleton) return 0;
677+ NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);
678+ if (!NotEq_type) return 0;
679+ NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);
680+ if (!NotEq_singleton) return 0;
681+ Lt_type = make_type("Lt", cmpop_type, NULL, 0);
682+ if (!Lt_type) return 0;
683+ Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);
684+ if (!Lt_singleton) return 0;
685+ LtE_type = make_type("LtE", cmpop_type, NULL, 0);
686+ if (!LtE_type) return 0;
687+ LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);
688+ if (!LtE_singleton) return 0;
689+ Gt_type = make_type("Gt", cmpop_type, NULL, 0);
690+ if (!Gt_type) return 0;
691+ Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);
692+ if (!Gt_singleton) return 0;
693+ GtE_type = make_type("GtE", cmpop_type, NULL, 0);
694+ if (!GtE_type) return 0;
695+ GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);
696+ if (!GtE_singleton) return 0;
697+ Is_type = make_type("Is", cmpop_type, NULL, 0);
698+ if (!Is_type) return 0;
699+ Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);
700+ if (!Is_singleton) return 0;
701+ IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);
702+ if (!IsNot_type) return 0;
703+ IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);
704+ if (!IsNot_singleton) return 0;
705+ In_type = make_type("In", cmpop_type, NULL, 0);
706+ if (!In_type) return 0;
707+ In_singleton = PyType_GenericNew(In_type, NULL, NULL);
708+ if (!In_singleton) return 0;
709+ NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);
710+ if (!NotIn_type) return 0;
711+ NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);
712+ if (!NotIn_singleton) return 0;
713+ comprehension_type = make_type("comprehension", AST_type,
714+ comprehension_fields, 3);
715+ if (!comprehension_type) return 0;
716+ excepthandler_type = make_type("excepthandler", AST_type,
717+ excepthandler_fields, 5);
718+ if (!excepthandler_type) return 0;
719+ arguments_type = make_type("arguments", AST_type, arguments_fields, 4);
720+ if (!arguments_type) return 0;
721+ keyword_type = make_type("keyword", AST_type, keyword_fields, 2);
722+ if (!keyword_type) return 0;
723+ alias_type = make_type("alias", AST_type, alias_fields, 2);
724+ if (!alias_type) return 0;
725+ initialized = 1;
726+ return 1;
727+}
728+
729+mod_ty
730+Module(asdl_seq * body, PyArena *arena)
731+{
732+ mod_ty p;
733+ p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
734+ if (!p) {
735+ PyErr_NoMemory();
736+ return NULL;
737+ }
738+ p->kind = Module_kind;
739+ p->v.Module.body = body;
740+ return p;
741+}
742+
743+mod_ty
744+Interactive(asdl_seq * body, PyArena *arena)
745+{
746+ mod_ty p;
747+ p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
748+ if (!p) {
749+ PyErr_NoMemory();
750+ return NULL;
751+ }
752+ p->kind = Interactive_kind;
753+ p->v.Interactive.body = body;
754+ return p;
755+}
756+
757+mod_ty
758+Expression(expr_ty body, PyArena *arena)
759+{
760+ mod_ty p;
761+ if (!body) {
762+ PyErr_SetString(PyExc_ValueError,
763+ "field body is required for Expression");
764+ return NULL;
765+ }
766+ p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
767+ if (!p) {
768+ PyErr_NoMemory();
769+ return NULL;
770+ }
771+ p->kind = Expression_kind;
772+ p->v.Expression.body = body;
773+ return p;
774+}
775+
776+mod_ty
777+Suite(asdl_seq * body, PyArena *arena)
778+{
779+ mod_ty p;
780+ p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
781+ if (!p) {
782+ PyErr_NoMemory();
783+ return NULL;
784+ }
785+ p->kind = Suite_kind;
786+ p->v.Suite.body = body;
787+ return p;
788+}
789+
790+stmt_ty
791+FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
792+ decorators, int lineno, int col_offset, PyArena *arena)
793+{
794+ stmt_ty p;
795+ if (!name) {
796+ PyErr_SetString(PyExc_ValueError,
797+ "field name is required for FunctionDef");
798+ return NULL;
799+ }
800+ if (!args) {
801+ PyErr_SetString(PyExc_ValueError,
802+ "field args is required for FunctionDef");
803+ return NULL;
804+ }
805+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
806+ if (!p) {
807+ PyErr_NoMemory();
808+ return NULL;
809+ }
810+ p->kind = FunctionDef_kind;
811+ p->v.FunctionDef.name = name;
812+ p->v.FunctionDef.args = args;
813+ p->v.FunctionDef.body = body;
814+ p->v.FunctionDef.decorators = decorators;
815+ p->lineno = lineno;
816+ p->col_offset = col_offset;
817+ return p;
818+}
819+
820+stmt_ty
821+ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno, int
822+ col_offset, PyArena *arena)
823+{
824+ stmt_ty p;
825+ if (!name) {
826+ PyErr_SetString(PyExc_ValueError,
827+ "field name is required for ClassDef");
828+ return NULL;
829+ }
830+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
831+ if (!p) {
832+ PyErr_NoMemory();
833+ return NULL;
834+ }
835+ p->kind = ClassDef_kind;
836+ p->v.ClassDef.name = name;
837+ p->v.ClassDef.bases = bases;
838+ p->v.ClassDef.body = body;
839+ p->lineno = lineno;
840+ p->col_offset = col_offset;
841+ return p;
842+}
843+
844+stmt_ty
845+Return(expr_ty value, int lineno, int col_offset, PyArena *arena)
846+{
847+ stmt_ty p;
848+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
849+ if (!p) {
850+ PyErr_NoMemory();
851+ return NULL;
852+ }
853+ p->kind = Return_kind;
854+ p->v.Return.value = value;
855+ p->lineno = lineno;
856+ p->col_offset = col_offset;
857+ return p;
858+}
859+
860+stmt_ty
861+Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena)
862+{
863+ stmt_ty p;
864+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
865+ if (!p) {
866+ PyErr_NoMemory();
867+ return NULL;
868+ }
869+ p->kind = Delete_kind;
870+ p->v.Delete.targets = targets;
871+ p->lineno = lineno;
872+ p->col_offset = col_offset;
873+ return p;
874+}
875+
876+stmt_ty
877+Assign(asdl_seq * targets, expr_ty value, int lineno, int col_offset, PyArena
878+ *arena)
879+{
880+ stmt_ty p;
881+ if (!value) {
882+ PyErr_SetString(PyExc_ValueError,
883+ "field value is required for Assign");
884+ return NULL;
885+ }
886+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
887+ if (!p) {
888+ PyErr_NoMemory();
889+ return NULL;
890+ }
891+ p->kind = Assign_kind;
892+ p->v.Assign.targets = targets;
893+ p->v.Assign.value = value;
894+ p->lineno = lineno;
895+ p->col_offset = col_offset;
896+ return p;
897+}
898+
899+stmt_ty
900+AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
901+ col_offset, PyArena *arena)
902+{
903+ stmt_ty p;
904+ if (!target) {
905+ PyErr_SetString(PyExc_ValueError,
906+ "field target is required for AugAssign");
907+ return NULL;
908+ }
909+ if (!op) {
910+ PyErr_SetString(PyExc_ValueError,
911+ "field op is required for AugAssign");
912+ return NULL;
913+ }
914+ if (!value) {
915+ PyErr_SetString(PyExc_ValueError,
916+ "field value is required for AugAssign");
917+ return NULL;
918+ }
919+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
920+ if (!p) {
921+ PyErr_NoMemory();
922+ return NULL;
923+ }
924+ p->kind = AugAssign_kind;
925+ p->v.AugAssign.target = target;
926+ p->v.AugAssign.op = op;
927+ p->v.AugAssign.value = value;
928+ p->lineno = lineno;
929+ p->col_offset = col_offset;
930+ return p;
931+}
932+
933+stmt_ty
934+Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset,
935+ PyArena *arena)
936+{
937+ stmt_ty p;
938+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
939+ if (!p) {
940+ PyErr_NoMemory();
941+ return NULL;
942+ }
943+ p->kind = Print_kind;
944+ p->v.Print.dest = dest;
945+ p->v.Print.values = values;
946+ p->v.Print.nl = nl;
947+ p->lineno = lineno;
948+ p->col_offset = col_offset;
949+ return p;
950+}
951+
952+stmt_ty
953+For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
954+ lineno, int col_offset, PyArena *arena)
955+{
956+ stmt_ty p;
957+ if (!target) {
958+ PyErr_SetString(PyExc_ValueError,
959+ "field target is required for For");
960+ return NULL;
961+ }
962+ if (!iter) {
963+ PyErr_SetString(PyExc_ValueError,
964+ "field iter is required for For");
965+ return NULL;
966+ }
967+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
968+ if (!p) {
969+ PyErr_NoMemory();
970+ return NULL;
971+ }
972+ p->kind = For_kind;
973+ p->v.For.target = target;
974+ p->v.For.iter = iter;
975+ p->v.For.body = body;
976+ p->v.For.orelse = orelse;
977+ p->lineno = lineno;
978+ p->col_offset = col_offset;
979+ return p;
980+}
981+
982+stmt_ty
983+While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
984+ col_offset, PyArena *arena)
985+{
986+ stmt_ty p;
987+ if (!test) {
988+ PyErr_SetString(PyExc_ValueError,
989+ "field test is required for While");
990+ return NULL;
991+ }
992+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
993+ if (!p) {
994+ PyErr_NoMemory();
995+ return NULL;
996+ }
997+ p->kind = While_kind;
998+ p->v.While.test = test;
999+ p->v.While.body = body;
1000+ p->v.While.orelse = orelse;
1001+ p->lineno = lineno;
1002+ p->col_offset = col_offset;
1003+ return p;
1004+}
1005+
1006+stmt_ty
1007+If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
1008+ col_offset, PyArena *arena)
1009+{
1010+ stmt_ty p;
1011+ if (!test) {
1012+ PyErr_SetString(PyExc_ValueError,
1013+ "field test is required for If");
1014+ return NULL;
1015+ }
1016+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1017+ if (!p) {
1018+ PyErr_NoMemory();
1019+ return NULL;
1020+ }
1021+ p->kind = If_kind;
1022+ p->v.If.test = test;
1023+ p->v.If.body = body;
1024+ p->v.If.orelse = orelse;
1025+ p->lineno = lineno;
1026+ p->col_offset = col_offset;
1027+ return p;
1028+}
1029+
1030+stmt_ty
1031+With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body, int lineno,
1032+ int col_offset, PyArena *arena)
1033+{
1034+ stmt_ty p;
1035+ if (!context_expr) {
1036+ PyErr_SetString(PyExc_ValueError,
1037+ "field context_expr is required for With");
1038+ return NULL;
1039+ }
1040+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1041+ if (!p) {
1042+ PyErr_NoMemory();
1043+ return NULL;
1044+ }
1045+ p->kind = With_kind;
1046+ p->v.With.context_expr = context_expr;
1047+ p->v.With.optional_vars = optional_vars;
1048+ p->v.With.body = body;
1049+ p->lineno = lineno;
1050+ p->col_offset = col_offset;
1051+ return p;
1052+}
1053+
1054+stmt_ty
1055+Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset,
1056+ PyArena *arena)
1057+{
1058+ stmt_ty p;
1059+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1060+ if (!p) {
1061+ PyErr_NoMemory();
1062+ return NULL;
1063+ }
1064+ p->kind = Raise_kind;
1065+ p->v.Raise.type = type;
1066+ p->v.Raise.inst = inst;
1067+ p->v.Raise.tback = tback;
1068+ p->lineno = lineno;
1069+ p->col_offset = col_offset;
1070+ return p;
1071+}
1072+
1073+stmt_ty
1074+TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno,
1075+ int col_offset, PyArena *arena)
1076+{
1077+ stmt_ty p;
1078+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1079+ if (!p) {
1080+ PyErr_NoMemory();
1081+ return NULL;
1082+ }
1083+ p->kind = TryExcept_kind;
1084+ p->v.TryExcept.body = body;
1085+ p->v.TryExcept.handlers = handlers;
1086+ p->v.TryExcept.orelse = orelse;
1087+ p->lineno = lineno;
1088+ p->col_offset = col_offset;
1089+ return p;
1090+}
1091+
1092+stmt_ty
1093+TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int col_offset,
1094+ PyArena *arena)
1095+{
1096+ stmt_ty p;
1097+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1098+ if (!p) {
1099+ PyErr_NoMemory();
1100+ return NULL;
1101+ }
1102+ p->kind = TryFinally_kind;
1103+ p->v.TryFinally.body = body;
1104+ p->v.TryFinally.finalbody = finalbody;
1105+ p->lineno = lineno;
1106+ p->col_offset = col_offset;
1107+ return p;
1108+}
1109+
1110+stmt_ty
1111+Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena)
1112+{
1113+ stmt_ty p;
1114+ if (!test) {
1115+ PyErr_SetString(PyExc_ValueError,
1116+ "field test is required for Assert");
1117+ return NULL;
1118+ }
1119+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1120+ if (!p) {
1121+ PyErr_NoMemory();
1122+ return NULL;
1123+ }
1124+ p->kind = Assert_kind;
1125+ p->v.Assert.test = test;
1126+ p->v.Assert.msg = msg;
1127+ p->lineno = lineno;
1128+ p->col_offset = col_offset;
1129+ return p;
1130+}
1131+
1132+stmt_ty
1133+Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1134+{
1135+ stmt_ty p;
1136+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1137+ if (!p) {
1138+ PyErr_NoMemory();
1139+ return NULL;
1140+ }
1141+ p->kind = Import_kind;
1142+ p->v.Import.names = names;
1143+ p->lineno = lineno;
1144+ p->col_offset = col_offset;
1145+ return p;
1146+}
1147+
1148+stmt_ty
1149+ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
1150+ col_offset, PyArena *arena)
1151+{
1152+ stmt_ty p;
1153+ if (!module) {
1154+ PyErr_SetString(PyExc_ValueError,
1155+ "field module is required for ImportFrom");
1156+ return NULL;
1157+ }
1158+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1159+ if (!p) {
1160+ PyErr_NoMemory();
1161+ return NULL;
1162+ }
1163+ p->kind = ImportFrom_kind;
1164+ p->v.ImportFrom.module = module;
1165+ p->v.ImportFrom.names = names;
1166+ p->v.ImportFrom.level = level;
1167+ p->lineno = lineno;
1168+ p->col_offset = col_offset;
1169+ return p;
1170+}
1171+
1172+stmt_ty
1173+Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int col_offset,
1174+ PyArena *arena)
1175+{
1176+ stmt_ty p;
1177+ if (!body) {
1178+ PyErr_SetString(PyExc_ValueError,
1179+ "field body is required for Exec");
1180+ return NULL;
1181+ }
1182+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1183+ if (!p) {
1184+ PyErr_NoMemory();
1185+ return NULL;
1186+ }
1187+ p->kind = Exec_kind;
1188+ p->v.Exec.body = body;
1189+ p->v.Exec.globals = globals;
1190+ p->v.Exec.locals = locals;
1191+ p->lineno = lineno;
1192+ p->col_offset = col_offset;
1193+ return p;
1194+}
1195+
1196+stmt_ty
1197+Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1198+{
1199+ stmt_ty p;
1200+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1201+ if (!p) {
1202+ PyErr_NoMemory();
1203+ return NULL;
1204+ }
1205+ p->kind = Global_kind;
1206+ p->v.Global.names = names;
1207+ p->lineno = lineno;
1208+ p->col_offset = col_offset;
1209+ return p;
1210+}
1211+
1212+stmt_ty
1213+Expr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1214+{
1215+ stmt_ty p;
1216+ if (!value) {
1217+ PyErr_SetString(PyExc_ValueError,
1218+ "field value is required for Expr");
1219+ return NULL;
1220+ }
1221+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1222+ if (!p) {
1223+ PyErr_NoMemory();
1224+ return NULL;
1225+ }
1226+ p->kind = Expr_kind;
1227+ p->v.Expr.value = value;
1228+ p->lineno = lineno;
1229+ p->col_offset = col_offset;
1230+ return p;
1231+}
1232+
1233+stmt_ty
1234+Pass(int lineno, int col_offset, PyArena *arena)
1235+{
1236+ stmt_ty p;
1237+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1238+ if (!p) {
1239+ PyErr_NoMemory();
1240+ return NULL;
1241+ }
1242+ p->kind = Pass_kind;
1243+ p->lineno = lineno;
1244+ p->col_offset = col_offset;
1245+ return p;
1246+}
1247+
1248+stmt_ty
1249+Break(int lineno, int col_offset, PyArena *arena)
1250+{
1251+ stmt_ty p;
1252+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1253+ if (!p) {
1254+ PyErr_NoMemory();
1255+ return NULL;
1256+ }
1257+ p->kind = Break_kind;
1258+ p->lineno = lineno;
1259+ p->col_offset = col_offset;
1260+ return p;
1261+}
1262+
1263+stmt_ty
1264+Continue(int lineno, int col_offset, PyArena *arena)
1265+{
1266+ stmt_ty p;
1267+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1268+ if (!p) {
1269+ PyErr_NoMemory();
1270+ return NULL;
1271+ }
1272+ p->kind = Continue_kind;
1273+ p->lineno = lineno;
1274+ p->col_offset = col_offset;
1275+ return p;
1276+}
1277+
1278+expr_ty
1279+BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena
1280+ *arena)
1281+{
1282+ expr_ty p;
1283+ if (!op) {
1284+ PyErr_SetString(PyExc_ValueError,
1285+ "field op is required for BoolOp");
1286+ return NULL;
1287+ }
1288+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1289+ if (!p) {
1290+ PyErr_NoMemory();
1291+ return NULL;
1292+ }
1293+ p->kind = BoolOp_kind;
1294+ p->v.BoolOp.op = op;
1295+ p->v.BoolOp.values = values;
1296+ p->lineno = lineno;
1297+ p->col_offset = col_offset;
1298+ return p;
1299+}
1300+
1301+expr_ty
1302+BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
1303+ PyArena *arena)
1304+{
1305+ expr_ty p;
1306+ if (!left) {
1307+ PyErr_SetString(PyExc_ValueError,
1308+ "field left is required for BinOp");
1309+ return NULL;
1310+ }
1311+ if (!op) {
1312+ PyErr_SetString(PyExc_ValueError,
1313+ "field op is required for BinOp");
1314+ return NULL;
1315+ }
1316+ if (!right) {
1317+ PyErr_SetString(PyExc_ValueError,
1318+ "field right is required for BinOp");
1319+ return NULL;
1320+ }
1321+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1322+ if (!p) {
1323+ PyErr_NoMemory();
1324+ return NULL;
1325+ }
1326+ p->kind = BinOp_kind;
1327+ p->v.BinOp.left = left;
1328+ p->v.BinOp.op = op;
1329+ p->v.BinOp.right = right;
1330+ p->lineno = lineno;
1331+ p->col_offset = col_offset;
1332+ return p;
1333+}
1334+
1335+expr_ty
1336+UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena
1337+ *arena)
1338+{
1339+ expr_ty p;
1340+ if (!op) {
1341+ PyErr_SetString(PyExc_ValueError,
1342+ "field op is required for UnaryOp");
1343+ return NULL;
1344+ }
1345+ if (!operand) {
1346+ PyErr_SetString(PyExc_ValueError,
1347+ "field operand is required for UnaryOp");
1348+ return NULL;
1349+ }
1350+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1351+ if (!p) {
1352+ PyErr_NoMemory();
1353+ return NULL;
1354+ }
1355+ p->kind = UnaryOp_kind;
1356+ p->v.UnaryOp.op = op;
1357+ p->v.UnaryOp.operand = operand;
1358+ p->lineno = lineno;
1359+ p->col_offset = col_offset;
1360+ return p;
1361+}
1362+
1363+expr_ty
1364+Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena
1365+ *arena)
1366+{
1367+ expr_ty p;
1368+ if (!args) {
1369+ PyErr_SetString(PyExc_ValueError,
1370+ "field args is required for Lambda");
1371+ return NULL;
1372+ }
1373+ if (!body) {
1374+ PyErr_SetString(PyExc_ValueError,
1375+ "field body is required for Lambda");
1376+ return NULL;
1377+ }
1378+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1379+ if (!p) {
1380+ PyErr_NoMemory();
1381+ return NULL;
1382+ }
1383+ p->kind = Lambda_kind;
1384+ p->v.Lambda.args = args;
1385+ p->v.Lambda.body = body;
1386+ p->lineno = lineno;
1387+ p->col_offset = col_offset;
1388+ return p;
1389+}
1390+
1391+expr_ty
1392+IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
1393+ PyArena *arena)
1394+{
1395+ expr_ty p;
1396+ if (!test) {
1397+ PyErr_SetString(PyExc_ValueError,
1398+ "field test is required for IfExp");
1399+ return NULL;
1400+ }
1401+ if (!body) {
1402+ PyErr_SetString(PyExc_ValueError,
1403+ "field body is required for IfExp");
1404+ return NULL;
1405+ }
1406+ if (!orelse) {
1407+ PyErr_SetString(PyExc_ValueError,
1408+ "field orelse is required for IfExp");
1409+ return NULL;
1410+ }
1411+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1412+ if (!p) {
1413+ PyErr_NoMemory();
1414+ return NULL;
1415+ }
1416+ p->kind = IfExp_kind;
1417+ p->v.IfExp.test = test;
1418+ p->v.IfExp.body = body;
1419+ p->v.IfExp.orelse = orelse;
1420+ p->lineno = lineno;
1421+ p->col_offset = col_offset;
1422+ return p;
1423+}
1424+
1425+expr_ty
1426+Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena
1427+ *arena)
1428+{
1429+ expr_ty p;
1430+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1431+ if (!p) {
1432+ PyErr_NoMemory();
1433+ return NULL;
1434+ }
1435+ p->kind = Dict_kind;
1436+ p->v.Dict.keys = keys;
1437+ p->v.Dict.values = values;
1438+ p->lineno = lineno;
1439+ p->col_offset = col_offset;
1440+ return p;
1441+}
1442+
1443+expr_ty
1444+ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1445+ PyArena *arena)
1446+{
1447+ expr_ty p;
1448+ if (!elt) {
1449+ PyErr_SetString(PyExc_ValueError,
1450+ "field elt is required for ListComp");
1451+ return NULL;
1452+ }
1453+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1454+ if (!p) {
1455+ PyErr_NoMemory();
1456+ return NULL;
1457+ }
1458+ p->kind = ListComp_kind;
1459+ p->v.ListComp.elt = elt;
1460+ p->v.ListComp.generators = generators;
1461+ p->lineno = lineno;
1462+ p->col_offset = col_offset;
1463+ return p;
1464+}
1465+
1466+expr_ty
1467+GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1468+ PyArena *arena)
1469+{
1470+ expr_ty p;
1471+ if (!elt) {
1472+ PyErr_SetString(PyExc_ValueError,
1473+ "field elt is required for GeneratorExp");
1474+ return NULL;
1475+ }
1476+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1477+ if (!p) {
1478+ PyErr_NoMemory();
1479+ return NULL;
1480+ }
1481+ p->kind = GeneratorExp_kind;
1482+ p->v.GeneratorExp.elt = elt;
1483+ p->v.GeneratorExp.generators = generators;
1484+ p->lineno = lineno;
1485+ p->col_offset = col_offset;
1486+ return p;
1487+}
1488+
1489+expr_ty
1490+Yield(expr_ty value, int lineno, int col_offset, PyArena *arena)
1491+{
1492+ expr_ty p;
1493+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1494+ if (!p) {
1495+ PyErr_NoMemory();
1496+ return NULL;
1497+ }
1498+ p->kind = Yield_kind;
1499+ p->v.Yield.value = value;
1500+ p->lineno = lineno;
1501+ p->col_offset = col_offset;
1502+ return p;
1503+}
1504+
1505+expr_ty
1506+Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
1507+ int col_offset, PyArena *arena)
1508+{
1509+ expr_ty p;
1510+ if (!left) {
1511+ PyErr_SetString(PyExc_ValueError,
1512+ "field left is required for Compare");
1513+ return NULL;
1514+ }
1515+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1516+ if (!p) {
1517+ PyErr_NoMemory();
1518+ return NULL;
1519+ }
1520+ p->kind = Compare_kind;
1521+ p->v.Compare.left = left;
1522+ p->v.Compare.ops = ops;
1523+ p->v.Compare.comparators = comparators;
1524+ p->lineno = lineno;
1525+ p->col_offset = col_offset;
1526+ return p;
1527+}
1528+
1529+expr_ty
1530+Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
1531+ expr_ty kwargs, int lineno, int col_offset, PyArena *arena)
1532+{
1533+ expr_ty p;
1534+ if (!func) {
1535+ PyErr_SetString(PyExc_ValueError,
1536+ "field func is required for Call");
1537+ return NULL;
1538+ }
1539+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1540+ if (!p) {
1541+ PyErr_NoMemory();
1542+ return NULL;
1543+ }
1544+ p->kind = Call_kind;
1545+ p->v.Call.func = func;
1546+ p->v.Call.args = args;
1547+ p->v.Call.keywords = keywords;
1548+ p->v.Call.starargs = starargs;
1549+ p->v.Call.kwargs = kwargs;
1550+ p->lineno = lineno;
1551+ p->col_offset = col_offset;
1552+ return p;
1553+}
1554+
1555+expr_ty
1556+Repr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1557+{
1558+ expr_ty p;
1559+ if (!value) {
1560+ PyErr_SetString(PyExc_ValueError,
1561+ "field value is required for Repr");
1562+ return NULL;
1563+ }
1564+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1565+ if (!p) {
1566+ PyErr_NoMemory();
1567+ return NULL;
1568+ }
1569+ p->kind = Repr_kind;
1570+ p->v.Repr.value = value;
1571+ p->lineno = lineno;
1572+ p->col_offset = col_offset;
1573+ return p;
1574+}
1575+
1576+expr_ty
1577+Num(object n, int lineno, int col_offset, PyArena *arena)
1578+{
1579+ expr_ty p;
1580+ if (!n) {
1581+ PyErr_SetString(PyExc_ValueError,
1582+ "field n is required for Num");
1583+ return NULL;
1584+ }
1585+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1586+ if (!p) {
1587+ PyErr_NoMemory();
1588+ return NULL;
1589+ }
1590+ p->kind = Num_kind;
1591+ p->v.Num.n = n;
1592+ p->lineno = lineno;
1593+ p->col_offset = col_offset;
1594+ return p;
1595+}
1596+
1597+expr_ty
1598+Str(string s, int lineno, int col_offset, PyArena *arena)
1599+{
1600+ expr_ty p;
1601+ if (!s) {
1602+ PyErr_SetString(PyExc_ValueError,
1603+ "field s is required for Str");
1604+ return NULL;
1605+ }
1606+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1607+ if (!p) {
1608+ PyErr_NoMemory();
1609+ return NULL;
1610+ }
1611+ p->kind = Str_kind;
1612+ p->v.Str.s = s;
1613+ p->lineno = lineno;
1614+ p->col_offset = col_offset;
1615+ return p;
1616+}
1617+
1618+expr_ty
1619+Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
1620+ col_offset, PyArena *arena)
1621+{
1622+ expr_ty p;
1623+ if (!value) {
1624+ PyErr_SetString(PyExc_ValueError,
1625+ "field value is required for Attribute");
1626+ return NULL;
1627+ }
1628+ if (!attr) {
1629+ PyErr_SetString(PyExc_ValueError,
1630+ "field attr is required for Attribute");
1631+ return NULL;
1632+ }
1633+ if (!ctx) {
1634+ PyErr_SetString(PyExc_ValueError,
1635+ "field ctx is required for Attribute");
1636+ return NULL;
1637+ }
1638+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1639+ if (!p) {
1640+ PyErr_NoMemory();
1641+ return NULL;
1642+ }
1643+ p->kind = Attribute_kind;
1644+ p->v.Attribute.value = value;
1645+ p->v.Attribute.attr = attr;
1646+ p->v.Attribute.ctx = ctx;
1647+ p->lineno = lineno;
1648+ p->col_offset = col_offset;
1649+ return p;
1650+}
1651+
1652+expr_ty
1653+Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int
1654+ col_offset, PyArena *arena)
1655+{
1656+ expr_ty p;
1657+ if (!value) {
1658+ PyErr_SetString(PyExc_ValueError,
1659+ "field value is required for Subscript");
1660+ return NULL;
1661+ }
1662+ if (!slice) {
1663+ PyErr_SetString(PyExc_ValueError,
1664+ "field slice is required for Subscript");
1665+ return NULL;
1666+ }
1667+ if (!ctx) {
1668+ PyErr_SetString(PyExc_ValueError,
1669+ "field ctx is required for Subscript");
1670+ return NULL;
1671+ }
1672+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1673+ if (!p) {
1674+ PyErr_NoMemory();
1675+ return NULL;
1676+ }
1677+ p->kind = Subscript_kind;
1678+ p->v.Subscript.value = value;
1679+ p->v.Subscript.slice = slice;
1680+ p->v.Subscript.ctx = ctx;
1681+ p->lineno = lineno;
1682+ p->col_offset = col_offset;
1683+ return p;
1684+}
1685+
1686+expr_ty
1687+Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena
1688+ *arena)
1689+{
1690+ expr_ty p;
1691+ if (!id) {
1692+ PyErr_SetString(PyExc_ValueError,
1693+ "field id is required for Name");
1694+ return NULL;
1695+ }
1696+ if (!ctx) {
1697+ PyErr_SetString(PyExc_ValueError,
1698+ "field ctx is required for Name");
1699+ return NULL;
1700+ }
1701+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1702+ if (!p) {
1703+ PyErr_NoMemory();
1704+ return NULL;
1705+ }
1706+ p->kind = Name_kind;
1707+ p->v.Name.id = id;
1708+ p->v.Name.ctx = ctx;
1709+ p->lineno = lineno;
1710+ p->col_offset = col_offset;
1711+ return p;
1712+}
1713+
1714+expr_ty
1715+List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1716+ *arena)
1717+{
1718+ expr_ty p;
1719+ if (!ctx) {
1720+ PyErr_SetString(PyExc_ValueError,
1721+ "field ctx is required for List");
1722+ return NULL;
1723+ }
1724+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1725+ if (!p) {
1726+ PyErr_NoMemory();
1727+ return NULL;
1728+ }
1729+ p->kind = List_kind;
1730+ p->v.List.elts = elts;
1731+ p->v.List.ctx = ctx;
1732+ p->lineno = lineno;
1733+ p->col_offset = col_offset;
1734+ return p;
1735+}
1736+
1737+expr_ty
1738+Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1739+ *arena)
1740+{
1741+ expr_ty p;
1742+ if (!ctx) {
1743+ PyErr_SetString(PyExc_ValueError,
1744+ "field ctx is required for Tuple");
1745+ return NULL;
1746+ }
1747+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1748+ if (!p) {
1749+ PyErr_NoMemory();
1750+ return NULL;
1751+ }
1752+ p->kind = Tuple_kind;
1753+ p->v.Tuple.elts = elts;
1754+ p->v.Tuple.ctx = ctx;
1755+ p->lineno = lineno;
1756+ p->col_offset = col_offset;
1757+ return p;
1758+}
1759+
1760+slice_ty
1761+Ellipsis(PyArena *arena)
1762+{
1763+ slice_ty p;
1764+ p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1765+ if (!p) {
1766+ PyErr_NoMemory();
1767+ return NULL;
1768+ }
1769+ p->kind = Ellipsis_kind;
1770+ return p;
1771+}
1772+
1773+slice_ty
1774+Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
1775+{
1776+ slice_ty p;
1777+ p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1778+ if (!p) {
1779+ PyErr_NoMemory();
1780+ return NULL;
1781+ }
1782+ p->kind = Slice_kind;
1783+ p->v.Slice.lower = lower;
1784+ p->v.Slice.upper = upper;
1785+ p->v.Slice.step = step;
1786+ return p;
1787+}
1788+
1789+slice_ty
1790+ExtSlice(asdl_seq * dims, PyArena *arena)
1791+{
1792+ slice_ty p;
1793+ p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1794+ if (!p) {
1795+ PyErr_NoMemory();
1796+ return NULL;
1797+ }
1798+ p->kind = ExtSlice_kind;
1799+ p->v.ExtSlice.dims = dims;
1800+ return p;
1801+}
1802+
1803+slice_ty
1804+Index(expr_ty value, PyArena *arena)
1805+{
1806+ slice_ty p;
1807+ if (!value) {
1808+ PyErr_SetString(PyExc_ValueError,
1809+ "field value is required for Index");
1810+ return NULL;
1811+ }
1812+ p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1813+ if (!p) {
1814+ PyErr_NoMemory();
1815+ return NULL;
1816+ }
1817+ p->kind = Index_kind;
1818+ p->v.Index.value = value;
1819+ return p;
1820+}
1821+
1822+comprehension_ty
1823+comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena)
1824+{
1825+ comprehension_ty p;
1826+ if (!target) {
1827+ PyErr_SetString(PyExc_ValueError,
1828+ "field target is required for comprehension");
1829+ return NULL;
1830+ }
1831+ if (!iter) {
1832+ PyErr_SetString(PyExc_ValueError,
1833+ "field iter is required for comprehension");
1834+ return NULL;
1835+ }
1836+ p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
1837+ if (!p) {
1838+ PyErr_NoMemory();
1839+ return NULL;
1840+ }
1841+ p->target = target;
1842+ p->iter = iter;
1843+ p->ifs = ifs;
1844+ return p;
1845+}
1846+
1847+excepthandler_ty
1848+excepthandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int
1849+ col_offset, PyArena *arena)
1850+{
1851+ excepthandler_ty p;
1852+ p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
1853+ if (!p) {
1854+ PyErr_NoMemory();
1855+ return NULL;
1856+ }
1857+ p->type = type;
1858+ p->name = name;
1859+ p->body = body;
1860+ p->lineno = lineno;
1861+ p->col_offset = col_offset;
1862+ return p;
1863+}
1864+
1865+arguments_ty
1866+arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
1867+ defaults, PyArena *arena)
1868+{
1869+ arguments_ty p;
1870+ p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
1871+ if (!p) {
1872+ PyErr_NoMemory();
1873+ return NULL;
1874+ }
1875+ p->args = args;
1876+ p->vararg = vararg;
1877+ p->kwarg = kwarg;
1878+ p->defaults = defaults;
1879+ return p;
1880+}
1881+
1882+keyword_ty
1883+keyword(identifier arg, expr_ty value, PyArena *arena)
1884+{
1885+ keyword_ty p;
1886+ if (!arg) {
1887+ PyErr_SetString(PyExc_ValueError,
1888+ "field arg is required for keyword");
1889+ return NULL;
1890+ }
1891+ if (!value) {
1892+ PyErr_SetString(PyExc_ValueError,
1893+ "field value is required for keyword");
1894+ return NULL;
1895+ }
1896+ p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
1897+ if (!p) {
1898+ PyErr_NoMemory();
1899+ return NULL;
1900+ }
1901+ p->arg = arg;
1902+ p->value = value;
1903+ return p;
1904+}
1905+
1906+alias_ty
1907+alias(identifier name, identifier asname, PyArena *arena)
1908+{
1909+ alias_ty p;
1910+ if (!name) {
1911+ PyErr_SetString(PyExc_ValueError,
1912+ "field name is required for alias");
1913+ return NULL;
1914+ }
1915+ p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
1916+ if (!p) {
1917+ PyErr_NoMemory();
1918+ return NULL;
1919+ }
1920+ p->name = name;
1921+ p->asname = asname;
1922+ return p;
1923+}
1924+
1925+
1926+PyObject*
1927+ast2obj_mod(void* _o)
1928+{
1929+ mod_ty o = (mod_ty)_o;
1930+ PyObject *result = NULL, *value = NULL;
1931+ if (!o) {
1932+ Py_INCREF(Py_None);
1933+ return Py_None;
1934+ }
1935+
1936+ switch (o->kind) {
1937+ case Module_kind:
1938+ result = PyType_GenericNew(Module_type, NULL, NULL);
1939+ if (!result) goto failed;
1940+ value = ast2obj_list(o->v.Module.body, ast2obj_stmt);
1941+ if (!value) goto failed;
1942+ if (PyObject_SetAttrString(result, "body", value) == -1)
1943+ goto failed;
1944+ Py_DECREF(value);
1945+ break;
1946+ case Interactive_kind:
1947+ result = PyType_GenericNew(Interactive_type, NULL, NULL);
1948+ if (!result) goto failed;
1949+ value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt);
1950+ if (!value) goto failed;
1951+ if (PyObject_SetAttrString(result, "body", value) == -1)
1952+ goto failed;
1953+ Py_DECREF(value);
1954+ break;
1955+ case Expression_kind:
1956+ result = PyType_GenericNew(Expression_type, NULL, NULL);
1957+ if (!result) goto failed;
1958+ value = ast2obj_expr(o->v.Expression.body);
1959+ if (!value) goto failed;
1960+ if (PyObject_SetAttrString(result, "body", value) == -1)
1961+ goto failed;
1962+ Py_DECREF(value);
1963+ break;
1964+ case Suite_kind:
1965+ result = PyType_GenericNew(Suite_type, NULL, NULL);
1966+ if (!result) goto failed;
1967+ value = ast2obj_list(o->v.Suite.body, ast2obj_stmt);
1968+ if (!value) goto failed;
1969+ if (PyObject_SetAttrString(result, "body", value) == -1)
1970+ goto failed;
1971+ Py_DECREF(value);
1972+ break;
1973+ }
1974+ return result;
1975+failed:
1976+ Py_XDECREF(value);
1977+ Py_XDECREF(result);
1978+ return NULL;
1979+}
1980+
1981+PyObject*
1982+ast2obj_stmt(void* _o)
1983+{
1984+ stmt_ty o = (stmt_ty)_o;
1985+ PyObject *result = NULL, *value = NULL;
1986+ if (!o) {
1987+ Py_INCREF(Py_None);
1988+ return Py_None;
1989+ }
1990+
1991+ switch (o->kind) {
1992+ case FunctionDef_kind:
1993+ result = PyType_GenericNew(FunctionDef_type, NULL, NULL);
1994+ if (!result) goto failed;
1995+ value = ast2obj_identifier(o->v.FunctionDef.name);
1996+ if (!value) goto failed;
1997+ if (PyObject_SetAttrString(result, "name", value) == -1)
1998+ goto failed;
1999+ Py_DECREF(value);
2000+ value = ast2obj_arguments(o->v.FunctionDef.args);
2001+ if (!value) goto failed;
2002+ if (PyObject_SetAttrString(result, "args", value) == -1)
2003+ goto failed;
2004+ Py_DECREF(value);
2005+ value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt);
2006+ if (!value) goto failed;
2007+ if (PyObject_SetAttrString(result, "body", value) == -1)
2008+ goto failed;
2009+ Py_DECREF(value);
2010+ value = ast2obj_list(o->v.FunctionDef.decorators, ast2obj_expr);
2011+ if (!value) goto failed;
2012+ if (PyObject_SetAttrString(result, "decorators", value) == -1)
2013+ goto failed;
2014+ Py_DECREF(value);
2015+ break;
2016+ case ClassDef_kind:
2017+ result = PyType_GenericNew(ClassDef_type, NULL, NULL);
2018+ if (!result) goto failed;
2019+ value = ast2obj_identifier(o->v.ClassDef.name);
2020+ if (!value) goto failed;
2021+ if (PyObject_SetAttrString(result, "name", value) == -1)
2022+ goto failed;
2023+ Py_DECREF(value);
2024+ value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr);
2025+ if (!value) goto failed;
2026+ if (PyObject_SetAttrString(result, "bases", value) == -1)
2027+ goto failed;
2028+ Py_DECREF(value);
2029+ value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt);
2030+ if (!value) goto failed;
2031+ if (PyObject_SetAttrString(result, "body", value) == -1)
2032+ goto failed;
2033+ Py_DECREF(value);
2034+ break;
2035+ case Return_kind:
2036+ result = PyType_GenericNew(Return_type, NULL, NULL);
2037+ if (!result) goto failed;
2038+ value = ast2obj_expr(o->v.Return.value);
2039+ if (!value) goto failed;
2040+ if (PyObject_SetAttrString(result, "value", value) == -1)
2041+ goto failed;
2042+ Py_DECREF(value);
2043+ break;
2044+ case Delete_kind:
2045+ result = PyType_GenericNew(Delete_type, NULL, NULL);
2046+ if (!result) goto failed;
2047+ value = ast2obj_list(o->v.Delete.targets, ast2obj_expr);
2048+ if (!value) goto failed;
2049+ if (PyObject_SetAttrString(result, "targets", value) == -1)
2050+ goto failed;
2051+ Py_DECREF(value);
2052+ break;
2053+ case Assign_kind:
2054+ result = PyType_GenericNew(Assign_type, NULL, NULL);
2055+ if (!result) goto failed;
2056+ value = ast2obj_list(o->v.Assign.targets, ast2obj_expr);
2057+ if (!value) goto failed;
2058+ if (PyObject_SetAttrString(result, "targets", value) == -1)
2059+ goto failed;
2060+ Py_DECREF(value);
2061+ value = ast2obj_expr(o->v.Assign.value);
2062+ if (!value) goto failed;
2063+ if (PyObject_SetAttrString(result, "value", value) == -1)
2064+ goto failed;
2065+ Py_DECREF(value);
2066+ break;
2067+ case AugAssign_kind:
2068+ result = PyType_GenericNew(AugAssign_type, NULL, NULL);
2069+ if (!result) goto failed;
2070+ value = ast2obj_expr(o->v.AugAssign.target);
2071+ if (!value) goto failed;
2072+ if (PyObject_SetAttrString(result, "target", value) == -1)
2073+ goto failed;
2074+ Py_DECREF(value);
2075+ value = ast2obj_operator(o->v.AugAssign.op);
2076+ if (!value) goto failed;
2077+ if (PyObject_SetAttrString(result, "op", value) == -1)
2078+ goto failed;
2079+ Py_DECREF(value);
2080+ value = ast2obj_expr(o->v.AugAssign.value);
2081+ if (!value) goto failed;
2082+ if (PyObject_SetAttrString(result, "value", value) == -1)
2083+ goto failed;
2084+ Py_DECREF(value);
2085+ break;
2086+ case Print_kind:
2087+ result = PyType_GenericNew(Print_type, NULL, NULL);
2088+ if (!result) goto failed;
2089+ value = ast2obj_expr(o->v.Print.dest);
2090+ if (!value) goto failed;
2091+ if (PyObject_SetAttrString(result, "dest", value) == -1)
2092+ goto failed;
2093+ Py_DECREF(value);
2094+ value = ast2obj_list(o->v.Print.values, ast2obj_expr);
2095+ if (!value) goto failed;
2096+ if (PyObject_SetAttrString(result, "values", value) == -1)
2097+ goto failed;
2098+ Py_DECREF(value);
2099+ value = ast2obj_bool(o->v.Print.nl);
2100+ if (!value) goto failed;
2101+ if (PyObject_SetAttrString(result, "nl", value) == -1)
2102+ goto failed;
2103+ Py_DECREF(value);
2104+ break;
2105+ case For_kind:
2106+ result = PyType_GenericNew(For_type, NULL, NULL);
2107+ if (!result) goto failed;
2108+ value = ast2obj_expr(o->v.For.target);
2109+ if (!value) goto failed;
2110+ if (PyObject_SetAttrString(result, "target", value) == -1)
2111+ goto failed;
2112+ Py_DECREF(value);
2113+ value = ast2obj_expr(o->v.For.iter);
2114+ if (!value) goto failed;
2115+ if (PyObject_SetAttrString(result, "iter", value) == -1)
2116+ goto failed;
2117+ Py_DECREF(value);
2118+ value = ast2obj_list(o->v.For.body, ast2obj_stmt);
2119+ if (!value) goto failed;
2120+ if (PyObject_SetAttrString(result, "body", value) == -1)
2121+ goto failed;
2122+ Py_DECREF(value);
2123+ value = ast2obj_list(o->v.For.orelse, ast2obj_stmt);
2124+ if (!value) goto failed;
2125+ if (PyObject_SetAttrString(result, "orelse", value) == -1)
2126+ goto failed;
2127+ Py_DECREF(value);
2128+ break;
2129+ case While_kind:
2130+ result = PyType_GenericNew(While_type, NULL, NULL);
2131+ if (!result) goto failed;
2132+ value = ast2obj_expr(o->v.While.test);
2133+ if (!value) goto failed;
2134+ if (PyObject_SetAttrString(result, "test", value) == -1)
2135+ goto failed;
2136+ Py_DECREF(value);
2137+ value = ast2obj_list(o->v.While.body, ast2obj_stmt);
2138+ if (!value) goto failed;
2139+ if (PyObject_SetAttrString(result, "body", value) == -1)
2140+ goto failed;
2141+ Py_DECREF(value);
2142+ value = ast2obj_list(o->v.While.orelse, ast2obj_stmt);
2143+ if (!value) goto failed;
2144+ if (PyObject_SetAttrString(result, "orelse", value) == -1)
2145+ goto failed;
2146+ Py_DECREF(value);
2147+ break;
2148+ case If_kind:
2149+ result = PyType_GenericNew(If_type, NULL, NULL);
2150+ if (!result) goto failed;
2151+ value = ast2obj_expr(o->v.If.test);
2152+ if (!value) goto failed;
2153+ if (PyObject_SetAttrString(result, "test", value) == -1)
2154+ goto failed;
2155+ Py_DECREF(value);
2156+ value = ast2obj_list(o->v.If.body, ast2obj_stmt);
2157+ if (!value) goto failed;
2158+ if (PyObject_SetAttrString(result, "body", value) == -1)
2159+ goto failed;
2160+ Py_DECREF(value);
2161+ value = ast2obj_list(o->v.If.orelse, ast2obj_stmt);
2162+ if (!value) goto failed;
2163+ if (PyObject_SetAttrString(result, "orelse", value) == -1)
2164+ goto failed;
2165+ Py_DECREF(value);
2166+ break;
2167+ case With_kind:
2168+ result = PyType_GenericNew(With_type, NULL, NULL);
2169+ if (!result) goto failed;
2170+ value = ast2obj_expr(o->v.With.context_expr);
2171+ if (!value) goto failed;
2172+ if (PyObject_SetAttrString(result, "context_expr", value) == -1)
2173+ goto failed;
2174+ Py_DECREF(value);
2175+ value = ast2obj_expr(o->v.With.optional_vars);
2176+ if (!value) goto failed;
2177+ if (PyObject_SetAttrString(result, "optional_vars", value) ==
2178+ -1)
2179+ goto failed;
2180+ Py_DECREF(value);
2181+ value = ast2obj_list(o->v.With.body, ast2obj_stmt);
2182+ if (!value) goto failed;
2183+ if (PyObject_SetAttrString(result, "body", value) == -1)
2184+ goto failed;
2185+ Py_DECREF(value);
2186+ break;
2187+ case Raise_kind:
2188+ result = PyType_GenericNew(Raise_type, NULL, NULL);
2189+ if (!result) goto failed;
2190+ value = ast2obj_expr(o->v.Raise.type);
2191+ if (!value) goto failed;
2192+ if (PyObject_SetAttrString(result, "type", value) == -1)
2193+ goto failed;
2194+ Py_DECREF(value);
2195+ value = ast2obj_expr(o->v.Raise.inst);
2196+ if (!value) goto failed;
2197+ if (PyObject_SetAttrString(result, "inst", value) == -1)
2198+ goto failed;
2199+ Py_DECREF(value);
2200+ value = ast2obj_expr(o->v.Raise.tback);
2201+ if (!value) goto failed;
2202+ if (PyObject_SetAttrString(result, "tback", value) == -1)
2203+ goto failed;
2204+ Py_DECREF(value);
2205+ break;
2206+ case TryExcept_kind:
2207+ result = PyType_GenericNew(TryExcept_type, NULL, NULL);
2208+ if (!result) goto failed;
2209+ value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt);
2210+ if (!value) goto failed;
2211+ if (PyObject_SetAttrString(result, "body", value) == -1)
2212+ goto failed;
2213+ Py_DECREF(value);
2214+ value = ast2obj_list(o->v.TryExcept.handlers,
2215+ ast2obj_excepthandler);
2216+ if (!value) goto failed;
2217+ if (PyObject_SetAttrString(result, "handlers", value) == -1)
2218+ goto failed;
2219+ Py_DECREF(value);
2220+ value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt);
2221+ if (!value) goto failed;
2222+ if (PyObject_SetAttrString(result, "orelse", value) == -1)
2223+ goto failed;
2224+ Py_DECREF(value);
2225+ break;
2226+ case TryFinally_kind:
2227+ result = PyType_GenericNew(TryFinally_type, NULL, NULL);
2228+ if (!result) goto failed;
2229+ value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt);
2230+ if (!value) goto failed;
2231+ if (PyObject_SetAttrString(result, "body", value) == -1)
2232+ goto failed;
2233+ Py_DECREF(value);
2234+ value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt);
2235+ if (!value) goto failed;
2236+ if (PyObject_SetAttrString(result, "finalbody", value) == -1)
2237+ goto failed;
2238+ Py_DECREF(value);
2239+ break;
2240+ case Assert_kind:
2241+ result = PyType_GenericNew(Assert_type, NULL, NULL);
2242+ if (!result) goto failed;
2243+ value = ast2obj_expr(o->v.Assert.test);
2244+ if (!value) goto failed;
2245+ if (PyObject_SetAttrString(result, "test", value) == -1)
2246+ goto failed;
2247+ Py_DECREF(value);
2248+ value = ast2obj_expr(o->v.Assert.msg);
2249+ if (!value) goto failed;
2250+ if (PyObject_SetAttrString(result, "msg", value) == -1)
2251+ goto failed;
2252+ Py_DECREF(value);
2253+ break;
2254+ case Import_kind:
2255+ result = PyType_GenericNew(Import_type, NULL, NULL);
2256+ if (!result) goto failed;
2257+ value = ast2obj_list(o->v.Import.names, ast2obj_alias);
2258+ if (!value) goto failed;
2259+ if (PyObject_SetAttrString(result, "names", value) == -1)
2260+ goto failed;
2261+ Py_DECREF(value);
2262+ break;
2263+ case ImportFrom_kind:
2264+ result = PyType_GenericNew(ImportFrom_type, NULL, NULL);
2265+ if (!result) goto failed;
2266+ value = ast2obj_identifier(o->v.ImportFrom.module);
2267+ if (!value) goto failed;
2268+ if (PyObject_SetAttrString(result, "module", value) == -1)
2269+ goto failed;
2270+ Py_DECREF(value);
2271+ value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias);
2272+ if (!value) goto failed;
2273+ if (PyObject_SetAttrString(result, "names", value) == -1)
2274+ goto failed;
2275+ Py_DECREF(value);
2276+ value = ast2obj_int(o->v.ImportFrom.level);
2277+ if (!value) goto failed;
2278+ if (PyObject_SetAttrString(result, "level", value) == -1)
2279+ goto failed;
2280+ Py_DECREF(value);
2281+ break;
2282+ case Exec_kind:
2283+ result = PyType_GenericNew(Exec_type, NULL, NULL);
2284+ if (!result) goto failed;
2285+ value = ast2obj_expr(o->v.Exec.body);
2286+ if (!value) goto failed;
2287+ if (PyObject_SetAttrString(result, "body", value) == -1)
2288+ goto failed;
2289+ Py_DECREF(value);
2290+ value = ast2obj_expr(o->v.Exec.globals);
2291+ if (!value) goto failed;
2292+ if (PyObject_SetAttrString(result, "globals", value) == -1)
2293+ goto failed;
2294+ Py_DECREF(value);
2295+ value = ast2obj_expr(o->v.Exec.locals);
2296+ if (!value) goto failed;
2297+ if (PyObject_SetAttrString(result, "locals", value) == -1)
2298+ goto failed;
2299+ Py_DECREF(value);
2300+ break;
2301+ case Global_kind:
2302+ result = PyType_GenericNew(Global_type, NULL, NULL);
2303+ if (!result) goto failed;
2304+ value = ast2obj_list(o->v.Global.names, ast2obj_identifier);
2305+ if (!value) goto failed;
2306+ if (PyObject_SetAttrString(result, "names", value) == -1)
2307+ goto failed;
2308+ Py_DECREF(value);
2309+ break;
2310+ case Expr_kind:
2311+ result = PyType_GenericNew(Expr_type, NULL, NULL);
2312+ if (!result) goto failed;
2313+ value = ast2obj_expr(o->v.Expr.value);
2314+ if (!value) goto failed;
2315+ if (PyObject_SetAttrString(result, "value", value) == -1)
2316+ goto failed;
2317+ Py_DECREF(value);
2318+ break;
2319+ case Pass_kind:
2320+ result = PyType_GenericNew(Pass_type, NULL, NULL);
2321+ if (!result) goto failed;
2322+ break;
2323+ case Break_kind:
2324+ result = PyType_GenericNew(Break_type, NULL, NULL);
2325+ if (!result) goto failed;
2326+ break;
2327+ case Continue_kind:
2328+ result = PyType_GenericNew(Continue_type, NULL, NULL);
2329+ if (!result) goto failed;
2330+ break;
2331+ }
2332+ value = ast2obj_int(o->lineno);
2333+ if (!value) goto failed;
2334+ if (PyObject_SetAttrString(result, "lineno", value) < 0)
2335+ goto failed;
2336+ Py_DECREF(value);
2337+ value = ast2obj_int(o->col_offset);
2338+ if (!value) goto failed;
2339+ if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2340+ goto failed;
2341+ Py_DECREF(value);
2342+ return result;
2343+failed:
2344+ Py_XDECREF(value);
2345+ Py_XDECREF(result);
2346+ return NULL;
2347+}
2348+
2349+PyObject*
2350+ast2obj_expr(void* _o)
2351+{
2352+ expr_ty o = (expr_ty)_o;
2353+ PyObject *result = NULL, *value = NULL;
2354+ if (!o) {
2355+ Py_INCREF(Py_None);
2356+ return Py_None;
2357+ }
2358+
2359+ switch (o->kind) {
2360+ case BoolOp_kind:
2361+ result = PyType_GenericNew(BoolOp_type, NULL, NULL);
2362+ if (!result) goto failed;
2363+ value = ast2obj_boolop(o->v.BoolOp.op);
2364+ if (!value) goto failed;
2365+ if (PyObject_SetAttrString(result, "op", value) == -1)
2366+ goto failed;
2367+ Py_DECREF(value);
2368+ value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr);
2369+ if (!value) goto failed;
2370+ if (PyObject_SetAttrString(result, "values", value) == -1)
2371+ goto failed;
2372+ Py_DECREF(value);
2373+ break;
2374+ case BinOp_kind:
2375+ result = PyType_GenericNew(BinOp_type, NULL, NULL);
2376+ if (!result) goto failed;
2377+ value = ast2obj_expr(o->v.BinOp.left);
2378+ if (!value) goto failed;
2379+ if (PyObject_SetAttrString(result, "left", value) == -1)
2380+ goto failed;
2381+ Py_DECREF(value);
2382+ value = ast2obj_operator(o->v.BinOp.op);
2383+ if (!value) goto failed;
2384+ if (PyObject_SetAttrString(result, "op", value) == -1)
2385+ goto failed;
2386+ Py_DECREF(value);
2387+ value = ast2obj_expr(o->v.BinOp.right);
2388+ if (!value) goto failed;
2389+ if (PyObject_SetAttrString(result, "right", value) == -1)
2390+ goto failed;
2391+ Py_DECREF(value);
2392+ break;
2393+ case UnaryOp_kind:
2394+ result = PyType_GenericNew(UnaryOp_type, NULL, NULL);
2395+ if (!result) goto failed;
2396+ value = ast2obj_unaryop(o->v.UnaryOp.op);
2397+ if (!value) goto failed;
2398+ if (PyObject_SetAttrString(result, "op", value) == -1)
2399+ goto failed;
2400+ Py_DECREF(value);
2401+ value = ast2obj_expr(o->v.UnaryOp.operand);
2402+ if (!value) goto failed;
2403+ if (PyObject_SetAttrString(result, "operand", value) == -1)
2404+ goto failed;
2405+ Py_DECREF(value);
2406+ break;
2407+ case Lambda_kind:
2408+ result = PyType_GenericNew(Lambda_type, NULL, NULL);
2409+ if (!result) goto failed;
2410+ value = ast2obj_arguments(o->v.Lambda.args);
2411+ if (!value) goto failed;
2412+ if (PyObject_SetAttrString(result, "args", value) == -1)
2413+ goto failed;
2414+ Py_DECREF(value);
2415+ value = ast2obj_expr(o->v.Lambda.body);
2416+ if (!value) goto failed;
2417+ if (PyObject_SetAttrString(result, "body", value) == -1)
2418+ goto failed;
2419+ Py_DECREF(value);
2420+ break;
2421+ case IfExp_kind:
2422+ result = PyType_GenericNew(IfExp_type, NULL, NULL);
2423+ if (!result) goto failed;
2424+ value = ast2obj_expr(o->v.IfExp.test);
2425+ if (!value) goto failed;
2426+ if (PyObject_SetAttrString(result, "test", value) == -1)
2427+ goto failed;
2428+ Py_DECREF(value);
2429+ value = ast2obj_expr(o->v.IfExp.body);
2430+ if (!value) goto failed;
2431+ if (PyObject_SetAttrString(result, "body", value) == -1)
2432+ goto failed;
2433+ Py_DECREF(value);
2434+ value = ast2obj_expr(o->v.IfExp.orelse);
2435+ if (!value) goto failed;
2436+ if (PyObject_SetAttrString(result, "orelse", value) == -1)
2437+ goto failed;
2438+ Py_DECREF(value);
2439+ break;
2440+ case Dict_kind:
2441+ result = PyType_GenericNew(Dict_type, NULL, NULL);
2442+ if (!result) goto failed;
2443+ value = ast2obj_list(o->v.Dict.keys, ast2obj_expr);
2444+ if (!value) goto failed;
2445+ if (PyObject_SetAttrString(result, "keys", value) == -1)
2446+ goto failed;
2447+ Py_DECREF(value);
2448+ value = ast2obj_list(o->v.Dict.values, ast2obj_expr);
2449+ if (!value) goto failed;
2450+ if (PyObject_SetAttrString(result, "values", value) == -1)
2451+ goto failed;
2452+ Py_DECREF(value);
2453+ break;
2454+ case ListComp_kind:
2455+ result = PyType_GenericNew(ListComp_type, NULL, NULL);
2456+ if (!result) goto failed;
2457+ value = ast2obj_expr(o->v.ListComp.elt);
2458+ if (!value) goto failed;
2459+ if (PyObject_SetAttrString(result, "elt", value) == -1)
2460+ goto failed;
2461+ Py_DECREF(value);
2462+ value = ast2obj_list(o->v.ListComp.generators,
2463+ ast2obj_comprehension);
2464+ if (!value) goto failed;
2465+ if (PyObject_SetAttrString(result, "generators", value) == -1)
2466+ goto failed;
2467+ Py_DECREF(value);
2468+ break;
2469+ case GeneratorExp_kind:
2470+ result = PyType_GenericNew(GeneratorExp_type, NULL, NULL);
2471+ if (!result) goto failed;
2472+ value = ast2obj_expr(o->v.GeneratorExp.elt);
2473+ if (!value) goto failed;
2474+ if (PyObject_SetAttrString(result, "elt", value) == -1)
2475+ goto failed;
2476+ Py_DECREF(value);
2477+ value = ast2obj_list(o->v.GeneratorExp.generators,
2478+ ast2obj_comprehension);
2479+ if (!value) goto failed;
2480+ if (PyObject_SetAttrString(result, "generators", value) == -1)
2481+ goto failed;
2482+ Py_DECREF(value);
2483+ break;
2484+ case Yield_kind:
2485+ result = PyType_GenericNew(Yield_type, NULL, NULL);
2486+ if (!result) goto failed;
2487+ value = ast2obj_expr(o->v.Yield.value);
2488+ if (!value) goto failed;
2489+ if (PyObject_SetAttrString(result, "value", value) == -1)
2490+ goto failed;
2491+ Py_DECREF(value);
2492+ break;
2493+ case Compare_kind:
2494+ result = PyType_GenericNew(Compare_type, NULL, NULL);
2495+ if (!result) goto failed;
2496+ value = ast2obj_expr(o->v.Compare.left);
2497+ if (!value) goto failed;
2498+ if (PyObject_SetAttrString(result, "left", value) == -1)
2499+ goto failed;
2500+ Py_DECREF(value);
2501+ {
2502+ int i, n = asdl_seq_LEN(o->v.Compare.ops);
2503+ value = PyList_New(n);
2504+ if (!value) goto failed;
2505+ for(i = 0; i < n; i++)
2506+ PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
2507+ }
2508+ if (!value) goto failed;
2509+ if (PyObject_SetAttrString(result, "ops", value) == -1)
2510+ goto failed;
2511+ Py_DECREF(value);
2512+ value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr);
2513+ if (!value) goto failed;
2514+ if (PyObject_SetAttrString(result, "comparators", value) == -1)
2515+ goto failed;
2516+ Py_DECREF(value);
2517+ break;
2518+ case Call_kind:
2519+ result = PyType_GenericNew(Call_type, NULL, NULL);
2520+ if (!result) goto failed;
2521+ value = ast2obj_expr(o->v.Call.func);
2522+ if (!value) goto failed;
2523+ if (PyObject_SetAttrString(result, "func", value) == -1)
2524+ goto failed;
2525+ Py_DECREF(value);
2526+ value = ast2obj_list(o->v.Call.args, ast2obj_expr);
2527+ if (!value) goto failed;
2528+ if (PyObject_SetAttrString(result, "args", value) == -1)
2529+ goto failed;
2530+ Py_DECREF(value);
2531+ value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword);
2532+ if (!value) goto failed;
2533+ if (PyObject_SetAttrString(result, "keywords", value) == -1)
2534+ goto failed;
2535+ Py_DECREF(value);
2536+ value = ast2obj_expr(o->v.Call.starargs);
2537+ if (!value) goto failed;
2538+ if (PyObject_SetAttrString(result, "starargs", value) == -1)
2539+ goto failed;
2540+ Py_DECREF(value);
2541+ value = ast2obj_expr(o->v.Call.kwargs);
2542+ if (!value) goto failed;
2543+ if (PyObject_SetAttrString(result, "kwargs", value) == -1)
2544+ goto failed;
2545+ Py_DECREF(value);
2546+ break;
2547+ case Repr_kind:
2548+ result = PyType_GenericNew(Repr_type, NULL, NULL);
2549+ if (!result) goto failed;
2550+ value = ast2obj_expr(o->v.Repr.value);
2551+ if (!value) goto failed;
2552+ if (PyObject_SetAttrString(result, "value", value) == -1)
2553+ goto failed;
2554+ Py_DECREF(value);
2555+ break;
2556+ case Num_kind:
2557+ result = PyType_GenericNew(Num_type, NULL, NULL);
2558+ if (!result) goto failed;
2559+ value = ast2obj_object(o->v.Num.n);
2560+ if (!value) goto failed;
2561+ if (PyObject_SetAttrString(result, "n", value) == -1)
2562+ goto failed;
2563+ Py_DECREF(value);
2564+ break;
2565+ case Str_kind:
2566+ result = PyType_GenericNew(Str_type, NULL, NULL);
2567+ if (!result) goto failed;
2568+ value = ast2obj_string(o->v.Str.s);
2569+ if (!value) goto failed;
2570+ if (PyObject_SetAttrString(result, "s", value) == -1)
2571+ goto failed;
2572+ Py_DECREF(value);
2573+ break;
2574+ case Attribute_kind:
2575+ result = PyType_GenericNew(Attribute_type, NULL, NULL);
2576+ if (!result) goto failed;
2577+ value = ast2obj_expr(o->v.Attribute.value);
2578+ if (!value) goto failed;
2579+ if (PyObject_SetAttrString(result, "value", value) == -1)
2580+ goto failed;
2581+ Py_DECREF(value);
2582+ value = ast2obj_identifier(o->v.Attribute.attr);
2583+ if (!value) goto failed;
2584+ if (PyObject_SetAttrString(result, "attr", value) == -1)
2585+ goto failed;
2586+ Py_DECREF(value);
2587+ value = ast2obj_expr_context(o->v.Attribute.ctx);
2588+ if (!value) goto failed;
2589+ if (PyObject_SetAttrString(result, "ctx", value) == -1)
2590+ goto failed;
2591+ Py_DECREF(value);
2592+ break;
2593+ case Subscript_kind:
2594+ result = PyType_GenericNew(Subscript_type, NULL, NULL);
2595+ if (!result) goto failed;
2596+ value = ast2obj_expr(o->v.Subscript.value);
2597+ if (!value) goto failed;
2598+ if (PyObject_SetAttrString(result, "value", value) == -1)
2599+ goto failed;
2600+ Py_DECREF(value);
2601+ value = ast2obj_slice(o->v.Subscript.slice);
2602+ if (!value) goto failed;
2603+ if (PyObject_SetAttrString(result, "slice", value) == -1)
2604+ goto failed;
2605+ Py_DECREF(value);
2606+ value = ast2obj_expr_context(o->v.Subscript.ctx);
2607+ if (!value) goto failed;
2608+ if (PyObject_SetAttrString(result, "ctx", value) == -1)
2609+ goto failed;
2610+ Py_DECREF(value);
2611+ break;
2612+ case Name_kind:
2613+ result = PyType_GenericNew(Name_type, NULL, NULL);
2614+ if (!result) goto failed;
2615+ value = ast2obj_identifier(o->v.Name.id);
2616+ if (!value) goto failed;
2617+ if (PyObject_SetAttrString(result, "id", value) == -1)
2618+ goto failed;
2619+ Py_DECREF(value);
2620+ value = ast2obj_expr_context(o->v.Name.ctx);
2621+ if (!value) goto failed;
2622+ if (PyObject_SetAttrString(result, "ctx", value) == -1)
2623+ goto failed;
2624+ Py_DECREF(value);
2625+ break;
2626+ case List_kind:
2627+ result = PyType_GenericNew(List_type, NULL, NULL);
2628+ if (!result) goto failed;
2629+ value = ast2obj_list(o->v.List.elts, ast2obj_expr);
2630+ if (!value) goto failed;
2631+ if (PyObject_SetAttrString(result, "elts", value) == -1)
2632+ goto failed;
2633+ Py_DECREF(value);
2634+ value = ast2obj_expr_context(o->v.List.ctx);
2635+ if (!value) goto failed;
2636+ if (PyObject_SetAttrString(result, "ctx", value) == -1)
2637+ goto failed;
2638+ Py_DECREF(value);
2639+ break;
2640+ case Tuple_kind:
2641+ result = PyType_GenericNew(Tuple_type, NULL, NULL);
2642+ if (!result) goto failed;
2643+ value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr);
2644+ if (!value) goto failed;
2645+ if (PyObject_SetAttrString(result, "elts", value) == -1)
2646+ goto failed;
2647+ Py_DECREF(value);
2648+ value = ast2obj_expr_context(o->v.Tuple.ctx);
2649+ if (!value) goto failed;
2650+ if (PyObject_SetAttrString(result, "ctx", value) == -1)
2651+ goto failed;
2652+ Py_DECREF(value);
2653+ break;
2654+ }
2655+ value = ast2obj_int(o->lineno);
2656+ if (!value) goto failed;
2657+ if (PyObject_SetAttrString(result, "lineno", value) < 0)
2658+ goto failed;
2659+ Py_DECREF(value);
2660+ value = ast2obj_int(o->col_offset);
2661+ if (!value) goto failed;
2662+ if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2663+ goto failed;
2664+ Py_DECREF(value);
2665+ return result;
2666+failed:
2667+ Py_XDECREF(value);
2668+ Py_XDECREF(result);
2669+ return NULL;
2670+}
2671+
2672+PyObject* ast2obj_expr_context(expr_context_ty o)
2673+{
2674+ switch(o) {
2675+ case Load:
2676+ Py_INCREF(Load_singleton);
2677+ return Load_singleton;
2678+ case Store:
2679+ Py_INCREF(Store_singleton);
2680+ return Store_singleton;
2681+ case Del:
2682+ Py_INCREF(Del_singleton);
2683+ return Del_singleton;
2684+ case AugLoad:
2685+ Py_INCREF(AugLoad_singleton);
2686+ return AugLoad_singleton;
2687+ case AugStore:
2688+ Py_INCREF(AugStore_singleton);
2689+ return AugStore_singleton;
2690+ case Param:
2691+ Py_INCREF(Param_singleton);
2692+ return Param_singleton;
2693+ }
2694+ return NULL; /* cannot happen */
2695+}
2696+PyObject*
2697+ast2obj_slice(void* _o)
2698+{
2699+ slice_ty o = (slice_ty)_o;
2700+ PyObject *result = NULL, *value = NULL;
2701+ if (!o) {
2702+ Py_INCREF(Py_None);
2703+ return Py_None;
2704+ }
2705+
2706+ switch (o->kind) {
2707+ case Ellipsis_kind:
2708+ result = PyType_GenericNew(Ellipsis_type, NULL, NULL);
2709+ if (!result) goto failed;
2710+ break;
2711+ case Slice_kind:
2712+ result = PyType_GenericNew(Slice_type, NULL, NULL);
2713+ if (!result) goto failed;
2714+ value = ast2obj_expr(o->v.Slice.lower);
2715+ if (!value) goto failed;
2716+ if (PyObject_SetAttrString(result, "lower", value) == -1)
2717+ goto failed;
2718+ Py_DECREF(value);
2719+ value = ast2obj_expr(o->v.Slice.upper);
2720+ if (!value) goto failed;
2721+ if (PyObject_SetAttrString(result, "upper", value) == -1)
2722+ goto failed;
2723+ Py_DECREF(value);
2724+ value = ast2obj_expr(o->v.Slice.step);
2725+ if (!value) goto failed;
2726+ if (PyObject_SetAttrString(result, "step", value) == -1)
2727+ goto failed;
2728+ Py_DECREF(value);
2729+ break;
2730+ case ExtSlice_kind:
2731+ result = PyType_GenericNew(ExtSlice_type, NULL, NULL);
2732+ if (!result) goto failed;
2733+ value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice);
2734+ if (!value) goto failed;
2735+ if (PyObject_SetAttrString(result, "dims", value) == -1)
2736+ goto failed;
2737+ Py_DECREF(value);
2738+ break;
2739+ case Index_kind:
2740+ result = PyType_GenericNew(Index_type, NULL, NULL);
2741+ if (!result) goto failed;
2742+ value = ast2obj_expr(o->v.Index.value);
2743+ if (!value) goto failed;
2744+ if (PyObject_SetAttrString(result, "value", value) == -1)
2745+ goto failed;
2746+ Py_DECREF(value);
2747+ break;
2748+ }
2749+ return result;
2750+failed:
2751+ Py_XDECREF(value);
2752+ Py_XDECREF(result);
2753+ return NULL;
2754+}
2755+
2756+PyObject* ast2obj_boolop(boolop_ty o)
2757+{
2758+ switch(o) {
2759+ case And:
2760+ Py_INCREF(And_singleton);
2761+ return And_singleton;
2762+ case Or:
2763+ Py_INCREF(Or_singleton);
2764+ return Or_singleton;
2765+ }
2766+ return NULL; /* cannot happen */
2767+}
2768+PyObject* ast2obj_operator(operator_ty o)
2769+{
2770+ switch(o) {
2771+ case Add:
2772+ Py_INCREF(Add_singleton);
2773+ return Add_singleton;
2774+ case Sub:
2775+ Py_INCREF(Sub_singleton);
2776+ return Sub_singleton;
2777+ case Mult:
2778+ Py_INCREF(Mult_singleton);
2779+ return Mult_singleton;
2780+ case Div:
2781+ Py_INCREF(Div_singleton);
2782+ return Div_singleton;
2783+ case Mod:
2784+ Py_INCREF(Mod_singleton);
2785+ return Mod_singleton;
2786+ case Pow:
2787+ Py_INCREF(Pow_singleton);
2788+ return Pow_singleton;
2789+ case LShift:
2790+ Py_INCREF(LShift_singleton);
2791+ return LShift_singleton;
2792+ case RShift:
2793+ Py_INCREF(RShift_singleton);
2794+ return RShift_singleton;
2795+ case BitOr:
2796+ Py_INCREF(BitOr_singleton);
2797+ return BitOr_singleton;
2798+ case BitXor:
2799+ Py_INCREF(BitXor_singleton);
2800+ return BitXor_singleton;
2801+ case BitAnd:
2802+ Py_INCREF(BitAnd_singleton);
2803+ return BitAnd_singleton;
2804+ case FloorDiv:
2805+ Py_INCREF(FloorDiv_singleton);
2806+ return FloorDiv_singleton;
2807+ }
2808+ return NULL; /* cannot happen */
2809+}
2810+PyObject* ast2obj_unaryop(unaryop_ty o)
2811+{
2812+ switch(o) {
2813+ case Invert:
2814+ Py_INCREF(Invert_singleton);
2815+ return Invert_singleton;
2816+ case Not:
2817+ Py_INCREF(Not_singleton);
2818+ return Not_singleton;
2819+ case UAdd:
2820+ Py_INCREF(UAdd_singleton);
2821+ return UAdd_singleton;
2822+ case USub:
2823+ Py_INCREF(USub_singleton);
2824+ return USub_singleton;
2825+ }
2826+ return NULL; /* cannot happen */
2827+}
2828+PyObject* ast2obj_cmpop(cmpop_ty o)
2829+{
2830+ switch(o) {
2831+ case Eq:
2832+ Py_INCREF(Eq_singleton);
2833+ return Eq_singleton;
2834+ case NotEq:
2835+ Py_INCREF(NotEq_singleton);
2836+ return NotEq_singleton;
2837+ case Lt:
2838+ Py_INCREF(Lt_singleton);
2839+ return Lt_singleton;
2840+ case LtE:
2841+ Py_INCREF(LtE_singleton);
2842+ return LtE_singleton;
2843+ case Gt:
2844+ Py_INCREF(Gt_singleton);
2845+ return Gt_singleton;
2846+ case GtE:
2847+ Py_INCREF(GtE_singleton);
2848+ return GtE_singleton;
2849+ case Is:
2850+ Py_INCREF(Is_singleton);
2851+ return Is_singleton;
2852+ case IsNot:
2853+ Py_INCREF(IsNot_singleton);
2854+ return IsNot_singleton;
2855+ case In:
2856+ Py_INCREF(In_singleton);
2857+ return In_singleton;
2858+ case NotIn:
2859+ Py_INCREF(NotIn_singleton);
2860+ return NotIn_singleton;
2861+ }
2862+ return NULL; /* cannot happen */
2863+}
2864+PyObject*
2865+ast2obj_comprehension(void* _o)
2866+{
2867+ comprehension_ty o = (comprehension_ty)_o;
2868+ PyObject *result = NULL, *value = NULL;
2869+ if (!o) {
2870+ Py_INCREF(Py_None);
2871+ return Py_None;
2872+ }
2873+
2874+ result = PyType_GenericNew(comprehension_type, NULL, NULL);
2875+ if (!result) return NULL;
2876+ value = ast2obj_expr(o->target);
2877+ if (!value) goto failed;
2878+ if (PyObject_SetAttrString(result, "target", value) == -1)
2879+ goto failed;
2880+ Py_DECREF(value);
2881+ value = ast2obj_expr(o->iter);
2882+ if (!value) goto failed;
2883+ if (PyObject_SetAttrString(result, "iter", value) == -1)
2884+ goto failed;
2885+ Py_DECREF(value);
2886+ value = ast2obj_list(o->ifs, ast2obj_expr);
2887+ if (!value) goto failed;
2888+ if (PyObject_SetAttrString(result, "ifs", value) == -1)
2889+ goto failed;
2890+ Py_DECREF(value);
2891+ return result;
2892+failed:
2893+ Py_XDECREF(value);
2894+ Py_XDECREF(result);
2895+ return NULL;
2896+}
2897+
2898+PyObject*
2899+ast2obj_excepthandler(void* _o)
2900+{
2901+ excepthandler_ty o = (excepthandler_ty)_o;
2902+ PyObject *result = NULL, *value = NULL;
2903+ if (!o) {
2904+ Py_INCREF(Py_None);
2905+ return Py_None;
2906+ }
2907+
2908+ result = PyType_GenericNew(excepthandler_type, NULL, NULL);
2909+ if (!result) return NULL;
2910+ value = ast2obj_expr(o->type);
2911+ if (!value) goto failed;
2912+ if (PyObject_SetAttrString(result, "type", value) == -1)
2913+ goto failed;
2914+ Py_DECREF(value);
2915+ value = ast2obj_expr(o->name);
2916+ if (!value) goto failed;
2917+ if (PyObject_SetAttrString(result, "name", value) == -1)
2918+ goto failed;
2919+ Py_DECREF(value);
2920+ value = ast2obj_list(o->body, ast2obj_stmt);
2921+ if (!value) goto failed;
2922+ if (PyObject_SetAttrString(result, "body", value) == -1)
2923+ goto failed;
2924+ Py_DECREF(value);
2925+ value = ast2obj_int(o->lineno);
2926+ if (!value) goto failed;
2927+ if (PyObject_SetAttrString(result, "lineno", value) == -1)
2928+ goto failed;
2929+ Py_DECREF(value);
2930+ value = ast2obj_int(o->col_offset);
2931+ if (!value) goto failed;
2932+ if (PyObject_SetAttrString(result, "col_offset", value) == -1)
2933+ goto failed;
2934+ Py_DECREF(value);
2935+ return result;
2936+failed:
2937+ Py_XDECREF(value);
2938+ Py_XDECREF(result);
2939+ return NULL;
2940+}
2941+
2942+PyObject*
2943+ast2obj_arguments(void* _o)
2944+{
2945+ arguments_ty o = (arguments_ty)_o;
2946+ PyObject *result = NULL, *value = NULL;
2947+ if (!o) {
2948+ Py_INCREF(Py_None);
2949+ return Py_None;
2950+ }
2951+
2952+ result = PyType_GenericNew(arguments_type, NULL, NULL);
2953+ if (!result) return NULL;
2954+ value = ast2obj_list(o->args, ast2obj_expr);
2955+ if (!value) goto failed;
2956+ if (PyObject_SetAttrString(result, "args", value) == -1)
2957+ goto failed;
2958+ Py_DECREF(value);
2959+ value = ast2obj_identifier(o->vararg);
2960+ if (!value) goto failed;
2961+ if (PyObject_SetAttrString(result, "vararg", value) == -1)
2962+ goto failed;
2963+ Py_DECREF(value);
2964+ value = ast2obj_identifier(o->kwarg);
2965+ if (!value) goto failed;
2966+ if (PyObject_SetAttrString(result, "kwarg", value) == -1)
2967+ goto failed;
2968+ Py_DECREF(value);
2969+ value = ast2obj_list(o->defaults, ast2obj_expr);
2970+ if (!value) goto failed;
2971+ if (PyObject_SetAttrString(result, "defaults", value) == -1)
2972+ goto failed;
2973+ Py_DECREF(value);
2974+ return result;
2975+failed:
2976+ Py_XDECREF(value);
2977+ Py_XDECREF(result);
2978+ return NULL;
2979+}
2980+
2981+PyObject*
2982+ast2obj_keyword(void* _o)
2983+{
2984+ keyword_ty o = (keyword_ty)_o;
2985+ PyObject *result = NULL, *value = NULL;
2986+ if (!o) {
2987+ Py_INCREF(Py_None);
2988+ return Py_None;
2989+ }
2990+
2991+ result = PyType_GenericNew(keyword_type, NULL, NULL);
2992+ if (!result) return NULL;
2993+ value = ast2obj_identifier(o->arg);
2994+ if (!value) goto failed;
2995+ if (PyObject_SetAttrString(result, "arg", value) == -1)
2996+ goto failed;
2997+ Py_DECREF(value);
2998+ value = ast2obj_expr(o->value);
2999+ if (!value) goto failed;
3000+ if (PyObject_SetAttrString(result, "value", value) == -1)
3001+ goto failed;
3002+ Py_DECREF(value);
3003+ return result;
3004+failed:
3005+ Py_XDECREF(value);
3006+ Py_XDECREF(result);
3007+ return NULL;
3008+}
3009+
3010+PyObject*
3011+ast2obj_alias(void* _o)
3012+{
3013+ alias_ty o = (alias_ty)_o;
3014+ PyObject *result = NULL, *value = NULL;
3015+ if (!o) {
3016+ Py_INCREF(Py_None);
3017+ return Py_None;
3018+ }
3019+
3020+ result = PyType_GenericNew(alias_type, NULL, NULL);
3021+ if (!result) return NULL;
3022+ value = ast2obj_identifier(o->name);
3023+ if (!value) goto failed;
3024+ if (PyObject_SetAttrString(result, "name", value) == -1)
3025+ goto failed;
3026+ Py_DECREF(value);
3027+ value = ast2obj_identifier(o->asname);
3028+ if (!value) goto failed;
3029+ if (PyObject_SetAttrString(result, "asname", value) == -1)
3030+ goto failed;
3031+ Py_DECREF(value);
3032+ return result;
3033+failed:
3034+ Py_XDECREF(value);
3035+ Py_XDECREF(result);
3036+ return NULL;
3037+}
3038+
3039+
3040+PyMODINIT_FUNC
3041+init_ast(void)
3042+{
3043+ PyObject *m, *d;
3044+ if (!init_types()) return;
3045+ m = Py_InitModule3("_ast", NULL, NULL);
3046+ if (!m) return;
3047+ d = PyModule_GetDict(m);
3048+ if (PyDict_SetItemString(d, "AST", (PyObject*)AST_type) < 0) return;
3049+ if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)
3050+ return;
3051+ if (PyModule_AddStringConstant(m, "__version__", "43614") < 0)
3052+ return;
3053+ if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return;
3054+ if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0)
3055+ return;
3056+ if (PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type)
3057+ < 0) return;
3058+ if (PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) <
3059+ 0) return;
3060+ if (PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return;
3061+ if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return;
3062+ if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type)
3063+ < 0) return;
3064+ if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0)
3065+ return;
3066+ if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0)
3067+ return;
3068+ if (PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0)
3069+ return;
3070+ if (PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0)
3071+ return;
3072+ if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) <
3073+ 0) return;
3074+ if (PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return;
3075+ if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return;
3076+ if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return;
3077+ if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return;
3078+ if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return;
3079+ if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return;
3080+ if (PyDict_SetItemString(d, "TryExcept", (PyObject*)TryExcept_type) <
3081+ 0) return;
3082+ if (PyDict_SetItemString(d, "TryFinally", (PyObject*)TryFinally_type) <
3083+ 0) return;
3084+ if (PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0)
3085+ return;
3086+ if (PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0)
3087+ return;
3088+ if (PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) <
3089+ 0) return;
3090+ if (PyDict_SetItemString(d, "Exec", (PyObject*)Exec_type) < 0) return;
3091+ if (PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0)
3092+ return;
3093+ if (PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return;
3094+ if (PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return;
3095+ if (PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return;
3096+ if (PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0)
3097+ return;
3098+ if (PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return;
3099+ if (PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0)
3100+ return;
3101+ if (PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return;
3102+ if (PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0)
3103+ return;
3104+ if (PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0)
3105+ return;
3106+ if (PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return;
3107+ if (PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return;
3108+ if (PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0)
3109+ return;
3110+ if (PyDict_SetItemString(d, "GeneratorExp",
3111+ (PyObject*)GeneratorExp_type) < 0) return;
3112+ if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return;
3113+ if (PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0)
3114+ return;
3115+ if (PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return;
3116+ if (PyDict_SetItemString(d, "Repr", (PyObject*)Repr_type) < 0) return;
3117+ if (PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return;
3118+ if (PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return;
3119+ if (PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) <
3120+ 0) return;
3121+ if (PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) <
3122+ 0) return;
3123+ if (PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return;
3124+ if (PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return;
3125+ if (PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return;
3126+ if (PyDict_SetItemString(d, "expr_context",
3127+ (PyObject*)expr_context_type) < 0) return;
3128+ if (PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return;
3129+ if (PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return;
3130+ if (PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return;
3131+ if (PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0)
3132+ return;
3133+ if (PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0)
3134+ return;
3135+ if (PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return;
3136+ if (PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return;
3137+ if (PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0)
3138+ return;
3139+ if (PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return;
3140+ if (PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0)
3141+ return;
3142+ if (PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return;
3143+ if (PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0)
3144+ return;
3145+ if (PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return;
3146+ if (PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return;
3147+ if (PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0)
3148+ return;
3149+ if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return;
3150+ if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return;
3151+ if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return;
3152+ if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return;
3153+ if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return;
3154+ if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return;
3155+ if (PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0)
3156+ return;
3157+ if (PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0)
3158+ return;
3159+ if (PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return;
3160+ if (PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0)
3161+ return;
3162+ if (PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0)
3163+ return;
3164+ if (PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0)
3165+ return;
3166+ if (PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0)
3167+ return;
3168+ if (PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0)
3169+ return;
3170+ if (PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return;
3171+ if (PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return;
3172+ if (PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return;
3173+ if (PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return;
3174+ if (PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return;
3175+ if (PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return;
3176+ if (PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return;
3177+ if (PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return;
3178+ if (PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return;
3179+ if (PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return;
3180+ if (PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return;
3181+ if (PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return;
3182+ if (PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return;
3183+ if (PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return;
3184+ if (PyDict_SetItemString(d, "comprehension",
3185+ (PyObject*)comprehension_type) < 0) return;
3186+ if (PyDict_SetItemString(d, "excepthandler",
3187+ (PyObject*)excepthandler_type) < 0) return;
3188+ if (PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) <
3189+ 0) return;
3190+ if (PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0)
3191+ return;
3192+ if (PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return;
3193+}
3194+
3195+
3196+PyObject* PyAST_mod2obj(mod_ty t)
3197+{
3198+ init_types();
3199+ return ast2obj_mod(t);
3200+}
3201+
3202+